1 /* $NetBSD: lfs_accessors.h,v 1.57 2025/12/02 01:23:09 perseant Exp $ */ 2 3 /* from NetBSD: lfs.h,v 1.165 2015/07/24 06:59:32 dholland Exp */ 4 /* from NetBSD: dinode.h,v 1.25 2016/01/22 23:06:10 dholland Exp */ 5 /* from NetBSD: dir.h,v 1.25 2015/09/01 06:16:03 dholland Exp */ 6 7 /*- 8 * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc. 9 * All rights reserved. 10 * 11 * This code is derived from software contributed to The NetBSD Foundation 12 * by Konrad E. Schroder <perseant (at) hhhh.org>. 13 * 14 * Redistribution and use in source and binary forms, with or without 15 * modification, are permitted provided that the following conditions 16 * are met: 17 * 1. Redistributions of source code must retain the above copyright 18 * notice, this list of conditions and the following disclaimer. 19 * 2. Redistributions in binary form must reproduce the above copyright 20 * notice, this list of conditions and the following disclaimer in the 21 * documentation and/or other materials provided with the distribution. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 24 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 25 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 27 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * POSSIBILITY OF SUCH DAMAGE. 34 */ 35 /*- 36 * Copyright (c) 1991, 1993 37 * The Regents of the University of California. All rights reserved. 38 * 39 * Redistribution and use in source and binary forms, with or without 40 * modification, are permitted provided that the following conditions 41 * are met: 42 * 1. Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * 2. Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in the 46 * documentation and/or other materials provided with the distribution. 47 * 3. Neither the name of the University nor the names of its contributors 48 * may be used to endorse or promote products derived from this software 49 * without specific prior written permission. 50 * 51 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 52 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 54 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 55 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 56 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 57 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 58 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 59 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 60 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 61 * SUCH DAMAGE. 62 * 63 * @(#)lfs.h 8.9 (Berkeley) 5/8/95 64 */ 65 /* 66 * Copyright (c) 2002 Networks Associates Technology, Inc. 67 * All rights reserved. 68 * 69 * This software was developed for the FreeBSD Project by Marshall 70 * Kirk McKusick and Network Associates Laboratories, the Security 71 * Research Division of Network Associates, Inc. under DARPA/SPAWAR 72 * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS 73 * research program 74 * 75 * Copyright (c) 1982, 1989, 1993 76 * The Regents of the University of California. All rights reserved. 77 * (c) UNIX System Laboratories, Inc. 78 * All or some portions of this file are derived from material licensed 79 * to the University of California by American Telephone and Telegraph 80 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 81 * the permission of UNIX System Laboratories, Inc. 82 * 83 * Redistribution and use in source and binary forms, with or without 84 * modification, are permitted provided that the following conditions 85 * are met: 86 * 1. Redistributions of source code must retain the above copyright 87 * notice, this list of conditions and the following disclaimer. 88 * 2. Redistributions in binary form must reproduce the above copyright 89 * notice, this list of conditions and the following disclaimer in the 90 * documentation and/or other materials provided with the distribution. 91 * 3. Neither the name of the University nor the names of its contributors 92 * may be used to endorse or promote products derived from this software 93 * without specific prior written permission. 94 * 95 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 96 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 97 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 98 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 99 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 100 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 101 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 102 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 103 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 104 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 105 * SUCH DAMAGE. 106 * 107 * @(#)dinode.h 8.9 (Berkeley) 3/29/95 108 */ 109 /* 110 * Copyright (c) 1982, 1986, 1989, 1993 111 * The Regents of the University of California. All rights reserved. 112 * (c) UNIX System Laboratories, Inc. 113 * All or some portions of this file are derived from material licensed 114 * to the University of California by American Telephone and Telegraph 115 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 116 * the permission of UNIX System Laboratories, Inc. 117 * 118 * Redistribution and use in source and binary forms, with or without 119 * modification, are permitted provided that the following conditions 120 * are met: 121 * 1. Redistributions of source code must retain the above copyright 122 * notice, this list of conditions and the following disclaimer. 123 * 2. Redistributions in binary form must reproduce the above copyright 124 * notice, this list of conditions and the following disclaimer in the 125 * documentation and/or other materials provided with the distribution. 126 * 3. Neither the name of the University nor the names of its contributors 127 * may be used to endorse or promote products derived from this software 128 * without specific prior written permission. 129 * 130 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 131 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 132 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 133 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 134 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 135 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 136 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 137 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 138 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 139 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 140 * SUCH DAMAGE. 141 * 142 * @(#)dir.h 8.5 (Berkeley) 4/27/95 143 */ 144 145 #ifndef _UFS_LFS_LFS_ACCESSORS_H_ 146 #define _UFS_LFS_LFS_ACCESSORS_H_ 147 148 #if defined(_KERNEL_OPT) 149 #include "opt_lfs.h" 150 #endif 151 152 #include <sys/bswap.h> 153 154 #include <ufs/lfs/lfs.h> 155 156 #if !defined(_KERNEL) && !defined(_STANDALONE) 157 #include <assert.h> 158 #include <string.h> 159 #define KASSERT assert 160 #else 161 #include <sys/systm.h> 162 #endif 163 164 /* 165 * STRUCT_LFS is used by the libsa code to get accessors that work 166 * with struct salfs instead of struct lfs, and by the cleaner to 167 * get accessors that work with struct clfs. 168 */ 169 170 #ifndef STRUCT_LFS 171 #define STRUCT_LFS struct lfs 172 #endif 173 174 /* 175 * byte order 176 */ 177 178 /* 179 * For now at least, the bootblocks shall not be endian-independent. 180 * We can see later if it fits in the size budget. Also disable the 181 * byteswapping if LFS_EI is off. 182 * 183 * Caution: these functions "know" that bswap16/32/64 are unsigned, 184 * and if that changes will likely break silently. 185 */ 186 187 #if defined(_STANDALONE) || (defined(_KERNEL) && !defined(LFS_EI)) 188 #define LFS_SWAP_int16_t(fs, val) (val) 189 #define LFS_SWAP_int32_t(fs, val) (val) 190 #define LFS_SWAP_int64_t(fs, val) (val) 191 #define LFS_SWAP_uint16_t(fs, val) (val) 192 #define LFS_SWAP_uint32_t(fs, val) (val) 193 #define LFS_SWAP_uint64_t(fs, val) (val) 194 #else 195 #define LFS_SWAP_int16_t(fs, val) \ 196 ((fs)->lfs_dobyteswap ? (int16_t)bswap16(val) : (val)) 197 #define LFS_SWAP_int32_t(fs, val) \ 198 ((fs)->lfs_dobyteswap ? (int32_t)bswap32(val) : (val)) 199 #define LFS_SWAP_int64_t(fs, val) \ 200 ((fs)->lfs_dobyteswap ? (int64_t)bswap64(val) : (val)) 201 #define LFS_SWAP_uint16_t(fs, val) \ 202 ((fs)->lfs_dobyteswap ? bswap16(val) : (val)) 203 #define LFS_SWAP_uint32_t(fs, val) \ 204 ((fs)->lfs_dobyteswap ? bswap32(val) : (val)) 205 #define LFS_SWAP_uint64_t(fs, val) \ 206 ((fs)->lfs_dobyteswap ? bswap64(val) : (val)) 207 #endif 208 209 /* 210 * For handling directories we will need to know if the volume is 211 * little-endian. 212 */ 213 #if BYTE_ORDER == LITTLE_ENDIAN 214 #define LFS_LITTLE_ENDIAN_ONDISK(fs) (!(fs)->lfs_dobyteswap) 215 #else 216 #define LFS_LITTLE_ENDIAN_ONDISK(fs) ((fs)->lfs_dobyteswap) 217 #endif 218 219 220 /* 221 * Suppress spurious warnings -- we use 222 * 223 * type *foo = &obj->member; 224 * 225 * in macros to verify that obj->member has the right type. When the 226 * object is a packed structure with misaligned members, this causes 227 * some compiles to squeal that taking the address might lead to 228 * undefined behaviour later on -- which is helpful in general, not 229 * relevant in this case, because we don't do anything with foo 230 * afterward; we only declare it to get a type check and then we 231 * discard it. 232 */ 233 #ifdef __GNUC__ 234 #if defined(__clang__) 235 #pragma clang diagnostic push 236 #pragma clang diagnostic ignored "-Waddress-of-packed-member" 237 #elif __GNUC_PREREQ__(9,0) 238 #pragma GCC diagnostic push 239 #pragma GCC diagnostic ignored "-Waddress-of-packed-member" 240 #endif 241 #endif 242 243 244 245 /* 246 * directories 247 */ 248 249 #define LFS_DIRHEADERSIZE(fs) \ 250 ((fs)->lfs_is64 ? sizeof(struct lfs_dirheader64) : sizeof(struct lfs_dirheader32)) 251 252 /* 253 * The LFS_DIRSIZ macro gives the minimum record length which will hold 254 * the directory entry. This requires the amount of space in struct lfs_direct 255 * without the d_name field, plus enough space for the name with a terminating 256 * null byte (dp->d_namlen+1), rounded up to a 4 byte boundary. 257 */ 258 #define LFS_DIRECTSIZ(fs, namlen) \ 259 (LFS_DIRHEADERSIZE(fs) + (((namlen)+1 + 3) &~ 3)) 260 261 /* 262 * The size of the largest possible directory entry. This is 263 * used by ulfs_dirhash to figure the size of an array, so we 264 * need a single constant value true for both lfs32 and lfs64. 265 */ 266 #define LFS_MAXDIRENTRYSIZE \ 267 (sizeof(struct lfs_dirheader64) + (((LFS_MAXNAMLEN+1)+1 + 3) & ~3)) 268 269 #if (BYTE_ORDER == LITTLE_ENDIAN) 270 #define LFS_OLDDIRSIZ(oldfmt, dp, needswap) \ 271 (((oldfmt) && !(needswap)) ? \ 272 LFS_DIRECTSIZ((dp)->d_type) : LFS_DIRECTSIZ((dp)->d_namlen)) 273 #else 274 #define LFS_OLDDIRSIZ(oldfmt, dp, needswap) \ 275 (((oldfmt) && (needswap)) ? \ 276 LFS_DIRECTSIZ((dp)->d_type) : LFS_DIRECTSIZ((dp)->d_namlen)) 277 #endif 278 279 #define LFS_DIRSIZ(fs, dp) LFS_DIRECTSIZ(fs, lfs_dir_getnamlen(fs, dp)) 280 281 /* Constants for the first argument of LFS_OLDDIRSIZ */ 282 #define LFS_OLDDIRFMT 1 283 #define LFS_NEWDIRFMT 0 284 285 #define LFS_NEXTDIR(fs, dp) \ 286 ((LFS_DIRHEADER *)((char *)(dp) + lfs_dir_getreclen(fs, dp))) 287 288 static __inline char * 289 lfs_dir_nameptr(const STRUCT_LFS *fs, LFS_DIRHEADER *dh) 290 { 291 if (fs->lfs_is64) { 292 return (char *)(&dh->u_64 + 1); 293 } else { 294 return (char *)(&dh->u_32 + 1); 295 } 296 } 297 298 static __inline uint64_t 299 lfs_dir_getino(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh) 300 { 301 if (fs->lfs_is64) { 302 return LFS_SWAP_uint64_t(fs, dh->u_64.dh_ino); 303 } else { 304 return LFS_SWAP_uint32_t(fs, dh->u_32.dh_ino); 305 } 306 } 307 308 static __inline uint16_t 309 lfs_dir_getreclen(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh) 310 { 311 if (fs->lfs_is64) { 312 return LFS_SWAP_uint16_t(fs, dh->u_64.dh_reclen); 313 } else { 314 return LFS_SWAP_uint16_t(fs, dh->u_32.dh_reclen); 315 } 316 } 317 318 static __inline uint8_t 319 lfs_dir_gettype(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh) 320 { 321 if (fs->lfs_is64) { 322 KASSERT(fs->lfs_hasolddirfmt == 0); 323 return dh->u_64.dh_type; 324 } else if (fs->lfs_hasolddirfmt) { 325 return LFS_DT_UNKNOWN; 326 } else { 327 return dh->u_32.dh_type; 328 } 329 } 330 331 static __inline uint8_t 332 lfs_dir_getnamlen(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh) 333 { 334 if (fs->lfs_is64) { 335 KASSERT(fs->lfs_hasolddirfmt == 0); 336 return dh->u_64.dh_namlen; 337 } else if (fs->lfs_hasolddirfmt && LFS_LITTLE_ENDIAN_ONDISK(fs)) { 338 /* low-order byte of old 16-bit namlen field */ 339 return dh->u_32.dh_type; 340 } else { 341 return dh->u_32.dh_namlen; 342 } 343 } 344 345 static __inline void 346 lfs_dir_setino(STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint64_t ino) 347 { 348 if (fs->lfs_is64) { 349 dh->u_64.dh_ino = LFS_SWAP_uint64_t(fs, ino); 350 } else { 351 dh->u_32.dh_ino = LFS_SWAP_uint32_t(fs, ino); 352 } 353 } 354 355 static __inline void 356 lfs_dir_setreclen(STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint16_t reclen) 357 { 358 if (fs->lfs_is64) { 359 dh->u_64.dh_reclen = LFS_SWAP_uint16_t(fs, reclen); 360 } else { 361 dh->u_32.dh_reclen = LFS_SWAP_uint16_t(fs, reclen); 362 } 363 } 364 365 static __inline void 366 lfs_dir_settype(const STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint8_t type) 367 { 368 if (fs->lfs_is64) { 369 KASSERT(fs->lfs_hasolddirfmt == 0); 370 dh->u_64.dh_type = type; 371 } else if (fs->lfs_hasolddirfmt) { 372 /* do nothing */ 373 return; 374 } else { 375 dh->u_32.dh_type = type; 376 } 377 } 378 379 static __inline void 380 lfs_dir_setnamlen(const STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint8_t namlen) 381 { 382 if (fs->lfs_is64) { 383 KASSERT(fs->lfs_hasolddirfmt == 0); 384 dh->u_64.dh_namlen = namlen; 385 } else if (fs->lfs_hasolddirfmt && LFS_LITTLE_ENDIAN_ONDISK(fs)) { 386 /* low-order byte of old 16-bit namlen field */ 387 dh->u_32.dh_type = namlen; 388 } else { 389 dh->u_32.dh_namlen = namlen; 390 } 391 } 392 393 static __inline void 394 lfs_copydirname(STRUCT_LFS *fs, char *dest, const char *src, 395 unsigned namlen, unsigned reclen) 396 { 397 unsigned spacelen; 398 399 KASSERT(reclen > LFS_DIRHEADERSIZE(fs)); 400 spacelen = reclen - LFS_DIRHEADERSIZE(fs); 401 402 /* must always be at least 1 byte as a null terminator */ 403 KASSERT(spacelen > namlen); 404 405 memcpy(dest, src, namlen); 406 memset(dest + namlen, '\0', spacelen - namlen); 407 } 408 409 static __inline LFS_DIRHEADER * 410 lfs_dirtemplate_dotdot(STRUCT_LFS *fs, union lfs_dirtemplate *dt) 411 { 412 /* XXX blah, be nice to have a way to do this w/o casts */ 413 if (fs->lfs_is64) { 414 return (LFS_DIRHEADER *)&dt->u_64.dotdot_header; 415 } else { 416 return (LFS_DIRHEADER *)&dt->u_32.dotdot_header; 417 } 418 } 419 420 static __inline char * 421 lfs_dirtemplate_dotdotname(STRUCT_LFS *fs, union lfs_dirtemplate *dt) 422 { 423 if (fs->lfs_is64) { 424 return dt->u_64.dotdot_name; 425 } else { 426 return dt->u_32.dotdot_name; 427 } 428 } 429 430 /* 431 * dinodes 432 */ 433 434 /* 435 * Maximum length of a symlink that can be stored within the inode. 436 */ 437 #define LFS32_MAXSYMLINKLEN ((ULFS_NDADDR + ULFS_NIADDR) * sizeof(int32_t)) 438 #define LFS64_MAXSYMLINKLEN ((ULFS_NDADDR + ULFS_NIADDR) * sizeof(int64_t)) 439 440 #define LFS_MAXSYMLINKLEN(fs) \ 441 ((fs)->lfs_is64 ? LFS64_MAXSYMLINKLEN : LFS32_MAXSYMLINKLEN) 442 443 #define DINOSIZE(fs) ((fs)->lfs_is64 ? sizeof(struct lfs64_dinode) : sizeof(struct lfs32_dinode)) 444 445 #define DINO_IN_BLOCK(fs, base, ix) \ 446 ((union lfs_dinode *)((char *)(base) + DINOSIZE(fs) * (ix))) 447 448 static __inline void 449 lfs_copy_dinode(STRUCT_LFS *fs, 450 union lfs_dinode *dst, const union lfs_dinode *src) 451 { 452 /* 453 * We can do structure assignment of the structs, but not of 454 * the whole union, as the union is the size of the (larger) 455 * 64-bit struct and on a 32-bit fs the upper half of it might 456 * be off the end of a buffer or otherwise invalid. 457 */ 458 if (fs->lfs_is64) { 459 dst->u_64 = src->u_64; 460 } else { 461 dst->u_32 = src->u_32; 462 } 463 } 464 465 #define LFS_DEF_DINO_ACCESSOR(type, type32, field) \ 466 static __inline type \ 467 lfs_dino_get##field(STRUCT_LFS *fs, union lfs_dinode *dip) \ 468 { \ 469 if (fs->lfs_is64) { \ 470 return LFS_SWAP_##type(fs, dip->u_64.di_##field); \ 471 } else { \ 472 return LFS_SWAP_##type32(fs, dip->u_32.di_##field); \ 473 } \ 474 } \ 475 static __inline void \ 476 lfs_dino_set##field(STRUCT_LFS *fs, union lfs_dinode *dip, type val) \ 477 { \ 478 if (fs->lfs_is64) { \ 479 type *p = &dip->u_64.di_##field; \ 480 (void)p; \ 481 dip->u_64.di_##field = LFS_SWAP_##type(fs, val); \ 482 } else { \ 483 type32 *p = &dip->u_32.di_##field; \ 484 (void)p; \ 485 dip->u_32.di_##field = LFS_SWAP_##type32(fs, val); \ 486 } \ 487 } \ 488 489 LFS_DEF_DINO_ACCESSOR(uint16_t, uint16_t, mode) 490 LFS_DEF_DINO_ACCESSOR(int16_t, int16_t, nlink) 491 LFS_DEF_DINO_ACCESSOR(uint64_t, uint32_t, inumber) 492 LFS_DEF_DINO_ACCESSOR(uint64_t, uint64_t, size) 493 LFS_DEF_DINO_ACCESSOR(int64_t, int32_t, atime) 494 LFS_DEF_DINO_ACCESSOR(int32_t, int32_t, atimensec) 495 LFS_DEF_DINO_ACCESSOR(int64_t, int32_t, mtime) 496 LFS_DEF_DINO_ACCESSOR(int32_t, int32_t, mtimensec) 497 LFS_DEF_DINO_ACCESSOR(int64_t, int32_t, ctime) 498 LFS_DEF_DINO_ACCESSOR(int32_t, int32_t, ctimensec) 499 LFS_DEF_DINO_ACCESSOR(uint32_t, uint32_t, flags) 500 LFS_DEF_DINO_ACCESSOR(uint64_t, uint32_t, blocks) 501 LFS_DEF_DINO_ACCESSOR(int32_t, int32_t, gen) 502 LFS_DEF_DINO_ACCESSOR(uint32_t, uint32_t, uid) 503 LFS_DEF_DINO_ACCESSOR(uint32_t, uint32_t, gid) 504 505 /* XXX this should be done differently (it's a fake field) */ 506 LFS_DEF_DINO_ACCESSOR(int64_t, int32_t, rdev) 507 508 static __inline daddr_t 509 lfs_dino_getdb(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix) 510 { 511 KASSERT(ix < ULFS_NDADDR); 512 if (fs->lfs_is64) { 513 return LFS_SWAP_int64_t(fs, dip->u_64.di_db[ix]); 514 } else { 515 /* note: this must sign-extend or UNWRITTEN gets trashed */ 516 return (int32_t)LFS_SWAP_int32_t(fs, dip->u_32.di_db[ix]); 517 } 518 } 519 520 static __inline daddr_t 521 lfs_dino_getib(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix) 522 { 523 KASSERT(ix < ULFS_NIADDR); 524 if (fs->lfs_is64) { 525 return LFS_SWAP_int64_t(fs, dip->u_64.di_ib[ix]); 526 } else { 527 /* note: this must sign-extend or UNWRITTEN gets trashed */ 528 return (int32_t)LFS_SWAP_int32_t(fs, dip->u_32.di_ib[ix]); 529 } 530 } 531 532 static __inline void 533 lfs_dino_setdb(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix, daddr_t val) 534 { 535 KASSERT(ix < ULFS_NDADDR); 536 if (fs->lfs_is64) { 537 dip->u_64.di_db[ix] = LFS_SWAP_int64_t(fs, val); 538 } else { 539 dip->u_32.di_db[ix] = LFS_SWAP_uint32_t(fs, val); 540 } 541 } 542 543 static __inline void 544 lfs_dino_setib(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix, daddr_t val) 545 { 546 KASSERT(ix < ULFS_NIADDR); 547 if (fs->lfs_is64) { 548 dip->u_64.di_ib[ix] = LFS_SWAP_int64_t(fs, val); 549 } else { 550 dip->u_32.di_ib[ix] = LFS_SWAP_uint32_t(fs, val); 551 } 552 } 553 554 /* birthtime is present only in the 64-bit inode */ 555 static __inline void 556 lfs_dino_setbirthtime(STRUCT_LFS *fs, union lfs_dinode *dip, 557 const struct timespec *ts) 558 { 559 if (fs->lfs_is64) { 560 dip->u_64.di_birthtime = ts->tv_sec; 561 dip->u_64.di_birthnsec = ts->tv_nsec; 562 } else { 563 /* drop it on the floor */ 564 } 565 } 566 567 /* 568 * indirect blocks 569 */ 570 571 static __inline daddr_t 572 lfs_iblock_get(STRUCT_LFS *fs, void *block, unsigned ix) 573 { 574 if (fs->lfs_is64) { 575 // XXX re-enable these asserts after reorging this file 576 //KASSERT(ix < lfs_sb_getbsize(fs) / sizeof(int64_t)); 577 return (daddr_t)(((int64_t *)block)[ix]); 578 } else { 579 //KASSERT(ix < lfs_sb_getbsize(fs) / sizeof(int32_t)); 580 /* must sign-extend or UNWRITTEN gets trashed */ 581 return (daddr_t)(int64_t)(((int32_t *)block)[ix]); 582 } 583 } 584 585 static __inline void 586 lfs_iblock_set(STRUCT_LFS *fs, void *block, unsigned ix, daddr_t val) 587 { 588 if (fs->lfs_is64) { 589 //KASSERT(ix < lfs_sb_getbsize(fs) / sizeof(int64_t)); 590 ((int64_t *)block)[ix] = val; 591 } else { 592 //KASSERT(ix < lfs_sb_getbsize(fs) / sizeof(int32_t)); 593 ((int32_t *)block)[ix] = val; 594 } 595 } 596 597 /* 598 * "struct buf" associated definitions 599 */ 600 601 # define LFS_LOCK_BUF(bp) do { \ 602 if (((bp)->b_flags & B_LOCKED) == 0 && bp->b_iodone == NULL) { \ 603 mutex_enter(&lfs_lock); \ 604 ++locked_queue_count; \ 605 locked_queue_bytes += bp->b_bufsize; \ 606 mutex_exit(&lfs_lock); \ 607 } \ 608 (bp)->b_flags |= B_LOCKED; \ 609 } while (0) 610 611 # define LFS_UNLOCK_BUF(bp) do { \ 612 if (((bp)->b_flags & B_LOCKED) != 0 && bp->b_iodone == NULL) { \ 613 mutex_enter(&lfs_lock); \ 614 --locked_queue_count; \ 615 locked_queue_bytes -= bp->b_bufsize; \ 616 if (locked_queue_count < LFS_WAIT_BUFS && \ 617 locked_queue_bytes < LFS_WAIT_BYTES) \ 618 cv_broadcast(&locked_queue_cv); \ 619 mutex_exit(&lfs_lock); \ 620 } \ 621 (bp)->b_flags &= ~B_LOCKED; \ 622 } while (0) 623 624 /* 625 * "struct inode" associated definitions 626 */ 627 628 #define LFS_SET_UINO(ip, states) do { \ 629 if (((states) & IN_ACCESSED) && !((ip)->i_state & IN_ACCESSED)) \ 630 lfs_sb_adduinodes((ip)->i_lfs, 1); \ 631 if (((states) & IN_CLEANING) && !((ip)->i_state & IN_CLEANING)) \ 632 lfs_sb_adduinodes((ip)->i_lfs, 1); \ 633 if (((states) & IN_MODIFIED) && !((ip)->i_state & IN_MODIFIED)) \ 634 lfs_sb_adduinodes((ip)->i_lfs, 1); \ 635 (ip)->i_state |= (states); \ 636 } while (0) 637 638 #define LFS_CLR_UINO(ip, states) do { \ 639 if (((states) & IN_ACCESSED) && ((ip)->i_state & IN_ACCESSED)) \ 640 lfs_sb_subuinodes((ip)->i_lfs, 1); \ 641 if (((states) & IN_CLEANING) && ((ip)->i_state & IN_CLEANING)) \ 642 lfs_sb_subuinodes((ip)->i_lfs, 1); \ 643 if (((states) & IN_MODIFIED) && ((ip)->i_state & IN_MODIFIED)) \ 644 lfs_sb_subuinodes((ip)->i_lfs, 1); \ 645 (ip)->i_state &= ~(states); \ 646 if (lfs_sb_getuinodes((ip)->i_lfs) < 0) { \ 647 panic("lfs_uinodes < 0"); \ 648 } \ 649 } while (0) 650 651 #define LFS_ITIMES(ip, acc, mod, cre) \ 652 while ((ip)->i_state & (IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFY)) \ 653 lfs_itimes(ip, acc, mod, cre) 654 655 /* 656 * On-disk and in-memory checkpoint segment usage structure. 657 */ 658 659 #define SEGUPB(fs) (lfs_sb_getsepb(fs)) 660 #define SEGTABSIZE_SU(fs) \ 661 ((lfs_sb_getnseg(fs) + SEGUPB(fs) - 1) / lfs_sb_getsepb(fs)) 662 663 #ifdef _KERNEL 664 # define SHARE_IFLOCK(F) \ 665 do { \ 666 rw_enter(&(F)->lfs_iflock, RW_READER); \ 667 } while(0) 668 # define UNSHARE_IFLOCK(F) \ 669 do { \ 670 rw_exit(&(F)->lfs_iflock); \ 671 } while(0) 672 #else /* ! _KERNEL */ 673 # define SHARE_IFLOCK(F) 674 # define UNSHARE_IFLOCK(F) 675 #endif /* ! _KERNEL */ 676 677 /* Read in the block with a specific segment usage entry from the ifile. */ 678 #define LFS_SEGENTRY(SP, F, IN, BP) do { \ 679 int _e; \ 680 SHARE_IFLOCK(F); \ 681 VTOI((F)->lfs_ivnode)->i_state |= IN_ACCESS; \ 682 if ((_e = bread((F)->lfs_ivnode, \ 683 ((IN) / lfs_sb_getsepb(F)) + lfs_sb_getcleansz(F), \ 684 lfs_sb_getbsize(F), 0, &(BP))) != 0) \ 685 panic("lfs: ifile read: segentry %llu: error %d\n", \ 686 (unsigned long long)(IN), _e); \ 687 if (lfs_sb_getversion(F) == 1) \ 688 (SP) = (SEGUSE *)((SEGUSE_V1 *)(BP)->b_data + \ 689 ((IN) & (lfs_sb_getsepb(F) - 1))); \ 690 else \ 691 (SP) = (SEGUSE *)(BP)->b_data + ((IN) % lfs_sb_getsepb(F)); \ 692 UNSHARE_IFLOCK(F); \ 693 } while (0) 694 695 #define LFS_WRITESEGENTRY(SP, F, IN, BP) do { \ 696 if (((BP)->b_flags & B_GATHERED) == 0) \ 697 (F)->lfs_flags |= LFS_IFDIRTY; \ 698 LFS_BWRITE_LOG(BP); \ 699 } while (0) 700 701 /* 702 * FINFO (file info) entries. 703 */ 704 705 /* Size of an on-disk block pointer, e.g. in an indirect block. */ 706 /* XXX: move to a more suitable location in this file */ 707 #define LFS_BLKPTRSIZE(fs) ((fs)->lfs_is64 ? sizeof(int64_t) : sizeof(int32_t)) 708 709 /* Size of an on-disk inode number. */ 710 /* XXX: move to a more suitable location in this file */ 711 #define LFS_INUMSIZE(fs) ((fs)->lfs_is64 ? sizeof(int64_t) : sizeof(int32_t)) 712 713 /* size of a FINFO, without the block pointers */ 714 #define FINFOSIZE(fs) ((fs)->lfs_is64 ? sizeof(FINFO64) : sizeof(FINFO32)) 715 716 /* Full size of the provided FINFO record, including its block pointers. */ 717 #define FINFO_FULLSIZE(fs, fip) \ 718 (FINFOSIZE(fs) + lfs_fi_getnblocks(fs, fip) * LFS_BLKPTRSIZE(fs)) 719 720 #define NEXT_FINFO(fs, fip) \ 721 ((FINFO *)((char *)(fip) + FINFO_FULLSIZE(fs, fip))) 722 723 #define LFS_DEF_FI_ACCESSOR(type, type32, field) \ 724 static __inline type \ 725 lfs_fi_get##field(STRUCT_LFS *fs, FINFO *fip) \ 726 { \ 727 if (fs->lfs_is64) { \ 728 return fip->u_64.fi_##field; \ 729 } else { \ 730 return fip->u_32.fi_##field; \ 731 } \ 732 } \ 733 static __inline void \ 734 lfs_fi_set##field(STRUCT_LFS *fs, FINFO *fip, type val) \ 735 { \ 736 if (fs->lfs_is64) { \ 737 type *p = &fip->u_64.fi_##field; \ 738 (void)p; \ 739 fip->u_64.fi_##field = val; \ 740 } else { \ 741 type32 *p = &fip->u_32.fi_##field; \ 742 (void)p; \ 743 fip->u_32.fi_##field = val; \ 744 } \ 745 } \ 746 747 LFS_DEF_FI_ACCESSOR(uint32_t, uint32_t, nblocks) 748 LFS_DEF_FI_ACCESSOR(uint32_t, uint32_t, version) 749 LFS_DEF_FI_ACCESSOR(uint64_t, uint32_t, ino) 750 LFS_DEF_FI_ACCESSOR(uint32_t, uint32_t, lastlength) 751 752 static __inline daddr_t 753 lfs_fi_getblock(STRUCT_LFS *fs, FINFO *fip, unsigned idx) 754 { 755 void *firstblock; 756 757 firstblock = (char *)fip + FINFOSIZE(fs); 758 KASSERT(idx < lfs_fi_getnblocks(fs, fip)); 759 if (fs->lfs_is64) { 760 return ((int64_t *)firstblock)[idx]; 761 } else { 762 return ((int32_t *)firstblock)[idx]; 763 } 764 } 765 766 static __inline void 767 lfs_fi_setblock(STRUCT_LFS *fs, FINFO *fip, unsigned idx, daddr_t blk) 768 { 769 void *firstblock; 770 771 firstblock = (char *)fip + FINFOSIZE(fs); 772 KASSERT(idx < lfs_fi_getnblocks(fs, fip)); 773 if (fs->lfs_is64) { 774 ((int64_t *)firstblock)[idx] = blk; 775 } else { 776 ((int32_t *)firstblock)[idx] = blk; 777 } 778 } 779 780 /* 781 * inode info entries (in the segment summary) 782 */ 783 784 #define IINFOSIZE(fs) ((fs)->lfs_is64 ? sizeof(IINFO64) : sizeof(IINFO32)) 785 786 /* iinfos scroll backward from the end of the segment summary block */ 787 #define SEGSUM_IINFOSTART(fs, buf) \ 788 ((IINFO *)((char *)buf + lfs_sb_getsumsize(fs) - IINFOSIZE(fs))) 789 790 #define NEXTLOWER_IINFO(fs, iip) \ 791 ((IINFO *)((char *)(iip) - IINFOSIZE(fs))) 792 793 #define NTH_IINFO(fs, buf, n) \ 794 ((IINFO *)((char *)SEGSUM_IINFOSTART(fs, buf) - (n)*IINFOSIZE(fs))) 795 796 static __inline uint64_t 797 lfs_ii_getblock(STRUCT_LFS *fs, IINFO *iip) 798 { 799 if (fs->lfs_is64) { 800 return iip->u_64.ii_block; 801 } else { 802 return iip->u_32.ii_block; 803 } 804 } 805 806 static __inline void 807 lfs_ii_setblock(STRUCT_LFS *fs, IINFO *iip, uint64_t block) 808 { 809 if (fs->lfs_is64) { 810 iip->u_64.ii_block = block; 811 } else { 812 iip->u_32.ii_block = block; 813 } 814 } 815 816 /* 817 * Index file inode entries. 818 */ 819 820 #define IFILE_ENTRYSIZE(fs) \ 821 ((fs)->lfs_is64 ? sizeof(IFILE64) : sizeof(IFILE32)) 822 823 /* No valid inode number can be as high as this */ 824 #ifdef _KERNEL 825 # define LFS_MAXINO(fs) (((fs->lfs_ivnode->v_size >> lfs_sb_getbshift(fs)) \ 826 - lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) \ 827 * lfs_sb_getifpb(fs)) 828 #define LFS_ASSERT_MAXINO(fs, ino) KASSERTMSG(ino < LFS_MAXINO(fs), \ 829 "inode %jd >= max %jd", (intmax_t)(ino), (intmax_t)LFS_MAXINO(fs)); 830 831 #endif 832 833 /* 834 * LFSv1 compatibility code is not allowed to touch if_atime, since it 835 * may not be mapped! 836 */ 837 /* Read in the block with a specific inode from the ifile. */ 838 #define LFS_IENTRY_INBLOCK(IP, F, IN, BP) do { \ 839 if ((F)->lfs_is64) { \ 840 (IP) = (IFILE *)((IFILE64 *)(BP)->b_data + \ 841 (IN) % lfs_sb_getifpb(F)); \ 842 } else if (lfs_sb_getversion(F) > 1) { \ 843 (IP) = (IFILE *)((IFILE32 *)(BP)->b_data + \ 844 (IN) % lfs_sb_getifpb(F)); \ 845 } else { \ 846 (IP) = (IFILE *)((IFILE_V1 *)(BP)->b_data + \ 847 (IN) % lfs_sb_getifpb(F)); \ 848 } \ 849 } while (0) 850 #define LFS_IENTRY(IP, F, IN, BP) do { \ 851 int _e; \ 852 SHARE_IFLOCK(F); \ 853 VTOI((F)->lfs_ivnode)->i_state |= IN_ACCESS; \ 854 if ((_e = bread((F)->lfs_ivnode, \ 855 (IN) / lfs_sb_getifpb(F) + lfs_sb_getcleansz(F) + lfs_sb_getsegtabsz(F), \ 856 lfs_sb_getbsize(F), 0, &(BP))) != 0) \ 857 panic("lfs: ifile ino %d read %d", (int)(IN), _e); \ 858 LFS_IENTRY_INBLOCK(IP, F, IN, BP); \ 859 UNSHARE_IFLOCK(F); \ 860 } while (0) 861 #define LFS_IENTRY_NEXT(IP, F) do { \ 862 if ((F)->lfs_is64) { \ 863 (IP) = (IFILE *)((IFILE64 *)(IP) + 1); \ 864 } else if (lfs_sb_getversion(F) > 1) { \ 865 (IP) = (IFILE *)((IFILE32 *)(IP) + 1); \ 866 } else { \ 867 (IP) = (IFILE *)((IFILE_V1 *)(IP) + 1); \ 868 } \ 869 } while (0) 870 #define LFS_WRITEIENTRY(IP, F, IN, BP) do { \ 871 if (((BP)->b_flags & B_GATHERED) == 0) \ 872 (F)->lfs_flags |= LFS_IFDIRTY; \ 873 LFS_BWRITE_LOG(BP); \ 874 } while (0) 875 876 #define LFS_DEF_IF_ACCESSOR(type, type32, field) \ 877 static __inline type \ 878 lfs_if_get##field(STRUCT_LFS *fs, IFILE *ifp) \ 879 { \ 880 if (fs->lfs_is64) { \ 881 return ifp->u_64.if_##field; \ 882 } else { \ 883 return ifp->u_32.if_##field; \ 884 } \ 885 } \ 886 static __inline void \ 887 lfs_if_set##field(STRUCT_LFS *fs, IFILE *ifp, type val) \ 888 { \ 889 if (fs->lfs_is64) { \ 890 type *p = &ifp->u_64.if_##field; \ 891 (void)p; \ 892 ifp->u_64.if_##field = val; \ 893 } else { \ 894 type32 *p = &ifp->u_32.if_##field; \ 895 (void)p; \ 896 ifp->u_32.if_##field = val; \ 897 } \ 898 } \ 899 900 LFS_DEF_IF_ACCESSOR(uint32_t, uint32_t, version) 901 LFS_DEF_IF_ACCESSOR(int64_t, int32_t, daddr) 902 LFS_DEF_IF_ACCESSOR(uint64_t, uint32_t, nextfree) 903 LFS_DEF_IF_ACCESSOR(uint64_t, uint32_t, atime_sec) 904 LFS_DEF_IF_ACCESSOR(uint32_t, uint32_t, atime_nsec) 905 906 /* 907 * Cleaner information structure. This resides in the ifile and is used 908 * to pass information from the kernel to the cleaner. 909 */ 910 911 #define CLEANSIZE_SU(fs) \ 912 ((((fs)->lfs_is64 ? sizeof(CLEANERINFO64) : sizeof(CLEANERINFO32)) + \ 913 lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs)) 914 915 #define LFS_DEF_CI_ACCESSOR(type, type32, field) \ 916 static __inline type \ 917 lfs_ci_get##field(STRUCT_LFS *fs, CLEANERINFO *cip) \ 918 { \ 919 if (fs->lfs_is64) { \ 920 return cip->u_64.field; \ 921 } else { \ 922 return cip->u_32.field; \ 923 } \ 924 } \ 925 static __inline void \ 926 lfs_ci_set##field(STRUCT_LFS *fs, CLEANERINFO *cip, type val) \ 927 { \ 928 if (fs->lfs_is64) { \ 929 type *p = &cip->u_64.field; \ 930 (void)p; \ 931 cip->u_64.field = val; \ 932 } else { \ 933 type32 *p = &cip->u_32.field; \ 934 (void)p; \ 935 cip->u_32.field = val; \ 936 } \ 937 } \ 938 939 LFS_DEF_CI_ACCESSOR(uint32_t, uint32_t, clean) 940 LFS_DEF_CI_ACCESSOR(uint32_t, uint32_t, dirty) 941 LFS_DEF_CI_ACCESSOR(int64_t, int32_t, bfree) 942 LFS_DEF_CI_ACCESSOR(int64_t, int32_t, avail) 943 LFS_DEF_CI_ACCESSOR(uint64_t, uint32_t, free_head) 944 LFS_DEF_CI_ACCESSOR(uint64_t, uint32_t, free_tail) 945 LFS_DEF_CI_ACCESSOR(uint32_t, uint32_t, flags) 946 947 static __inline void 948 lfs_ci_shiftcleantodirty(STRUCT_LFS *fs, CLEANERINFO *cip, unsigned num) 949 { 950 lfs_ci_setclean(fs, cip, lfs_ci_getclean(fs, cip) - num); 951 lfs_ci_setdirty(fs, cip, lfs_ci_getdirty(fs, cip) + num); 952 } 953 954 static __inline void 955 lfs_ci_shiftdirtytoclean(STRUCT_LFS *fs, CLEANERINFO *cip, unsigned num) 956 { 957 lfs_ci_setdirty(fs, cip, lfs_ci_getdirty(fs, cip) - num); 958 lfs_ci_setclean(fs, cip, lfs_ci_getclean(fs, cip) + num); 959 } 960 961 /* Read in the block with the cleaner info from the ifile. */ 962 #define LFS_CLEANERINFO(CP, F, BP) do { \ 963 int _e; \ 964 SHARE_IFLOCK(F); \ 965 VTOI((F)->lfs_ivnode)->i_state |= IN_ACCESS; \ 966 _e = bread((F)->lfs_ivnode, \ 967 (daddr_t)0, lfs_sb_getbsize(F), 0, &(BP)); \ 968 if (_e) \ 969 panic("lfs: ifile read: cleanerinfo: error %d\n", _e); \ 970 (CP) = (CLEANERINFO *)(BP)->b_data; \ 971 UNSHARE_IFLOCK(F); \ 972 } while (0) 973 974 /* 975 * Synchronize the Ifile cleaner info with current avail and bfree. 976 */ 977 #define LFS_SYNC_CLEANERINFO(cip, fs, bp, w) do { \ 978 mutex_enter(&lfs_lock); \ 979 if ((w) || lfs_ci_getbfree(fs, cip) != lfs_sb_getbfree(fs) || \ 980 lfs_ci_getavail(fs, cip) != lfs_sb_getavail(fs) - fs->lfs_ravail - \ 981 fs->lfs_favail) { \ 982 lfs_ci_setbfree(fs, cip, lfs_sb_getbfree(fs)); \ 983 lfs_ci_setavail(fs, cip, lfs_sb_getavail(fs) - fs->lfs_ravail - \ 984 fs->lfs_favail); \ 985 if (((bp)->b_flags & B_GATHERED) == 0) { \ 986 fs->lfs_flags |= LFS_IFDIRTY; \ 987 } \ 988 mutex_exit(&lfs_lock); \ 989 (void) LFS_BWRITE_LOG(bp); /* Ifile */ \ 990 } else { \ 991 mutex_exit(&lfs_lock); \ 992 brelse(bp, 0); \ 993 } \ 994 } while (0) 995 996 /* 997 * Get the head of the inode free list. 998 * Always called with the segment lock held. 999 */ 1000 #define LFS_GET_HEADFREE(FS, CIP, BP, FREEP) do { \ 1001 if (lfs_sb_getversion(FS) > 1) { \ 1002 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 1003 lfs_sb_setfreehd(FS, lfs_ci_getfree_head(FS, CIP)); \ 1004 brelse(BP, 0); \ 1005 } \ 1006 *(FREEP) = lfs_sb_getfreehd(FS); \ 1007 } while (0) 1008 1009 #define LFS_PUT_HEADFREE(FS, CIP, BP, VAL) do { \ 1010 lfs_sb_setfreehd(FS, VAL); \ 1011 if (lfs_sb_getversion(FS) > 1) { \ 1012 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 1013 lfs_ci_setfree_head(FS, CIP, VAL); \ 1014 if ((VAL) == LFS_UNUSED_INUM) \ 1015 lfs_ci_setfree_tail(FS, CIP, VAL); \ 1016 mutex_enter(&lfs_lock); \ 1017 if (((BP)->b_flags & B_GATHERED) == 0) \ 1018 (FS)->lfs_flags |= LFS_IFDIRTY; \ 1019 mutex_exit(&lfs_lock); \ 1020 LFS_BWRITE_LOG(BP); \ 1021 } \ 1022 } while (0) 1023 1024 #define LFS_GET_TAILFREE(FS, CIP, BP, FREEP) do { \ 1025 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 1026 *(FREEP) = lfs_ci_getfree_tail(FS, CIP); \ 1027 brelse(BP, 0); \ 1028 } while (0) 1029 1030 #define LFS_PUT_TAILFREE(FS, CIP, BP, VAL) do { \ 1031 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 1032 lfs_ci_setfree_tail(FS, CIP, VAL); \ 1033 if ((VAL) == LFS_UNUSED_INUM) \ 1034 lfs_ci_setfree_head(FS, CIP, VAL); \ 1035 mutex_enter(&lfs_lock); \ 1036 if (((BP)->b_flags & B_GATHERED) == 0) \ 1037 (FS)->lfs_flags |= LFS_IFDIRTY; \ 1038 mutex_exit(&lfs_lock); \ 1039 LFS_BWRITE_LOG(BP); \ 1040 } while (0) 1041 1042 /* 1043 * On-disk segment summary information 1044 */ 1045 1046 #define SEGSUM_SIZE(fs) \ 1047 (fs->lfs_is64 ? sizeof(SEGSUM64) : \ 1048 lfs_sb_getversion(fs) > 1 ? sizeof(SEGSUM32) : sizeof(SEGSUM_V1)) 1049 1050 /* 1051 * The SEGSUM structure is followed by FINFO structures. Get the pointer 1052 * to the first FINFO. 1053 * 1054 * XXX this can't be a macro yet; this file needs to be resorted. 1055 */ 1056 #if 0 1057 static __inline FINFO * 1058 segsum_finfobase(STRUCT_LFS *fs, SEGSUM *ssp) 1059 { 1060 return (FINFO *)((char *)ssp + SEGSUM_SIZE(fs)); 1061 } 1062 #else 1063 #define SEGSUM_FINFOBASE(fs, ssp) \ 1064 ((FINFO *)((char *)(ssp) + SEGSUM_SIZE(fs))); 1065 #endif 1066 1067 #define LFS_DEF_SS_ACCESSOR(type, type32, field) \ 1068 static __inline type \ 1069 lfs_ss_get##field(STRUCT_LFS *fs, SEGSUM *ssp) \ 1070 { \ 1071 if (fs->lfs_is64) { \ 1072 return ssp->u_64.ss_##field; \ 1073 } else { \ 1074 return ssp->u_32.ss_##field; \ 1075 } \ 1076 } \ 1077 static __inline void \ 1078 lfs_ss_set##field(STRUCT_LFS *fs, SEGSUM *ssp, type val) \ 1079 { \ 1080 if (fs->lfs_is64) { \ 1081 type *p = &ssp->u_64.ss_##field; \ 1082 (void)p; \ 1083 ssp->u_64.ss_##field = val; \ 1084 } else { \ 1085 type32 *p = &ssp->u_32.ss_##field; \ 1086 (void)p; \ 1087 ssp->u_32.ss_##field = val; \ 1088 } \ 1089 } \ 1090 1091 LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, sumsum) 1092 LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, datasum) 1093 LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, magic) 1094 LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, ident) 1095 LFS_DEF_SS_ACCESSOR(int64_t, int32_t, next) 1096 LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, nfinfo) 1097 LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, ninos) 1098 LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, flags) 1099 LFS_DEF_SS_ACCESSOR(uint64_t, uint32_t, reclino) 1100 LFS_DEF_SS_ACCESSOR(uint64_t, uint64_t, serial) 1101 LFS_DEF_SS_ACCESSOR(uint64_t, uint64_t, create) 1102 1103 static __inline size_t 1104 lfs_ss_getsumstart(STRUCT_LFS *fs) 1105 { 1106 /* These are actually all the same. */ 1107 if (fs->lfs_is64) { 1108 return offsetof(SEGSUM64, ss_datasum); 1109 } else /* if (lfs_sb_getversion(fs) > 1) */ { 1110 return offsetof(SEGSUM32, ss_datasum); 1111 } /* else { 1112 return offsetof(SEGSUM_V1, ss_datasum); 1113 } */ 1114 /* 1115 * XXX ^^^ until this file is resorted lfs_sb_getversion isn't 1116 * defined yet. 1117 */ 1118 } 1119 1120 static __inline uint32_t 1121 lfs_ss_getocreate(STRUCT_LFS *fs, SEGSUM *ssp) 1122 { 1123 KASSERT(fs->lfs_is64 == 0); 1124 /* XXX need to resort this file before we can do this */ 1125 //KASSERT(lfs_sb_getversion(fs) == 1); 1126 1127 return ssp->u_v1.ss_create; 1128 } 1129 1130 static __inline void 1131 lfs_ss_setocreate(STRUCT_LFS *fs, SEGSUM *ssp, uint32_t val) 1132 { 1133 KASSERT(fs->lfs_is64 == 0); 1134 /* XXX need to resort this file before we can do this */ 1135 //KASSERT(lfs_sb_getversion(fs) == 1); 1136 1137 ssp->u_v1.ss_create = val; 1138 } 1139 1140 1141 /* 1142 * Super block. 1143 */ 1144 1145 /* 1146 * Generate accessors for the on-disk superblock fields with cpp. 1147 */ 1148 1149 #define LFS_DEF_SB_ACCESSOR_FULL(type, type32, field) \ 1150 static __inline type \ 1151 lfs_sb_get##field(STRUCT_LFS *fs) \ 1152 { \ 1153 if (fs->lfs_is64) { \ 1154 return fs->lfs_dlfs_u.u_64.dlfs_##field; \ 1155 } else { \ 1156 return fs->lfs_dlfs_u.u_32.dlfs_##field; \ 1157 } \ 1158 } \ 1159 static __inline void \ 1160 lfs_sb_set##field(STRUCT_LFS *fs, type val) \ 1161 { \ 1162 if (fs->lfs_is64) { \ 1163 fs->lfs_dlfs_u.u_64.dlfs_##field = val; \ 1164 } else { \ 1165 fs->lfs_dlfs_u.u_32.dlfs_##field = val; \ 1166 } \ 1167 } \ 1168 static __inline void \ 1169 lfs_sb_add##field(STRUCT_LFS *fs, type val) \ 1170 { \ 1171 if (fs->lfs_is64) { \ 1172 type *p64 = &fs->lfs_dlfs_u.u_64.dlfs_##field; \ 1173 *p64 += val; \ 1174 } else { \ 1175 type32 *p32 = &fs->lfs_dlfs_u.u_32.dlfs_##field; \ 1176 *p32 += val; \ 1177 } \ 1178 } \ 1179 static __inline void \ 1180 lfs_sb_sub##field(STRUCT_LFS *fs, type val) \ 1181 { \ 1182 if (fs->lfs_is64) { \ 1183 type *p64 = &fs->lfs_dlfs_u.u_64.dlfs_##field; \ 1184 *p64 -= val; \ 1185 } else { \ 1186 type32 *p32 = &fs->lfs_dlfs_u.u_32.dlfs_##field; \ 1187 *p32 -= val; \ 1188 } \ 1189 } 1190 1191 #define LFS_DEF_SB_ACCESSOR(t, f) LFS_DEF_SB_ACCESSOR_FULL(t, t, f) 1192 1193 #define LFS_DEF_SB_ACCESSOR_32ONLY(type, field, val64) \ 1194 static __inline type \ 1195 lfs_sb_get##field(STRUCT_LFS *fs) \ 1196 { \ 1197 if (fs->lfs_is64) { \ 1198 return val64; \ 1199 } else { \ 1200 return fs->lfs_dlfs_u.u_32.dlfs_##field; \ 1201 } \ 1202 } 1203 1204 LFS_DEF_SB_ACCESSOR(uint32_t, version) 1205 LFS_DEF_SB_ACCESSOR_FULL(uint64_t, uint32_t, size) 1206 LFS_DEF_SB_ACCESSOR(uint32_t, ssize) 1207 LFS_DEF_SB_ACCESSOR_FULL(uint64_t, uint32_t, dsize) 1208 LFS_DEF_SB_ACCESSOR(uint32_t, bsize) 1209 LFS_DEF_SB_ACCESSOR(uint32_t, fsize) 1210 LFS_DEF_SB_ACCESSOR(uint32_t, frag) 1211 LFS_DEF_SB_ACCESSOR_FULL(uint64_t, uint32_t, freehd) 1212 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, bfree) 1213 LFS_DEF_SB_ACCESSOR_FULL(uint64_t, uint32_t, nfiles) 1214 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, avail) 1215 LFS_DEF_SB_ACCESSOR(int32_t, uinodes) 1216 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, idaddr) 1217 LFS_DEF_SB_ACCESSOR_32ONLY(uint32_t, ifile, LFS_IFILE_INUM) 1218 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, lastseg) 1219 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, nextseg) 1220 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, curseg) 1221 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, offset) 1222 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, lastpseg) 1223 LFS_DEF_SB_ACCESSOR(uint32_t, inopf) 1224 LFS_DEF_SB_ACCESSOR(uint32_t, minfree) 1225 LFS_DEF_SB_ACCESSOR(uint64_t, maxfilesize) 1226 LFS_DEF_SB_ACCESSOR(uint32_t, fsbpseg) 1227 LFS_DEF_SB_ACCESSOR(uint32_t, inopb) 1228 LFS_DEF_SB_ACCESSOR(uint32_t, ifpb) 1229 LFS_DEF_SB_ACCESSOR(uint32_t, sepb) 1230 LFS_DEF_SB_ACCESSOR(uint32_t, nindir) 1231 LFS_DEF_SB_ACCESSOR(uint32_t, nseg) 1232 LFS_DEF_SB_ACCESSOR(uint32_t, nspf) 1233 LFS_DEF_SB_ACCESSOR(uint32_t, cleansz) 1234 LFS_DEF_SB_ACCESSOR(uint32_t, segtabsz) 1235 LFS_DEF_SB_ACCESSOR_32ONLY(uint32_t, segmask, 0) 1236 LFS_DEF_SB_ACCESSOR_32ONLY(uint32_t, segshift, 0) 1237 LFS_DEF_SB_ACCESSOR(uint64_t, bmask) 1238 LFS_DEF_SB_ACCESSOR(uint32_t, bshift) 1239 LFS_DEF_SB_ACCESSOR(uint64_t, ffmask) 1240 LFS_DEF_SB_ACCESSOR(uint32_t, ffshift) 1241 LFS_DEF_SB_ACCESSOR(uint64_t, fbmask) 1242 LFS_DEF_SB_ACCESSOR(uint32_t, fbshift) 1243 LFS_DEF_SB_ACCESSOR(uint32_t, blktodb) 1244 LFS_DEF_SB_ACCESSOR(uint32_t, fsbtodb) 1245 LFS_DEF_SB_ACCESSOR(uint32_t, sushift) 1246 LFS_DEF_SB_ACCESSOR(int32_t, maxsymlinklen) 1247 LFS_DEF_SB_ACCESSOR(uint32_t, cksum) 1248 LFS_DEF_SB_ACCESSOR(uint16_t, pflags) 1249 LFS_DEF_SB_ACCESSOR(uint32_t, nclean) 1250 LFS_DEF_SB_ACCESSOR(int32_t, dmeta) 1251 LFS_DEF_SB_ACCESSOR(uint32_t, minfreeseg) 1252 LFS_DEF_SB_ACCESSOR(uint32_t, sumsize) 1253 LFS_DEF_SB_ACCESSOR(uint64_t, serial) 1254 LFS_DEF_SB_ACCESSOR(uint32_t, ibsize) 1255 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, s0addr) 1256 LFS_DEF_SB_ACCESSOR(uint64_t, tstamp) 1257 LFS_DEF_SB_ACCESSOR(uint32_t, inodefmt) 1258 LFS_DEF_SB_ACCESSOR(uint32_t, interleave) 1259 LFS_DEF_SB_ACCESSOR(uint32_t, ident) 1260 LFS_DEF_SB_ACCESSOR(uint32_t, resvseg) 1261 1262 /* special-case accessors */ 1263 1264 /* 1265 * the v1 otstamp field lives in what's now dlfs_inopf 1266 */ 1267 #define lfs_sb_getotstamp(fs) lfs_sb_getinopf(fs) 1268 #define lfs_sb_setotstamp(fs, val) lfs_sb_setinopf(fs, val) 1269 1270 /* 1271 * lfs_sboffs is an array 1272 */ 1273 static __inline int32_t 1274 lfs_sb_getsboff(STRUCT_LFS *fs, unsigned n) 1275 { 1276 #ifdef KASSERT /* ugh */ 1277 KASSERT(n < LFS_MAXNUMSB); 1278 #endif 1279 if (fs->lfs_is64) { 1280 return fs->lfs_dlfs_u.u_64.dlfs_sboffs[n]; 1281 } else { 1282 return fs->lfs_dlfs_u.u_32.dlfs_sboffs[n]; 1283 } 1284 } 1285 static __inline void 1286 lfs_sb_setsboff(STRUCT_LFS *fs, unsigned n, int32_t val) 1287 { 1288 #ifdef KASSERT /* ugh */ 1289 KASSERT(n < LFS_MAXNUMSB); 1290 #endif 1291 if (fs->lfs_is64) { 1292 fs->lfs_dlfs_u.u_64.dlfs_sboffs[n] = val; 1293 } else { 1294 fs->lfs_dlfs_u.u_32.dlfs_sboffs[n] = val; 1295 } 1296 } 1297 1298 /* 1299 * lfs_fsmnt is a string 1300 */ 1301 static __inline const char * 1302 lfs_sb_getfsmnt(STRUCT_LFS *fs) 1303 { 1304 if (fs->lfs_is64) { 1305 return (const char *)fs->lfs_dlfs_u.u_64.dlfs_fsmnt; 1306 } else { 1307 return (const char *)fs->lfs_dlfs_u.u_32.dlfs_fsmnt; 1308 } 1309 } 1310 1311 static __inline void 1312 lfs_sb_setfsmnt(STRUCT_LFS *fs, const char *str) 1313 { 1314 if (fs->lfs_is64) { 1315 (void)strncpy((char *)fs->lfs_dlfs_u.u_64.dlfs_fsmnt, str, 1316 sizeof(fs->lfs_dlfs_u.u_64.dlfs_fsmnt)); 1317 } else { 1318 (void)strncpy((char *)fs->lfs_dlfs_u.u_32.dlfs_fsmnt, str, 1319 sizeof(fs->lfs_dlfs_u.u_32.dlfs_fsmnt)); 1320 } 1321 } 1322 1323 /* Highest addressable fsb */ 1324 #define LFS_MAX_DADDR(fs) \ 1325 ((fs)->lfs_is64 ? 0x7fffffffffffffff : 0x7fffffff) 1326 1327 /* LFS_NINDIR is the number of indirects in a file system block. */ 1328 #define LFS_NINDIR(fs) (lfs_sb_getnindir(fs)) 1329 1330 /* LFS_INOPB is the number of inodes in a secondary storage block. */ 1331 #define LFS_INOPB(fs) (lfs_sb_getinopb(fs)) 1332 /* LFS_INOPF is the number of inodes in a fragment. */ 1333 #define LFS_INOPF(fs) (lfs_sb_getinopf(fs)) 1334 1335 #define lfs_blkoff(fs, loc) ((int)((loc) & lfs_sb_getbmask(fs))) 1336 #define lfs_fragoff(fs, loc) /* calculates (loc % fs->lfs_fsize) */ \ 1337 ((int)((loc) & lfs_sb_getffmask(fs))) 1338 1339 /* XXX: lowercase these as they're no longer macros */ 1340 /* Frags to diskblocks */ 1341 static __inline uint64_t 1342 LFS_FSBTODB(STRUCT_LFS *fs, uint64_t b) 1343 { 1344 #if defined(_KERNEL) 1345 return b << (lfs_sb_getffshift(fs) - DEV_BSHIFT); 1346 #else 1347 return b << lfs_sb_getfsbtodb(fs); 1348 #endif 1349 } 1350 /* Diskblocks to frags */ 1351 static __inline uint64_t 1352 LFS_DBTOFSB(STRUCT_LFS *fs, uint64_t b) 1353 { 1354 #if defined(_KERNEL) 1355 return b >> (lfs_sb_getffshift(fs) - DEV_BSHIFT); 1356 #else 1357 return b >> lfs_sb_getfsbtodb(fs); 1358 #endif 1359 } 1360 1361 #define lfs_lblkno(fs, loc) ((loc) >> lfs_sb_getbshift(fs)) 1362 #define lfs_lblktosize(fs, blk) ((blk) << lfs_sb_getbshift(fs)) 1363 1364 /* Frags to bytes */ 1365 static __inline uint64_t 1366 lfs_fsbtob(STRUCT_LFS *fs, uint64_t b) 1367 { 1368 return b << lfs_sb_getffshift(fs); 1369 } 1370 /* Bytes to frags */ 1371 static __inline uint64_t 1372 lfs_btofsb(STRUCT_LFS *fs, uint64_t b) 1373 { 1374 return b >> lfs_sb_getffshift(fs); 1375 } 1376 1377 #define lfs_numfrags(fs, loc) /* calculates (loc / fs->lfs_fsize) */ \ 1378 ((loc) >> lfs_sb_getffshift(fs)) 1379 #define lfs_blkroundup(fs, size)/* calculates roundup(size, lfs_sb_getbsize(fs)) */ \ 1380 ((off_t)(((size) + lfs_sb_getbmask(fs)) & (~lfs_sb_getbmask(fs)))) 1381 #define lfs_fragroundup(fs, size)/* calculates roundup(size, fs->lfs_fsize) */ \ 1382 ((off_t)(((size) + lfs_sb_getffmask(fs)) & (~lfs_sb_getffmask(fs)))) 1383 #define lfs_fragstoblks(fs, frags)/* calculates (frags / fs->fs_frag) */ \ 1384 ((frags) >> lfs_sb_getfbshift(fs)) 1385 #define lfs_blkstofrags(fs, blks)/* calculates (blks * fs->fs_frag) */ \ 1386 ((blks) << lfs_sb_getfbshift(fs)) 1387 #define lfs_fragnum(fs, fsb) /* calculates (fsb % fs->lfs_frag) */ \ 1388 ((fsb) & ((fs)->lfs_frag - 1)) 1389 #define lfs_blknum(fs, fsb) /* calculates rounddown(fsb, fs->lfs_frag) */ \ 1390 ((fsb) &~ ((fs)->lfs_frag - 1)) 1391 #define lfs_dblksize(fs, dp, lbn) \ 1392 (((lbn) >= ULFS_NDADDR || lfs_dino_getsize(fs, dp) >= ((lbn) + 1) << lfs_sb_getbshift(fs)) \ 1393 ? lfs_sb_getbsize(fs) \ 1394 : (lfs_fragroundup(fs, lfs_blkoff(fs, lfs_dino_getsize(fs, dp))))) 1395 1396 #define lfs_segsize(fs) (lfs_sb_getversion(fs) == 1 ? \ 1397 lfs_lblktosize((fs), lfs_sb_getssize(fs)) : \ 1398 lfs_sb_getssize(fs)) 1399 /* XXX segtod produces a result in frags despite the 'd' */ 1400 #define lfs_segtod(fs, seg) (lfs_btofsb(fs, lfs_segsize(fs)) * (seg)) 1401 #define lfs_dtosn(fs, daddr) /* block address to segment number */ \ 1402 ((uint32_t)(((daddr) - lfs_sb_gets0addr(fs)) / lfs_segtod((fs), 1))) 1403 #define lfs_sntod(fs, sn) /* segment number to disk address */ \ 1404 ((daddr_t)(lfs_segtod((fs), (sn)) + lfs_sb_gets0addr(fs))) 1405 1406 /* XXX, blah. make this appear only if struct inode is defined */ 1407 #ifdef _UFS_LFS_LFS_INODE_H_ 1408 static __inline uint32_t 1409 lfs_blksize(STRUCT_LFS *fs, struct inode *ip, uint64_t lbn) 1410 { 1411 if (lbn >= ULFS_NDADDR || lfs_dino_getsize(fs, ip->i_din) >= (lbn + 1) << lfs_sb_getbshift(fs)) { 1412 return lfs_sb_getbsize(fs); 1413 } else { 1414 return lfs_fragroundup(fs, lfs_blkoff(fs, lfs_dino_getsize(fs, ip->i_din))); 1415 } 1416 } 1417 #endif 1418 1419 /* 1420 * union lfs_blocks 1421 */ 1422 1423 static __inline void 1424 lfs_blocks_fromvoid(STRUCT_LFS *fs, union lfs_blocks *bp, void *p) 1425 { 1426 if (fs->lfs_is64) { 1427 bp->b64 = p; 1428 } else { 1429 bp->b32 = p; 1430 } 1431 } 1432 1433 static __inline void 1434 lfs_blocks_fromfinfo(STRUCT_LFS *fs, union lfs_blocks *bp, FINFO *fip) 1435 { 1436 void *firstblock; 1437 1438 firstblock = (char *)fip + FINFOSIZE(fs); 1439 if (fs->lfs_is64) { 1440 bp->b64 = (int64_t *)firstblock; 1441 } else { 1442 bp->b32 = (int32_t *)firstblock; 1443 } 1444 } 1445 1446 static __inline daddr_t 1447 lfs_blocks_get(STRUCT_LFS *fs, union lfs_blocks *bp, unsigned idx) 1448 { 1449 if (fs->lfs_is64) { 1450 return bp->b64[idx]; 1451 } else { 1452 return bp->b32[idx]; 1453 } 1454 } 1455 1456 static __inline void 1457 lfs_blocks_set(STRUCT_LFS *fs, union lfs_blocks *bp, unsigned idx, daddr_t val) 1458 { 1459 if (fs->lfs_is64) { 1460 bp->b64[idx] = val; 1461 } else { 1462 bp->b32[idx] = val; 1463 } 1464 } 1465 1466 static __inline void 1467 lfs_blocks_inc(STRUCT_LFS *fs, union lfs_blocks *bp) 1468 { 1469 if (fs->lfs_is64) { 1470 bp->b64++; 1471 } else { 1472 bp->b32++; 1473 } 1474 } 1475 1476 static __inline int 1477 lfs_blocks_eq(STRUCT_LFS *fs, union lfs_blocks *bp1, union lfs_blocks *bp2) 1478 { 1479 if (fs->lfs_is64) { 1480 return bp1->b64 == bp2->b64; 1481 } else { 1482 return bp1->b32 == bp2->b32; 1483 } 1484 } 1485 1486 static __inline int 1487 lfs_blocks_sub(STRUCT_LFS *fs, union lfs_blocks *bp1, union lfs_blocks *bp2) 1488 { 1489 /* (remember that the pointers are typed) */ 1490 if (fs->lfs_is64) { 1491 return bp1->b64 - bp2->b64; 1492 } else { 1493 return bp1->b32 - bp2->b32; 1494 } 1495 } 1496 1497 /* 1498 * struct segment 1499 */ 1500 1501 1502 /* 1503 * Macros for determining free space on the disk, with the variable metadata 1504 * of segment summaries and inode blocks taken into account. 1505 */ 1506 /* 1507 * Estimate number of clean blocks not available for writing because 1508 * they will contain metadata or overhead. This is calculated as 1509 * 1510 * E = ((C * M / D) * D + (0) * (T - D)) / T 1511 * or more simply 1512 * E = (C * M) / T 1513 * 1514 * where 1515 * C is the clean space, 1516 * D is the dirty space, 1517 * M is the dirty metadata, and 1518 * T = C + D is the total space on disk. 1519 * 1520 * This approximates the old formula of E = C * M / D when D is close to T, 1521 * but avoids falsely reporting "disk full" when the sample size (D) is small. 1522 */ 1523 #define LFS_EST_CMETA(F) (( \ 1524 (lfs_sb_getdmeta(F) * (int64_t)lfs_sb_getnclean(F)) / \ 1525 (lfs_sb_getnseg(F)))) 1526 1527 /* Estimate total size of the disk not including metadata */ 1528 #define LFS_EST_NONMETA(F) (lfs_sb_getdsize(F) - lfs_sb_getdmeta(F) - LFS_EST_CMETA(F)) 1529 1530 /* Estimate number of blocks actually available for writing */ 1531 #define LFS_EST_BFREE(F) (lfs_sb_getbfree(F) > LFS_EST_CMETA(F) ? \ 1532 lfs_sb_getbfree(F) - LFS_EST_CMETA(F) : 0) 1533 1534 /* Amount of non-meta space not available to mortal man */ 1535 #define LFS_EST_RSVD(F) ((LFS_EST_NONMETA(F) * \ 1536 (uint64_t)lfs_sb_getminfree(F)) / \ 1537 100) 1538 1539 /* Can credential C write BB blocks? XXX: kauth_cred_geteuid is abusive */ 1540 #define ISSPACE(F, BB, C) \ 1541 ((((C) == NOCRED || kauth_cred_geteuid(C) == 0) && \ 1542 LFS_EST_BFREE(F) >= (BB)) || \ 1543 (kauth_cred_geteuid(C) != 0 && IS_FREESPACE(F, BB))) 1544 1545 /* Can an ordinary user write BB blocks */ 1546 #define IS_FREESPACE(F, BB) \ 1547 (LFS_EST_BFREE(F) >= (BB) + LFS_EST_RSVD(F)) 1548 1549 /* 1550 * The minimum number of blocks to create a new inode. This is: 1551 * directory direct block (1) + ULFS_NIADDR indirect blocks + inode block (1) + 1552 * ifile direct block (1) + ULFS_NIADDR indirect blocks = 3 + 2 * ULFS_NIADDR blocks. 1553 */ 1554 #define LFS_NRESERVE(F) (lfs_btofsb((F), (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(F))) 1555 1556 1557 /* 1558 * Suppress spurious clang warnings 1559 */ 1560 #ifdef __GNUC__ 1561 #if defined(__clang__) 1562 #pragma clang diagnostic pop 1563 #elif __GNUC_PREREQ__(9,0) 1564 #pragma GCC diagnostic pop 1565 #endif 1566 #endif 1567 1568 1569 #endif /* _UFS_LFS_LFS_ACCESSORS_H_ */ 1570
Indexes created Fri Feb 20 16:20:20 UTC 2026