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