Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 1 | /* |
| 2 | * the_nilfs.h - the_nilfs shared structure. |
| 3 | * |
| 4 | * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
Ryusuke Konishi | 4b420ab | 2016-05-23 16:23:09 -0700 | [diff] [blame] | 16 | * Written by Ryusuke Konishi. |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 17 | * |
| 18 | */ |
| 19 | |
| 20 | #ifndef _THE_NILFS_H |
| 21 | #define _THE_NILFS_H |
| 22 | |
| 23 | #include <linux/types.h> |
| 24 | #include <linux/buffer_head.h> |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 25 | #include <linux/rbtree.h> |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 26 | #include <linux/fs.h> |
| 27 | #include <linux/blkdev.h> |
| 28 | #include <linux/backing-dev.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 29 | #include <linux/slab.h> |
Elena Reshetova | d4f0284 | 2017-11-17 15:29:39 -0800 | [diff] [blame] | 30 | #include <linux/refcount.h> |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 31 | |
Ryusuke Konishi | 3fd3fe5 | 2011-03-09 11:05:08 +0900 | [diff] [blame] | 32 | struct nilfs_sc_info; |
Vyacheslav Dubeyko | caa05d4 | 2014-08-08 14:20:42 -0700 | [diff] [blame] | 33 | struct nilfs_sysfs_dev_subgroups; |
Ryusuke Konishi | 3fd3fe5 | 2011-03-09 11:05:08 +0900 | [diff] [blame] | 34 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 35 | /* the_nilfs struct */ |
| 36 | enum { |
| 37 | THE_NILFS_INIT = 0, /* Information from super_block is set */ |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 38 | THE_NILFS_DISCONTINUED, /* 'next' pointer chain has broken */ |
Jiro SEKIBA | 1cf58fa | 2009-09-03 22:24:17 +0900 | [diff] [blame] | 39 | THE_NILFS_GC_RUNNING, /* gc process is running */ |
Ryusuke Konishi | e605f0a | 2009-12-09 00:57:52 +0900 | [diff] [blame] | 40 | THE_NILFS_SB_DIRTY, /* super block is dirty */ |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 41 | }; |
| 42 | |
| 43 | /** |
| 44 | * struct the_nilfs - struct to supervise multiple nilfs mount points |
| 45 | * @ns_flags: flags |
Andreas Rohner | e2c7617 | 2014-10-13 15:53:20 -0700 | [diff] [blame] | 46 | * @ns_flushed_device: flag indicating if all volatile data was flushed |
Ryusuke Konishi | 6625689 | 2016-08-02 14:05:06 -0700 | [diff] [blame] | 47 | * @ns_sb: back pointer to super block instance |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 48 | * @ns_bdev: block device |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 49 | * @ns_sem: semaphore for shared states |
Ryusuke Konishi | 572d8b3 | 2012-07-30 14:42:07 -0700 | [diff] [blame] | 50 | * @ns_snapshot_mount_mutex: mutex to protect snapshot mounts |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 51 | * @ns_sbh: buffer heads of on-disk super blocks |
| 52 | * @ns_sbp: pointers to super block data |
Jiro SEKIBA | b2ac86e | 2010-06-28 17:49:33 +0900 | [diff] [blame] | 53 | * @ns_sbwtime: previous write time of super block |
| 54 | * @ns_sbwcount: write count of super block |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 55 | * @ns_sbsize: size of valid data in super block |
Vyacheslav Dubeyko | 6b0f339 | 2012-07-30 14:42:02 -0700 | [diff] [blame] | 56 | * @ns_mount_state: file system state |
Vyacheslav Dubeyko | caa05d4 | 2014-08-08 14:20:42 -0700 | [diff] [blame] | 57 | * @ns_sb_update_freq: interval of periodical update of superblocks (in seconds) |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 58 | * @ns_seg_seq: segment sequence counter |
| 59 | * @ns_segnum: index number of the latest full segment. |
| 60 | * @ns_nextnum: index number of the full segment index to be used next |
| 61 | * @ns_pseg_offset: offset of next partial segment in the current full segment |
| 62 | * @ns_cno: next checkpoint number |
| 63 | * @ns_ctime: write time of the last segment |
| 64 | * @ns_nongc_ctime: write time of the last segment not for cleaner operation |
| 65 | * @ns_ndirtyblks: Number of dirty data blocks |
| 66 | * @ns_last_segment_lock: lock protecting fields for the latest segment |
| 67 | * @ns_last_pseg: start block number of the latest segment |
| 68 | * @ns_last_seq: sequence value of the latest segment |
| 69 | * @ns_last_cno: checkpoint number of the latest segment |
Ryusuke Konishi | 2c2e52f | 2009-04-06 19:01:54 -0700 | [diff] [blame] | 70 | * @ns_prot_seq: least sequence number of segments which must not be reclaimed |
Ryusuke Konishi | 3250204 | 2010-06-29 14:42:13 +0900 | [diff] [blame] | 71 | * @ns_prev_seq: base sequence number used to decide if advance log cursor |
Ryusuke Konishi | 3fd3fe5 | 2011-03-09 11:05:08 +0900 | [diff] [blame] | 72 | * @ns_writer: log writer |
| 73 | * @ns_segctor_sem: semaphore protecting log write |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 74 | * @ns_dat: DAT file inode |
| 75 | * @ns_cpfile: checkpoint file inode |
| 76 | * @ns_sufile: segusage file inode |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 77 | * @ns_cptree: rb-tree of all mounted checkpoints (nilfs_root) |
| 78 | * @ns_cptree_lock: lock protecting @ns_cptree |
Ryusuke Konishi | 693dd32 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 79 | * @ns_dirty_files: list of dirty files |
| 80 | * @ns_inode_lock: lock protecting @ns_dirty_files |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 81 | * @ns_gc_inodes: dummy inodes to keep live blocks |
Ryusuke Konishi | 9b1fc4e4 | 2011-03-09 11:05:08 +0900 | [diff] [blame] | 82 | * @ns_next_generation: next generation number for inodes |
| 83 | * @ns_next_gen_lock: lock protecting @ns_next_generation |
Ryusuke Konishi | 3b2ce58 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 84 | * @ns_mount_opt: mount options |
Ryusuke Konishi | 574e6c3 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 85 | * @ns_resuid: uid for reserved blocks |
| 86 | * @ns_resgid: gid for reserved blocks |
| 87 | * @ns_interval: checkpoint creation interval |
| 88 | * @ns_watermark: watermark for the number of dirty buffers |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 89 | * @ns_blocksize_bits: bit length of block size |
Ryusuke Konishi | 92c60cc | 2010-05-23 00:17:48 +0900 | [diff] [blame] | 90 | * @ns_blocksize: block size |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 91 | * @ns_nsegments: number of segments in filesystem |
| 92 | * @ns_blocks_per_segment: number of blocks per segment |
| 93 | * @ns_r_segments_percentage: reserved segments percentage |
| 94 | * @ns_nrsvsegs: number of reserved segments |
| 95 | * @ns_first_data_block: block number of first data block |
| 96 | * @ns_inode_size: size of on-disk inode |
| 97 | * @ns_first_ino: first not-special inode number |
| 98 | * @ns_crc_seed: seed value of CRC32 calculation |
Vyacheslav Dubeyko | da7141f | 2014-08-08 14:20:39 -0700 | [diff] [blame] | 99 | * @ns_dev_kobj: /sys/fs/<nilfs>/<device> |
| 100 | * @ns_dev_kobj_unregister: completion state |
Vyacheslav Dubeyko | caa05d4 | 2014-08-08 14:20:42 -0700 | [diff] [blame] | 101 | * @ns_dev_subgroups: <device> subgroups pointer |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 102 | */ |
| 103 | struct the_nilfs { |
| 104 | unsigned long ns_flags; |
Andreas Rohner | e2c7617 | 2014-10-13 15:53:20 -0700 | [diff] [blame] | 105 | int ns_flushed_device; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 106 | |
Ryusuke Konishi | 6625689 | 2016-08-02 14:05:06 -0700 | [diff] [blame] | 107 | struct super_block *ns_sb; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 108 | struct block_device *ns_bdev; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 109 | struct rw_semaphore ns_sem; |
Ryusuke Konishi | 572d8b3 | 2012-07-30 14:42:07 -0700 | [diff] [blame] | 110 | struct mutex ns_snapshot_mount_mutex; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 111 | |
Ryusuke Konishi | e59399d | 2009-06-08 01:39:32 +0900 | [diff] [blame] | 112 | /* |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 113 | * used for |
| 114 | * - loading the latest checkpoint exclusively. |
| 115 | * - allocating a new full segment. |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 116 | */ |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 117 | struct buffer_head *ns_sbh[2]; |
| 118 | struct nilfs_super_block *ns_sbp[2]; |
Arnd Bergmann | fb04b91b | 2018-02-06 15:39:21 -0800 | [diff] [blame] | 119 | time64_t ns_sbwtime; |
Ryusuke Konishi | 0c6c44c | 2016-05-23 16:23:39 -0700 | [diff] [blame] | 120 | unsigned int ns_sbwcount; |
| 121 | unsigned int ns_sbsize; |
| 122 | unsigned int ns_mount_state; |
| 123 | unsigned int ns_sb_update_freq; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 124 | |
| 125 | /* |
Ryusuke Konishi | ad980c9 | 2016-08-02 14:05:25 -0700 | [diff] [blame] | 126 | * The following fields are updated by a writable FS-instance. |
| 127 | * These fields are protected by ns_segctor_sem outside load_nilfs(). |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 128 | */ |
| 129 | u64 ns_seg_seq; |
| 130 | __u64 ns_segnum; |
| 131 | __u64 ns_nextnum; |
| 132 | unsigned long ns_pseg_offset; |
| 133 | __u64 ns_cno; |
Arnd Bergmann | fb04b91b | 2018-02-06 15:39:21 -0800 | [diff] [blame] | 134 | time64_t ns_ctime; |
| 135 | time64_t ns_nongc_ctime; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 136 | atomic_t ns_ndirtyblks; |
| 137 | |
| 138 | /* |
| 139 | * The following fields hold information on the latest partial segment |
| 140 | * written to disk with a super root. These fields are protected by |
| 141 | * ns_last_segment_lock. |
| 142 | */ |
| 143 | spinlock_t ns_last_segment_lock; |
| 144 | sector_t ns_last_pseg; |
| 145 | u64 ns_last_seq; |
| 146 | __u64 ns_last_cno; |
Ryusuke Konishi | 2c2e52f | 2009-04-06 19:01:54 -0700 | [diff] [blame] | 147 | u64 ns_prot_seq; |
Ryusuke Konishi | 3250204 | 2010-06-29 14:42:13 +0900 | [diff] [blame] | 148 | u64 ns_prev_seq; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 149 | |
Ryusuke Konishi | 3fd3fe5 | 2011-03-09 11:05:08 +0900 | [diff] [blame] | 150 | struct nilfs_sc_info *ns_writer; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 151 | struct rw_semaphore ns_segctor_sem; |
| 152 | |
| 153 | /* |
| 154 | * Following fields are lock free except for the period before |
| 155 | * the_nilfs is initialized. |
| 156 | */ |
| 157 | struct inode *ns_dat; |
| 158 | struct inode *ns_cpfile; |
| 159 | struct inode *ns_sufile; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 160 | |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 161 | /* Checkpoint tree */ |
| 162 | struct rb_root ns_cptree; |
| 163 | spinlock_t ns_cptree_lock; |
| 164 | |
Ryusuke Konishi | 693dd32 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 165 | /* Dirty inode list */ |
| 166 | struct list_head ns_dirty_files; |
| 167 | spinlock_t ns_inode_lock; |
| 168 | |
Ryusuke Konishi | 263d90c | 2010-08-20 19:06:11 +0900 | [diff] [blame] | 169 | /* GC inode list */ |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 170 | struct list_head ns_gc_inodes; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 171 | |
Ryusuke Konishi | 9b1fc4e4 | 2011-03-09 11:05:08 +0900 | [diff] [blame] | 172 | /* Inode allocator */ |
| 173 | u32 ns_next_generation; |
| 174 | spinlock_t ns_next_gen_lock; |
| 175 | |
Ryusuke Konishi | 3b2ce58 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 176 | /* Mount options */ |
| 177 | unsigned long ns_mount_opt; |
| 178 | |
Ryusuke Konishi | 574e6c3 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 179 | uid_t ns_resuid; |
| 180 | gid_t ns_resgid; |
| 181 | unsigned long ns_interval; |
| 182 | unsigned long ns_watermark; |
| 183 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 184 | /* Disk layout information (static) */ |
| 185 | unsigned int ns_blocksize_bits; |
Ryusuke Konishi | 92c60cc | 2010-05-23 00:17:48 +0900 | [diff] [blame] | 186 | unsigned int ns_blocksize; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 187 | unsigned long ns_nsegments; |
| 188 | unsigned long ns_blocks_per_segment; |
| 189 | unsigned long ns_r_segments_percentage; |
| 190 | unsigned long ns_nrsvsegs; |
| 191 | unsigned long ns_first_data_block; |
| 192 | int ns_inode_size; |
| 193 | int ns_first_ino; |
| 194 | u32 ns_crc_seed; |
Vyacheslav Dubeyko | da7141f | 2014-08-08 14:20:39 -0700 | [diff] [blame] | 195 | |
| 196 | /* /sys/fs/<nilfs>/<device> */ |
| 197 | struct kobject ns_dev_kobj; |
| 198 | struct completion ns_dev_kobj_unregister; |
Vyacheslav Dubeyko | caa05d4 | 2014-08-08 14:20:42 -0700 | [diff] [blame] | 199 | struct nilfs_sysfs_dev_subgroups *ns_dev_subgroups; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 200 | }; |
| 201 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 202 | #define THE_NILFS_FNS(bit, name) \ |
| 203 | static inline void set_nilfs_##name(struct the_nilfs *nilfs) \ |
| 204 | { \ |
| 205 | set_bit(THE_NILFS_##bit, &(nilfs)->ns_flags); \ |
| 206 | } \ |
| 207 | static inline void clear_nilfs_##name(struct the_nilfs *nilfs) \ |
| 208 | { \ |
| 209 | clear_bit(THE_NILFS_##bit, &(nilfs)->ns_flags); \ |
| 210 | } \ |
| 211 | static inline int nilfs_##name(struct the_nilfs *nilfs) \ |
| 212 | { \ |
| 213 | return test_bit(THE_NILFS_##bit, &(nilfs)->ns_flags); \ |
| 214 | } |
| 215 | |
| 216 | THE_NILFS_FNS(INIT, init) |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 217 | THE_NILFS_FNS(DISCONTINUED, discontinued) |
Jiro SEKIBA | 1cf58fa | 2009-09-03 22:24:17 +0900 | [diff] [blame] | 218 | THE_NILFS_FNS(GC_RUNNING, gc_running) |
Ryusuke Konishi | e605f0a | 2009-12-09 00:57:52 +0900 | [diff] [blame] | 219 | THE_NILFS_FNS(SB_DIRTY, sb_dirty) |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 220 | |
Ryusuke Konishi | 3b2ce58 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 221 | /* |
| 222 | * Mount option operations |
| 223 | */ |
| 224 | #define nilfs_clear_opt(nilfs, opt) \ |
Ryusuke Konishi | 80d6505 | 2016-05-23 16:23:45 -0700 | [diff] [blame] | 225 | ((nilfs)->ns_mount_opt &= ~NILFS_MOUNT_##opt) |
Ryusuke Konishi | 3b2ce58 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 226 | #define nilfs_set_opt(nilfs, opt) \ |
Ryusuke Konishi | 80d6505 | 2016-05-23 16:23:45 -0700 | [diff] [blame] | 227 | ((nilfs)->ns_mount_opt |= NILFS_MOUNT_##opt) |
Ryusuke Konishi | 3b2ce58 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 228 | #define nilfs_test_opt(nilfs, opt) ((nilfs)->ns_mount_opt & NILFS_MOUNT_##opt) |
| 229 | #define nilfs_write_opt(nilfs, mask, opt) \ |
Ryusuke Konishi | 80d6505 | 2016-05-23 16:23:45 -0700 | [diff] [blame] | 230 | ((nilfs)->ns_mount_opt = \ |
Ryusuke Konishi | 3b2ce58 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 231 | (((nilfs)->ns_mount_opt & ~NILFS_MOUNT_##mask) | \ |
Ryusuke Konishi | 80d6505 | 2016-05-23 16:23:45 -0700 | [diff] [blame] | 232 | NILFS_MOUNT_##opt)) \ |
Ryusuke Konishi | 3b2ce58 | 2011-03-09 11:05:07 +0900 | [diff] [blame] | 233 | |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 234 | /** |
| 235 | * struct nilfs_root - nilfs root object |
| 236 | * @cno: checkpoint number |
| 237 | * @rb_node: red-black tree node |
| 238 | * @count: refcount of this structure |
| 239 | * @nilfs: nilfs object |
| 240 | * @ifile: inode file |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 241 | * @inodes_count: number of inodes |
Vyacheslav Dubeyko | f5974c8 | 2012-07-30 14:42:10 -0700 | [diff] [blame] | 242 | * @blocks_count: number of blocks |
Vyacheslav Dubeyko | a5a7332 | 2014-08-08 14:20:52 -0700 | [diff] [blame] | 243 | * @snapshot_kobj: /sys/fs/<nilfs>/<device>/mounted_snapshots/<snapshot> |
| 244 | * @snapshot_kobj_unregister: completion state for kernel object |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 245 | */ |
| 246 | struct nilfs_root { |
| 247 | __u64 cno; |
| 248 | struct rb_node rb_node; |
| 249 | |
Elena Reshetova | d4f0284 | 2017-11-17 15:29:39 -0800 | [diff] [blame] | 250 | refcount_t count; |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 251 | struct the_nilfs *nilfs; |
| 252 | struct inode *ifile; |
| 253 | |
Vyacheslav Dubeyko | e5f7f84 | 2013-07-03 15:08:06 -0700 | [diff] [blame] | 254 | atomic64_t inodes_count; |
| 255 | atomic64_t blocks_count; |
Vyacheslav Dubeyko | a5a7332 | 2014-08-08 14:20:52 -0700 | [diff] [blame] | 256 | |
| 257 | /* /sys/fs/<nilfs>/<device>/mounted_snapshots/<snapshot> */ |
| 258 | struct kobject snapshot_kobj; |
| 259 | struct completion snapshot_kobj_unregister; |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 260 | }; |
| 261 | |
| 262 | /* Special checkpoint number */ |
| 263 | #define NILFS_CPTREE_CURRENT_CNO 0 |
| 264 | |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 265 | /* Minimum interval of periodical update of superblocks (in seconds) */ |
| 266 | #define NILFS_SB_FREQ 10 |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 267 | |
Jiro SEKIBA | 79efdd9 | 2009-07-23 01:26:34 +0900 | [diff] [blame] | 268 | static inline int nilfs_sb_need_update(struct the_nilfs *nilfs) |
| 269 | { |
Arnd Bergmann | fb04b91b | 2018-02-06 15:39:21 -0800 | [diff] [blame] | 270 | u64 t = ktime_get_real_seconds(); |
Ryusuke Konishi | 4ad364c | 2016-05-23 16:23:25 -0700 | [diff] [blame] | 271 | |
Vyacheslav Dubeyko | caa05d4 | 2014-08-08 14:20:42 -0700 | [diff] [blame] | 272 | return t < nilfs->ns_sbwtime || |
| 273 | t > nilfs->ns_sbwtime + nilfs->ns_sb_update_freq; |
Jiro SEKIBA | 79efdd9 | 2009-07-23 01:26:34 +0900 | [diff] [blame] | 274 | } |
| 275 | |
Jiro SEKIBA | b2ac86e | 2010-06-28 17:49:33 +0900 | [diff] [blame] | 276 | static inline int nilfs_sb_will_flip(struct the_nilfs *nilfs) |
Jiro SEKIBA | 79efdd9 | 2009-07-23 01:26:34 +0900 | [diff] [blame] | 277 | { |
Jiro SEKIBA | b2ac86e | 2010-06-28 17:49:33 +0900 | [diff] [blame] | 278 | int flip_bits = nilfs->ns_sbwcount & 0x0FL; |
Ryusuke Konishi | 4ad364c | 2016-05-23 16:23:25 -0700 | [diff] [blame] | 279 | |
Jiro SEKIBA | b2ac86e | 2010-06-28 17:49:33 +0900 | [diff] [blame] | 280 | return (flip_bits != 0x08 && flip_bits != 0x0F); |
Jiro SEKIBA | 79efdd9 | 2009-07-23 01:26:34 +0900 | [diff] [blame] | 281 | } |
| 282 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 283 | void nilfs_set_last_segment(struct the_nilfs *, sector_t, u64, __u64); |
Ryusuke Konishi | 6625689 | 2016-08-02 14:05:06 -0700 | [diff] [blame] | 284 | struct the_nilfs *alloc_nilfs(struct super_block *sb); |
Ryusuke Konishi | 348fe8d | 2010-09-09 02:07:56 +0900 | [diff] [blame] | 285 | void destroy_nilfs(struct the_nilfs *nilfs); |
Ryusuke Konishi | f754514 | 2011-03-09 11:05:08 +0900 | [diff] [blame] | 286 | int init_nilfs(struct the_nilfs *nilfs, struct super_block *sb, char *data); |
| 287 | int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb); |
Ryusuke Konishi | 4e33f9e | 2011-05-05 01:23:58 +0900 | [diff] [blame] | 288 | unsigned long nilfs_nrsvsegs(struct the_nilfs *nilfs, unsigned long nsegs); |
| 289 | void nilfs_set_nsegments(struct the_nilfs *nilfs, unsigned long nsegs); |
Jiro SEKIBA | e902ec9 | 2010-01-30 18:06:35 +0900 | [diff] [blame] | 290 | int nilfs_discard_segments(struct the_nilfs *, __u64 *, size_t); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 291 | int nilfs_count_free_blocks(struct the_nilfs *, sector_t *); |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 292 | struct nilfs_root *nilfs_lookup_root(struct the_nilfs *nilfs, __u64 cno); |
| 293 | struct nilfs_root *nilfs_find_or_create_root(struct the_nilfs *nilfs, |
| 294 | __u64 cno); |
| 295 | void nilfs_put_root(struct nilfs_root *root); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 296 | int nilfs_near_disk_full(struct the_nilfs *); |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 297 | void nilfs_fall_back_super_block(struct the_nilfs *); |
| 298 | void nilfs_swap_super_block(struct the_nilfs *); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 299 | |
| 300 | |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 301 | static inline void nilfs_get_root(struct nilfs_root *root) |
| 302 | { |
Elena Reshetova | d4f0284 | 2017-11-17 15:29:39 -0800 | [diff] [blame] | 303 | refcount_inc(&root->count); |
Ryusuke Konishi | ba65ae4 | 2010-08-14 12:59:15 +0900 | [diff] [blame] | 304 | } |
| 305 | |
Ryusuke Konishi | a057d2c | 2009-11-19 19:58:46 +0900 | [diff] [blame] | 306 | static inline int nilfs_valid_fs(struct the_nilfs *nilfs) |
| 307 | { |
Ryusuke Konishi | 0c6c44c | 2016-05-23 16:23:39 -0700 | [diff] [blame] | 308 | unsigned int valid_fs; |
Ryusuke Konishi | a057d2c | 2009-11-19 19:58:46 +0900 | [diff] [blame] | 309 | |
| 310 | down_read(&nilfs->ns_sem); |
| 311 | valid_fs = (nilfs->ns_mount_state & NILFS_VALID_FS); |
| 312 | up_read(&nilfs->ns_sem); |
| 313 | return valid_fs; |
| 314 | } |
| 315 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 316 | static inline void |
| 317 | nilfs_get_segment_range(struct the_nilfs *nilfs, __u64 segnum, |
| 318 | sector_t *seg_start, sector_t *seg_end) |
| 319 | { |
| 320 | *seg_start = (sector_t)nilfs->ns_blocks_per_segment * segnum; |
| 321 | *seg_end = *seg_start + nilfs->ns_blocks_per_segment - 1; |
| 322 | if (segnum == 0) |
| 323 | *seg_start = nilfs->ns_first_data_block; |
| 324 | } |
| 325 | |
| 326 | static inline sector_t |
| 327 | nilfs_get_segment_start_blocknr(struct the_nilfs *nilfs, __u64 segnum) |
| 328 | { |
| 329 | return (segnum == 0) ? nilfs->ns_first_data_block : |
| 330 | (sector_t)nilfs->ns_blocks_per_segment * segnum; |
| 331 | } |
| 332 | |
| 333 | static inline __u64 |
| 334 | nilfs_get_segnum_of_block(struct the_nilfs *nilfs, sector_t blocknr) |
| 335 | { |
| 336 | sector_t segnum = blocknr; |
| 337 | |
| 338 | sector_div(segnum, nilfs->ns_blocks_per_segment); |
| 339 | return segnum; |
| 340 | } |
| 341 | |
| 342 | static inline void |
| 343 | nilfs_terminate_segment(struct the_nilfs *nilfs, sector_t seg_start, |
| 344 | sector_t seg_end) |
| 345 | { |
| 346 | /* terminate the current full segment (used in case of I/O-error) */ |
| 347 | nilfs->ns_pseg_offset = seg_end - seg_start + 1; |
| 348 | } |
| 349 | |
| 350 | static inline void nilfs_shift_to_next_segment(struct the_nilfs *nilfs) |
| 351 | { |
| 352 | /* move forward with a full segment */ |
| 353 | nilfs->ns_segnum = nilfs->ns_nextnum; |
| 354 | nilfs->ns_pseg_offset = 0; |
| 355 | nilfs->ns_seg_seq++; |
| 356 | } |
| 357 | |
| 358 | static inline __u64 nilfs_last_cno(struct the_nilfs *nilfs) |
| 359 | { |
| 360 | __u64 cno; |
| 361 | |
| 362 | spin_lock(&nilfs->ns_last_segment_lock); |
| 363 | cno = nilfs->ns_last_cno; |
| 364 | spin_unlock(&nilfs->ns_last_segment_lock); |
| 365 | return cno; |
| 366 | } |
| 367 | |
Ryusuke Konishi | cece552 | 2009-04-06 19:01:58 -0700 | [diff] [blame] | 368 | static inline int nilfs_segment_is_active(struct the_nilfs *nilfs, __u64 n) |
| 369 | { |
| 370 | return n == nilfs->ns_segnum || n == nilfs->ns_nextnum; |
| 371 | } |
| 372 | |
Andreas Rohner | e2c7617 | 2014-10-13 15:53:20 -0700 | [diff] [blame] | 373 | static inline int nilfs_flush_device(struct the_nilfs *nilfs) |
| 374 | { |
| 375 | int err; |
| 376 | |
| 377 | if (!nilfs_test_opt(nilfs, BARRIER) || nilfs->ns_flushed_device) |
| 378 | return 0; |
| 379 | |
| 380 | nilfs->ns_flushed_device = 1; |
| 381 | /* |
| 382 | * the store to ns_flushed_device must not be reordered after |
| 383 | * blkdev_issue_flush(). |
| 384 | */ |
| 385 | smp_wmb(); |
| 386 | |
| 387 | err = blkdev_issue_flush(nilfs->ns_bdev, GFP_KERNEL, NULL); |
| 388 | if (err != -EIO) |
| 389 | err = 0; |
| 390 | return err; |
| 391 | } |
| 392 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 393 | #endif /* _THE_NILFS_H */ |