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 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 19 | * |
| 20 | * Written by Ryusuke Konishi <ryusuke@osrg.net> |
| 21 | * |
| 22 | */ |
| 23 | |
| 24 | #ifndef _THE_NILFS_H |
| 25 | #define _THE_NILFS_H |
| 26 | |
| 27 | #include <linux/types.h> |
| 28 | #include <linux/buffer_head.h> |
| 29 | #include <linux/fs.h> |
| 30 | #include <linux/blkdev.h> |
| 31 | #include <linux/backing-dev.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 32 | #include <linux/slab.h> |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 33 | #include "sb.h" |
| 34 | |
| 35 | /* the_nilfs struct */ |
| 36 | enum { |
| 37 | THE_NILFS_INIT = 0, /* Information from super_block is set */ |
| 38 | THE_NILFS_LOADED, /* Roll-back/roll-forward has done and |
| 39 | the latest checkpoint was loaded */ |
| 40 | THE_NILFS_DISCONTINUED, /* 'next' pointer chain has broken */ |
Jiro SEKIBA | 1cf58fa | 2009-09-03 22:24:17 +0900 | [diff] [blame] | 41 | THE_NILFS_GC_RUNNING, /* gc process is running */ |
Ryusuke Konishi | e605f0a | 2009-12-09 00:57:52 +0900 | [diff] [blame] | 42 | THE_NILFS_SB_DIRTY, /* super block is dirty */ |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 43 | }; |
| 44 | |
| 45 | /** |
| 46 | * struct the_nilfs - struct to supervise multiple nilfs mount points |
| 47 | * @ns_flags: flags |
| 48 | * @ns_count: reference count |
Ryusuke Konishi | 33c8e57 | 2009-06-08 01:39:29 +0900 | [diff] [blame] | 49 | * @ns_list: list head for nilfs_list |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 50 | * @ns_bdev: block device |
| 51 | * @ns_bdi: backing dev info |
| 52 | * @ns_writer: back pointer to writable nilfs_sb_info |
| 53 | * @ns_sem: semaphore for shared states |
Ryusuke Konishi | e59399d | 2009-06-08 01:39:32 +0900 | [diff] [blame] | 54 | * @ns_super_sem: semaphore for global operations across super block instances |
Ryusuke Konishi | aa7dfb8 | 2009-06-08 01:39:33 +0900 | [diff] [blame] | 55 | * @ns_mount_mutex: mutex protecting mount process of nilfs |
Ryusuke Konishi | 027d640 | 2009-08-02 22:45:33 +0900 | [diff] [blame] | 56 | * @ns_writer_sem: semaphore protecting ns_writer attach/detach |
Ryusuke Konishi | 3f82ff5 | 2009-06-08 01:39:30 +0900 | [diff] [blame] | 57 | * @ns_current: back pointer to current mount |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 58 | * @ns_sbh: buffer heads of on-disk super blocks |
| 59 | * @ns_sbp: pointers to super block data |
| 60 | * @ns_sbwtime: previous write time of super blocks |
| 61 | * @ns_sbsize: size of valid data in super block |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 62 | * @ns_supers: list of nilfs super block structs |
| 63 | * @ns_seg_seq: segment sequence counter |
| 64 | * @ns_segnum: index number of the latest full segment. |
| 65 | * @ns_nextnum: index number of the full segment index to be used next |
| 66 | * @ns_pseg_offset: offset of next partial segment in the current full segment |
| 67 | * @ns_cno: next checkpoint number |
| 68 | * @ns_ctime: write time of the last segment |
| 69 | * @ns_nongc_ctime: write time of the last segment not for cleaner operation |
| 70 | * @ns_ndirtyblks: Number of dirty data blocks |
| 71 | * @ns_last_segment_lock: lock protecting fields for the latest segment |
| 72 | * @ns_last_pseg: start block number of the latest segment |
| 73 | * @ns_last_seq: sequence value of the latest segment |
| 74 | * @ns_last_cno: checkpoint number of the latest segment |
Ryusuke Konishi | 2c2e52f | 2009-04-06 19:01:54 -0700 | [diff] [blame] | 75 | * @ns_prot_seq: least sequence number of segments which must not be reclaimed |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 76 | * @ns_free_segments_count: counter of free segments |
| 77 | * @ns_segctor_sem: segment constructor semaphore |
| 78 | * @ns_dat: DAT file inode |
| 79 | * @ns_cpfile: checkpoint file inode |
| 80 | * @ns_sufile: segusage file inode |
| 81 | * @ns_gc_dat: shadow inode of the DAT file inode for GC |
| 82 | * @ns_gc_inodes: dummy inodes to keep live blocks |
| 83 | * @ns_gc_inodes_h: hash list to keep dummy inode holding live blocks |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 84 | * @ns_blocksize_bits: bit length of block size |
| 85 | * @ns_nsegments: number of segments in filesystem |
| 86 | * @ns_blocks_per_segment: number of blocks per segment |
| 87 | * @ns_r_segments_percentage: reserved segments percentage |
| 88 | * @ns_nrsvsegs: number of reserved segments |
| 89 | * @ns_first_data_block: block number of first data block |
| 90 | * @ns_inode_size: size of on-disk inode |
| 91 | * @ns_first_ino: first not-special inode number |
| 92 | * @ns_crc_seed: seed value of CRC32 calculation |
| 93 | */ |
| 94 | struct the_nilfs { |
| 95 | unsigned long ns_flags; |
| 96 | atomic_t ns_count; |
Ryusuke Konishi | 33c8e57 | 2009-06-08 01:39:29 +0900 | [diff] [blame] | 97 | struct list_head ns_list; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 98 | |
| 99 | struct block_device *ns_bdev; |
| 100 | struct backing_dev_info *ns_bdi; |
| 101 | struct nilfs_sb_info *ns_writer; |
| 102 | struct rw_semaphore ns_sem; |
Ryusuke Konishi | e59399d | 2009-06-08 01:39:32 +0900 | [diff] [blame] | 103 | struct rw_semaphore ns_super_sem; |
Ryusuke Konishi | aa7dfb8 | 2009-06-08 01:39:33 +0900 | [diff] [blame] | 104 | struct mutex ns_mount_mutex; |
Ryusuke Konishi | 027d640 | 2009-08-02 22:45:33 +0900 | [diff] [blame] | 105 | struct rw_semaphore ns_writer_sem; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 106 | |
Ryusuke Konishi | e59399d | 2009-06-08 01:39:32 +0900 | [diff] [blame] | 107 | /* |
| 108 | * components protected by ns_super_sem |
| 109 | */ |
Ryusuke Konishi | 3f82ff5 | 2009-06-08 01:39:30 +0900 | [diff] [blame] | 110 | struct nilfs_sb_info *ns_current; |
Ryusuke Konishi | e59399d | 2009-06-08 01:39:32 +0900 | [diff] [blame] | 111 | struct list_head ns_supers; |
Ryusuke Konishi | 3f82ff5 | 2009-06-08 01:39:30 +0900 | [diff] [blame] | 112 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 113 | /* |
| 114 | * used for |
| 115 | * - loading the latest checkpoint exclusively. |
| 116 | * - allocating a new full segment. |
| 117 | * - protecting s_dirt in the super_block struct |
| 118 | * (see nilfs_write_super) and the following fields. |
| 119 | */ |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 120 | struct buffer_head *ns_sbh[2]; |
| 121 | struct nilfs_super_block *ns_sbp[2]; |
| 122 | time_t ns_sbwtime[2]; |
| 123 | unsigned ns_sbsize; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 124 | unsigned ns_mount_state; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 125 | |
| 126 | /* |
| 127 | * Following fields are dedicated to a writable FS-instance. |
| 128 | * Except for the period seeking checkpoint, code outside the segment |
Ryusuke Konishi | 47420c7 | 2009-04-06 19:01:45 -0700 | [diff] [blame] | 129 | * constructor must lock a segment semaphore while accessing these |
| 130 | * fields. |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 131 | * The writable FS-instance is sole during a lifetime of the_nilfs. |
| 132 | */ |
| 133 | u64 ns_seg_seq; |
| 134 | __u64 ns_segnum; |
| 135 | __u64 ns_nextnum; |
| 136 | unsigned long ns_pseg_offset; |
| 137 | __u64 ns_cno; |
| 138 | time_t ns_ctime; |
| 139 | time_t ns_nongc_ctime; |
| 140 | atomic_t ns_ndirtyblks; |
| 141 | |
| 142 | /* |
| 143 | * The following fields hold information on the latest partial segment |
| 144 | * written to disk with a super root. These fields are protected by |
| 145 | * ns_last_segment_lock. |
| 146 | */ |
| 147 | spinlock_t ns_last_segment_lock; |
| 148 | sector_t ns_last_pseg; |
| 149 | u64 ns_last_seq; |
| 150 | __u64 ns_last_cno; |
Ryusuke Konishi | 2c2e52f | 2009-04-06 19:01:54 -0700 | [diff] [blame] | 151 | u64 ns_prot_seq; |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 152 | unsigned long ns_free_segments_count; |
| 153 | |
| 154 | struct rw_semaphore ns_segctor_sem; |
| 155 | |
| 156 | /* |
| 157 | * Following fields are lock free except for the period before |
| 158 | * the_nilfs is initialized. |
| 159 | */ |
| 160 | struct inode *ns_dat; |
| 161 | struct inode *ns_cpfile; |
| 162 | struct inode *ns_sufile; |
| 163 | struct inode *ns_gc_dat; |
| 164 | |
| 165 | /* GC inode list and hash table head */ |
| 166 | struct list_head ns_gc_inodes; |
| 167 | struct hlist_head *ns_gc_inodes_h; |
| 168 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 169 | /* Disk layout information (static) */ |
| 170 | unsigned int ns_blocksize_bits; |
| 171 | unsigned long ns_nsegments; |
| 172 | unsigned long ns_blocks_per_segment; |
| 173 | unsigned long ns_r_segments_percentage; |
| 174 | unsigned long ns_nrsvsegs; |
| 175 | unsigned long ns_first_data_block; |
| 176 | int ns_inode_size; |
| 177 | int ns_first_ino; |
| 178 | u32 ns_crc_seed; |
| 179 | }; |
| 180 | |
| 181 | #define NILFS_GCINODE_HASH_BITS 8 |
| 182 | #define NILFS_GCINODE_HASH_SIZE (1<<NILFS_GCINODE_HASH_BITS) |
| 183 | |
| 184 | #define THE_NILFS_FNS(bit, name) \ |
| 185 | static inline void set_nilfs_##name(struct the_nilfs *nilfs) \ |
| 186 | { \ |
| 187 | set_bit(THE_NILFS_##bit, &(nilfs)->ns_flags); \ |
| 188 | } \ |
| 189 | static inline void clear_nilfs_##name(struct the_nilfs *nilfs) \ |
| 190 | { \ |
| 191 | clear_bit(THE_NILFS_##bit, &(nilfs)->ns_flags); \ |
| 192 | } \ |
| 193 | static inline int nilfs_##name(struct the_nilfs *nilfs) \ |
| 194 | { \ |
| 195 | return test_bit(THE_NILFS_##bit, &(nilfs)->ns_flags); \ |
| 196 | } |
| 197 | |
| 198 | THE_NILFS_FNS(INIT, init) |
| 199 | THE_NILFS_FNS(LOADED, loaded) |
| 200 | THE_NILFS_FNS(DISCONTINUED, discontinued) |
Jiro SEKIBA | 1cf58fa | 2009-09-03 22:24:17 +0900 | [diff] [blame] | 201 | THE_NILFS_FNS(GC_RUNNING, gc_running) |
Ryusuke Konishi | e605f0a | 2009-12-09 00:57:52 +0900 | [diff] [blame] | 202 | THE_NILFS_FNS(SB_DIRTY, sb_dirty) |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 203 | |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 204 | /* Minimum interval of periodical update of superblocks (in seconds) */ |
| 205 | #define NILFS_SB_FREQ 10 |
| 206 | #define NILFS_ALTSB_FREQ 60 /* spare superblock */ |
| 207 | |
Jiro SEKIBA | 79efdd9 | 2009-07-23 01:26:34 +0900 | [diff] [blame] | 208 | static inline int nilfs_sb_need_update(struct the_nilfs *nilfs) |
| 209 | { |
| 210 | u64 t = get_seconds(); |
| 211 | return t < nilfs->ns_sbwtime[0] || |
| 212 | t > nilfs->ns_sbwtime[0] + NILFS_SB_FREQ; |
| 213 | } |
| 214 | |
| 215 | static inline int nilfs_altsb_need_update(struct the_nilfs *nilfs) |
| 216 | { |
| 217 | u64 t = get_seconds(); |
| 218 | struct nilfs_super_block **sbp = nilfs->ns_sbp; |
| 219 | return sbp[1] && t > nilfs->ns_sbwtime[1] + NILFS_ALTSB_FREQ; |
| 220 | } |
| 221 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 222 | void nilfs_set_last_segment(struct the_nilfs *, sector_t, u64, __u64); |
Ryusuke Konishi | 33c8e57 | 2009-06-08 01:39:29 +0900 | [diff] [blame] | 223 | struct the_nilfs *find_or_create_nilfs(struct block_device *); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 224 | void put_nilfs(struct the_nilfs *); |
| 225 | int init_nilfs(struct the_nilfs *, struct nilfs_sb_info *, char *); |
| 226 | int load_nilfs(struct the_nilfs *, struct nilfs_sb_info *); |
Jiro SEKIBA | e902ec9 | 2010-01-30 18:06:35 +0900 | [diff] [blame] | 227 | int nilfs_discard_segments(struct the_nilfs *, __u64 *, size_t); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 228 | int nilfs_count_free_blocks(struct the_nilfs *, sector_t *); |
Ryusuke Konishi | 6dd4740 | 2009-06-08 01:39:31 +0900 | [diff] [blame] | 229 | struct nilfs_sb_info *nilfs_find_sbinfo(struct the_nilfs *, int, __u64); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 230 | int nilfs_checkpoint_is_mounted(struct the_nilfs *, __u64, int); |
| 231 | int nilfs_near_disk_full(struct the_nilfs *); |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 232 | void nilfs_fall_back_super_block(struct the_nilfs *); |
| 233 | void nilfs_swap_super_block(struct the_nilfs *); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 234 | |
| 235 | |
| 236 | static inline void get_nilfs(struct the_nilfs *nilfs) |
| 237 | { |
| 238 | /* Caller must have at least one reference of the_nilfs. */ |
| 239 | atomic_inc(&nilfs->ns_count); |
| 240 | } |
| 241 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 242 | static inline void |
| 243 | nilfs_attach_writer(struct the_nilfs *nilfs, struct nilfs_sb_info *sbi) |
| 244 | { |
Ryusuke Konishi | 027d640 | 2009-08-02 22:45:33 +0900 | [diff] [blame] | 245 | down_write(&nilfs->ns_writer_sem); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 246 | nilfs->ns_writer = sbi; |
Ryusuke Konishi | 027d640 | 2009-08-02 22:45:33 +0900 | [diff] [blame] | 247 | up_write(&nilfs->ns_writer_sem); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 248 | } |
| 249 | |
| 250 | static inline void |
| 251 | nilfs_detach_writer(struct the_nilfs *nilfs, struct nilfs_sb_info *sbi) |
| 252 | { |
Ryusuke Konishi | 027d640 | 2009-08-02 22:45:33 +0900 | [diff] [blame] | 253 | down_write(&nilfs->ns_writer_sem); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 254 | if (sbi == nilfs->ns_writer) |
| 255 | nilfs->ns_writer = NULL; |
Ryusuke Konishi | 027d640 | 2009-08-02 22:45:33 +0900 | [diff] [blame] | 256 | up_write(&nilfs->ns_writer_sem); |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 257 | } |
| 258 | |
Ryusuke Konishi | 6dd4740 | 2009-06-08 01:39:31 +0900 | [diff] [blame] | 259 | static inline void nilfs_put_sbinfo(struct nilfs_sb_info *sbi) |
| 260 | { |
Ryusuke Konishi | a924586 | 2009-08-19 00:29:43 +0900 | [diff] [blame] | 261 | if (atomic_dec_and_test(&sbi->s_count)) |
Ryusuke Konishi | 6dd4740 | 2009-06-08 01:39:31 +0900 | [diff] [blame] | 262 | kfree(sbi); |
| 263 | } |
| 264 | |
Ryusuke Konishi | a057d2c | 2009-11-19 19:58:46 +0900 | [diff] [blame] | 265 | static inline int nilfs_valid_fs(struct the_nilfs *nilfs) |
| 266 | { |
| 267 | unsigned valid_fs; |
| 268 | |
| 269 | down_read(&nilfs->ns_sem); |
| 270 | valid_fs = (nilfs->ns_mount_state & NILFS_VALID_FS); |
| 271 | up_read(&nilfs->ns_sem); |
| 272 | return valid_fs; |
| 273 | } |
| 274 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 275 | static inline void |
| 276 | nilfs_get_segment_range(struct the_nilfs *nilfs, __u64 segnum, |
| 277 | sector_t *seg_start, sector_t *seg_end) |
| 278 | { |
| 279 | *seg_start = (sector_t)nilfs->ns_blocks_per_segment * segnum; |
| 280 | *seg_end = *seg_start + nilfs->ns_blocks_per_segment - 1; |
| 281 | if (segnum == 0) |
| 282 | *seg_start = nilfs->ns_first_data_block; |
| 283 | } |
| 284 | |
| 285 | static inline sector_t |
| 286 | nilfs_get_segment_start_blocknr(struct the_nilfs *nilfs, __u64 segnum) |
| 287 | { |
| 288 | return (segnum == 0) ? nilfs->ns_first_data_block : |
| 289 | (sector_t)nilfs->ns_blocks_per_segment * segnum; |
| 290 | } |
| 291 | |
| 292 | static inline __u64 |
| 293 | nilfs_get_segnum_of_block(struct the_nilfs *nilfs, sector_t blocknr) |
| 294 | { |
| 295 | sector_t segnum = blocknr; |
| 296 | |
| 297 | sector_div(segnum, nilfs->ns_blocks_per_segment); |
| 298 | return segnum; |
| 299 | } |
| 300 | |
| 301 | static inline void |
| 302 | nilfs_terminate_segment(struct the_nilfs *nilfs, sector_t seg_start, |
| 303 | sector_t seg_end) |
| 304 | { |
| 305 | /* terminate the current full segment (used in case of I/O-error) */ |
| 306 | nilfs->ns_pseg_offset = seg_end - seg_start + 1; |
| 307 | } |
| 308 | |
| 309 | static inline void nilfs_shift_to_next_segment(struct the_nilfs *nilfs) |
| 310 | { |
| 311 | /* move forward with a full segment */ |
| 312 | nilfs->ns_segnum = nilfs->ns_nextnum; |
| 313 | nilfs->ns_pseg_offset = 0; |
| 314 | nilfs->ns_seg_seq++; |
| 315 | } |
| 316 | |
| 317 | static inline __u64 nilfs_last_cno(struct the_nilfs *nilfs) |
| 318 | { |
| 319 | __u64 cno; |
| 320 | |
| 321 | spin_lock(&nilfs->ns_last_segment_lock); |
| 322 | cno = nilfs->ns_last_cno; |
| 323 | spin_unlock(&nilfs->ns_last_segment_lock); |
| 324 | return cno; |
| 325 | } |
| 326 | |
Ryusuke Konishi | cece552 | 2009-04-06 19:01:58 -0700 | [diff] [blame] | 327 | static inline int nilfs_segment_is_active(struct the_nilfs *nilfs, __u64 n) |
| 328 | { |
| 329 | return n == nilfs->ns_segnum || n == nilfs->ns_nextnum; |
| 330 | } |
| 331 | |
Ryusuke Konishi | 65b4643 | 2009-04-06 19:01:23 -0700 | [diff] [blame] | 332 | #endif /* _THE_NILFS_H */ |