nilfs2: extend nilfs_sustat ioctl struct
[linux-2.6.git] / include / linux / nilfs2_fs.h
1 /*
2  * nilfs2_fs.h - NILFS2 on-disk structures and common declarations.
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 Koji Sato <koji@osrg.net>
21  *            Ryusuke Konishi <ryusuke@osrg.net>
22  */
23 /*
24  *  linux/include/linux/ext2_fs.h
25  *
26  * Copyright (C) 1992, 1993, 1994, 1995
27  * Remy Card (card@masi.ibp.fr)
28  * Laboratoire MASI - Institut Blaise Pascal
29  * Universite Pierre et Marie Curie (Paris VI)
30  *
31  *  from
32  *
33  *  linux/include/linux/minix_fs.h
34  *
35  *  Copyright (C) 1991, 1992  Linus Torvalds
36  */
37
38 #ifndef _LINUX_NILFS_FS_H
39 #define _LINUX_NILFS_FS_H
40
41 #include <linux/types.h>
42 #include <linux/ioctl.h>
43
44 /*
45  * Inode flags stored in nilfs_inode and on-memory nilfs inode
46  *
47  * We define these flags based on ext2-fs because of the
48  * compatibility reason; to avoid problems in chattr(1)
49  */
50 #define NILFS_SECRM_FL          0x00000001 /* Secure deletion */
51 #define NILFS_UNRM_FL           0x00000002 /* Undelete */
52 #define NILFS_SYNC_FL           0x00000008 /* Synchronous updates */
53 #define NILFS_IMMUTABLE_FL      0x00000010 /* Immutable file */
54 #define NILFS_APPEND_FL         0x00000020 /* writes to file may only append */
55 #define NILFS_NODUMP_FL         0x00000040 /* do not dump file */
56 #define NILFS_NOATIME_FL        0x00000080 /* do not update atime */
57 /* Reserved for compression usage... */
58 #define NILFS_NOTAIL_FL         0x00008000 /* file tail should not be merged */
59 #define NILFS_DIRSYNC_FL        0x00010000 /* dirsync behaviour */
60
61 #define NILFS_FL_USER_VISIBLE   0x0003DFFF /* User visible flags */
62 #define NILFS_FL_USER_MODIFIABLE        0x000380FF /* User modifiable flags */
63
64
65 #define NILFS_INODE_BMAP_SIZE   7
66 /**
67  * struct nilfs_inode - structure of an inode on disk
68  * @i_blocks: blocks count
69  * @i_size: size in bytes
70  * @i_ctime: creation time
71  * @i_mtime: modification time
72  * @i_dtime: deletion time
73  * @i_uid: user id
74  * @i_gid: group id
75  * @i_mode: file mode
76  * @i_links_count: links count
77  * @i_flags: file flags
78  * @i_bmap: block mapping
79  * @i_xattr: extended attributes
80  * @i_generation: file generation (for NFS)
81  * @i_pad:      padding
82  */
83 struct nilfs_inode {
84         __le64  i_blocks;
85         __le64  i_size;
86         __le64  i_ctime;
87         __le64  i_mtime;
88         __le64  i_dtime;
89         __le32  i_uid;
90         __le32  i_gid;
91         __le16  i_mode;
92         __le16  i_links_count;
93         __le32  i_flags;
94         __le64  i_bmap[NILFS_INODE_BMAP_SIZE];
95 #define i_device_code   i_bmap[0]
96         __le64  i_xattr;
97         __le32  i_generation;
98         __le32  i_pad;
99 };
100
101 /**
102  * struct nilfs_super_root - structure of super root
103  * @sr_sum: check sum
104  * @sr_bytes: byte count of the structure
105  * @sr_flags: flags (reserved)
106  * @sr_nongc_ctime: write time of the last segment not for cleaner operation
107  * @sr_dat: DAT file inode
108  * @sr_cpfile: checkpoint file inode
109  * @sr_sufile: segment usage file inode
110  */
111 struct nilfs_super_root {
112         __le32 sr_sum;
113         __le16 sr_bytes;
114         __le16 sr_flags;
115         __le64 sr_nongc_ctime;
116         struct nilfs_inode sr_dat;
117         struct nilfs_inode sr_cpfile;
118         struct nilfs_inode sr_sufile;
119 };
120
121 #define NILFS_SR_MDT_OFFSET(inode_size, i)  \
122         ((unsigned long)&((struct nilfs_super_root *)0)->sr_dat + \
123                         (inode_size) * (i))
124 #define NILFS_SR_DAT_OFFSET(inode_size)     NILFS_SR_MDT_OFFSET(inode_size, 0)
125 #define NILFS_SR_CPFILE_OFFSET(inode_size)  NILFS_SR_MDT_OFFSET(inode_size, 1)
126 #define NILFS_SR_SUFILE_OFFSET(inode_size)  NILFS_SR_MDT_OFFSET(inode_size, 2)
127 #define NILFS_SR_BYTES                  (sizeof(struct nilfs_super_root))
128
129 /*
130  * Maximal mount counts
131  */
132 #define NILFS_DFL_MAX_MNT_COUNT         50      /* 50 mounts */
133
134 /*
135  * File system states (sbp->s_state, nilfs->ns_mount_state)
136  */
137 #define NILFS_VALID_FS                  0x0001  /* Unmounted cleanly */
138 #define NILFS_ERROR_FS                  0x0002  /* Errors detected */
139 #define NILFS_RESIZE_FS                 0x0004  /* Resize required */
140
141 /*
142  * Mount flags (sbi->s_mount_opt)
143  */
144 #define NILFS_MOUNT_ERROR_MODE          0x0070  /* Error mode mask */
145 #define NILFS_MOUNT_ERRORS_CONT         0x0010  /* Continue on errors */
146 #define NILFS_MOUNT_ERRORS_RO           0x0020  /* Remount fs ro on errors */
147 #define NILFS_MOUNT_ERRORS_PANIC        0x0040  /* Panic on errors */
148 #define NILFS_MOUNT_SNAPSHOT            0x0080  /* Snapshot flag */
149 #define NILFS_MOUNT_BARRIER             0x1000  /* Use block barriers */
150 #define NILFS_MOUNT_STRICT_ORDER        0x2000  /* Apply strict in-order
151                                                    semantics also for data */
152
153
154 /**
155  * struct nilfs_super_block - structure of super block on disk
156  */
157 struct nilfs_super_block {
158         __le32  s_rev_level;            /* Revision level */
159         __le16  s_minor_rev_level;      /* minor revision level */
160         __le16  s_magic;                /* Magic signature */
161
162         __le16  s_bytes;                /* Bytes count of CRC calculation
163                                            for this structure. s_reserved
164                                            is excluded. */
165         __le16  s_flags;                /* flags */
166         __le32  s_crc_seed;             /* Seed value of CRC calculation */
167         __le32  s_sum;                  /* Check sum of super block */
168
169         __le32  s_log_block_size;       /* Block size represented as follows
170                                            blocksize =
171                                                1 << (s_log_block_size + 10) */
172         __le64  s_nsegments;            /* Number of segments in filesystem */
173         __le64  s_dev_size;             /* block device size in bytes */
174         __le64  s_first_data_block;     /* 1st seg disk block number */
175         __le32  s_blocks_per_segment;   /* number of blocks per full segment */
176         __le32  s_r_segments_percentage; /* Reserved segments percentage */
177
178         __le64  s_last_cno;             /* Last checkpoint number */
179         __le64  s_last_pseg;            /* disk block addr pseg written last */
180         __le64  s_last_seq;             /* seq. number of seg written last */
181         __le64  s_free_blocks_count;    /* Free blocks count */
182
183         __le64  s_ctime;                /* Creation time (execution time of
184                                            newfs) */
185         __le64  s_mtime;                /* Mount time */
186         __le64  s_wtime;                /* Write time */
187         __le16  s_mnt_count;            /* Mount count */
188         __le16  s_max_mnt_count;        /* Maximal mount count */
189         __le16  s_state;                /* File system state */
190         __le16  s_errors;               /* Behaviour when detecting errors */
191         __le64  s_lastcheck;            /* time of last check */
192
193         __le32  s_checkinterval;        /* max. time between checks */
194         __le32  s_creator_os;           /* OS */
195         __le16  s_def_resuid;           /* Default uid for reserved blocks */
196         __le16  s_def_resgid;           /* Default gid for reserved blocks */
197         __le32  s_first_ino;            /* First non-reserved inode */
198
199         __le16  s_inode_size;           /* Size of an inode */
200         __le16  s_dat_entry_size;       /* Size of a dat entry */
201         __le16  s_checkpoint_size;      /* Size of a checkpoint */
202         __le16  s_segment_usage_size;   /* Size of a segment usage */
203
204         __u8    s_uuid[16];             /* 128-bit uuid for volume */
205         char    s_volume_name[16];      /* volume name */
206         char    s_last_mounted[64];     /* directory where last mounted */
207
208         __le32  s_c_interval;           /* Commit interval of segment */
209         __le32  s_c_block_max;          /* Threshold of data amount for
210                                            the segment construction */
211         __u32   s_reserved[192];        /* padding to the end of the block */
212 };
213
214 /*
215  * Codes for operating systems
216  */
217 #define NILFS_OS_LINUX          0
218 /* Codes from 1 to 4 are reserved to keep compatibility with ext2 creator-OS */
219
220 /*
221  * Revision levels
222  */
223 #define NILFS_CURRENT_REV       2       /* current major revision */
224 #define NILFS_MINOR_REV         0       /* minor revision */
225
226 /*
227  * Bytes count of super_block for CRC-calculation
228  */
229 #define NILFS_SB_BYTES  \
230         ((long)&((struct nilfs_super_block *)0)->s_reserved)
231
232 /*
233  * Special inode number
234  */
235 #define NILFS_ROOT_INO          2       /* Root file inode */
236 #define NILFS_DAT_INO           3       /* DAT file */
237 #define NILFS_CPFILE_INO        4       /* checkpoint file */
238 #define NILFS_SUFILE_INO        5       /* segment usage file */
239 #define NILFS_IFILE_INO         6       /* ifile */
240 #define NILFS_ATIME_INO         7       /* Atime file (reserved) */
241 #define NILFS_XATTR_INO         8       /* Xattribute file (reserved) */
242 #define NILFS_SKETCH_INO        10      /* Sketch file */
243 #define NILFS_USER_INO          11      /* Fisrt user's file inode number */
244
245 #define NILFS_SB_OFFSET_BYTES   1024    /* byte offset of nilfs superblock */
246 #define NILFS_SUPER_MAGIC       0x3434  /* NILFS filesystem  magic number */
247
248 #define NILFS_SEG_MIN_BLOCKS    16      /* Minimum number of blocks in
249                                            a full segment */
250 #define NILFS_PSEG_MIN_BLOCKS   2       /* Minimum number of blocks in
251                                            a partial segment */
252 #define NILFS_MIN_NRSVSEGS      8       /* Minimum number of reserved
253                                            segments */
254
255
256 /*
257  * Maximal count of links to a file
258  */
259 #define NILFS_LINK_MAX          32000
260
261 /*
262  * Structure of a directory entry
263  *  (Same as ext2)
264  */
265
266 #define NILFS_NAME_LEN 255
267
268 /*
269  * The new version of the directory entry.  Since V0 structures are
270  * stored in intel byte order, and the name_len field could never be
271  * bigger than 255 chars, it's safe to reclaim the extra byte for the
272  * file_type field.
273  */
274 struct nilfs_dir_entry {
275         __le64  inode;                  /* Inode number */
276         __le16  rec_len;                /* Directory entry length */
277         __u8    name_len;               /* Name length */
278         __u8    file_type;
279         char    name[NILFS_NAME_LEN];   /* File name */
280         char    pad;
281 };
282
283 /*
284  * NILFS directory file types.  Only the low 3 bits are used.  The
285  * other bits are reserved for now.
286  */
287 enum {
288         NILFS_FT_UNKNOWN,
289         NILFS_FT_REG_FILE,
290         NILFS_FT_DIR,
291         NILFS_FT_CHRDEV,
292         NILFS_FT_BLKDEV,
293         NILFS_FT_FIFO,
294         NILFS_FT_SOCK,
295         NILFS_FT_SYMLINK,
296         NILFS_FT_MAX
297 };
298
299 /*
300  * NILFS_DIR_PAD defines the directory entries boundaries
301  *
302  * NOTE: It must be a multiple of 8
303  */
304 #define NILFS_DIR_PAD                   8
305 #define NILFS_DIR_ROUND                 (NILFS_DIR_PAD - 1)
306 #define NILFS_DIR_REC_LEN(name_len)     (((name_len) + 12 + NILFS_DIR_ROUND) & \
307                                         ~NILFS_DIR_ROUND)
308
309
310 /**
311  * struct nilfs_finfo - file information
312  * @fi_ino: inode number
313  * @fi_cno: checkpoint number
314  * @fi_nblocks: number of blocks (including intermediate blocks)
315  * @fi_ndatablk: number of file data blocks
316  */
317 struct nilfs_finfo {
318         __le64 fi_ino;
319         __le64 fi_cno;
320         __le32 fi_nblocks;
321         __le32 fi_ndatablk;
322         /* array of virtual block numbers */
323 };
324
325 /**
326  * struct nilfs_binfo_v - information for the block to which a virtual block number is assigned
327  * @bi_vblocknr: virtual block number
328  * @bi_blkoff: block offset
329  */
330 struct nilfs_binfo_v {
331         __le64 bi_vblocknr;
332         __le64 bi_blkoff;
333 };
334
335 /**
336  * struct nilfs_binfo_dat - information for the block which belongs to the DAT file
337  * @bi_blkoff: block offset
338  * @bi_level: level
339  * @bi_pad: padding
340  */
341 struct nilfs_binfo_dat {
342         __le64 bi_blkoff;
343         __u8 bi_level;
344         __u8 bi_pad[7];
345 };
346
347 /**
348  * union nilfs_binfo: block information
349  * @bi_v: nilfs_binfo_v structure
350  * @bi_dat: nilfs_binfo_dat structure
351  */
352 union nilfs_binfo {
353         struct nilfs_binfo_v bi_v;
354         struct nilfs_binfo_dat bi_dat;
355 };
356
357 /**
358  * struct nilfs_segment_summary - segment summary
359  * @ss_datasum: checksum of data
360  * @ss_sumsum: checksum of segment summary
361  * @ss_magic: magic number
362  * @ss_bytes: size of this structure in bytes
363  * @ss_flags: flags
364  * @ss_seq: sequence number
365  * @ss_create: creation timestamp
366  * @ss_next: next segment
367  * @ss_nblocks: number of blocks
368  * @ss_nfinfo: number of finfo structures
369  * @ss_sumbytes: total size of segment summary in bytes
370  * @ss_pad: padding
371  */
372 struct nilfs_segment_summary {
373         __le32 ss_datasum;
374         __le32 ss_sumsum;
375         __le32 ss_magic;
376         __le16 ss_bytes;
377         __le16 ss_flags;
378         __le64 ss_seq;
379         __le64 ss_create;
380         __le64 ss_next;
381         __le32 ss_nblocks;
382         __le32 ss_nfinfo;
383         __le32 ss_sumbytes;
384         __le32 ss_pad;
385         /* array of finfo structures */
386 };
387
388 #define NILFS_SEGSUM_MAGIC      0x1eaffa11  /* segment summary magic number */
389
390 /*
391  * Segment summary flags
392  */
393 #define NILFS_SS_LOGBGN 0x0001  /* begins a logical segment */
394 #define NILFS_SS_LOGEND 0x0002  /* ends a logical segment */
395 #define NILFS_SS_SR     0x0004  /* has super root */
396 #define NILFS_SS_SYNDT  0x0008  /* includes data only updates */
397 #define NILFS_SS_GC     0x0010  /* segment written for cleaner operation */
398
399 /**
400  * struct nilfs_palloc_group_desc - block group descriptor
401  * @pg_nfrees: number of free entries in block group
402  */
403 struct nilfs_palloc_group_desc {
404         __le32 pg_nfrees;
405 };
406
407 /**
408  * struct nilfs_dat_entry - disk address translation entry
409  * @dt_blocknr: block number
410  * @dt_start: start checkpoint number
411  * @dt_end: end checkpoint number
412  * @dt_rsv: reserved for future use
413  */
414 struct nilfs_dat_entry {
415         __le64 de_blocknr;
416         __le64 de_start;
417         __le64 de_end;
418         __le64 de_rsv;
419 };
420
421 /**
422  * struct nilfs_dat_group_desc - block group descriptor
423  * @dg_nfrees: number of free virtual block numbers in block group
424  */
425 struct nilfs_dat_group_desc {
426         __le32 dg_nfrees;
427 };
428
429
430 /**
431  * struct nilfs_snapshot_list - snapshot list
432  * @ssl_next: next checkpoint number on snapshot list
433  * @ssl_prev: previous checkpoint number on snapshot list
434  */
435 struct nilfs_snapshot_list {
436         __le64 ssl_next;
437         __le64 ssl_prev;
438 };
439
440 /**
441  * struct nilfs_checkpoint - checkpoint structure
442  * @cp_flags: flags
443  * @cp_checkpoints_count: checkpoints count in a block
444  * @cp_snapshot_list: snapshot list
445  * @cp_cno: checkpoint number
446  * @cp_create: creation timestamp
447  * @cp_nblk_inc: number of blocks incremented by this checkpoint
448  * @cp_inodes_count: inodes count
449  * @cp_blocks_count: blocks count
450  * @cp_ifile_inode: inode of ifile
451  */
452 struct nilfs_checkpoint {
453         __le32 cp_flags;
454         __le32 cp_checkpoints_count;
455         struct nilfs_snapshot_list cp_snapshot_list;
456         __le64 cp_cno;
457         __le64 cp_create;
458         __le64 cp_nblk_inc;
459         __le64 cp_inodes_count;
460         __le64 cp_blocks_count;         /* Reserved (might be deleted) */
461
462         /* Do not change the byte offset of ifile inode.
463            To keep the compatibility of the disk format,
464            additional fields should be added behind cp_ifile_inode. */
465         struct nilfs_inode cp_ifile_inode;
466 };
467
468 /* checkpoint flags */
469 enum {
470         NILFS_CHECKPOINT_SNAPSHOT,
471         NILFS_CHECKPOINT_INVALID,
472         NILFS_CHECKPOINT_SKETCH,
473 };
474
475 #define NILFS_CHECKPOINT_FNS(flag, name)                                \
476 static inline void                                                      \
477 nilfs_checkpoint_set_##name(struct nilfs_checkpoint *cp)                \
478 {                                                                       \
479         cp->cp_flags = cpu_to_le32(le32_to_cpu(cp->cp_flags) |          \
480                                    (1UL << NILFS_CHECKPOINT_##flag));   \
481 }                                                                       \
482 static inline void                                                      \
483 nilfs_checkpoint_clear_##name(struct nilfs_checkpoint *cp)              \
484 {                                                                       \
485         cp->cp_flags = cpu_to_le32(le32_to_cpu(cp->cp_flags) &          \
486                                    ~(1UL << NILFS_CHECKPOINT_##flag));  \
487 }                                                                       \
488 static inline int                                                       \
489 nilfs_checkpoint_##name(const struct nilfs_checkpoint *cp)              \
490 {                                                                       \
491         return !!(le32_to_cpu(cp->cp_flags) &                           \
492                   (1UL << NILFS_CHECKPOINT_##flag));                    \
493 }
494
495 NILFS_CHECKPOINT_FNS(SNAPSHOT, snapshot)
496 NILFS_CHECKPOINT_FNS(INVALID, invalid)
497 NILFS_CHECKPOINT_FNS(SKETCH, sketch)
498
499 /**
500  * struct nilfs_cpinfo - checkpoint information
501  * @ci_flags: flags
502  * @ci_pad: padding
503  * @ci_cno: checkpoint number
504  * @ci_create: creation timestamp
505  * @ci_nblk_inc: number of blocks incremented by this checkpoint
506  * @ci_inodes_count: inodes count
507  * @ci_blocks_count: blocks count
508  * @ci_next: next checkpoint number in snapshot list
509  */
510 struct nilfs_cpinfo {
511         __u32 ci_flags;
512         __u32 ci_pad;
513         __u64 ci_cno;
514         __u64 ci_create;
515         __u64 ci_nblk_inc;
516         __u64 ci_inodes_count;
517         __u64 ci_blocks_count;
518         __u64 ci_next;
519 };
520
521 #define NILFS_CPINFO_FNS(flag, name)                                    \
522 static inline int                                                       \
523 nilfs_cpinfo_##name(const struct nilfs_cpinfo *cpinfo)                  \
524 {                                                                       \
525         return !!(cpinfo->ci_flags & (1UL << NILFS_CHECKPOINT_##flag)); \
526 }
527
528 NILFS_CPINFO_FNS(SNAPSHOT, snapshot)
529 NILFS_CPINFO_FNS(INVALID, invalid)
530 NILFS_CPINFO_FNS(SKETCH, sketch)
531
532
533 /**
534  * struct nilfs_cpfile_header - checkpoint file header
535  * @ch_ncheckpoints: number of checkpoints
536  * @ch_nsnapshots: number of snapshots
537  * @ch_snapshot_list: snapshot list
538  */
539 struct nilfs_cpfile_header {
540         __le64 ch_ncheckpoints;
541         __le64 ch_nsnapshots;
542         struct nilfs_snapshot_list ch_snapshot_list;
543 };
544
545 #define NILFS_CPFILE_FIRST_CHECKPOINT_OFFSET    \
546         ((sizeof(struct nilfs_cpfile_header) +                          \
547           sizeof(struct nilfs_checkpoint) - 1) /                        \
548                         sizeof(struct nilfs_checkpoint))
549
550 /**
551  * struct nilfs_segment_usage - segment usage
552  * @su_lastmod: last modified timestamp
553  * @su_nblocks: number of blocks in segment
554  * @su_flags: flags
555  */
556 struct nilfs_segment_usage {
557         __le64 su_lastmod;
558         __le32 su_nblocks;
559         __le32 su_flags;
560 };
561
562 /* segment usage flag */
563 enum {
564         NILFS_SEGMENT_USAGE_ACTIVE,
565         NILFS_SEGMENT_USAGE_DIRTY,
566         NILFS_SEGMENT_USAGE_ERROR,
567
568         /* ... */
569 };
570
571 #define NILFS_SEGMENT_USAGE_FNS(flag, name)                             \
572 static inline void                                                      \
573 nilfs_segment_usage_set_##name(struct nilfs_segment_usage *su)          \
574 {                                                                       \
575         su->su_flags = cpu_to_le32(le32_to_cpu(su->su_flags) |          \
576                                    (1UL << NILFS_SEGMENT_USAGE_##flag));\
577 }                                                                       \
578 static inline void                                                      \
579 nilfs_segment_usage_clear_##name(struct nilfs_segment_usage *su)        \
580 {                                                                       \
581         su->su_flags =                                                  \
582                 cpu_to_le32(le32_to_cpu(su->su_flags) &                 \
583                             ~(1UL << NILFS_SEGMENT_USAGE_##flag));      \
584 }                                                                       \
585 static inline int                                                       \
586 nilfs_segment_usage_##name(const struct nilfs_segment_usage *su)        \
587 {                                                                       \
588         return !!(le32_to_cpu(su->su_flags) &                           \
589                   (1UL << NILFS_SEGMENT_USAGE_##flag));                 \
590 }
591
592 NILFS_SEGMENT_USAGE_FNS(ACTIVE, active)
593 NILFS_SEGMENT_USAGE_FNS(DIRTY, dirty)
594 NILFS_SEGMENT_USAGE_FNS(ERROR, error)
595
596 static inline void
597 nilfs_segment_usage_set_clean(struct nilfs_segment_usage *su)
598 {
599         su->su_lastmod = cpu_to_le64(0);
600         su->su_nblocks = cpu_to_le32(0);
601         su->su_flags = cpu_to_le32(0);
602 }
603
604 static inline int
605 nilfs_segment_usage_clean(const struct nilfs_segment_usage *su)
606 {
607         return !le32_to_cpu(su->su_flags);
608 }
609
610 /**
611  * struct nilfs_sufile_header - segment usage file header
612  * @sh_ncleansegs: number of clean segments
613  * @sh_ndirtysegs: number of dirty segments
614  * @sh_last_alloc: last allocated segment number
615  */
616 struct nilfs_sufile_header {
617         __le64 sh_ncleansegs;
618         __le64 sh_ndirtysegs;
619         __le64 sh_last_alloc;
620         /* ... */
621 };
622
623 #define NILFS_SUFILE_FIRST_SEGMENT_USAGE_OFFSET \
624         ((sizeof(struct nilfs_sufile_header) +                          \
625           sizeof(struct nilfs_segment_usage) - 1) /                     \
626                          sizeof(struct nilfs_segment_usage))
627
628 /**
629  * nilfs_suinfo - segment usage information
630  * @sui_lastmod:
631  * @sui_nblocks:
632  * @sui_flags:
633  */
634 struct nilfs_suinfo {
635         __u64 sui_lastmod;
636         __u32 sui_nblocks;
637         __u32 sui_flags;
638 };
639
640 #define NILFS_SUINFO_FNS(flag, name)                                    \
641 static inline int                                                       \
642 nilfs_suinfo_##name(const struct nilfs_suinfo *si)                      \
643 {                                                                       \
644         return si->sui_flags & (1UL << NILFS_SEGMENT_USAGE_##flag);     \
645 }
646
647 NILFS_SUINFO_FNS(ACTIVE, active)
648 NILFS_SUINFO_FNS(DIRTY, dirty)
649 NILFS_SUINFO_FNS(ERROR, error)
650
651 static inline int nilfs_suinfo_clean(const struct nilfs_suinfo *si)
652 {
653         return !si->sui_flags;
654 }
655
656 /* ioctl */
657 enum {
658         NILFS_CHECKPOINT,
659         NILFS_SNAPSHOT,
660 };
661
662 /**
663  * struct nilfs_cpmode -
664  * @cc_cno:
665  * @cc_mode:
666  */
667 struct nilfs_cpmode {
668         __u64 cm_cno;
669         __u32 cm_mode;
670         __u32 cm_pad;
671 };
672
673 /**
674  * struct nilfs_argv - argument vector
675  * @v_base:
676  * @v_nmembs:
677  * @v_size:
678  * @v_flags:
679  * @v_index:
680  */
681 struct nilfs_argv {
682         __u64 v_base;
683         __u32 v_nmembs; /* number of members */
684         __u16 v_size;   /* size of members */
685         __u16 v_flags;
686         __u64 v_index;
687 };
688
689 /**
690  * struct nilfs_period -
691  * @p_start:
692  * @p_end:
693  */
694 struct nilfs_period {
695         __u64 p_start;
696         __u64 p_end;
697 };
698
699 /**
700  * struct nilfs_cpstat -
701  * @cs_cno: checkpoint number
702  * @cs_ncps: number of checkpoints
703  * @cs_nsss: number of snapshots
704  */
705 struct nilfs_cpstat {
706         __u64 cs_cno;
707         __u64 cs_ncps;
708         __u64 cs_nsss;
709 };
710
711 /**
712  * struct nilfs_sustat -
713  * @ss_nsegs: number of segments
714  * @ss_ncleansegs: number of clean segments
715  * @ss_ndirtysegs: number of dirty segments
716  * @ss_ctime: creation time of the last segment
717  * @ss_nongc_ctime: creation time of the last segment not for GC
718  * @ss_prot_seq: least sequence number of segments which must not be reclaimed
719  */
720 struct nilfs_sustat {
721         __u64 ss_nsegs;
722         __u64 ss_ncleansegs;
723         __u64 ss_ndirtysegs;
724         __u64 ss_ctime;
725         __u64 ss_nongc_ctime;
726         __u64 ss_prot_seq;
727 };
728
729 /**
730  * struct nilfs_vinfo - virtual block number information
731  * @vi_vblocknr:
732  * @vi_start:
733  * @vi_end:
734  * @vi_blocknr:
735  */
736 struct nilfs_vinfo {
737         __u64 vi_vblocknr;
738         __u64 vi_start;
739         __u64 vi_end;
740         __u64 vi_blocknr;
741 };
742
743 /**
744  * struct nilfs_vdesc -
745  */
746 struct nilfs_vdesc {
747         __u64 vd_ino;
748         __u64 vd_cno;
749         __u64 vd_vblocknr;
750         struct nilfs_period vd_period;
751         __u64 vd_blocknr;
752         __u64 vd_offset;
753         __u32 vd_flags;
754         __u32 vd_pad;
755 };
756
757 /**
758  * struct nilfs_bdesc -
759  */
760 struct nilfs_bdesc {
761         __u64 bd_ino;
762         __u64 bd_oblocknr;
763         __u64 bd_blocknr;
764         __u64 bd_offset;
765         __u32 bd_level;
766         __u32 bd_pad;
767 };
768
769 #define NILFS_IOCTL_IDENT               'n'
770
771 #define NILFS_IOCTL_CHANGE_CPMODE  \
772         _IOW(NILFS_IOCTL_IDENT, 0x80, struct nilfs_cpmode)
773 #define NILFS_IOCTL_DELETE_CHECKPOINT  \
774         _IOW(NILFS_IOCTL_IDENT, 0x81, __u64)
775 #define NILFS_IOCTL_GET_CPINFO  \
776         _IOR(NILFS_IOCTL_IDENT, 0x82, struct nilfs_argv)
777 #define NILFS_IOCTL_GET_CPSTAT  \
778         _IOR(NILFS_IOCTL_IDENT, 0x83, struct nilfs_cpstat)
779 #define NILFS_IOCTL_GET_SUINFO  \
780         _IOR(NILFS_IOCTL_IDENT, 0x84, struct nilfs_argv)
781 #define NILFS_IOCTL_GET_SUSTAT  \
782         _IOR(NILFS_IOCTL_IDENT, 0x85, struct nilfs_sustat)
783 #define NILFS_IOCTL_GET_VINFO  \
784         _IOWR(NILFS_IOCTL_IDENT, 0x86, struct nilfs_argv)
785 #define NILFS_IOCTL_GET_BDESCS  \
786         _IOWR(NILFS_IOCTL_IDENT, 0x87, struct nilfs_argv)
787 #define NILFS_IOCTL_CLEAN_SEGMENTS  \
788         _IOW(NILFS_IOCTL_IDENT, 0x88, struct nilfs_argv[5])
789 #define NILFS_IOCTL_SYNC  \
790         _IOR(NILFS_IOCTL_IDENT, 0x8A, __u64)
791 #define NILFS_IOCTL_RESIZE  \
792         _IOW(NILFS_IOCTL_IDENT, 0x8B, __u64)
793
794 #endif  /* _LINUX_NILFS_FS_H */