lfs.h revision 1.147
1 /* $NetBSD: lfs.h,v 1.147 2013/06/08 02:15:12 dholland Exp $ */ 2 3 /*- 4 * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Konrad E. Schroder <perseant (at) hhhh.org>. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 /*- 32 * Copyright (c) 1991, 1993 33 * The Regents of the University of California. All rights reserved. 34 * 35 * Redistribution and use in source and binary forms, with or without 36 * modification, are permitted provided that the following conditions 37 * are met: 38 * 1. Redistributions of source code must retain the above copyright 39 * notice, this list of conditions and the following disclaimer. 40 * 2. Redistributions in binary form must reproduce the above copyright 41 * notice, this list of conditions and the following disclaimer in the 42 * documentation and/or other materials provided with the distribution. 43 * 3. Neither the name of the University nor the names of its contributors 44 * may be used to endorse or promote products derived from this software 45 * without specific prior written permission. 46 * 47 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 48 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 50 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 51 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 52 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 53 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 54 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 55 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 56 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 57 * SUCH DAMAGE. 58 * 59 * @(#)lfs.h 8.9 (Berkeley) 5/8/95 60 */ 61 62 #ifndef _UFS_LFS_LFS_H_ 63 #define _UFS_LFS_LFS_H_ 64 65 #include <sys/rwlock.h> 66 #include <sys/mutex.h> 67 #include <sys/queue.h> 68 #include <sys/condvar.h> 69 #include <sys/mount.h> 70 #include <sys/pool.h> 71 72 /* 73 * Compile-time options for LFS. 74 */ 75 #define LFS_IFIND_RETRIES 16 76 #define LFS_LOGLENGTH 1024 /* size of debugging log */ 77 #define LFS_MAX_ACTIVE 10 /* Dirty segments before ckp forced */ 78 79 /* 80 * Fixed filesystem layout parameters 81 */ 82 #define LFS_LABELPAD 8192 /* LFS label size */ 83 #define LFS_SBPAD 8192 /* LFS superblock size */ 84 85 #define LFS_UNUSED_INUM 0 /* 0: out of band inode number */ 86 #define LFS_IFILE_INUM 1 /* 1: IFILE inode number */ 87 /* 2: Root inode number */ 88 #define LFS_LOSTFOUNDINO 3 /* 3: lost+found inode number */ 89 #define LFS_FIRST_INUM 4 /* 4: first free inode number */ 90 91 /* 92 * The root inode is the root of the file system. Inode 0 can't be used for 93 * normal purposes and historically bad blocks were linked to inode 1, thus 94 * the root inode is 2. (Inode 1 is no longer used for this purpose, however 95 * numerous dump tapes make this assumption, so we are stuck with it). 96 */ 97 #define ULFS_ROOTINO ((ino_t)2) 98 99 /* 100 * The Whiteout inode# is a dummy non-zero inode number which will 101 * never be allocated to a real file. It is used as a place holder 102 * in the directory entry which has been tagged as a LFS_DT_WHT entry. 103 * See the comments about ULFS_ROOTINO above. 104 */ 105 #define ULFS_WINO ((ino_t)1) 106 107 108 #define LFS_V1_SUMMARY_SIZE 512 /* V1 fixed summary size */ 109 #define LFS_DFL_SUMMARY_SIZE 512 /* Default summary size */ 110 111 #define LFS_MAX_DADDR 0x7fffffff /* Highest addressable fsb */ 112 113 #define LFS_MAXNAMLEN 255 /* maximum name length in a dir */ 114 115 #define ULFS_NXADDR 2 116 #define ULFS_NDADDR 12 /* Direct addresses in inode. */ 117 #define ULFS_NIADDR 3 /* Indirect addresses in inode. */ 118 119 /* 120 * Adjustable filesystem parameters 121 */ 122 #define MIN_FREE_SEGS 20 123 #define MIN_RESV_SEGS 15 124 #ifndef LFS_ATIME_IFILE 125 # define LFS_ATIME_IFILE 0 /* Store atime info in ifile (optional in LFSv1) */ 126 #endif 127 #define LFS_MARKV_MAXBLKCNT 65536 /* Max block count for lfs_markv() */ 128 129 /* Misc. definitions */ 130 #define BW_CLEAN 1 /* Flag for lfs_bwrite_ext() */ 131 #define PG_DELWRI PG_PAGER1 /* Local def for delayed pageout */ 132 133 /* Resource limits */ 134 #define LFS_MAX_RESOURCE(x, u) (((x) >> 2) - 10 * (u)) 135 #define LFS_WAIT_RESOURCE(x, u) (((x) >> 1) - ((x) >> 3) - 10 * (u)) 136 #define LFS_INVERSE_MAX_RESOURCE(x, u) (((x) + 10 * (u)) << 2) 137 #define LFS_MAX_BUFS LFS_MAX_RESOURCE(nbuf, 1) 138 #define LFS_WAIT_BUFS LFS_WAIT_RESOURCE(nbuf, 1) 139 #define LFS_INVERSE_MAX_BUFS(n) LFS_INVERSE_MAX_RESOURCE(n, 1) 140 #define LFS_MAX_BYTES LFS_MAX_RESOURCE(bufmem_lowater, PAGE_SIZE) 141 #define LFS_INVERSE_MAX_BYTES(n) LFS_INVERSE_MAX_RESOURCE(n, PAGE_SIZE) 142 #define LFS_WAIT_BYTES LFS_WAIT_RESOURCE(bufmem_lowater, PAGE_SIZE) 143 #define LFS_MAX_DIROP ((desiredvnodes >> 2) + (desiredvnodes >> 3)) 144 #define SIZEOF_DIROP(fs) (2 * ((fs)->lfs_bsize + LFS_DINODE1_SIZE)) 145 #define LFS_MAX_FSDIROP(fs) \ 146 ((fs)->lfs_nclean <= (fs)->lfs_resvseg ? 0 : \ 147 (((fs)->lfs_nclean - (fs)->lfs_resvseg) * (fs)->lfs_ssize) / \ 148 (2 * SIZEOF_DIROP(fs))) 149 #define LFS_MAX_PAGES lfs_max_pages() 150 #define LFS_WAIT_PAGES lfs_wait_pages() 151 #define LFS_BUFWAIT 2 /* How long to wait if over *_WAIT_* */ 152 153 #ifdef _KERNEL 154 int lfs_wait_pages(void); 155 int lfs_max_pages(void); 156 #endif /* _KERNEL */ 157 158 /* How starved can we be before we start holding back page writes */ 159 #define LFS_STARVED_FOR_SEGS(fs) ((fs)->lfs_nclean < (fs)->lfs_resvseg) 160 161 /* 162 * Reserved blocks for lfs_malloc 163 */ 164 165 /* Structure to keep reserved blocks */ 166 typedef struct lfs_res_blk { 167 void *p; 168 LIST_ENTRY(lfs_res_blk) res; 169 int size; 170 char inuse; 171 } res_t; 172 173 /* Types for lfs_newbuf and lfs_malloc */ 174 #define LFS_NB_UNKNOWN -1 175 #define LFS_NB_SUMMARY 0 176 #define LFS_NB_SBLOCK 1 177 #define LFS_NB_IBLOCK 2 178 #define LFS_NB_CLUSTER 3 179 #define LFS_NB_CLEAN 4 180 #define LFS_NB_BLKIOV 5 181 #define LFS_NB_COUNT 6 /* always last */ 182 183 /* Number of reserved memory blocks of each type */ 184 #define LFS_N_SUMMARIES 2 185 #define LFS_N_SBLOCKS 1 /* Always 1, to throttle superblock writes */ 186 #define LFS_N_IBLOCKS 16 /* In theory ssize/bsize; in practice around 2 */ 187 #define LFS_N_CLUSTERS 16 /* In theory ssize/MAXPHYS */ 188 #define LFS_N_CLEAN 0 189 #define LFS_N_BLKIOV 1 190 191 /* Total count of "large" (non-pool) types */ 192 #define LFS_N_TOTAL (LFS_N_SUMMARIES + LFS_N_SBLOCKS + LFS_N_IBLOCKS + \ 193 LFS_N_CLUSTERS + LFS_N_CLEAN + LFS_N_BLKIOV) 194 195 /* Counts for pool types */ 196 #define LFS_N_CL LFS_N_CLUSTERS 197 #define LFS_N_BPP 2 198 #define LFS_N_SEG 2 199 200 /* 201 * Directories 202 */ 203 204 /* 205 * A directory consists of some number of blocks of LFS_DIRBLKSIZ 206 * bytes, where LFS_DIRBLKSIZ is chosen such that it can be transferred 207 * to disk in a single atomic operation (e.g. 512 bytes on most machines). 208 * 209 * Each LFS_DIRBLKSIZ byte block contains some number of directory entry 210 * structures, which are of variable length. Each directory entry has 211 * a struct lfs_direct at the front of it, containing its inode number, 212 * the length of the entry, and the length of the name contained in 213 * the entry. These are followed by the name padded to a 4 byte boundary. 214 * All names are guaranteed null terminated. 215 * The maximum length of a name in a directory is LFS_MAXNAMLEN. 216 * 217 * The macro DIRSIZ(fmt, dp) gives the amount of space required to represent 218 * a directory entry. Free space in a directory is represented by 219 * entries which have dp->d_reclen > DIRSIZ(fmt, dp). All LFS_DIRBLKSIZ bytes 220 * in a directory block are claimed by the directory entries. This 221 * usually results in the last entry in a directory having a large 222 * dp->d_reclen. When entries are deleted from a directory, the 223 * space is returned to the previous entry in the same directory 224 * block by increasing its dp->d_reclen. If the first entry of 225 * a directory block is free, then its dp->d_ino is set to 0. 226 * Entries other than the first in a directory do not normally have 227 * dp->d_ino set to 0. 228 */ 229 230 /* 231 * Directory block size. 232 */ 233 #undef LFS_DIRBLKSIZ 234 #define LFS_DIRBLKSIZ DEV_BSIZE 235 236 /* 237 * Convert between stat structure types and directory types. 238 */ 239 #define LFS_IFTODT(mode) (((mode) & 0170000) >> 12) 240 #define LFS_DTTOIF(dirtype) ((dirtype) << 12) 241 242 /* 243 * The LFS_DIRSIZ macro gives the minimum record length which will hold 244 * the directory entry. This requires the amount of space in struct lfs_direct 245 * without the d_name field, plus enough space for the name with a terminating 246 * null byte (dp->d_namlen+1), rounded up to a 4 byte boundary. 247 */ 248 #define LFS_DIRECTSIZ(namlen) \ 249 ((sizeof(struct lfs_direct) - (LFS_MAXNAMLEN+1)) + (((namlen)+1 + 3) &~ 3)) 250 251 #if (BYTE_ORDER == LITTLE_ENDIAN) 252 #define LFS_DIRSIZ(oldfmt, dp, needswap) \ 253 (((oldfmt) && !(needswap)) ? \ 254 LFS_DIRECTSIZ((dp)->d_type) : LFS_DIRECTSIZ((dp)->d_namlen)) 255 #else 256 #define LFS_DIRSIZ(oldfmt, dp, needswap) \ 257 (((oldfmt) && (needswap)) ? \ 258 LFS_DIRECTSIZ((dp)->d_type) : LFS_DIRECTSIZ((dp)->d_namlen)) 259 #endif 260 261 /* Constants for the first argument of LFS_DIRSIZ */ 262 #define LFS_OLDDIRFMT 1 263 #define LFS_NEWDIRFMT 0 264 265 /* 266 * Theoretically, directories can be more than 2Gb in length; however, in 267 * practice this seems unlikely. So, we define the type doff_t as a 32-bit 268 * quantity to keep down the cost of doing lookup on a 32-bit machine. 269 */ 270 #define doff_t int32_t 271 #define lfs_doff_t int32_t 272 #define MAXDIRSIZE (0x7fffffff) 273 274 #define LFS_MAXNAMLEN 255 275 276 /* 277 * File types for d_type 278 */ 279 #define LFS_DT_UNKNOWN 0 280 #define LFS_DT_FIFO 1 281 #define LFS_DT_CHR 2 282 #define LFS_DT_DIR 4 283 #define LFS_DT_BLK 6 284 #define LFS_DT_REG 8 285 #define LFS_DT_LNK 10 286 #define LFS_DT_SOCK 12 287 #define LFS_DT_WHT 14 288 289 /* 290 * (See notes in ulfs_dir.h) 291 */ 292 #define d_ino d_fileno 293 struct lfs_direct { 294 u_int32_t d_fileno; /* inode number of entry */ 295 u_int16_t d_reclen; /* length of this record */ 296 u_int8_t d_type; /* file type, see below */ 297 u_int8_t d_namlen; /* length of string in d_name */ 298 char d_name[LFS_MAXNAMLEN + 1];/* name with length <= LFS_MAXNAMLEN */ 299 }; 300 301 /* 302 * Template for manipulating directories. Should use struct lfs_direct's, 303 * but the name field is LFS_MAXNAMLEN - 1, and this just won't do. 304 */ 305 struct lfs_dirtemplate { 306 u_int32_t dot_ino; 307 int16_t dot_reclen; 308 u_int8_t dot_type; 309 u_int8_t dot_namlen; 310 char dot_name[4]; /* must be multiple of 4 */ 311 u_int32_t dotdot_ino; 312 int16_t dotdot_reclen; 313 u_int8_t dotdot_type; 314 u_int8_t dotdot_namlen; 315 char dotdot_name[4]; /* ditto */ 316 }; 317 318 /* 319 * This is the old format of directories, sans type element. 320 */ 321 struct lfs_odirtemplate { 322 u_int32_t dot_ino; 323 int16_t dot_reclen; 324 u_int16_t dot_namlen; 325 char dot_name[4]; /* must be multiple of 4 */ 326 u_int32_t dotdot_ino; 327 int16_t dotdot_reclen; 328 u_int16_t dotdot_namlen; 329 char dotdot_name[4]; /* ditto */ 330 }; 331 332 /* 333 * Inodes 334 */ 335 336 /* 337 * A dinode contains all the meta-data associated with a ULFS file. 338 * This structure defines the on-disk format of a dinode. Since 339 * this structure describes an on-disk structure, all its fields 340 * are defined by types with precise widths. 341 */ 342 343 struct ulfs1_dinode { 344 u_int16_t di_mode; /* 0: IFMT, permissions; see below. */ 345 int16_t di_nlink; /* 2: File link count. */ 346 union { 347 u_int16_t oldids[2]; /* 4: Ffs: old user and group ids. */ 348 u_int32_t inumber; /* 4: Lfs: inode number. */ 349 } di_u; 350 u_int64_t di_size; /* 8: File byte count. */ 351 int32_t di_atime; /* 16: Last access time. */ 352 int32_t di_atimensec; /* 20: Last access time. */ 353 int32_t di_mtime; /* 24: Last modified time. */ 354 int32_t di_mtimensec; /* 28: Last modified time. */ 355 int32_t di_ctime; /* 32: Last inode change time. */ 356 int32_t di_ctimensec; /* 36: Last inode change time. */ 357 int32_t di_db[ULFS_NDADDR]; /* 40: Direct disk blocks. */ 358 int32_t di_ib[ULFS_NIADDR]; /* 88: Indirect disk blocks. */ 359 u_int32_t di_flags; /* 100: Status flags (chflags). */ 360 u_int32_t di_blocks; /* 104: Blocks actually held. */ 361 int32_t di_gen; /* 108: Generation number. */ 362 u_int32_t di_uid; /* 112: File owner. */ 363 u_int32_t di_gid; /* 116: File group. */ 364 u_int64_t di_modrev; /* 120: i_modrev for NFSv4 */ 365 }; 366 367 struct ulfs2_dinode { 368 u_int16_t di_mode; /* 0: IFMT, permissions; see below. */ 369 int16_t di_nlink; /* 2: File link count. */ 370 u_int32_t di_uid; /* 4: File owner. */ 371 u_int32_t di_gid; /* 8: File group. */ 372 u_int32_t di_blksize; /* 12: Inode blocksize. */ 373 u_int64_t di_size; /* 16: File byte count. */ 374 u_int64_t di_blocks; /* 24: Bytes actually held. */ 375 int64_t di_atime; /* 32: Last access time. */ 376 int64_t di_mtime; /* 40: Last modified time. */ 377 int64_t di_ctime; /* 48: Last inode change time. */ 378 int64_t di_birthtime; /* 56: Inode creation time. */ 379 int32_t di_mtimensec; /* 64: Last modified time. */ 380 int32_t di_atimensec; /* 68: Last access time. */ 381 int32_t di_ctimensec; /* 72: Last inode change time. */ 382 int32_t di_birthnsec; /* 76: Inode creation time. */ 383 int32_t di_gen; /* 80: Generation number. */ 384 u_int32_t di_kernflags; /* 84: Kernel flags. */ 385 u_int32_t di_flags; /* 88: Status flags (chflags). */ 386 int32_t di_extsize; /* 92: External attributes block. */ 387 int64_t di_extb[ULFS_NXADDR];/* 96: External attributes block. */ 388 int64_t di_db[ULFS_NDADDR]; /* 112: Direct disk blocks. */ 389 int64_t di_ib[ULFS_NIADDR]; /* 208: Indirect disk blocks. */ 390 u_int64_t di_modrev; /* 232: i_modrev for NFSv4 */ 391 int64_t di_spare[2]; /* 240: Reserved; currently unused */ 392 }; 393 394 /* 395 * The di_db fields may be overlaid with other information for 396 * file types that do not have associated disk storage. Block 397 * and character devices overlay the first data block with their 398 * dev_t value. Short symbolic links place their path in the 399 * di_db area. 400 */ 401 #define di_inumber di_u.inumber 402 #define di_ogid di_u.oldids[1] 403 #define di_ouid di_u.oldids[0] 404 #define di_rdev di_db[0] 405 406 /* Size of the on-disk inode. */ 407 #define LFS_DINODE1_SIZE (sizeof(struct ulfs1_dinode)) /* 128 */ 408 #define LFS_DINODE2_SIZE (sizeof(struct ulfs2_dinode)) 409 410 /* File types, found in the upper bits of di_mode. */ 411 #define LFS_IFMT 0170000 /* Mask of file type. */ 412 #define LFS_IFIFO 0010000 /* Named pipe (fifo). */ 413 #define LFS_IFCHR 0020000 /* Character device. */ 414 #define LFS_IFDIR 0040000 /* Directory file. */ 415 #define LFS_IFBLK 0060000 /* Block device. */ 416 #define LFS_IFREG 0100000 /* Regular file. */ 417 #define LFS_IFLNK 0120000 /* Symbolic link. */ 418 #define LFS_IFSOCK 0140000 /* UNIX domain socket. */ 419 #define LFS_IFWHT 0160000 /* Whiteout. */ 420 421 /* 422 * Maximum length of a symlink that can be stored within the inode. 423 */ 424 #define ULFS1_MAXSYMLINKLEN ((ULFS_NDADDR + ULFS_NIADDR) * sizeof(int32_t)) 425 #define ULFS2_MAXSYMLINKLEN ((ULFS_NDADDR + ULFS_NIADDR) * sizeof(int64_t)) 426 427 #define ULFS_MAXSYMLINKLEN(ip) \ 428 ((ip)->i_ump->um_fstype == ULFS1) ? \ 429 ULFS1_MAXSYMLINKLEN : ULFS2_MAXSYMLINKLEN 430 431 /* 432 * "struct buf" associated definitions 433 */ 434 435 /* Unassigned disk addresses. */ 436 #define UNASSIGNED -1 437 #define UNWRITTEN -2 438 439 /* Unused logical block number */ 440 #define LFS_UNUSED_LBN -1 441 442 /* Determine if a buffer belongs to the ifile */ 443 #define IS_IFILE(bp) (VTOI(bp->b_vp)->i_number == LFS_IFILE_INUM) 444 445 # define LFS_LOCK_BUF(bp) do { \ 446 if (((bp)->b_flags & B_LOCKED) == 0 && bp->b_iodone == NULL) { \ 447 mutex_enter(&lfs_lock); \ 448 ++locked_queue_count; \ 449 locked_queue_bytes += bp->b_bufsize; \ 450 mutex_exit(&lfs_lock); \ 451 } \ 452 (bp)->b_flags |= B_LOCKED; \ 453 } while (0) 454 455 # define LFS_UNLOCK_BUF(bp) do { \ 456 if (((bp)->b_flags & B_LOCKED) != 0 && bp->b_iodone == NULL) { \ 457 mutex_enter(&lfs_lock); \ 458 --locked_queue_count; \ 459 locked_queue_bytes -= bp->b_bufsize; \ 460 if (locked_queue_count < LFS_WAIT_BUFS && \ 461 locked_queue_bytes < LFS_WAIT_BYTES) \ 462 cv_broadcast(&locked_queue_cv); \ 463 mutex_exit(&lfs_lock); \ 464 } \ 465 (bp)->b_flags &= ~B_LOCKED; \ 466 } while (0) 467 468 #ifdef _KERNEL 469 470 extern u_long bufmem_lowater, bufmem_hiwater; /* XXX */ 471 472 # define LFS_IS_MALLOC_BUF(bp) ((bp)->b_iodone == lfs_callback) 473 474 # ifdef DEBUG 475 # define LFS_DEBUG_COUNTLOCKED(m) do { \ 476 if (lfs_debug_log_subsys[DLOG_LLIST]) { \ 477 lfs_countlocked(&locked_queue_count, &locked_queue_bytes, (m)); \ 478 cv_broadcast(&locked_queue_cv); \ 479 } \ 480 } while (0) 481 # else 482 # define LFS_DEBUG_COUNTLOCKED(m) 483 # endif 484 485 /* log for debugging writes to the Ifile */ 486 # ifdef DEBUG 487 struct lfs_log_entry { 488 const char *op; 489 const char *file; 490 int pid; 491 int line; 492 daddr_t block; 493 unsigned long flags; 494 }; 495 extern int lfs_lognum; 496 extern struct lfs_log_entry lfs_log[LFS_LOGLENGTH]; 497 # define LFS_BWRITE_LOG(bp) lfs_bwrite_log((bp), __FILE__, __LINE__) 498 # define LFS_ENTER_LOG(theop, thefile, theline, lbn, theflags, thepid) do {\ 499 int _s; \ 500 \ 501 mutex_enter(&lfs_lock); \ 502 _s = splbio(); \ 503 lfs_log[lfs_lognum].op = theop; \ 504 lfs_log[lfs_lognum].file = thefile; \ 505 lfs_log[lfs_lognum].line = (theline); \ 506 lfs_log[lfs_lognum].pid = (thepid); \ 507 lfs_log[lfs_lognum].block = (lbn); \ 508 lfs_log[lfs_lognum].flags = (theflags); \ 509 lfs_lognum = (lfs_lognum + 1) % LFS_LOGLENGTH; \ 510 splx(_s); \ 511 mutex_exit(&lfs_lock); \ 512 } while (0) 513 514 # define LFS_BCLEAN_LOG(fs, bp) do { \ 515 if ((bp)->b_vp == (fs)->lfs_ivnode) \ 516 LFS_ENTER_LOG("clear", __FILE__, __LINE__, \ 517 bp->b_lblkno, bp->b_flags, curproc->p_pid);\ 518 } while (0) 519 520 /* Must match list in lfs_vfsops.c ! */ 521 # define DLOG_RF 0 /* roll forward */ 522 # define DLOG_ALLOC 1 /* inode alloc */ 523 # define DLOG_AVAIL 2 /* lfs_{,r,f}avail */ 524 # define DLOG_FLUSH 3 /* flush */ 525 # define DLOG_LLIST 4 /* locked list accounting */ 526 # define DLOG_WVNODE 5 /* vflush/writevnodes verbose */ 527 # define DLOG_VNODE 6 /* vflush/writevnodes */ 528 # define DLOG_SEG 7 /* segwrite */ 529 # define DLOG_SU 8 /* seguse accounting */ 530 # define DLOG_CLEAN 9 /* cleaner routines */ 531 # define DLOG_MOUNT 10 /* mount/unmount */ 532 # define DLOG_PAGE 11 /* putpages/gop_write */ 533 # define DLOG_DIROP 12 /* dirop accounting */ 534 # define DLOG_MALLOC 13 /* lfs_malloc accounting */ 535 # define DLOG_MAX 14 /* The terminator */ 536 # define DLOG(a) lfs_debug_log a 537 # else /* ! DEBUG */ 538 # define LFS_BCLEAN_LOG(fs, bp) 539 # define LFS_BWRITE_LOG(bp) VOP_BWRITE((bp)->b_vp, (bp)) 540 # define DLOG(a) 541 # endif /* ! DEBUG */ 542 #else /* ! _KERNEL */ 543 # define LFS_BWRITE_LOG(bp) VOP_BWRITE((bp)) 544 #endif /* _KERNEL */ 545 546 #ifdef _KERNEL 547 /* This overlays the fid structure (see fstypes.h). */ 548 struct ulfs_ufid { 549 u_int16_t ufid_len; /* Length of structure. */ 550 u_int16_t ufid_pad; /* Force 32-bit alignment. */ 551 u_int32_t ufid_ino; /* File number (ino). */ 552 int32_t ufid_gen; /* Generation number. */ 553 }; 554 /* Filehandle structure for exported LFSes */ 555 struct lfid { 556 struct ulfs_ufid lfid_ufid; 557 #define lfid_len lfid_ufid.ufid_len 558 #define lfid_ino lfid_ufid.ufid_ino 559 #define lfid_gen lfid_ufid.ufid_gen 560 uint32_t lfid_ident; 561 }; 562 #endif /* _KERNEL */ 563 564 /* 565 * "struct inode" associated definitions 566 */ 567 568 /* Address calculations for metadata located in the inode */ 569 #define S_INDIR(fs) -ULFS_NDADDR 570 #define D_INDIR(fs) (S_INDIR(fs) - NINDIR(fs) - 1) 571 #define T_INDIR(fs) (D_INDIR(fs) - NINDIR(fs) * NINDIR(fs) - 1) 572 573 /* For convenience */ 574 #define IN_ALLMOD (IN_MODIFIED|IN_ACCESS|IN_CHANGE|IN_UPDATE|IN_MODIFY|IN_ACCESSED|IN_CLEANING) 575 576 #define LFS_SET_UINO(ip, flags) do { \ 577 if (((flags) & IN_ACCESSED) && !((ip)->i_flag & IN_ACCESSED)) \ 578 ++(ip)->i_lfs->lfs_uinodes; \ 579 if (((flags) & IN_CLEANING) && !((ip)->i_flag & IN_CLEANING)) \ 580 ++(ip)->i_lfs->lfs_uinodes; \ 581 if (((flags) & IN_MODIFIED) && !((ip)->i_flag & IN_MODIFIED)) \ 582 ++(ip)->i_lfs->lfs_uinodes; \ 583 (ip)->i_flag |= (flags); \ 584 } while (0) 585 586 #define LFS_CLR_UINO(ip, flags) do { \ 587 if (((flags) & IN_ACCESSED) && ((ip)->i_flag & IN_ACCESSED)) \ 588 --(ip)->i_lfs->lfs_uinodes; \ 589 if (((flags) & IN_CLEANING) && ((ip)->i_flag & IN_CLEANING)) \ 590 --(ip)->i_lfs->lfs_uinodes; \ 591 if (((flags) & IN_MODIFIED) && ((ip)->i_flag & IN_MODIFIED)) \ 592 --(ip)->i_lfs->lfs_uinodes; \ 593 (ip)->i_flag &= ~(flags); \ 594 if ((ip)->i_lfs->lfs_uinodes < 0) { \ 595 panic("lfs_uinodes < 0"); \ 596 } \ 597 } while (0) 598 599 #define LFS_ITIMES(ip, acc, mod, cre) \ 600 while ((ip)->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFY)) \ 601 lfs_itimes(ip, acc, mod, cre) 602 603 /* 604 * "struct vnode" associated definitions 605 */ 606 607 /* Heuristic emptiness measure */ 608 #define VPISEMPTY(vp) (LIST_EMPTY(&(vp)->v_dirtyblkhd) && \ 609 !(vp->v_type == VREG && (vp)->v_iflag & VI_ONWORKLST) &&\ 610 VTOI(vp)->i_lfs_nbtree == 0) 611 612 #define WRITEINPROG(vp) ((vp)->v_numoutput > 0 || \ 613 (!LIST_EMPTY(&(vp)->v_dirtyblkhd) && \ 614 !(VTOI(vp)->i_flag & (IN_MODIFIED | IN_ACCESSED | IN_CLEANING)))) 615 616 617 /* 618 * On-disk and in-memory checkpoint segment usage structure. 619 */ 620 typedef struct segusage SEGUSE; 621 struct segusage { 622 u_int32_t su_nbytes; /* 0: number of live bytes */ 623 u_int32_t su_olastmod; /* 4: SEGUSE last modified timestamp */ 624 u_int16_t su_nsums; /* 8: number of summaries in segment */ 625 u_int16_t su_ninos; /* 10: number of inode blocks in seg */ 626 627 #define SEGUSE_ACTIVE 0x01 /* segment currently being written */ 628 #define SEGUSE_DIRTY 0x02 /* segment has data in it */ 629 #define SEGUSE_SUPERBLOCK 0x04 /* segment contains a superblock */ 630 #define SEGUSE_ERROR 0x08 /* cleaner: do not clean segment */ 631 #define SEGUSE_EMPTY 0x10 /* segment is empty */ 632 #define SEGUSE_INVAL 0x20 /* segment is invalid */ 633 u_int32_t su_flags; /* 12: segment flags */ 634 u_int64_t su_lastmod; /* 16: last modified timestamp */ 635 }; 636 637 typedef struct segusage_v1 SEGUSE_V1; 638 struct segusage_v1 { 639 u_int32_t su_nbytes; /* 0: number of live bytes */ 640 u_int32_t su_lastmod; /* 4: SEGUSE last modified timestamp */ 641 u_int16_t su_nsums; /* 8: number of summaries in segment */ 642 u_int16_t su_ninos; /* 10: number of inode blocks in seg */ 643 u_int32_t su_flags; /* 12: segment flags */ 644 }; 645 646 #define SEGUPB(fs) (fs->lfs_sepb) 647 #define SEGTABSIZE_SU(fs) \ 648 (((fs)->lfs_nseg + SEGUPB(fs) - 1) / (fs)->lfs_sepb) 649 650 #ifdef _KERNEL 651 # define SHARE_IFLOCK(F) \ 652 do { \ 653 rw_enter(&(F)->lfs_iflock, RW_READER); \ 654 } while(0) 655 # define UNSHARE_IFLOCK(F) \ 656 do { \ 657 rw_exit(&(F)->lfs_iflock); \ 658 } while(0) 659 #else /* ! _KERNEL */ 660 # define SHARE_IFLOCK(F) 661 # define UNSHARE_IFLOCK(F) 662 #endif /* ! _KERNEL */ 663 664 /* Read in the block with a specific segment usage entry from the ifile. */ 665 #define LFS_SEGENTRY(SP, F, IN, BP) do { \ 666 int _e; \ 667 SHARE_IFLOCK(F); \ 668 VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ 669 if ((_e = bread((F)->lfs_ivnode, \ 670 ((IN) / (F)->lfs_sepb) + (F)->lfs_cleansz, \ 671 (F)->lfs_bsize, NOCRED, 0, &(BP))) != 0) \ 672 panic("lfs: ifile read: %d", _e); \ 673 if ((F)->lfs_version == 1) \ 674 (SP) = (SEGUSE *)((SEGUSE_V1 *)(BP)->b_data + \ 675 ((IN) & ((F)->lfs_sepb - 1))); \ 676 else \ 677 (SP) = (SEGUSE *)(BP)->b_data + ((IN) % (F)->lfs_sepb); \ 678 UNSHARE_IFLOCK(F); \ 679 } while (0) 680 681 #define LFS_WRITESEGENTRY(SP, F, IN, BP) do { \ 682 if ((SP)->su_nbytes == 0) \ 683 (SP)->su_flags |= SEGUSE_EMPTY; \ 684 else \ 685 (SP)->su_flags &= ~SEGUSE_EMPTY; \ 686 (F)->lfs_suflags[(F)->lfs_activesb][(IN)] = (SP)->su_flags; \ 687 LFS_BWRITE_LOG(BP); \ 688 } while (0) 689 690 /* 691 * On-disk file information. One per file with data blocks in the segment. 692 */ 693 typedef struct finfo FINFO; 694 struct finfo { 695 u_int32_t fi_nblocks; /* number of blocks */ 696 u_int32_t fi_version; /* version number */ 697 u_int32_t fi_ino; /* inode number */ 698 u_int32_t fi_lastlength; /* length of last block in array */ 699 int32_t fi_blocks[1]; /* array of logical block numbers */ 700 }; 701 /* sizeof FINFO except fi_blocks */ 702 #define FINFOSIZE (sizeof(FINFO) - sizeof(int32_t)) 703 704 /* 705 * Index file inode entries. 706 */ 707 typedef struct ifile IFILE; 708 struct ifile { 709 u_int32_t if_version; /* inode version number */ 710 #define LFS_UNUSED_DADDR 0 /* out-of-band daddr */ 711 int32_t if_daddr; /* inode disk address */ 712 #define LFS_ORPHAN_NEXTFREE (~(u_int32_t)0) /* indicate orphaned file */ 713 u_int32_t if_nextfree; /* next-unallocated inode */ 714 u_int32_t if_atime_sec; /* Last access time, seconds */ 715 u_int32_t if_atime_nsec; /* and nanoseconds */ 716 }; 717 718 typedef struct ifile_v1 IFILE_V1; 719 struct ifile_v1 { 720 u_int32_t if_version; /* inode version number */ 721 int32_t if_daddr; /* inode disk address */ 722 u_int32_t if_nextfree; /* next-unallocated inode */ 723 #if LFS_ATIME_IFILE 724 struct timespec if_atime; /* Last access time */ 725 #endif 726 }; 727 728 /* 729 * LFSv1 compatibility code is not allowed to touch if_atime, since it 730 * may not be mapped! 731 */ 732 /* Read in the block with a specific inode from the ifile. */ 733 #define LFS_IENTRY(IP, F, IN, BP) do { \ 734 int _e; \ 735 SHARE_IFLOCK(F); \ 736 VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ 737 if ((_e = bread((F)->lfs_ivnode, \ 738 (IN) / (F)->lfs_ifpb + (F)->lfs_cleansz + (F)->lfs_segtabsz, \ 739 (F)->lfs_bsize, NOCRED, 0, &(BP))) != 0) \ 740 panic("lfs: ifile ino %d read %d", (int)(IN), _e); \ 741 if ((F)->lfs_version == 1) \ 742 (IP) = (IFILE *)((IFILE_V1 *)(BP)->b_data + \ 743 (IN) % (F)->lfs_ifpb); \ 744 else \ 745 (IP) = (IFILE *)(BP)->b_data + (IN) % (F)->lfs_ifpb; \ 746 UNSHARE_IFLOCK(F); \ 747 } while (0) 748 749 /* 750 * Cleaner information structure. This resides in the ifile and is used 751 * to pass information from the kernel to the cleaner. 752 */ 753 typedef struct _cleanerinfo { 754 u_int32_t clean; /* number of clean segments */ 755 u_int32_t dirty; /* number of dirty segments */ 756 int32_t bfree; /* disk blocks free */ 757 int32_t avail; /* disk blocks available */ 758 u_int32_t free_head; /* head of the inode free list */ 759 u_int32_t free_tail; /* tail of the inode free list */ 760 #define LFS_CLEANER_MUST_CLEAN 0x01 761 u_int32_t flags; /* status word from the kernel */ 762 } CLEANERINFO; 763 764 #define CLEANSIZE_SU(fs) \ 765 ((sizeof(CLEANERINFO) + (fs)->lfs_bsize - 1) >> (fs)->lfs_bshift) 766 767 /* Read in the block with the cleaner info from the ifile. */ 768 #define LFS_CLEANERINFO(CP, F, BP) do { \ 769 SHARE_IFLOCK(F); \ 770 VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ 771 if (bread((F)->lfs_ivnode, \ 772 (daddr_t)0, (F)->lfs_bsize, NOCRED, 0, &(BP))) \ 773 panic("lfs: ifile read"); \ 774 (CP) = (CLEANERINFO *)(BP)->b_data; \ 775 UNSHARE_IFLOCK(F); \ 776 } while (0) 777 778 /* 779 * Synchronize the Ifile cleaner info with current avail and bfree. 780 */ 781 #define LFS_SYNC_CLEANERINFO(cip, fs, bp, w) do { \ 782 mutex_enter(&lfs_lock); \ 783 if ((w) || (cip)->bfree != (fs)->lfs_bfree || \ 784 (cip)->avail != (fs)->lfs_avail - (fs)->lfs_ravail - \ 785 (fs)->lfs_favail) { \ 786 (cip)->bfree = (fs)->lfs_bfree; \ 787 (cip)->avail = (fs)->lfs_avail - (fs)->lfs_ravail - \ 788 (fs)->lfs_favail; \ 789 if (((bp)->b_flags & B_GATHERED) == 0) { \ 790 (fs)->lfs_flags |= LFS_IFDIRTY; \ 791 } \ 792 mutex_exit(&lfs_lock); \ 793 (void) LFS_BWRITE_LOG(bp); /* Ifile */ \ 794 } else { \ 795 mutex_exit(&lfs_lock); \ 796 brelse(bp, 0); \ 797 } \ 798 } while (0) 799 800 /* 801 * Get the head of the inode free list. 802 * Always called with the segment lock held. 803 */ 804 #define LFS_GET_HEADFREE(FS, CIP, BP, FREEP) do { \ 805 if ((FS)->lfs_version > 1) { \ 806 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 807 (FS)->lfs_freehd = (CIP)->free_head; \ 808 brelse(BP, 0); \ 809 } \ 810 *(FREEP) = (FS)->lfs_freehd; \ 811 } while (0) 812 813 #define LFS_PUT_HEADFREE(FS, CIP, BP, VAL) do { \ 814 (FS)->lfs_freehd = (VAL); \ 815 if ((FS)->lfs_version > 1) { \ 816 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 817 (CIP)->free_head = (VAL); \ 818 LFS_BWRITE_LOG(BP); \ 819 mutex_enter(&lfs_lock); \ 820 (FS)->lfs_flags |= LFS_IFDIRTY; \ 821 mutex_exit(&lfs_lock); \ 822 } \ 823 } while (0) 824 825 #define LFS_GET_TAILFREE(FS, CIP, BP, FREEP) do { \ 826 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 827 *(FREEP) = (CIP)->free_tail; \ 828 brelse(BP, 0); \ 829 } while (0) 830 831 #define LFS_PUT_TAILFREE(FS, CIP, BP, VAL) do { \ 832 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 833 (CIP)->free_tail = (VAL); \ 834 LFS_BWRITE_LOG(BP); \ 835 mutex_enter(&lfs_lock); \ 836 (FS)->lfs_flags |= LFS_IFDIRTY; \ 837 mutex_exit(&lfs_lock); \ 838 } while (0) 839 840 /* 841 * On-disk segment summary information 842 */ 843 typedef struct segsum_v1 SEGSUM_V1; 844 struct segsum_v1 { 845 u_int32_t ss_sumsum; /* 0: check sum of summary block */ 846 u_int32_t ss_datasum; /* 4: check sum of data */ 847 u_int32_t ss_magic; /* 8: segment summary magic number */ 848 #define SS_MAGIC 0x061561 849 int32_t ss_next; /* 12: next segment */ 850 u_int32_t ss_create; /* 16: creation time stamp */ 851 u_int16_t ss_nfinfo; /* 20: number of file info structures */ 852 u_int16_t ss_ninos; /* 22: number of inodes in summary */ 853 854 #define SS_DIROP 0x01 /* segment begins a dirop */ 855 #define SS_CONT 0x02 /* more partials to finish this write*/ 856 #define SS_CLEAN 0x04 /* written by the cleaner */ 857 #define SS_RFW 0x08 /* written by the roll-forward agent */ 858 #define SS_RECLAIM 0x10 /* written by the roll-forward agent */ 859 u_int16_t ss_flags; /* 24: used for directory operations */ 860 u_int16_t ss_pad; /* 26: extra space */ 861 /* FINFO's and inode daddr's... */ 862 }; 863 864 typedef struct segsum SEGSUM; 865 struct segsum { 866 u_int32_t ss_sumsum; /* 0: check sum of summary block */ 867 u_int32_t ss_datasum; /* 4: check sum of data */ 868 u_int32_t ss_magic; /* 8: segment summary magic number */ 869 int32_t ss_next; /* 12: next segment */ 870 u_int32_t ss_ident; /* 16: roll-forward fsid */ 871 #define ss_ocreate ss_ident /* ident is where create was in v1 */ 872 u_int16_t ss_nfinfo; /* 20: number of file info structures */ 873 u_int16_t ss_ninos; /* 22: number of inodes in summary */ 874 u_int16_t ss_flags; /* 24: used for directory operations */ 875 u_int8_t ss_pad[2]; /* 26: extra space */ 876 u_int32_t ss_reclino; /* 28: inode being reclaimed */ 877 u_int64_t ss_serial; /* 32: serial number */ 878 u_int64_t ss_create; /* 40: time stamp */ 879 /* FINFO's and inode daddr's... */ 880 }; 881 882 #define SEGSUM_SIZE(fs) ((fs)->lfs_version == 1 ? sizeof(SEGSUM_V1) : sizeof(SEGSUM)) 883 884 885 /* 886 * On-disk super block. 887 */ 888 struct dlfs { 889 #define LFS_MAGIC 0x070162 890 u_int32_t dlfs_magic; /* 0: magic number */ 891 #define LFS_VERSION 2 892 u_int32_t dlfs_version; /* 4: version number */ 893 894 u_int32_t dlfs_size; /* 8: number of blocks in fs (v1) */ 895 /* number of frags in fs (v2) */ 896 u_int32_t dlfs_ssize; /* 12: number of blocks per segment (v1) */ 897 /* number of bytes per segment (v2) */ 898 u_int32_t dlfs_dsize; /* 16: number of disk blocks in fs */ 899 u_int32_t dlfs_bsize; /* 20: file system block size */ 900 u_int32_t dlfs_fsize; /* 24: size of frag blocks in fs */ 901 u_int32_t dlfs_frag; /* 28: number of frags in a block in fs */ 902 903 /* Checkpoint region. */ 904 u_int32_t dlfs_freehd; /* 32: start of the free list */ 905 int32_t dlfs_bfree; /* 36: number of free disk blocks */ 906 u_int32_t dlfs_nfiles; /* 40: number of allocated inodes */ 907 int32_t dlfs_avail; /* 44: blocks available for writing */ 908 int32_t dlfs_uinodes; /* 48: inodes in cache not yet on disk */ 909 int32_t dlfs_idaddr; /* 52: inode file disk address */ 910 u_int32_t dlfs_ifile; /* 56: inode file inode number */ 911 int32_t dlfs_lastseg; /* 60: address of last segment written */ 912 int32_t dlfs_nextseg; /* 64: address of next segment to write */ 913 int32_t dlfs_curseg; /* 68: current segment being written */ 914 int32_t dlfs_offset; /* 72: offset in curseg for next partial */ 915 int32_t dlfs_lastpseg; /* 76: address of last partial written */ 916 u_int32_t dlfs_inopf; /* 80: v1: time stamp; v2: inodes per frag */ 917 #define dlfs_otstamp dlfs_inopf 918 919 /* These are configuration parameters. */ 920 u_int32_t dlfs_minfree; /* 84: minimum percentage of free blocks */ 921 922 /* These fields can be computed from the others. */ 923 u_int64_t dlfs_maxfilesize; /* 88: maximum representable file size */ 924 u_int32_t dlfs_fsbpseg; /* 96: fsb per segment */ 925 u_int32_t dlfs_inopb; /* 100: inodes per block */ 926 u_int32_t dlfs_ifpb; /* 104: IFILE entries per block */ 927 u_int32_t dlfs_sepb; /* 108: SEGUSE entries per block */ 928 u_int32_t dlfs_nindir; /* 112: indirect pointers per block */ 929 u_int32_t dlfs_nseg; /* 116: number of segments */ 930 u_int32_t dlfs_nspf; /* 120: number of sectors per fragment */ 931 u_int32_t dlfs_cleansz; /* 124: cleaner info size in blocks */ 932 u_int32_t dlfs_segtabsz; /* 128: segment table size in blocks */ 933 u_int32_t dlfs_segmask; /* 132: calculate offset within a segment */ 934 u_int32_t dlfs_segshift; /* 136: fast mult/div for segments */ 935 u_int32_t dlfs_bshift; /* 140: calc block number from file offset */ 936 u_int32_t dlfs_ffshift; /* 144: fast mult/div for frag from file */ 937 u_int32_t dlfs_fbshift; /* 148: fast mult/div for frag from block */ 938 u_int64_t dlfs_bmask; /* 152: calc block offset from file offset */ 939 u_int64_t dlfs_ffmask; /* 160: calc frag offset from file offset */ 940 u_int64_t dlfs_fbmask; /* 168: calc frag offset from block offset */ 941 u_int32_t dlfs_blktodb; /* 176: blktodb and dbtoblk shift constant */ 942 u_int32_t dlfs_sushift; /* 180: fast mult/div for segusage table */ 943 944 int32_t dlfs_maxsymlinklen; /* 184: max length of an internal symlink */ 945 #define LFS_MIN_SBINTERVAL 5 /* minimum superblock segment spacing */ 946 #define LFS_MAXNUMSB 10 /* 188: superblock disk offsets */ 947 int32_t dlfs_sboffs[LFS_MAXNUMSB]; 948 949 u_int32_t dlfs_nclean; /* 228: Number of clean segments */ 950 u_char dlfs_fsmnt[MNAMELEN]; /* 232: name mounted on */ 951 #define LFS_PF_CLEAN 0x1 952 u_int16_t dlfs_pflags; /* 322: file system persistent flags */ 953 int32_t dlfs_dmeta; /* 324: total number of dirty summaries */ 954 u_int32_t dlfs_minfreeseg; /* 328: segments not counted in bfree */ 955 u_int32_t dlfs_sumsize; /* 332: size of summary blocks */ 956 u_int64_t dlfs_serial; /* 336: serial number */ 957 u_int32_t dlfs_ibsize; /* 344: size of inode blocks */ 958 int32_t dlfs_start; /* 348: start of segment 0 */ 959 u_int64_t dlfs_tstamp; /* 352: time stamp */ 960 #define LFS_44INODEFMT 0 961 #define LFS_MAXINODEFMT 0 962 u_int32_t dlfs_inodefmt; /* 360: inode format version */ 963 u_int32_t dlfs_interleave; /* 364: segment interleave */ 964 u_int32_t dlfs_ident; /* 368: per-fs identifier */ 965 u_int32_t dlfs_fsbtodb; /* 372: fsbtodb abd dbtodsb shift constant */ 966 u_int32_t dlfs_resvseg; /* 376: segments reserved for the cleaner */ 967 int8_t dlfs_pad[128]; /* 380: round to 512 bytes */ 968 /* Checksum -- last valid disk field. */ 969 u_int32_t dlfs_cksum; /* 508: checksum for superblock checking */ 970 }; 971 972 /* Type used for the inode bitmap */ 973 typedef u_int32_t lfs_bm_t; 974 975 /* 976 * Linked list of segments whose byte count needs updating following a 977 * file truncation. 978 */ 979 struct segdelta { 980 long segnum; 981 size_t num; 982 LIST_ENTRY(segdelta) list; 983 }; 984 985 /* 986 * In-memory super block. 987 */ 988 struct lfs { 989 struct dlfs lfs_dlfs; /* on-disk parameters */ 990 #define lfs_magic lfs_dlfs.dlfs_magic 991 #define lfs_version lfs_dlfs.dlfs_version 992 #define lfs_size lfs_dlfs.dlfs_size 993 #define lfs_ssize lfs_dlfs.dlfs_ssize 994 #define lfs_dsize lfs_dlfs.dlfs_dsize 995 #define lfs_bsize lfs_dlfs.dlfs_bsize 996 #define lfs_fsize lfs_dlfs.dlfs_fsize 997 #define lfs_frag lfs_dlfs.dlfs_frag 998 #define lfs_freehd lfs_dlfs.dlfs_freehd 999 #define lfs_bfree lfs_dlfs.dlfs_bfree 1000 #define lfs_nfiles lfs_dlfs.dlfs_nfiles 1001 #define lfs_avail lfs_dlfs.dlfs_avail 1002 #define lfs_uinodes lfs_dlfs.dlfs_uinodes 1003 #define lfs_idaddr lfs_dlfs.dlfs_idaddr 1004 #define lfs_ifile lfs_dlfs.dlfs_ifile 1005 #define lfs_lastseg lfs_dlfs.dlfs_lastseg 1006 #define lfs_nextseg lfs_dlfs.dlfs_nextseg 1007 #define lfs_curseg lfs_dlfs.dlfs_curseg 1008 #define lfs_offset lfs_dlfs.dlfs_offset 1009 #define lfs_lastpseg lfs_dlfs.dlfs_lastpseg 1010 #define lfs_otstamp lfs_dlfs.dlfs_inopf 1011 #define lfs_inopf lfs_dlfs.dlfs_inopf 1012 #define lfs_minfree lfs_dlfs.dlfs_minfree 1013 #define lfs_maxfilesize lfs_dlfs.dlfs_maxfilesize 1014 #define lfs_fsbpseg lfs_dlfs.dlfs_fsbpseg 1015 #define lfs_inopb lfs_dlfs.dlfs_inopb 1016 #define lfs_ifpb lfs_dlfs.dlfs_ifpb 1017 #define lfs_sepb lfs_dlfs.dlfs_sepb 1018 #define lfs_nindir lfs_dlfs.dlfs_nindir 1019 #define lfs_nseg lfs_dlfs.dlfs_nseg 1020 #define lfs_nspf lfs_dlfs.dlfs_nspf 1021 #define lfs_cleansz lfs_dlfs.dlfs_cleansz 1022 #define lfs_segtabsz lfs_dlfs.dlfs_segtabsz 1023 #define lfs_segmask lfs_dlfs.dlfs_segmask 1024 #define lfs_segshift lfs_dlfs.dlfs_segshift 1025 #define lfs_bmask lfs_dlfs.dlfs_bmask 1026 #define lfs_bshift lfs_dlfs.dlfs_bshift 1027 #define lfs_ffmask lfs_dlfs.dlfs_ffmask 1028 #define lfs_ffshift lfs_dlfs.dlfs_ffshift 1029 #define lfs_fbmask lfs_dlfs.dlfs_fbmask 1030 #define lfs_fbshift lfs_dlfs.dlfs_fbshift 1031 #define lfs_blktodb lfs_dlfs.dlfs_blktodb 1032 #define lfs_fsbtodb lfs_dlfs.dlfs_fsbtodb 1033 #define lfs_sushift lfs_dlfs.dlfs_sushift 1034 #define lfs_maxsymlinklen lfs_dlfs.dlfs_maxsymlinklen 1035 #define lfs_sboffs lfs_dlfs.dlfs_sboffs 1036 #define lfs_cksum lfs_dlfs.dlfs_cksum 1037 #define lfs_pflags lfs_dlfs.dlfs_pflags 1038 #define lfs_fsmnt lfs_dlfs.dlfs_fsmnt 1039 #define lfs_nclean lfs_dlfs.dlfs_nclean 1040 #define lfs_dmeta lfs_dlfs.dlfs_dmeta 1041 #define lfs_minfreeseg lfs_dlfs.dlfs_minfreeseg 1042 #define lfs_sumsize lfs_dlfs.dlfs_sumsize 1043 #define lfs_serial lfs_dlfs.dlfs_serial 1044 #define lfs_ibsize lfs_dlfs.dlfs_ibsize 1045 #define lfs_start lfs_dlfs.dlfs_start 1046 #define lfs_tstamp lfs_dlfs.dlfs_tstamp 1047 #define lfs_inodefmt lfs_dlfs.dlfs_inodefmt 1048 #define lfs_interleave lfs_dlfs.dlfs_interleave 1049 #define lfs_ident lfs_dlfs.dlfs_ident 1050 #define lfs_resvseg lfs_dlfs.dlfs_resvseg 1051 1052 /* These fields are set at mount time and are meaningless on disk. */ 1053 struct segment *lfs_sp; /* current segment being written */ 1054 struct vnode *lfs_ivnode; /* vnode for the ifile */ 1055 u_int32_t lfs_seglock; /* single-thread the segment writer */ 1056 pid_t lfs_lockpid; /* pid of lock holder */ 1057 lwpid_t lfs_locklwp; /* lwp of lock holder */ 1058 u_int32_t lfs_iocount; /* number of ios pending */ 1059 u_int32_t lfs_writer; /* don't allow any dirops to start */ 1060 u_int32_t lfs_dirops; /* count of active directory ops */ 1061 u_int32_t lfs_dirvcount; /* count of VDIROP nodes in this fs */ 1062 u_int32_t lfs_doifile; /* Write ifile blocks on next write */ 1063 u_int32_t lfs_nactive; /* Number of segments since last ckp */ 1064 int8_t lfs_fmod; /* super block modified flag */ 1065 int8_t lfs_ronly; /* mounted read-only flag */ 1066 #define LFS_NOTYET 0x01 1067 #define LFS_IFDIRTY 0x02 1068 #define LFS_WARNED 0x04 1069 #define LFS_UNDIROP 0x08 1070 int8_t lfs_flags; /* currently unused flag */ 1071 u_int16_t lfs_activesb; /* toggle between superblocks */ 1072 daddr_t lfs_sbactive; /* disk address of current sb write */ 1073 struct vnode *lfs_flushvp; /* vnode being flushed */ 1074 int lfs_flushvp_fakevref; /* fake vref count for flushvp */ 1075 struct vnode *lfs_unlockvp; /* being inactivated in lfs_segunlock */ 1076 u_int32_t lfs_diropwait; /* # procs waiting on dirop flush */ 1077 size_t lfs_devbsize; /* Device block size */ 1078 size_t lfs_devbshift; /* Device block shift */ 1079 krwlock_t lfs_fraglock; 1080 krwlock_t lfs_iflock; /* Ifile lock */ 1081 kcondvar_t lfs_stopcv; /* Wrap lock */ 1082 struct lwp *lfs_stoplwp; 1083 pid_t lfs_rfpid; /* Process ID of roll-forward agent */ 1084 int lfs_nadirop; /* number of active dirop nodes */ 1085 long lfs_ravail; /* blocks pre-reserved for writing */ 1086 long lfs_favail; /* blocks pre-reserved for writing */ 1087 res_t *lfs_resblk; /* Reserved memory for pageout */ 1088 TAILQ_HEAD(, inode) lfs_dchainhd; /* dirop vnodes */ 1089 TAILQ_HEAD(, inode) lfs_pchainhd; /* paging vnodes */ 1090 #define LFS_RESHASH_WIDTH 17 1091 LIST_HEAD(, lfs_res_blk) lfs_reshash[LFS_RESHASH_WIDTH]; 1092 int lfs_pdflush; /* pagedaemon wants us to flush */ 1093 u_int32_t **lfs_suflags; /* Segment use flags */ 1094 #ifdef _KERNEL 1095 struct pool lfs_clpool; /* Pool for struct lfs_cluster */ 1096 struct pool lfs_bpppool; /* Pool for bpp */ 1097 struct pool lfs_segpool; /* Pool for struct segment */ 1098 #endif /* _KERNEL */ 1099 #define LFS_MAX_CLEANIND 64 1100 int32_t lfs_cleanint[LFS_MAX_CLEANIND]; /* Active cleaning intervals */ 1101 int lfs_cleanind; /* Index into intervals */ 1102 int lfs_sleepers; /* # procs sleeping this fs */ 1103 int lfs_pages; /* dirty pages blaming this fs */ 1104 lfs_bm_t *lfs_ino_bitmap; /* Inuse inodes bitmap */ 1105 int lfs_nowrap; /* Suspend log wrap */ 1106 int lfs_wrappass; /* Allow first log wrap requester to pass */ 1107 int lfs_wrapstatus; /* Wrap status */ 1108 int lfs_reclino; /* Inode being reclaimed */ 1109 int lfs_startseg; /* Segment we started writing at */ 1110 LIST_HEAD(, segdelta) lfs_segdhd; /* List of pending trunc accounting events */ 1111 }; 1112 1113 /* NINDIR is the number of indirects in a file system block. */ 1114 #define NINDIR(fs) ((fs)->lfs_nindir) 1115 1116 /* INOPB is the number of inodes in a secondary storage block. */ 1117 #define INOPB(fs) ((fs)->lfs_inopb) 1118 /* INOPF is the number of inodes in a fragment. */ 1119 #define INOPF(fs) ((fs)->lfs_inopf) 1120 1121 #define blksize(fs, ip, lbn) \ 1122 (((lbn) >= ULFS_NDADDR || (ip)->i_ffs1_size >= ((lbn) + 1) << (fs)->lfs_bshift) \ 1123 ? (fs)->lfs_bsize \ 1124 : (fragroundup(fs, blkoff(fs, (ip)->i_ffs1_size)))) 1125 #define blkoff(fs, loc) ((int)((loc) & (fs)->lfs_bmask)) 1126 #define fragoff(fs, loc) /* calculates (loc % fs->lfs_fsize) */ \ 1127 ((int)((loc) & (fs)->lfs_ffmask)) 1128 1129 #if defined (_KERNEL) 1130 #define fsbtodb(fs, b) ((b) << ((fs)->lfs_ffshift - DEV_BSHIFT)) 1131 #define dbtofsb(fs, b) ((b) >> ((fs)->lfs_ffshift - DEV_BSHIFT)) 1132 #else 1133 #define fsbtodb(fs, b) ((b) << (fs)->lfs_fsbtodb) 1134 #define dbtofsb(fs, b) ((b) >> (fs)->lfs_fsbtodb) 1135 #endif 1136 1137 #define lblkno(fs, loc) ((loc) >> (fs)->lfs_bshift) 1138 #define lblktosize(fs, blk) ((blk) << (fs)->lfs_bshift) 1139 1140 #define fsbtob(fs, b) ((b) << (fs)->lfs_ffshift) 1141 #define btofsb(fs, b) ((b) >> (fs)->lfs_ffshift) 1142 1143 #define numfrags(fs, loc) /* calculates (loc / fs->lfs_fsize) */ \ 1144 ((loc) >> (fs)->lfs_ffshift) 1145 #define blkroundup(fs, size) /* calculates roundup(size, fs->lfs_bsize) */ \ 1146 ((off_t)(((size) + (fs)->lfs_bmask) & (~(fs)->lfs_bmask))) 1147 #define fragroundup(fs, size) /* calculates roundup(size, fs->lfs_fsize) */ \ 1148 ((off_t)(((size) + (fs)->lfs_ffmask) & (~(fs)->lfs_ffmask))) 1149 #define fragstoblks(fs, frags)/* calculates (frags / fs->fs_frag) */ \ 1150 ((frags) >> (fs)->lfs_fbshift) 1151 #define blkstofrags(fs, blks) /* calculates (blks * fs->fs_frag) */ \ 1152 ((blks) << (fs)->lfs_fbshift) 1153 #define fragnum(fs, fsb) /* calculates (fsb % fs->lfs_frag) */ \ 1154 ((fsb) & ((fs)->lfs_frag - 1)) 1155 #define blknum(fs, fsb) /* calculates rounddown(fsb, fs->lfs_frag) */ \ 1156 ((fsb) &~ ((fs)->lfs_frag - 1)) 1157 #define dblksize(fs, dp, lbn) \ 1158 (((lbn) >= ULFS_NDADDR || (dp)->di_size >= ((lbn) + 1) << (fs)->lfs_bshift)\ 1159 ? (fs)->lfs_bsize \ 1160 : (fragroundup(fs, blkoff(fs, (dp)->di_size)))) 1161 1162 #define segsize(fs) ((fs)->lfs_version == 1 ? \ 1163 lblktosize((fs), (fs)->lfs_ssize) : \ 1164 (fs)->lfs_ssize) 1165 #define segtod(fs, seg) (((fs)->lfs_version == 1 ? \ 1166 (fs)->lfs_ssize << (fs)->lfs_blktodb : \ 1167 btofsb((fs), (fs)->lfs_ssize)) * (seg)) 1168 #define dtosn(fs, daddr) /* block address to segment number */ \ 1169 ((uint32_t)(((daddr) - (fs)->lfs_start) / segtod((fs), 1))) 1170 #define sntod(fs, sn) /* segment number to disk address */ \ 1171 ((daddr_t)(segtod((fs), (sn)) + (fs)->lfs_start)) 1172 1173 /* 1174 * Structures used by lfs_bmapv and lfs_markv to communicate information 1175 * about inodes and data blocks. 1176 */ 1177 typedef struct block_info { 1178 u_int32_t bi_inode; /* inode # */ 1179 int32_t bi_lbn; /* logical block w/in file */ 1180 int32_t bi_daddr; /* disk address of block */ 1181 u_int64_t bi_segcreate; /* origin segment create time */ 1182 int bi_version; /* file version number */ 1183 void *bi_bp; /* data buffer */ 1184 int bi_size; /* size of the block (if fragment) */ 1185 } BLOCK_INFO; 1186 1187 /* Compatibility for 1.5 binaries */ 1188 typedef struct block_info_15 { 1189 u_int32_t bi_inode; /* inode # */ 1190 int32_t bi_lbn; /* logical block w/in file */ 1191 int32_t bi_daddr; /* disk address of block */ 1192 u_int32_t bi_segcreate; /* origin segment create time */ 1193 int bi_version; /* file version number */ 1194 void *bi_bp; /* data buffer */ 1195 int bi_size; /* size of the block (if fragment) */ 1196 } BLOCK_INFO_15; 1197 1198 /* In-memory description of a segment about to be written. */ 1199 struct segment { 1200 struct lfs *fs; /* file system pointer */ 1201 struct buf **bpp; /* pointer to buffer array */ 1202 struct buf **cbpp; /* pointer to next available bp */ 1203 struct buf **start_bpp; /* pointer to first bp in this set */ 1204 struct buf *ibp; /* buffer pointer to inode page */ 1205 struct ulfs1_dinode *idp; /* pointer to ifile dinode */ 1206 struct finfo *fip; /* current fileinfo pointer */ 1207 struct vnode *vp; /* vnode being gathered */ 1208 void *segsum; /* segment summary info */ 1209 u_int32_t ninodes; /* number of inodes in this segment */ 1210 int32_t seg_bytes_left; /* bytes left in segment */ 1211 int32_t sum_bytes_left; /* bytes left in summary block */ 1212 u_int32_t seg_number; /* number of this segment */ 1213 int32_t *start_lbp; /* beginning lbn for this set */ 1214 1215 #define SEGM_CKP 0x0001 /* doing a checkpoint */ 1216 #define SEGM_CLEAN 0x0002 /* cleaner call; don't sort */ 1217 #define SEGM_SYNC 0x0004 /* wait for segment */ 1218 #define SEGM_PROT 0x0008 /* don't inactivate at segunlock */ 1219 #define SEGM_PAGEDAEMON 0x0010 /* pagedaemon called us */ 1220 #define SEGM_WRITERD 0x0020 /* LFS writed called us */ 1221 #define SEGM_FORCE_CKP 0x0040 /* Force checkpoint right away */ 1222 #define SEGM_RECLAIM 0x0080 /* Writing to reclaim vnode */ 1223 #define SEGM_SINGLE 0x0100 /* Opportunistic writevnodes */ 1224 u_int16_t seg_flags; /* run-time flags for this segment */ 1225 u_int32_t seg_iocount; /* number of ios pending */ 1226 int ndupino; /* number of duplicate inodes */ 1227 }; 1228 1229 #ifdef _KERNEL 1230 struct lfs_cluster { 1231 size_t bufsize; /* Size of kept data */ 1232 struct buf **bpp; /* Array of kept buffers */ 1233 int bufcount; /* Number of kept buffers */ 1234 #define LFS_CL_MALLOC 0x00000001 1235 #define LFS_CL_SHIFT 0x00000002 1236 #define LFS_CL_SYNC 0x00000004 1237 u_int32_t flags; /* Flags */ 1238 struct lfs *fs; /* LFS that this belongs to */ 1239 struct segment *seg; /* Segment structure, for LFS_CL_SYNC */ 1240 }; 1241 1242 /* 1243 * Splay tree containing block numbers allocated through lfs_balloc. 1244 */ 1245 struct lbnentry { 1246 SPLAY_ENTRY(lbnentry) entry; 1247 daddr_t lbn; 1248 }; 1249 #endif /* _KERNEL */ 1250 1251 /* 1252 * LFS inode extensions. 1253 */ 1254 struct lfs_inode_ext { 1255 off_t lfs_osize; /* size of file on disk */ 1256 u_int32_t lfs_effnblocks; /* number of blocks when i/o completes */ 1257 size_t lfs_fragsize[ULFS_NDADDR]; /* size of on-disk direct blocks */ 1258 TAILQ_ENTRY(inode) lfs_dchain; /* Dirop chain. */ 1259 TAILQ_ENTRY(inode) lfs_pchain; /* Paging chain. */ 1260 #define LFSI_NO_GOP_WRITE 0x01 1261 #define LFSI_DELETED 0x02 1262 #define LFSI_WRAPBLOCK 0x04 1263 #define LFSI_WRAPWAIT 0x08 1264 #define LFSI_BMAP 0x10 1265 u_int32_t lfs_iflags; /* Inode flags */ 1266 daddr_t lfs_hiblk; /* Highest lbn held by inode */ 1267 #ifdef _KERNEL 1268 SPLAY_HEAD(lfs_splay, lbnentry) lfs_lbtree; /* Tree of balloc'd lbns */ 1269 int lfs_nbtree; /* Size of tree */ 1270 LIST_HEAD(, segdelta) lfs_segdhd; 1271 #endif 1272 int16_t lfs_odnlink; /* on-disk nlink count for cleaner */ 1273 }; 1274 #define i_lfs_osize inode_ext.lfs->lfs_osize 1275 #define i_lfs_effnblks inode_ext.lfs->lfs_effnblocks 1276 #define i_lfs_fragsize inode_ext.lfs->lfs_fragsize 1277 #define i_lfs_dchain inode_ext.lfs->lfs_dchain 1278 #define i_lfs_pchain inode_ext.lfs->lfs_pchain 1279 #define i_lfs_iflags inode_ext.lfs->lfs_iflags 1280 #define i_lfs_hiblk inode_ext.lfs->lfs_hiblk 1281 #define i_lfs_lbtree inode_ext.lfs->lfs_lbtree 1282 #define i_lfs_nbtree inode_ext.lfs->lfs_nbtree 1283 #define i_lfs_segdhd inode_ext.lfs->lfs_segdhd 1284 #define i_lfs_odnlink inode_ext.lfs->lfs_odnlink 1285 1286 /* 1287 * Macros for determining free space on the disk, with the variable metadata 1288 * of segment summaries and inode blocks taken into account. 1289 */ 1290 /* 1291 * Estimate number of clean blocks not available for writing because 1292 * they will contain metadata or overhead. This is calculated as 1293 * 1294 * E = ((C * M / D) * D + (0) * (T - D)) / T 1295 * or more simply 1296 * E = (C * M) / T 1297 * 1298 * where 1299 * C is the clean space, 1300 * D is the dirty space, 1301 * M is the dirty metadata, and 1302 * T = C + D is the total space on disk. 1303 * 1304 * This approximates the old formula of E = C * M / D when D is close to T, 1305 * but avoids falsely reporting "disk full" when the sample size (D) is small. 1306 */ 1307 #define LFS_EST_CMETA(F) (int32_t)(( \ 1308 ((F)->lfs_dmeta * (int64_t)(F)->lfs_nclean) / \ 1309 ((F)->lfs_nseg))) 1310 1311 /* Estimate total size of the disk not including metadata */ 1312 #define LFS_EST_NONMETA(F) ((F)->lfs_dsize - (F)->lfs_dmeta - LFS_EST_CMETA(F)) 1313 1314 /* Estimate number of blocks actually available for writing */ 1315 #define LFS_EST_BFREE(F) ((F)->lfs_bfree > LFS_EST_CMETA(F) ? \ 1316 (F)->lfs_bfree - LFS_EST_CMETA(F) : 0) 1317 1318 /* Amount of non-meta space not available to mortal man */ 1319 #define LFS_EST_RSVD(F) (int32_t)((LFS_EST_NONMETA(F) * \ 1320 (u_int64_t)(F)->lfs_minfree) / \ 1321 100) 1322 1323 /* Can credential C write BB blocks */ 1324 #define ISSPACE(F, BB, C) \ 1325 ((((C) == NOCRED || kauth_cred_geteuid(C) == 0) && \ 1326 LFS_EST_BFREE(F) >= (BB)) || \ 1327 (kauth_cred_geteuid(C) != 0 && IS_FREESPACE(F, BB))) 1328 1329 /* Can an ordinary user write BB blocks */ 1330 #define IS_FREESPACE(F, BB) \ 1331 (LFS_EST_BFREE(F) >= (BB) + LFS_EST_RSVD(F)) 1332 1333 /* 1334 * The minimum number of blocks to create a new inode. This is: 1335 * directory direct block (1) + ULFS_NIADDR indirect blocks + inode block (1) + 1336 * ifile direct block (1) + ULFS_NIADDR indirect blocks = 3 + 2 * ULFS_NIADDR blocks. 1337 */ 1338 #define LFS_NRESERVE(F) (btofsb((F), (2 * ULFS_NIADDR + 3) << (F)->lfs_bshift)) 1339 1340 /* Statistics Counters */ 1341 struct lfs_stats { /* Must match sysctl list in lfs_vfsops.h ! */ 1342 u_int segsused; 1343 u_int psegwrites; 1344 u_int psyncwrites; 1345 u_int pcleanwrites; 1346 u_int blocktot; 1347 u_int cleanblocks; 1348 u_int ncheckpoints; 1349 u_int nwrites; 1350 u_int nsync_writes; 1351 u_int wait_exceeded; 1352 u_int write_exceeded; 1353 u_int flush_invoked; 1354 u_int vflush_invoked; 1355 u_int clean_inlocked; 1356 u_int clean_vnlocked; 1357 u_int segs_reclaimed; 1358 }; 1359 #ifdef _KERNEL 1360 extern struct lfs_stats lfs_stats; 1361 #endif 1362 1363 /* Fcntls to take the place of the lfs syscalls */ 1364 struct lfs_fcntl_markv { 1365 BLOCK_INFO *blkiov; /* blocks to relocate */ 1366 int blkcnt; /* number of blocks */ 1367 }; 1368 1369 #define LFCNSEGWAITALL _FCNR_FSPRIV('L', 14, struct timeval) 1370 #define LFCNSEGWAIT _FCNR_FSPRIV('L', 15, struct timeval) 1371 #define LFCNBMAPV _FCNRW_FSPRIV('L', 2, struct lfs_fcntl_markv) 1372 #define LFCNMARKV _FCNRW_FSPRIV('L', 3, struct lfs_fcntl_markv) 1373 #define LFCNRECLAIM _FCNO_FSPRIV('L', 4) 1374 1375 struct lfs_fhandle { 1376 char space[28]; /* FHANDLE_SIZE_COMPAT (but used from userland too) */ 1377 }; 1378 #define LFCNREWIND _FCNR_FSPRIV('L', 6, int) 1379 #define LFCNINVAL _FCNR_FSPRIV('L', 7, int) 1380 #define LFCNRESIZE _FCNR_FSPRIV('L', 8, int) 1381 #define LFCNWRAPSTOP _FCNR_FSPRIV('L', 9, int) 1382 #define LFCNWRAPGO _FCNR_FSPRIV('L', 10, int) 1383 #define LFCNIFILEFH _FCNW_FSPRIV('L', 11, struct lfs_fhandle) 1384 #define LFCNWRAPPASS _FCNR_FSPRIV('L', 12, int) 1385 # define LFS_WRAP_GOING 0x0 1386 # define LFS_WRAP_WAITING 0x1 1387 #define LFCNWRAPSTATUS _FCNW_FSPRIV('L', 13, int) 1388 1389 /* 1390 * Compat. Defined for kernel only. Userland always uses 1391 * "the one true version". 1392 */ 1393 #ifdef _KERNEL 1394 #include <compat/sys/time_types.h> 1395 1396 #define LFCNSEGWAITALL_COMPAT _FCNW_FSPRIV('L', 0, struct timeval50) 1397 #define LFCNSEGWAIT_COMPAT _FCNW_FSPRIV('L', 1, struct timeval50) 1398 #define LFCNIFILEFH_COMPAT _FCNW_FSPRIV('L', 5, struct lfs_fhandle) 1399 #define LFCNIFILEFH_COMPAT2 _FCN_FSPRIV(F_FSOUT, 'L', 11, 32) 1400 #define LFCNWRAPSTOP_COMPAT _FCNO_FSPRIV('L', 9) 1401 #define LFCNWRAPGO_COMPAT _FCNO_FSPRIV('L', 10) 1402 #define LFCNSEGWAITALL_COMPAT_50 _FCNR_FSPRIV('L', 0, struct timeval50) 1403 #define LFCNSEGWAIT_COMPAT_50 _FCNR_FSPRIV('L', 1, struct timeval50) 1404 #endif 1405 1406 #ifdef _KERNEL 1407 /* XXX MP */ 1408 #define LFS_SEGLOCK_HELD(fs) \ 1409 ((fs)->lfs_seglock != 0 && \ 1410 (fs)->lfs_lockpid == curproc->p_pid && \ 1411 (fs)->lfs_locklwp == curlwp->l_lid) 1412 #endif /* _KERNEL */ 1413 1414 /* Debug segment lock */ 1415 #ifdef notyet 1416 # define ASSERT_SEGLOCK(fs) KASSERT(LFS_SEGLOCK_HELD(fs)) 1417 # define ASSERT_NO_SEGLOCK(fs) KASSERT(!LFS_SEGLOCK_HELD(fs)) 1418 # define ASSERT_DUNNO_SEGLOCK(fs) 1419 # define ASSERT_MAYBE_SEGLOCK(fs) 1420 #else /* !notyet */ 1421 # define ASSERT_DUNNO_SEGLOCK(fs) \ 1422 DLOG((DLOG_SEG, "lfs func %s seglock wrong (%d)\n", __func__, \ 1423 LFS_SEGLOCK_HELD(fs))) 1424 # define ASSERT_SEGLOCK(fs) do { \ 1425 if (!LFS_SEGLOCK_HELD(fs)) { \ 1426 DLOG((DLOG_SEG, "lfs func %s seglock wrong (0)\n", __func__)); \ 1427 } \ 1428 } while(0) 1429 # define ASSERT_NO_SEGLOCK(fs) do { \ 1430 if (LFS_SEGLOCK_HELD(fs)) { \ 1431 DLOG((DLOG_SEG, "lfs func %s seglock wrong (1)\n", __func__)); \ 1432 } \ 1433 } while(0) 1434 # define ASSERT_MAYBE_SEGLOCK(x) 1435 #endif /* !notyet */ 1436 1437 /* 1438 * Arguments to mount LFS filesystems 1439 */ 1440 struct ulfs_args { 1441 char *fspec; /* block special device to mount */ 1442 }; 1443 1444 __BEGIN_DECLS 1445 void lfs_itimes(struct inode *, const struct timespec *, 1446 const struct timespec *, const struct timespec *); 1447 __END_DECLS 1448 1449 #endif /* !_UFS_LFS_LFS_H_ */ 1450
Indexes created Tue Sep 30 20:09:53 GMT 2025