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 Lesser General Public License as published 8 * by the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser 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#include <linux/magic.h> 44#include <linux/bug.h> 45 46 47#define NILFS_INODE_BMAP_SIZE 7 48/** 49 * struct nilfs_inode - structure of an inode on disk 50 * @i_blocks: blocks count 51 * @i_size: size in bytes 52 * @i_ctime: creation time (seconds) 53 * @i_mtime: modification time (seconds) 54 * @i_ctime_nsec: creation time (nano seconds) 55 * @i_mtime_nsec: modification time (nano seconds) 56 * @i_uid: user id 57 * @i_gid: group id 58 * @i_mode: file mode 59 * @i_links_count: links count 60 * @i_flags: file flags 61 * @i_bmap: block mapping 62 * @i_xattr: extended attributes 63 * @i_generation: file generation (for NFS) 64 * @i_pad: padding 65 */ 66struct nilfs_inode { 67 __le64 i_blocks; 68 __le64 i_size; 69 __le64 i_ctime; 70 __le64 i_mtime; 71 __le32 i_ctime_nsec; 72 __le32 i_mtime_nsec; 73 __le32 i_uid; 74 __le32 i_gid; 75 __le16 i_mode; 76 __le16 i_links_count; 77 __le32 i_flags; 78 __le64 i_bmap[NILFS_INODE_BMAP_SIZE]; 79#define i_device_code i_bmap[0] 80 __le64 i_xattr; 81 __le32 i_generation; 82 __le32 i_pad; 83}; 84 85#define NILFS_MIN_INODE_SIZE 128 86 87/** 88 * struct nilfs_super_root - structure of super root 89 * @sr_sum: check sum 90 * @sr_bytes: byte count of the structure 91 * @sr_flags: flags (reserved) 92 * @sr_nongc_ctime: write time of the last segment not for cleaner operation 93 * @sr_dat: DAT file inode 94 * @sr_cpfile: checkpoint file inode 95 * @sr_sufile: segment usage file inode 96 */ 97struct nilfs_super_root { 98 __le32 sr_sum; 99 __le16 sr_bytes; 100 __le16 sr_flags; 101 __le64 sr_nongc_ctime; 102 struct nilfs_inode sr_dat; 103 struct nilfs_inode sr_cpfile; 104 struct nilfs_inode sr_sufile; 105}; 106 107#define NILFS_SR_MDT_OFFSET(inode_size, i) \ 108 ((unsigned long)&((struct nilfs_super_root *)0)->sr_dat + \ 109 (inode_size) * (i)) 110#define NILFS_SR_DAT_OFFSET(inode_size) NILFS_SR_MDT_OFFSET(inode_size, 0) 111#define NILFS_SR_CPFILE_OFFSET(inode_size) NILFS_SR_MDT_OFFSET(inode_size, 1) 112#define NILFS_SR_SUFILE_OFFSET(inode_size) NILFS_SR_MDT_OFFSET(inode_size, 2) 113#define NILFS_SR_BYTES(inode_size) NILFS_SR_MDT_OFFSET(inode_size, 3) 114 115/* 116 * Maximal mount counts 117 */ 118#define NILFS_DFL_MAX_MNT_COUNT 50 /* 50 mounts */ 119 120/* 121 * File system states (sbp->s_state, nilfs->ns_mount_state) 122 */ 123#define NILFS_VALID_FS 0x0001 /* Unmounted cleanly */ 124#define NILFS_ERROR_FS 0x0002 /* Errors detected */ 125#define NILFS_RESIZE_FS 0x0004 /* Resize required */ 126 127/* 128 * Mount flags (sbi->s_mount_opt) 129 */ 130#define NILFS_MOUNT_ERROR_MODE 0x0070 /* Error mode mask */ 131#define NILFS_MOUNT_ERRORS_CONT 0x0010 /* Continue on errors */ 132#define NILFS_MOUNT_ERRORS_RO 0x0020 /* Remount fs ro on errors */ 133#define NILFS_MOUNT_ERRORS_PANIC 0x0040 /* Panic on errors */ 134#define NILFS_MOUNT_BARRIER 0x1000 /* Use block barriers */ 135#define NILFS_MOUNT_STRICT_ORDER 0x2000 /* Apply strict in-order 136 semantics also for data */ 137#define NILFS_MOUNT_NORECOVERY 0x4000 /* Disable write access during 138 mount-time recovery */ 139#define NILFS_MOUNT_DISCARD 0x8000 /* Issue DISCARD requests */ 140 141 142/** 143 * struct nilfs_super_block - structure of super block on disk 144 */ 145struct nilfs_super_block { 146/*00*/ __le32 s_rev_level; /* Revision level */ 147 __le16 s_minor_rev_level; /* minor revision level */ 148 __le16 s_magic; /* Magic signature */ 149 150 __le16 s_bytes; /* Bytes count of CRC calculation 151 for this structure. s_reserved 152 is excluded. */ 153 __le16 s_flags; /* flags */ 154 __le32 s_crc_seed; /* Seed value of CRC calculation */ 155/*10*/ __le32 s_sum; /* Check sum of super block */ 156 157 __le32 s_log_block_size; /* Block size represented as follows 158 blocksize = 159 1 << (s_log_block_size + 10) */ 160 __le64 s_nsegments; /* Number of segments in filesystem */ 161/*20*/ __le64 s_dev_size; /* block device size in bytes */ 162 __le64 s_first_data_block; /* 1st seg disk block number */ 163/*30*/ __le32 s_blocks_per_segment; /* number of blocks per full segment */ 164 __le32 s_r_segments_percentage; /* Reserved segments percentage */ 165 166 __le64 s_last_cno; /* Last checkpoint number */ 167/*40*/ __le64 s_last_pseg; /* disk block addr pseg written last */ 168 __le64 s_last_seq; /* seq. number of seg written last */ 169/*50*/ __le64 s_free_blocks_count; /* Free blocks count */ 170 171 __le64 s_ctime; /* Creation time (execution time of 172 newfs) */ 173/*60*/ __le64 s_mtime; /* Mount time */ 174 __le64 s_wtime; /* Write time */ 175/*70*/ __le16 s_mnt_count; /* Mount count */ 176 __le16 s_max_mnt_count; /* Maximal mount count */ 177 __le16 s_state; /* File system state */ 178 __le16 s_errors; /* Behaviour when detecting errors */ 179 __le64 s_lastcheck; /* time of last check */ 180 181/*80*/ __le32 s_checkinterval; /* max. time between checks */ 182 __le32 s_creator_os; /* OS */ 183 __le16 s_def_resuid; /* Default uid for reserved blocks */ 184 __le16 s_def_resgid; /* Default gid for reserved blocks */ 185 __le32 s_first_ino; /* First non-reserved inode */ 186 187/*90*/ __le16 s_inode_size; /* Size of an inode */ 188 __le16 s_dat_entry_size; /* Size of a dat entry */ 189 __le16 s_checkpoint_size; /* Size of a checkpoint */ 190 __le16 s_segment_usage_size; /* Size of a segment usage */ 191 192/*98*/ __u8 s_uuid[16]; /* 128-bit uuid for volume */ 193/*A8*/ char s_volume_name[80]; /* volume name */ 194 195/*F8*/ __le32 s_c_interval; /* Commit interval of segment */ 196 __le32 s_c_block_max; /* Threshold of data amount for 197 the segment construction */ 198/*100*/ __le64 s_feature_compat; /* Compatible feature set */ 199 __le64 s_feature_compat_ro; /* Read-only compatible feature set */ 200 __le64 s_feature_incompat; /* Incompatible feature set */ 201 __u32 s_reserved[186]; /* padding to the end of the block */ 202}; 203 204/* 205 * Codes for operating systems 206 */ 207#define NILFS_OS_LINUX 0 208/* Codes from 1 to 4 are reserved to keep compatibility with ext2 creator-OS */ 209 210/* 211 * Revision levels 212 */ 213#define NILFS_CURRENT_REV 2 /* current major revision */ 214#define NILFS_MINOR_REV 0 /* minor revision */ 215#define NILFS_MIN_SUPP_REV 2 /* minimum supported revision */ 216 217/* 218 * Feature set definitions 219 * 220 * If there is a bit set in the incompatible feature set that the kernel 221 * doesn't know about, it should refuse to mount the filesystem. 222 */ 223#define NILFS_FEATURE_COMPAT_RO_BLOCK_COUNT 0x00000001ULL 224 225#define NILFS_FEATURE_COMPAT_SUPP 0ULL 226#define NILFS_FEATURE_COMPAT_RO_SUPP NILFS_FEATURE_COMPAT_RO_BLOCK_COUNT 227#define NILFS_FEATURE_INCOMPAT_SUPP 0ULL 228 229/* 230 * Bytes count of super_block for CRC-calculation 231 */ 232#define NILFS_SB_BYTES \ 233 ((long)&((struct nilfs_super_block *)0)->s_reserved) 234 235/* 236 * Special inode number 237 */ 238#define NILFS_ROOT_INO 2 /* Root file inode */ 239#define NILFS_DAT_INO 3 /* DAT file */ 240#define NILFS_CPFILE_INO 4 /* checkpoint file */ 241#define NILFS_SUFILE_INO 5 /* segment usage file */ 242#define NILFS_IFILE_INO 6 /* ifile */ 243#define NILFS_ATIME_INO 7 /* Atime file (reserved) */ 244#define NILFS_XATTR_INO 8 /* Xattribute file (reserved) */ 245#define NILFS_SKETCH_INO 10 /* Sketch file */ 246#define NILFS_USER_INO 11 /* Fisrt user's file inode number */ 247 248#define NILFS_SB_OFFSET_BYTES 1024 /* byte offset of nilfs superblock */ 249 250#define NILFS_SEG_MIN_BLOCKS 16 /* Minimum number of blocks in 251 a full segment */ 252#define NILFS_PSEG_MIN_BLOCKS 2 /* Minimum number of blocks in 253 a partial segment */ 254#define NILFS_MIN_NRSVSEGS 8 /* Minimum number of reserved 255 segments */ 256 257/* 258 * We call DAT, cpfile, and sufile root metadata files. Inodes of 259 * these files are written in super root block instead of ifile, and 260 * garbage collector doesn't keep any past versions of these files. 261 */ 262#define NILFS_ROOT_METADATA_FILE(ino) \ 263 ((ino) >= NILFS_DAT_INO && (ino) <= NILFS_SUFILE_INO) 264 265/* 266 * bytes offset of secondary super block 267 */ 268#define NILFS_SB2_OFFSET_BYTES(devsize) ((((devsize) >> 12) - 1) << 12) 269 270/* 271 * Maximal count of links to a file 272 */ 273#define NILFS_LINK_MAX 32000 274 275/* 276 * Structure of a directory entry 277 * (Same as ext2) 278 */ 279 280#define NILFS_NAME_LEN 255 281 282/* 283 * Block size limitations 284 */ 285#define NILFS_MIN_BLOCK_SIZE 1024 286#define NILFS_MAX_BLOCK_SIZE 65536 287 288/* 289 * The new version of the directory entry. Since V0 structures are 290 * stored in intel byte order, and the name_len field could never be 291 * bigger than 255 chars, it's safe to reclaim the extra byte for the 292 * file_type field. 293 */ 294struct nilfs_dir_entry { 295 __le64 inode; /* Inode number */ 296 __le16 rec_len; /* Directory entry length */ 297 __u8 name_len; /* Name length */ 298 __u8 file_type; /* Dir entry type (file, dir, etc) */ 299 char name[NILFS_NAME_LEN]; /* File name */ 300 char pad; 301}; 302 303/* 304 * NILFS directory file types. Only the low 3 bits are used. The 305 * other bits are reserved for now. 306 */ 307enum { 308 NILFS_FT_UNKNOWN, 309 NILFS_FT_REG_FILE, 310 NILFS_FT_DIR, 311 NILFS_FT_CHRDEV, 312 NILFS_FT_BLKDEV, 313 NILFS_FT_FIFO, 314 NILFS_FT_SOCK, 315 NILFS_FT_SYMLINK, 316 NILFS_FT_MAX 317}; 318 319/* 320 * NILFS_DIR_PAD defines the directory entries boundaries 321 * 322 * NOTE: It must be a multiple of 8 323 */ 324#define NILFS_DIR_PAD 8 325#define NILFS_DIR_ROUND (NILFS_DIR_PAD - 1) 326#define NILFS_DIR_REC_LEN(name_len) (((name_len) + 12 + NILFS_DIR_ROUND) & \ 327 ~NILFS_DIR_ROUND) 328#define NILFS_MAX_REC_LEN ((1<<16)-1) 329 330static inline unsigned nilfs_rec_len_from_disk(__le16 dlen) 331{ 332 unsigned len = le16_to_cpu(dlen); 333 334#if !defined(__KERNEL__) || (PAGE_CACHE_SIZE >= 65536) 335 if (len == NILFS_MAX_REC_LEN) 336 return 1 << 16; 337#endif 338 return len; 339} 340 341static inline __le16 nilfs_rec_len_to_disk(unsigned len) 342{ 343#if !defined(__KERNEL__) || (PAGE_CACHE_SIZE >= 65536) 344 if (len == (1 << 16)) 345 return cpu_to_le16(NILFS_MAX_REC_LEN); 346 else if (len > (1 << 16)) 347 BUG(); 348#endif 349 return cpu_to_le16(len); 350} 351 352/** 353 * struct nilfs_finfo - file information 354 * @fi_ino: inode number 355 * @fi_cno: checkpoint number 356 * @fi_nblocks: number of blocks (including intermediate blocks) 357 * @fi_ndatablk: number of file data blocks 358 */ 359struct nilfs_finfo { 360 __le64 fi_ino; 361 __le64 fi_cno; 362 __le32 fi_nblocks; 363 __le32 fi_ndatablk; 364 /* array of virtual block numbers */ 365}; 366 367/** 368 * struct nilfs_binfo_v - information for the block to which a virtual block number is assigned 369 * @bi_vblocknr: virtual block number 370 * @bi_blkoff: block offset 371 */ 372struct nilfs_binfo_v { 373 __le64 bi_vblocknr; 374 __le64 bi_blkoff; 375}; 376 377/** 378 * struct nilfs_binfo_dat - information for the block which belongs to the DAT file 379 * @bi_blkoff: block offset 380 * @bi_level: level 381 * @bi_pad: padding 382 */ 383struct nilfs_binfo_dat { 384 __le64 bi_blkoff; 385 __u8 bi_level; 386 __u8 bi_pad[7]; 387}; 388 389/** 390 * union nilfs_binfo: block information 391 * @bi_v: nilfs_binfo_v structure 392 * @bi_dat: nilfs_binfo_dat structure 393 */ 394union nilfs_binfo { 395 struct nilfs_binfo_v bi_v; 396 struct nilfs_binfo_dat bi_dat; 397}; 398 399/** 400 * struct nilfs_segment_summary - segment summary header 401 * @ss_datasum: checksum of data 402 * @ss_sumsum: checksum of segment summary 403 * @ss_magic: magic number 404 * @ss_bytes: size of this structure in bytes 405 * @ss_flags: flags 406 * @ss_seq: sequence number 407 * @ss_create: creation timestamp 408 * @ss_next: next segment 409 * @ss_nblocks: number of blocks 410 * @ss_nfinfo: number of finfo structures 411 * @ss_sumbytes: total size of segment summary in bytes 412 * @ss_pad: padding 413 * @ss_cno: checkpoint number 414 */ 415struct nilfs_segment_summary { 416 __le32 ss_datasum; 417 __le32 ss_sumsum; 418 __le32 ss_magic; 419 __le16 ss_bytes; 420 __le16 ss_flags; 421 __le64 ss_seq; 422 __le64 ss_create; 423 __le64 ss_next; 424 __le32 ss_nblocks; 425 __le32 ss_nfinfo; 426 __le32 ss_sumbytes; 427 __le32 ss_pad; 428 __le64 ss_cno; 429 /* array of finfo structures */ 430}; 431 432#define NILFS_SEGSUM_MAGIC 0x1eaffa11 /* segment summary magic number */ 433 434/* 435 * Segment summary flags 436 */ 437#define NILFS_SS_LOGBGN 0x0001 /* begins a logical segment */ 438#define NILFS_SS_LOGEND 0x0002 /* ends a logical segment */ 439#define NILFS_SS_SR 0x0004 /* has super root */ 440#define NILFS_SS_SYNDT 0x0008 /* includes data only updates */ 441#define NILFS_SS_GC 0x0010 /* segment written for cleaner operation */ 442 443/** 444 * struct nilfs_btree_node - B-tree node 445 * @bn_flags: flags 446 * @bn_level: level 447 * @bn_nchildren: number of children 448 * @bn_pad: padding 449 */ 450struct nilfs_btree_node { 451 __u8 bn_flags; 452 __u8 bn_level; 453 __le16 bn_nchildren; 454 __le32 bn_pad; 455}; 456 457/* flags */ 458#define NILFS_BTREE_NODE_ROOT 0x01 459 460/* level */ 461#define NILFS_BTREE_LEVEL_DATA 0 462#define NILFS_BTREE_LEVEL_NODE_MIN (NILFS_BTREE_LEVEL_DATA + 1) 463#define NILFS_BTREE_LEVEL_MAX 14 /* Max level (exclusive) */ 464 465/** 466 * struct nilfs_palloc_group_desc - block group descriptor 467 * @pg_nfrees: number of free entries in block group 468 */ 469struct nilfs_palloc_group_desc { 470 __le32 pg_nfrees; 471}; 472 473/** 474 * struct nilfs_dat_entry - disk address translation entry 475 * @de_blocknr: block number 476 * @de_start: start checkpoint number 477 * @de_end: end checkpoint number 478 * @de_rsv: reserved for future use 479 */ 480struct nilfs_dat_entry { 481 __le64 de_blocknr; 482 __le64 de_start; 483 __le64 de_end; 484 __le64 de_rsv; 485}; 486 487#define NILFS_MIN_DAT_ENTRY_SIZE 32 488 489/** 490 * struct nilfs_snapshot_list - snapshot list 491 * @ssl_next: next checkpoint number on snapshot list 492 * @ssl_prev: previous checkpoint number on snapshot list 493 */ 494struct nilfs_snapshot_list { 495 __le64 ssl_next; 496 __le64 ssl_prev; 497}; 498 499/** 500 * struct nilfs_checkpoint - checkpoint structure 501 * @cp_flags: flags 502 * @cp_checkpoints_count: checkpoints count in a block 503 * @cp_snapshot_list: snapshot list 504 * @cp_cno: checkpoint number 505 * @cp_create: creation timestamp 506 * @cp_nblk_inc: number of blocks incremented by this checkpoint 507 * @cp_inodes_count: inodes count 508 * @cp_blocks_count: blocks count 509 * @cp_ifile_inode: inode of ifile 510 */ 511struct nilfs_checkpoint { 512 __le32 cp_flags; 513 __le32 cp_checkpoints_count; 514 struct nilfs_snapshot_list cp_snapshot_list; 515 __le64 cp_cno; 516 __le64 cp_create; 517 __le64 cp_nblk_inc; 518 __le64 cp_inodes_count; 519 __le64 cp_blocks_count; 520 521 /* Do not change the byte offset of ifile inode. 522 To keep the compatibility of the disk format, 523 additional fields should be added behind cp_ifile_inode. */ 524 struct nilfs_inode cp_ifile_inode; 525}; 526 527#define NILFS_MIN_CHECKPOINT_SIZE (64 + NILFS_MIN_INODE_SIZE) 528 529/* checkpoint flags */ 530enum { 531 NILFS_CHECKPOINT_SNAPSHOT, 532 NILFS_CHECKPOINT_INVALID, 533 NILFS_CHECKPOINT_SKETCH, 534 NILFS_CHECKPOINT_MINOR, 535}; 536 537#define NILFS_CHECKPOINT_FNS(flag, name) \ 538static inline void \ 539nilfs_checkpoint_set_##name(struct nilfs_checkpoint *cp) \ 540{ \ 541 cp->cp_flags = cpu_to_le32(le32_to_cpu(cp->cp_flags) | \ 542 (1UL << NILFS_CHECKPOINT_##flag)); \ 543} \ 544static inline void \ 545nilfs_checkpoint_clear_##name(struct nilfs_checkpoint *cp) \ 546{ \ 547 cp->cp_flags = cpu_to_le32(le32_to_cpu(cp->cp_flags) & \ 548 ~(1UL << NILFS_CHECKPOINT_##flag)); \ 549} \ 550static inline int \ 551nilfs_checkpoint_##name(const struct nilfs_checkpoint *cp) \ 552{ \ 553 return !!(le32_to_cpu(cp->cp_flags) & \ 554 (1UL << NILFS_CHECKPOINT_##flag)); \ 555} 556 557NILFS_CHECKPOINT_FNS(SNAPSHOT, snapshot) 558NILFS_CHECKPOINT_FNS(INVALID, invalid) 559NILFS_CHECKPOINT_FNS(MINOR, minor) 560 561/** 562 * struct nilfs_cpinfo - checkpoint information 563 * @ci_flags: flags 564 * @ci_pad: padding 565 * @ci_cno: checkpoint number 566 * @ci_create: creation timestamp 567 * @ci_nblk_inc: number of blocks incremented by this checkpoint 568 * @ci_inodes_count: inodes count 569 * @ci_blocks_count: blocks count 570 * @ci_next: next checkpoint number in snapshot list 571 */ 572struct nilfs_cpinfo { 573 __u32 ci_flags; 574 __u32 ci_pad; 575 __u64 ci_cno; 576 __u64 ci_create; 577 __u64 ci_nblk_inc; 578 __u64 ci_inodes_count; 579 __u64 ci_blocks_count; 580 __u64 ci_next; 581}; 582 583#define NILFS_CPINFO_FNS(flag, name) \ 584static inline int \ 585nilfs_cpinfo_##name(const struct nilfs_cpinfo *cpinfo) \ 586{ \ 587 return !!(cpinfo->ci_flags & (1UL << NILFS_CHECKPOINT_##flag)); \ 588} 589 590NILFS_CPINFO_FNS(SNAPSHOT, snapshot) 591NILFS_CPINFO_FNS(INVALID, invalid) 592NILFS_CPINFO_FNS(MINOR, minor) 593 594 595/** 596 * struct nilfs_cpfile_header - checkpoint file header 597 * @ch_ncheckpoints: number of checkpoints 598 * @ch_nsnapshots: number of snapshots 599 * @ch_snapshot_list: snapshot list 600 */ 601struct nilfs_cpfile_header { 602 __le64 ch_ncheckpoints; 603 __le64 ch_nsnapshots; 604 struct nilfs_snapshot_list ch_snapshot_list; 605}; 606 607#define NILFS_CPFILE_FIRST_CHECKPOINT_OFFSET \ 608 ((sizeof(struct nilfs_cpfile_header) + \ 609 sizeof(struct nilfs_checkpoint) - 1) / \ 610 sizeof(struct nilfs_checkpoint)) 611 612/** 613 * struct nilfs_segment_usage - segment usage 614 * @su_lastmod: last modified timestamp 615 * @su_nblocks: number of blocks in segment 616 * @su_flags: flags 617 */ 618struct nilfs_segment_usage { 619 __le64 su_lastmod; 620 __le32 su_nblocks; 621 __le32 su_flags; 622}; 623 624#define NILFS_MIN_SEGMENT_USAGE_SIZE 16 625 626/* segment usage flag */ 627enum { 628 NILFS_SEGMENT_USAGE_ACTIVE, 629 NILFS_SEGMENT_USAGE_DIRTY, 630 NILFS_SEGMENT_USAGE_ERROR, 631 632 /* ... */ 633}; 634 635#define NILFS_SEGMENT_USAGE_FNS(flag, name) \ 636static inline void \ 637nilfs_segment_usage_set_##name(struct nilfs_segment_usage *su) \ 638{ \ 639 su->su_flags = cpu_to_le32(le32_to_cpu(su->su_flags) | \ 640 (1UL << NILFS_SEGMENT_USAGE_##flag));\ 641} \ 642static inline void \ 643nilfs_segment_usage_clear_##name(struct nilfs_segment_usage *su) \ 644{ \ 645 su->su_flags = \ 646 cpu_to_le32(le32_to_cpu(su->su_flags) & \ 647 ~(1UL << NILFS_SEGMENT_USAGE_##flag)); \ 648} \ 649static inline int \ 650nilfs_segment_usage_##name(const struct nilfs_segment_usage *su) \ 651{ \ 652 return !!(le32_to_cpu(su->su_flags) & \ 653 (1UL << NILFS_SEGMENT_USAGE_##flag)); \ 654} 655 656NILFS_SEGMENT_USAGE_FNS(ACTIVE, active) 657NILFS_SEGMENT_USAGE_FNS(DIRTY, dirty) 658NILFS_SEGMENT_USAGE_FNS(ERROR, error) 659 660static inline void 661nilfs_segment_usage_set_clean(struct nilfs_segment_usage *su) 662{ 663 su->su_lastmod = cpu_to_le64(0); 664 su->su_nblocks = cpu_to_le32(0); 665 su->su_flags = cpu_to_le32(0); 666} 667 668static inline int 669nilfs_segment_usage_clean(const struct nilfs_segment_usage *su) 670{ 671 return !le32_to_cpu(su->su_flags); 672} 673 674/** 675 * struct nilfs_sufile_header - segment usage file header 676 * @sh_ncleansegs: number of clean segments 677 * @sh_ndirtysegs: number of dirty segments 678 * @sh_last_alloc: last allocated segment number 679 */ 680struct nilfs_sufile_header { 681 __le64 sh_ncleansegs; 682 __le64 sh_ndirtysegs; 683 __le64 sh_last_alloc; 684 /* ... */ 685}; 686 687#define NILFS_SUFILE_FIRST_SEGMENT_USAGE_OFFSET \ 688 ((sizeof(struct nilfs_sufile_header) + \ 689 sizeof(struct nilfs_segment_usage) - 1) / \ 690 sizeof(struct nilfs_segment_usage)) 691 692/** 693 * nilfs_suinfo - segment usage information 694 * @sui_lastmod: timestamp of last modification 695 * @sui_nblocks: number of written blocks in segment 696 * @sui_flags: segment usage flags 697 */ 698struct nilfs_suinfo { 699 __u64 sui_lastmod; 700 __u32 sui_nblocks; 701 __u32 sui_flags; 702}; 703 704#define NILFS_SUINFO_FNS(flag, name) \ 705static inline int \ 706nilfs_suinfo_##name(const struct nilfs_suinfo *si) \ 707{ \ 708 return si->sui_flags & (1UL << NILFS_SEGMENT_USAGE_##flag); \ 709} 710 711NILFS_SUINFO_FNS(ACTIVE, active) 712NILFS_SUINFO_FNS(DIRTY, dirty) 713NILFS_SUINFO_FNS(ERROR, error) 714 715static inline int nilfs_suinfo_clean(const struct nilfs_suinfo *si) 716{ 717 return !si->sui_flags; 718} 719 720/* ioctl */ 721/** 722 * nilfs_suinfo_update - segment usage information update 723 * @sup_segnum: segment number 724 * @sup_flags: flags for which fields are active in sup_sui 725 * @sup_reserved: reserved necessary for alignment 726 * @sup_sui: segment usage information 727 */ 728struct nilfs_suinfo_update { 729 __u64 sup_segnum; 730 __u32 sup_flags; 731 __u32 sup_reserved; 732 struct nilfs_suinfo sup_sui; 733}; 734 735enum { 736 NILFS_SUINFO_UPDATE_LASTMOD, 737 NILFS_SUINFO_UPDATE_NBLOCKS, 738 NILFS_SUINFO_UPDATE_FLAGS, 739 __NR_NILFS_SUINFO_UPDATE_FIELDS, 740}; 741 742#define NILFS_SUINFO_UPDATE_FNS(flag, name) \ 743static inline void \ 744nilfs_suinfo_update_set_##name(struct nilfs_suinfo_update *sup) \ 745{ \ 746 sup->sup_flags |= 1UL << NILFS_SUINFO_UPDATE_##flag; \ 747} \ 748static inline void \ 749nilfs_suinfo_update_clear_##name(struct nilfs_suinfo_update *sup) \ 750{ \ 751 sup->sup_flags &= ~(1UL << NILFS_SUINFO_UPDATE_##flag); \ 752} \ 753static inline int \ 754nilfs_suinfo_update_##name(const struct nilfs_suinfo_update *sup) \ 755{ \ 756 return !!(sup->sup_flags & (1UL << NILFS_SUINFO_UPDATE_##flag));\ 757} 758 759NILFS_SUINFO_UPDATE_FNS(LASTMOD, lastmod) 760NILFS_SUINFO_UPDATE_FNS(NBLOCKS, nblocks) 761NILFS_SUINFO_UPDATE_FNS(FLAGS, flags) 762 763enum { 764 NILFS_CHECKPOINT, 765 NILFS_SNAPSHOT, 766}; 767 768/** 769 * struct nilfs_cpmode - change checkpoint mode structure 770 * @cm_cno: checkpoint number 771 * @cm_mode: mode of checkpoint 772 * @cm_pad: padding 773 */ 774struct nilfs_cpmode { 775 __u64 cm_cno; 776 __u32 cm_mode; 777 __u32 cm_pad; 778}; 779 780/** 781 * struct nilfs_argv - argument vector 782 * @v_base: pointer on data array from userspace 783 * @v_nmembs: number of members in data array 784 * @v_size: size of data array in bytes 785 * @v_flags: flags 786 * @v_index: start number of target data items 787 */ 788struct nilfs_argv { 789 __u64 v_base; 790 __u32 v_nmembs; /* number of members */ 791 __u16 v_size; /* size of members */ 792 __u16 v_flags; 793 __u64 v_index; 794}; 795 796/** 797 * struct nilfs_period - period of checkpoint numbers 798 * @p_start: start checkpoint number (inclusive) 799 * @p_end: end checkpoint number (exclusive) 800 */ 801struct nilfs_period { 802 __u64 p_start; 803 __u64 p_end; 804}; 805 806/** 807 * struct nilfs_cpstat - checkpoint statistics 808 * @cs_cno: checkpoint number 809 * @cs_ncps: number of checkpoints 810 * @cs_nsss: number of snapshots 811 */ 812struct nilfs_cpstat { 813 __u64 cs_cno; 814 __u64 cs_ncps; 815 __u64 cs_nsss; 816}; 817 818/** 819 * struct nilfs_sustat - segment usage statistics 820 * @ss_nsegs: number of segments 821 * @ss_ncleansegs: number of clean segments 822 * @ss_ndirtysegs: number of dirty segments 823 * @ss_ctime: creation time of the last segment 824 * @ss_nongc_ctime: creation time of the last segment not for GC 825 * @ss_prot_seq: least sequence number of segments which must not be reclaimed 826 */ 827struct nilfs_sustat { 828 __u64 ss_nsegs; 829 __u64 ss_ncleansegs; 830 __u64 ss_ndirtysegs; 831 __u64 ss_ctime; 832 __u64 ss_nongc_ctime; 833 __u64 ss_prot_seq; 834}; 835 836/** 837 * struct nilfs_vinfo - virtual block number information 838 * @vi_vblocknr: virtual block number 839 * @vi_start: start checkpoint number (inclusive) 840 * @vi_end: end checkpoint number (exclusive) 841 * @vi_blocknr: disk block number 842 */ 843struct nilfs_vinfo { 844 __u64 vi_vblocknr; 845 __u64 vi_start; 846 __u64 vi_end; 847 __u64 vi_blocknr; 848}; 849 850/** 851 * struct nilfs_vdesc - descriptor of virtual block number 852 * @vd_ino: inode number 853 * @vd_cno: checkpoint number 854 * @vd_vblocknr: virtual block number 855 * @vd_period: period of checkpoint numbers 856 * @vd_blocknr: disk block number 857 * @vd_offset: logical block offset inside a file 858 * @vd_flags: flags (data or node block) 859 * @vd_pad: padding 860 */ 861struct nilfs_vdesc { 862 __u64 vd_ino; 863 __u64 vd_cno; 864 __u64 vd_vblocknr; 865 struct nilfs_period vd_period; 866 __u64 vd_blocknr; 867 __u64 vd_offset; 868 __u32 vd_flags; 869 __u32 vd_pad; 870}; 871 872/** 873 * struct nilfs_bdesc - descriptor of disk block number 874 * @bd_ino: inode number 875 * @bd_oblocknr: disk block address (for skipping dead blocks) 876 * @bd_blocknr: disk block address 877 * @bd_offset: logical block offset inside a file 878 * @bd_level: level in the b-tree organization 879 * @bd_pad: padding 880 */ 881struct nilfs_bdesc { 882 __u64 bd_ino; 883 __u64 bd_oblocknr; 884 __u64 bd_blocknr; 885 __u64 bd_offset; 886 __u32 bd_level; 887 __u32 bd_pad; 888}; 889 890#define NILFS_IOCTL_IDENT 'n' 891 892#define NILFS_IOCTL_CHANGE_CPMODE \ 893 _IOW(NILFS_IOCTL_IDENT, 0x80, struct nilfs_cpmode) 894#define NILFS_IOCTL_DELETE_CHECKPOINT \ 895 _IOW(NILFS_IOCTL_IDENT, 0x81, __u64) 896#define NILFS_IOCTL_GET_CPINFO \ 897 _IOR(NILFS_IOCTL_IDENT, 0x82, struct nilfs_argv) 898#define NILFS_IOCTL_GET_CPSTAT \ 899 _IOR(NILFS_IOCTL_IDENT, 0x83, struct nilfs_cpstat) 900#define NILFS_IOCTL_GET_SUINFO \ 901 _IOR(NILFS_IOCTL_IDENT, 0x84, struct nilfs_argv) 902#define NILFS_IOCTL_GET_SUSTAT \ 903 _IOR(NILFS_IOCTL_IDENT, 0x85, struct nilfs_sustat) 904#define NILFS_IOCTL_GET_VINFO \ 905 _IOWR(NILFS_IOCTL_IDENT, 0x86, struct nilfs_argv) 906#define NILFS_IOCTL_GET_BDESCS \ 907 _IOWR(NILFS_IOCTL_IDENT, 0x87, struct nilfs_argv) 908#define NILFS_IOCTL_CLEAN_SEGMENTS \ 909 _IOW(NILFS_IOCTL_IDENT, 0x88, struct nilfs_argv[5]) 910#define NILFS_IOCTL_SYNC \ 911 _IOR(NILFS_IOCTL_IDENT, 0x8A, __u64) 912#define NILFS_IOCTL_RESIZE \ 913 _IOW(NILFS_IOCTL_IDENT, 0x8B, __u64) 914#define NILFS_IOCTL_SET_ALLOC_RANGE \ 915 _IOW(NILFS_IOCTL_IDENT, 0x8C, __u64[2]) 916#define NILFS_IOCTL_SET_SUINFO \ 917 _IOW(NILFS_IOCTL_IDENT, 0x8D, struct nilfs_argv) 918 919#endif /* _LINUX_NILFS_FS_H */ 920