the_nilfs.h

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