lfs_accessors.h revision 1.33.2.3
1 /* $NetBSD: lfs_accessors.h,v 1.33.2.3 2015/12/27 12:10:19 skrll 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_namlen; 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 LFS_SWAP_uint64_t(fs, dip->u_64.di_db[ix]); 503 } else { 504 /* note: this must sign-extend or UNWRITTEN gets trashed */ 505 return (int32_t)LFS_SWAP_uint32_t(fs, 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 LFS_SWAP_uint64_t(fs, dip->u_64.di_ib[ix]); 515 } else { 516 /* note: this must sign-extend or UNWRITTEN gets trashed */ 517 return (int32_t)LFS_SWAP_uint32_t(fs, 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] = LFS_SWAP_uint64_t(fs, val); 527 } else { 528 dip->u_32.di_db[ix] = LFS_SWAP_uint32_t(fs, 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] = LFS_SWAP_uint64_t(fs, val); 538 } else { 539 dip->u_32.di_ib[ix] = LFS_SWAP_uint32_t(fs, 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: segentry %llu: error %d\n", \ 675 (unsigned long long)(IN), _e); \ 676 if (lfs_sb_getversion(F) == 1) \ 677 (SP) = (SEGUSE *)((SEGUSE_V1 *)(BP)->b_data + \ 678 ((IN) & (lfs_sb_getsepb(F) - 1))); \ 679 else \ 680 (SP) = (SEGUSE *)(BP)->b_data + ((IN) % lfs_sb_getsepb(F)); \ 681 UNSHARE_IFLOCK(F); \ 682 } while (0) 683 684 #define LFS_WRITESEGENTRY(SP, F, IN, BP) do { \ 685 if ((SP)->su_nbytes == 0) \ 686 (SP)->su_flags |= SEGUSE_EMPTY; \ 687 else \ 688 (SP)->su_flags &= ~SEGUSE_EMPTY; \ 689 (F)->lfs_suflags[(F)->lfs_activesb][(IN)] = (SP)->su_flags; \ 690 LFS_BWRITE_LOG(BP); \ 691 } while (0) 692 693 /* 694 * FINFO (file info) entries. 695 */ 696 697 /* Size of an on-disk block pointer, e.g. in an indirect block. */ 698 /* XXX: move to a more suitable location in this file */ 699 #define LFS_BLKPTRSIZE(fs) ((fs)->lfs_is64 ? sizeof(int64_t) : sizeof(int32_t)) 700 701 /* Size of an on-disk inode number. */ 702 /* XXX: move to a more suitable location in this file */ 703 #define LFS_INUMSIZE(fs) ((fs)->lfs_is64 ? sizeof(int64_t) : sizeof(int32_t)) 704 705 /* size of a FINFO, without the block pointers */ 706 #define FINFOSIZE(fs) ((fs)->lfs_is64 ? sizeof(FINFO64) : sizeof(FINFO32)) 707 708 /* Full size of the provided FINFO record, including its block pointers. */ 709 #define FINFO_FULLSIZE(fs, fip) \ 710 (FINFOSIZE(fs) + lfs_fi_getnblocks(fs, fip) * LFS_BLKPTRSIZE(fs)) 711 712 #define NEXT_FINFO(fs, fip) \ 713 ((FINFO *)((char *)(fip) + FINFO_FULLSIZE(fs, fip))) 714 715 #define LFS_DEF_FI_ACCESSOR(type, type32, field) \ 716 static __unused inline type \ 717 lfs_fi_get##field(STRUCT_LFS *fs, FINFO *fip) \ 718 { \ 719 if (fs->lfs_is64) { \ 720 return fip->u_64.fi_##field; \ 721 } else { \ 722 return fip->u_32.fi_##field; \ 723 } \ 724 } \ 725 static __unused inline void \ 726 lfs_fi_set##field(STRUCT_LFS *fs, FINFO *fip, type val) \ 727 { \ 728 if (fs->lfs_is64) { \ 729 type *p = &fip->u_64.fi_##field; \ 730 (void)p; \ 731 fip->u_64.fi_##field = val; \ 732 } else { \ 733 type32 *p = &fip->u_32.fi_##field; \ 734 (void)p; \ 735 fip->u_32.fi_##field = val; \ 736 } \ 737 } \ 738 739 LFS_DEF_FI_ACCESSOR(uint32_t, uint32_t, nblocks); 740 LFS_DEF_FI_ACCESSOR(uint32_t, uint32_t, version); 741 LFS_DEF_FI_ACCESSOR(uint64_t, uint32_t, ino); 742 LFS_DEF_FI_ACCESSOR(uint32_t, uint32_t, lastlength); 743 744 static __unused inline daddr_t 745 lfs_fi_getblock(STRUCT_LFS *fs, FINFO *fip, unsigned index) 746 { 747 void *firstblock; 748 749 firstblock = (char *)fip + FINFOSIZE(fs); 750 KASSERT(index < lfs_fi_getnblocks(fs, fip)); 751 if (fs->lfs_is64) { 752 return ((int64_t *)firstblock)[index]; 753 } else { 754 return ((int32_t *)firstblock)[index]; 755 } 756 } 757 758 static __unused inline void 759 lfs_fi_setblock(STRUCT_LFS *fs, FINFO *fip, unsigned index, daddr_t blk) 760 { 761 void *firstblock; 762 763 firstblock = (char *)fip + FINFOSIZE(fs); 764 KASSERT(index < lfs_fi_getnblocks(fs, fip)); 765 if (fs->lfs_is64) { 766 ((int64_t *)firstblock)[index] = blk; 767 } else { 768 ((int32_t *)firstblock)[index] = blk; 769 } 770 } 771 772 /* 773 * inode info entries (in the segment summary) 774 */ 775 776 #define IINFOSIZE(fs) ((fs)->lfs_is64 ? sizeof(IINFO64) : sizeof(IINFO32)) 777 778 /* iinfos scroll backward from the end of the segment summary block */ 779 #define SEGSUM_IINFOSTART(fs, buf) \ 780 ((IINFO *)((char *)buf + lfs_sb_getsumsize(fs) - IINFOSIZE(fs))) 781 782 #define NEXTLOWER_IINFO(fs, iip) \ 783 ((IINFO *)((char *)(iip) - IINFOSIZE(fs))) 784 785 #define NTH_IINFO(fs, buf, n) \ 786 ((IINFO *)((char *)SEGSUM_IINFOSTART(fs, buf) - (n)*IINFOSIZE(fs))) 787 788 static __unused inline uint64_t 789 lfs_ii_getblock(STRUCT_LFS *fs, IINFO *iip) 790 { 791 if (fs->lfs_is64) { 792 return iip->u_64.ii_block; 793 } else { 794 return iip->u_32.ii_block; 795 } 796 } 797 798 static __unused inline void 799 lfs_ii_setblock(STRUCT_LFS *fs, IINFO *iip, uint64_t block) 800 { 801 if (fs->lfs_is64) { 802 iip->u_64.ii_block = block; 803 } else { 804 iip->u_32.ii_block = block; 805 } 806 } 807 808 /* 809 * Index file inode entries. 810 */ 811 812 #define IFILE_ENTRYSIZE(fs) \ 813 ((fs)->lfs_is64 ? sizeof(IFILE64) : sizeof(IFILE32)) 814 815 /* 816 * LFSv1 compatibility code is not allowed to touch if_atime, since it 817 * may not be mapped! 818 */ 819 /* Read in the block with a specific inode from the ifile. */ 820 #define LFS_IENTRY(IP, F, IN, BP) do { \ 821 int _e; \ 822 SHARE_IFLOCK(F); \ 823 VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ 824 if ((_e = bread((F)->lfs_ivnode, \ 825 (IN) / lfs_sb_getifpb(F) + lfs_sb_getcleansz(F) + lfs_sb_getsegtabsz(F), \ 826 lfs_sb_getbsize(F), 0, &(BP))) != 0) \ 827 panic("lfs: ifile ino %d read %d", (int)(IN), _e); \ 828 if ((F)->lfs_is64) { \ 829 (IP) = (IFILE *)((IFILE64 *)(BP)->b_data + \ 830 (IN) % lfs_sb_getifpb(F)); \ 831 } else if (lfs_sb_getversion(F) > 1) { \ 832 (IP) = (IFILE *)((IFILE32 *)(BP)->b_data + \ 833 (IN) % lfs_sb_getifpb(F)); \ 834 } else { \ 835 (IP) = (IFILE *)((IFILE_V1 *)(BP)->b_data + \ 836 (IN) % lfs_sb_getifpb(F)); \ 837 } \ 838 UNSHARE_IFLOCK(F); \ 839 } while (0) 840 #define LFS_IENTRY_NEXT(IP, F) do { \ 841 if ((F)->lfs_is64) { \ 842 (IP) = (IFILE *)((IFILE64 *)(IP) + 1); \ 843 } else if (lfs_sb_getversion(F) > 1) { \ 844 (IP) = (IFILE *)((IFILE32 *)(IP) + 1); \ 845 } else { \ 846 (IP) = (IFILE *)((IFILE_V1 *)(IP) + 1); \ 847 } \ 848 } while (0) 849 850 #define LFS_DEF_IF_ACCESSOR(type, type32, field) \ 851 static __unused inline type \ 852 lfs_if_get##field(STRUCT_LFS *fs, IFILE *ifp) \ 853 { \ 854 if (fs->lfs_is64) { \ 855 return ifp->u_64.if_##field; \ 856 } else { \ 857 return ifp->u_32.if_##field; \ 858 } \ 859 } \ 860 static __unused inline void \ 861 lfs_if_set##field(STRUCT_LFS *fs, IFILE *ifp, type val) \ 862 { \ 863 if (fs->lfs_is64) { \ 864 type *p = &ifp->u_64.if_##field; \ 865 (void)p; \ 866 ifp->u_64.if_##field = val; \ 867 } else { \ 868 type32 *p = &ifp->u_32.if_##field; \ 869 (void)p; \ 870 ifp->u_32.if_##field = val; \ 871 } \ 872 } \ 873 874 LFS_DEF_IF_ACCESSOR(u_int32_t, u_int32_t, version); 875 LFS_DEF_IF_ACCESSOR(int64_t, int32_t, daddr); 876 LFS_DEF_IF_ACCESSOR(u_int64_t, u_int32_t, nextfree); 877 LFS_DEF_IF_ACCESSOR(u_int64_t, u_int32_t, atime_sec); 878 LFS_DEF_IF_ACCESSOR(u_int32_t, u_int32_t, atime_nsec); 879 880 /* 881 * Cleaner information structure. This resides in the ifile and is used 882 * to pass information from the kernel to the cleaner. 883 */ 884 885 #define CLEANSIZE_SU(fs) \ 886 ((((fs)->lfs_is64 ? sizeof(CLEANERINFO64) : sizeof(CLEANERINFO32)) + \ 887 lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs)) 888 889 #define LFS_DEF_CI_ACCESSOR(type, type32, field) \ 890 static __unused inline type \ 891 lfs_ci_get##field(STRUCT_LFS *fs, CLEANERINFO *cip) \ 892 { \ 893 if (fs->lfs_is64) { \ 894 return cip->u_64.field; \ 895 } else { \ 896 return cip->u_32.field; \ 897 } \ 898 } \ 899 static __unused inline void \ 900 lfs_ci_set##field(STRUCT_LFS *fs, CLEANERINFO *cip, type val) \ 901 { \ 902 if (fs->lfs_is64) { \ 903 type *p = &cip->u_64.field; \ 904 (void)p; \ 905 cip->u_64.field = val; \ 906 } else { \ 907 type32 *p = &cip->u_32.field; \ 908 (void)p; \ 909 cip->u_32.field = val; \ 910 } \ 911 } \ 912 913 LFS_DEF_CI_ACCESSOR(u_int32_t, u_int32_t, clean); 914 LFS_DEF_CI_ACCESSOR(u_int32_t, u_int32_t, dirty); 915 LFS_DEF_CI_ACCESSOR(int64_t, int32_t, bfree); 916 LFS_DEF_CI_ACCESSOR(int64_t, int32_t, avail); 917 LFS_DEF_CI_ACCESSOR(u_int64_t, u_int32_t, free_head); 918 LFS_DEF_CI_ACCESSOR(u_int64_t, u_int32_t, free_tail); 919 LFS_DEF_CI_ACCESSOR(u_int32_t, u_int32_t, flags); 920 921 static __unused inline void 922 lfs_ci_shiftcleantodirty(STRUCT_LFS *fs, CLEANERINFO *cip, unsigned num) 923 { 924 lfs_ci_setclean(fs, cip, lfs_ci_getclean(fs, cip) - num); 925 lfs_ci_setdirty(fs, cip, lfs_ci_getdirty(fs, cip) + num); 926 } 927 928 static __unused inline void 929 lfs_ci_shiftdirtytoclean(STRUCT_LFS *fs, CLEANERINFO *cip, unsigned num) 930 { 931 lfs_ci_setdirty(fs, cip, lfs_ci_getdirty(fs, cip) - num); 932 lfs_ci_setclean(fs, cip, lfs_ci_getclean(fs, cip) + num); 933 } 934 935 /* Read in the block with the cleaner info from the ifile. */ 936 #define LFS_CLEANERINFO(CP, F, BP) do { \ 937 int _e; \ 938 SHARE_IFLOCK(F); \ 939 VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ 940 _e = bread((F)->lfs_ivnode, \ 941 (daddr_t)0, lfs_sb_getbsize(F), 0, &(BP)); \ 942 if (_e) \ 943 panic("lfs: ifile read: cleanerinfo: error %d\n", _e); \ 944 (CP) = (CLEANERINFO *)(BP)->b_data; \ 945 UNSHARE_IFLOCK(F); \ 946 } while (0) 947 948 /* 949 * Synchronize the Ifile cleaner info with current avail and bfree. 950 */ 951 #define LFS_SYNC_CLEANERINFO(cip, fs, bp, w) do { \ 952 mutex_enter(&lfs_lock); \ 953 if ((w) || lfs_ci_getbfree(fs, cip) != lfs_sb_getbfree(fs) || \ 954 lfs_ci_getavail(fs, cip) != lfs_sb_getavail(fs) - fs->lfs_ravail - \ 955 fs->lfs_favail) { \ 956 lfs_ci_setbfree(fs, cip, lfs_sb_getbfree(fs)); \ 957 lfs_ci_setavail(fs, cip, lfs_sb_getavail(fs) - fs->lfs_ravail - \ 958 fs->lfs_favail); \ 959 if (((bp)->b_flags & B_GATHERED) == 0) { \ 960 fs->lfs_flags |= LFS_IFDIRTY; \ 961 } \ 962 mutex_exit(&lfs_lock); \ 963 (void) LFS_BWRITE_LOG(bp); /* Ifile */ \ 964 } else { \ 965 mutex_exit(&lfs_lock); \ 966 brelse(bp, 0); \ 967 } \ 968 } while (0) 969 970 /* 971 * Get the head of the inode free list. 972 * Always called with the segment lock held. 973 */ 974 #define LFS_GET_HEADFREE(FS, CIP, BP, FREEP) do { \ 975 if (lfs_sb_getversion(FS) > 1) { \ 976 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 977 lfs_sb_setfreehd(FS, lfs_ci_getfree_head(FS, CIP)); \ 978 brelse(BP, 0); \ 979 } \ 980 *(FREEP) = lfs_sb_getfreehd(FS); \ 981 } while (0) 982 983 #define LFS_PUT_HEADFREE(FS, CIP, BP, VAL) do { \ 984 lfs_sb_setfreehd(FS, VAL); \ 985 if (lfs_sb_getversion(FS) > 1) { \ 986 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 987 lfs_ci_setfree_head(FS, CIP, VAL); \ 988 LFS_BWRITE_LOG(BP); \ 989 mutex_enter(&lfs_lock); \ 990 (FS)->lfs_flags |= LFS_IFDIRTY; \ 991 mutex_exit(&lfs_lock); \ 992 } \ 993 } while (0) 994 995 #define LFS_GET_TAILFREE(FS, CIP, BP, FREEP) do { \ 996 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 997 *(FREEP) = lfs_ci_getfree_tail(FS, CIP); \ 998 brelse(BP, 0); \ 999 } while (0) 1000 1001 #define LFS_PUT_TAILFREE(FS, CIP, BP, VAL) do { \ 1002 LFS_CLEANERINFO((CIP), (FS), (BP)); \ 1003 lfs_ci_setfree_tail(FS, CIP, VAL); \ 1004 LFS_BWRITE_LOG(BP); \ 1005 mutex_enter(&lfs_lock); \ 1006 (FS)->lfs_flags |= LFS_IFDIRTY; \ 1007 mutex_exit(&lfs_lock); \ 1008 } while (0) 1009 1010 /* 1011 * On-disk segment summary information 1012 */ 1013 1014 #define SEGSUM_SIZE(fs) \ 1015 (fs->lfs_is64 ? sizeof(SEGSUM64) : \ 1016 lfs_sb_getversion(fs) > 1 ? sizeof(SEGSUM32) : sizeof(SEGSUM_V1)) 1017 1018 /* 1019 * The SEGSUM structure is followed by FINFO structures. Get the pointer 1020 * to the first FINFO. 1021 * 1022 * XXX this can't be a macro yet; this file needs to be resorted. 1023 */ 1024 #if 0 1025 static __unused inline FINFO * 1026 segsum_finfobase(STRUCT_LFS *fs, SEGSUM *ssp) 1027 { 1028 return (FINFO *)((char *)ssp + SEGSUM_SIZE(fs)); 1029 } 1030 #else 1031 #define SEGSUM_FINFOBASE(fs, ssp) \ 1032 ((FINFO *)((char *)(ssp) + SEGSUM_SIZE(fs))); 1033 #endif 1034 1035 #define LFS_DEF_SS_ACCESSOR(type, type32, field) \ 1036 static __unused inline type \ 1037 lfs_ss_get##field(STRUCT_LFS *fs, SEGSUM *ssp) \ 1038 { \ 1039 if (fs->lfs_is64) { \ 1040 return ssp->u_64.ss_##field; \ 1041 } else { \ 1042 return ssp->u_32.ss_##field; \ 1043 } \ 1044 } \ 1045 static __unused inline void \ 1046 lfs_ss_set##field(STRUCT_LFS *fs, SEGSUM *ssp, type val) \ 1047 { \ 1048 if (fs->lfs_is64) { \ 1049 type *p = &ssp->u_64.ss_##field; \ 1050 (void)p; \ 1051 ssp->u_64.ss_##field = val; \ 1052 } else { \ 1053 type32 *p = &ssp->u_32.ss_##field; \ 1054 (void)p; \ 1055 ssp->u_32.ss_##field = val; \ 1056 } \ 1057 } \ 1058 1059 LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, sumsum); 1060 LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, datasum); 1061 LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, magic); 1062 LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, ident); 1063 LFS_DEF_SS_ACCESSOR(int64_t, int32_t, next); 1064 LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, nfinfo); 1065 LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, ninos); 1066 LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, flags); 1067 LFS_DEF_SS_ACCESSOR(uint64_t, uint32_t, reclino); 1068 LFS_DEF_SS_ACCESSOR(uint64_t, uint64_t, serial); 1069 LFS_DEF_SS_ACCESSOR(uint64_t, uint64_t, create); 1070 1071 static __unused inline size_t 1072 lfs_ss_getsumstart(STRUCT_LFS *fs) 1073 { 1074 /* These are actually all the same. */ 1075 if (fs->lfs_is64) { 1076 return offsetof(SEGSUM64, ss_datasum); 1077 } else /* if (lfs_sb_getversion(fs) > 1) */ { 1078 return offsetof(SEGSUM32, ss_datasum); 1079 } /* else { 1080 return offsetof(SEGSUM_V1, ss_datasum); 1081 } */ 1082 /* 1083 * XXX ^^^ until this file is resorted lfs_sb_getversion isn't 1084 * defined yet. 1085 */ 1086 } 1087 1088 static __unused inline uint32_t 1089 lfs_ss_getocreate(STRUCT_LFS *fs, SEGSUM *ssp) 1090 { 1091 KASSERT(fs->lfs_is64 == 0); 1092 /* XXX need to resort this file before we can do this */ 1093 //KASSERT(lfs_sb_getversion(fs) == 1); 1094 1095 return ssp->u_v1.ss_create; 1096 } 1097 1098 static __unused inline void 1099 lfs_ss_setocreate(STRUCT_LFS *fs, SEGSUM *ssp, uint32_t val) 1100 { 1101 KASSERT(fs->lfs_is64 == 0); 1102 /* XXX need to resort this file before we can do this */ 1103 //KASSERT(lfs_sb_getversion(fs) == 1); 1104 1105 ssp->u_v1.ss_create = val; 1106 } 1107 1108 1109 /* 1110 * Super block. 1111 */ 1112 1113 /* 1114 * Generate accessors for the on-disk superblock fields with cpp. 1115 */ 1116 1117 #define LFS_DEF_SB_ACCESSOR_FULL(type, type32, field) \ 1118 static __unused inline type \ 1119 lfs_sb_get##field(STRUCT_LFS *fs) \ 1120 { \ 1121 if (fs->lfs_is64) { \ 1122 return fs->lfs_dlfs_u.u_64.dlfs_##field; \ 1123 } else { \ 1124 return fs->lfs_dlfs_u.u_32.dlfs_##field; \ 1125 } \ 1126 } \ 1127 static __unused inline void \ 1128 lfs_sb_set##field(STRUCT_LFS *fs, type val) \ 1129 { \ 1130 if (fs->lfs_is64) { \ 1131 fs->lfs_dlfs_u.u_64.dlfs_##field = val; \ 1132 } else { \ 1133 fs->lfs_dlfs_u.u_32.dlfs_##field = val; \ 1134 } \ 1135 } \ 1136 static __unused inline void \ 1137 lfs_sb_add##field(STRUCT_LFS *fs, type val) \ 1138 { \ 1139 if (fs->lfs_is64) { \ 1140 type *p64 = &fs->lfs_dlfs_u.u_64.dlfs_##field; \ 1141 *p64 += val; \ 1142 } else { \ 1143 type32 *p32 = &fs->lfs_dlfs_u.u_32.dlfs_##field; \ 1144 *p32 += val; \ 1145 } \ 1146 } \ 1147 static __unused inline void \ 1148 lfs_sb_sub##field(STRUCT_LFS *fs, type val) \ 1149 { \ 1150 if (fs->lfs_is64) { \ 1151 type *p64 = &fs->lfs_dlfs_u.u_64.dlfs_##field; \ 1152 *p64 -= val; \ 1153 } else { \ 1154 type32 *p32 = &fs->lfs_dlfs_u.u_32.dlfs_##field; \ 1155 *p32 -= val; \ 1156 } \ 1157 } 1158 1159 #define LFS_DEF_SB_ACCESSOR(t, f) LFS_DEF_SB_ACCESSOR_FULL(t, t, f) 1160 1161 #define LFS_DEF_SB_ACCESSOR_32ONLY(type, field, val64) \ 1162 static __unused inline type \ 1163 lfs_sb_get##field(STRUCT_LFS *fs) \ 1164 { \ 1165 if (fs->lfs_is64) { \ 1166 return val64; \ 1167 } else { \ 1168 return fs->lfs_dlfs_u.u_32.dlfs_##field; \ 1169 } \ 1170 } 1171 1172 LFS_DEF_SB_ACCESSOR(u_int32_t, version); 1173 LFS_DEF_SB_ACCESSOR_FULL(u_int64_t, u_int32_t, size); 1174 LFS_DEF_SB_ACCESSOR(u_int32_t, ssize); 1175 LFS_DEF_SB_ACCESSOR_FULL(u_int64_t, u_int32_t, dsize); 1176 LFS_DEF_SB_ACCESSOR(u_int32_t, bsize); 1177 LFS_DEF_SB_ACCESSOR(u_int32_t, fsize); 1178 LFS_DEF_SB_ACCESSOR(u_int32_t, frag); 1179 LFS_DEF_SB_ACCESSOR_FULL(uint64_t, uint32_t, freehd); 1180 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, bfree); 1181 LFS_DEF_SB_ACCESSOR_FULL(uint64_t, uint32_t, nfiles); 1182 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, avail); 1183 LFS_DEF_SB_ACCESSOR(int32_t, uinodes); 1184 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, idaddr); 1185 LFS_DEF_SB_ACCESSOR_32ONLY(u_int32_t, ifile, LFS_IFILE_INUM); 1186 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, lastseg); 1187 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, nextseg); 1188 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, curseg); 1189 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, offset); 1190 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, lastpseg); 1191 LFS_DEF_SB_ACCESSOR(u_int32_t, inopf); 1192 LFS_DEF_SB_ACCESSOR(u_int32_t, minfree); 1193 LFS_DEF_SB_ACCESSOR(uint64_t, maxfilesize); 1194 LFS_DEF_SB_ACCESSOR(u_int32_t, fsbpseg); 1195 LFS_DEF_SB_ACCESSOR(u_int32_t, inopb); 1196 LFS_DEF_SB_ACCESSOR(u_int32_t, ifpb); 1197 LFS_DEF_SB_ACCESSOR(u_int32_t, sepb); 1198 LFS_DEF_SB_ACCESSOR(u_int32_t, nindir); 1199 LFS_DEF_SB_ACCESSOR(u_int32_t, nseg); 1200 LFS_DEF_SB_ACCESSOR(u_int32_t, nspf); 1201 LFS_DEF_SB_ACCESSOR(u_int32_t, cleansz); 1202 LFS_DEF_SB_ACCESSOR(u_int32_t, segtabsz); 1203 LFS_DEF_SB_ACCESSOR_32ONLY(u_int32_t, segmask, 0); 1204 LFS_DEF_SB_ACCESSOR_32ONLY(u_int32_t, segshift, 0); 1205 LFS_DEF_SB_ACCESSOR(u_int64_t, bmask); 1206 LFS_DEF_SB_ACCESSOR(u_int32_t, bshift); 1207 LFS_DEF_SB_ACCESSOR(u_int64_t, ffmask); 1208 LFS_DEF_SB_ACCESSOR(u_int32_t, ffshift); 1209 LFS_DEF_SB_ACCESSOR(u_int64_t, fbmask); 1210 LFS_DEF_SB_ACCESSOR(u_int32_t, fbshift); 1211 LFS_DEF_SB_ACCESSOR(u_int32_t, blktodb); 1212 LFS_DEF_SB_ACCESSOR(u_int32_t, fsbtodb); 1213 LFS_DEF_SB_ACCESSOR(u_int32_t, sushift); 1214 LFS_DEF_SB_ACCESSOR(int32_t, maxsymlinklen); 1215 LFS_DEF_SB_ACCESSOR(u_int32_t, cksum); 1216 LFS_DEF_SB_ACCESSOR(u_int16_t, pflags); 1217 LFS_DEF_SB_ACCESSOR(u_int32_t, nclean); 1218 LFS_DEF_SB_ACCESSOR(int32_t, dmeta); 1219 LFS_DEF_SB_ACCESSOR(u_int32_t, minfreeseg); 1220 LFS_DEF_SB_ACCESSOR(u_int32_t, sumsize); 1221 LFS_DEF_SB_ACCESSOR(u_int64_t, serial); 1222 LFS_DEF_SB_ACCESSOR(u_int32_t, ibsize); 1223 LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, s0addr); 1224 LFS_DEF_SB_ACCESSOR(u_int64_t, tstamp); 1225 LFS_DEF_SB_ACCESSOR(u_int32_t, inodefmt); 1226 LFS_DEF_SB_ACCESSOR(u_int32_t, interleave); 1227 LFS_DEF_SB_ACCESSOR(u_int32_t, ident); 1228 LFS_DEF_SB_ACCESSOR(u_int32_t, resvseg); 1229 1230 /* special-case accessors */ 1231 1232 /* 1233 * the v1 otstamp field lives in what's now dlfs_inopf 1234 */ 1235 #define lfs_sb_getotstamp(fs) lfs_sb_getinopf(fs) 1236 #define lfs_sb_setotstamp(fs, val) lfs_sb_setinopf(fs, val) 1237 1238 /* 1239 * lfs_sboffs is an array 1240 */ 1241 static __unused inline int32_t 1242 lfs_sb_getsboff(STRUCT_LFS *fs, unsigned n) 1243 { 1244 #ifdef KASSERT /* ugh */ 1245 KASSERT(n < LFS_MAXNUMSB); 1246 #endif 1247 if (fs->lfs_is64) { 1248 return fs->lfs_dlfs_u.u_64.dlfs_sboffs[n]; 1249 } else { 1250 return fs->lfs_dlfs_u.u_32.dlfs_sboffs[n]; 1251 } 1252 } 1253 static __unused inline void 1254 lfs_sb_setsboff(STRUCT_LFS *fs, unsigned n, int32_t val) 1255 { 1256 #ifdef KASSERT /* ugh */ 1257 KASSERT(n < LFS_MAXNUMSB); 1258 #endif 1259 if (fs->lfs_is64) { 1260 fs->lfs_dlfs_u.u_64.dlfs_sboffs[n] = val; 1261 } else { 1262 fs->lfs_dlfs_u.u_32.dlfs_sboffs[n] = val; 1263 } 1264 } 1265 1266 /* 1267 * lfs_fsmnt is a string 1268 */ 1269 static __unused inline const char * 1270 lfs_sb_getfsmnt(STRUCT_LFS *fs) 1271 { 1272 if (fs->lfs_is64) { 1273 return fs->lfs_dlfs_u.u_64.dlfs_fsmnt; 1274 } else { 1275 return fs->lfs_dlfs_u.u_32.dlfs_fsmnt; 1276 } 1277 } 1278 1279 static __unused inline void 1280 lfs_sb_setfsmnt(STRUCT_LFS *fs, const char *str) 1281 { 1282 if (fs->lfs_is64) { 1283 (void)strncpy(fs->lfs_dlfs_u.u_64.dlfs_fsmnt, str, 1284 sizeof(fs->lfs_dlfs_u.u_64.dlfs_fsmnt)); 1285 } else { 1286 (void)strncpy(fs->lfs_dlfs_u.u_32.dlfs_fsmnt, str, 1287 sizeof(fs->lfs_dlfs_u.u_32.dlfs_fsmnt)); 1288 } 1289 } 1290 1291 /* Highest addressable fsb */ 1292 #define LFS_MAX_DADDR(fs) \ 1293 ((fs)->lfs_is64 ? 0x7fffffffffffffff : 0x7fffffff) 1294 1295 /* LFS_NINDIR is the number of indirects in a file system block. */ 1296 #define LFS_NINDIR(fs) (lfs_sb_getnindir(fs)) 1297 1298 /* LFS_INOPB is the number of inodes in a secondary storage block. */ 1299 #define LFS_INOPB(fs) (lfs_sb_getinopb(fs)) 1300 /* LFS_INOPF is the number of inodes in a fragment. */ 1301 #define LFS_INOPF(fs) (lfs_sb_getinopf(fs)) 1302 1303 #define lfs_blkoff(fs, loc) ((int)((loc) & lfs_sb_getbmask(fs))) 1304 #define lfs_fragoff(fs, loc) /* calculates (loc % fs->lfs_fsize) */ \ 1305 ((int)((loc) & lfs_sb_getffmask(fs))) 1306 1307 /* XXX: lowercase these as they're no longer macros */ 1308 /* Frags to diskblocks */ 1309 static __unused inline uint64_t 1310 LFS_FSBTODB(STRUCT_LFS *fs, uint64_t b) 1311 { 1312 #if defined(_KERNEL) 1313 return b << (lfs_sb_getffshift(fs) - DEV_BSHIFT); 1314 #else 1315 return b << lfs_sb_getfsbtodb(fs); 1316 #endif 1317 } 1318 /* Diskblocks to frags */ 1319 static __unused inline uint64_t 1320 LFS_DBTOFSB(STRUCT_LFS *fs, uint64_t b) 1321 { 1322 #if defined(_KERNEL) 1323 return b >> (lfs_sb_getffshift(fs) - DEV_BSHIFT); 1324 #else 1325 return b >> lfs_sb_getfsbtodb(fs); 1326 #endif 1327 } 1328 1329 #define lfs_lblkno(fs, loc) ((loc) >> lfs_sb_getbshift(fs)) 1330 #define lfs_lblktosize(fs, blk) ((blk) << lfs_sb_getbshift(fs)) 1331 1332 /* Frags to bytes */ 1333 static __unused inline uint64_t 1334 lfs_fsbtob(STRUCT_LFS *fs, uint64_t b) 1335 { 1336 return b << lfs_sb_getffshift(fs); 1337 } 1338 /* Bytes to frags */ 1339 static __unused inline uint64_t 1340 lfs_btofsb(STRUCT_LFS *fs, uint64_t b) 1341 { 1342 return b >> lfs_sb_getffshift(fs); 1343 } 1344 1345 #define lfs_numfrags(fs, loc) /* calculates (loc / fs->lfs_fsize) */ \ 1346 ((loc) >> lfs_sb_getffshift(fs)) 1347 #define lfs_blkroundup(fs, size)/* calculates roundup(size, lfs_sb_getbsize(fs)) */ \ 1348 ((off_t)(((size) + lfs_sb_getbmask(fs)) & (~lfs_sb_getbmask(fs)))) 1349 #define lfs_fragroundup(fs, size)/* calculates roundup(size, fs->lfs_fsize) */ \ 1350 ((off_t)(((size) + lfs_sb_getffmask(fs)) & (~lfs_sb_getffmask(fs)))) 1351 #define lfs_fragstoblks(fs, frags)/* calculates (frags / fs->fs_frag) */ \ 1352 ((frags) >> lfs_sb_getfbshift(fs)) 1353 #define lfs_blkstofrags(fs, blks)/* calculates (blks * fs->fs_frag) */ \ 1354 ((blks) << lfs_sb_getfbshift(fs)) 1355 #define lfs_fragnum(fs, fsb) /* calculates (fsb % fs->lfs_frag) */ \ 1356 ((fsb) & ((fs)->lfs_frag - 1)) 1357 #define lfs_blknum(fs, fsb) /* calculates rounddown(fsb, fs->lfs_frag) */ \ 1358 ((fsb) &~ ((fs)->lfs_frag - 1)) 1359 #define lfs_dblksize(fs, dp, lbn) \ 1360 (((lbn) >= ULFS_NDADDR || lfs_dino_getsize(fs, dp) >= ((lbn) + 1) << lfs_sb_getbshift(fs)) \ 1361 ? lfs_sb_getbsize(fs) \ 1362 : (lfs_fragroundup(fs, lfs_blkoff(fs, lfs_dino_getsize(fs, dp))))) 1363 1364 #define lfs_segsize(fs) (lfs_sb_getversion(fs) == 1 ? \ 1365 lfs_lblktosize((fs), lfs_sb_getssize(fs)) : \ 1366 lfs_sb_getssize(fs)) 1367 /* XXX segtod produces a result in frags despite the 'd' */ 1368 #define lfs_segtod(fs, seg) (lfs_btofsb(fs, lfs_segsize(fs)) * (seg)) 1369 #define lfs_dtosn(fs, daddr) /* block address to segment number */ \ 1370 ((uint32_t)(((daddr) - lfs_sb_gets0addr(fs)) / lfs_segtod((fs), 1))) 1371 #define lfs_sntod(fs, sn) /* segment number to disk address */ \ 1372 ((daddr_t)(lfs_segtod((fs), (sn)) + lfs_sb_gets0addr(fs))) 1373 1374 /* XXX, blah. make this appear only if struct inode is defined */ 1375 #ifdef _UFS_LFS_LFS_INODE_H_ 1376 static __unused inline uint32_t 1377 lfs_blksize(STRUCT_LFS *fs, struct inode *ip, uint64_t lbn) 1378 { 1379 if (lbn >= ULFS_NDADDR || lfs_dino_getsize(fs, ip->i_din) >= (lbn + 1) << lfs_sb_getbshift(fs)) { 1380 return lfs_sb_getbsize(fs); 1381 } else { 1382 return lfs_fragroundup(fs, lfs_blkoff(fs, lfs_dino_getsize(fs, ip->i_din))); 1383 } 1384 } 1385 #endif 1386 1387 /* 1388 * union lfs_blocks 1389 */ 1390 1391 static __unused inline void 1392 lfs_blocks_fromvoid(STRUCT_LFS *fs, union lfs_blocks *bp, void *p) 1393 { 1394 if (fs->lfs_is64) { 1395 bp->b64 = p; 1396 } else { 1397 bp->b32 = p; 1398 } 1399 } 1400 1401 static __unused inline void 1402 lfs_blocks_fromfinfo(STRUCT_LFS *fs, union lfs_blocks *bp, FINFO *fip) 1403 { 1404 void *firstblock; 1405 1406 firstblock = (char *)fip + FINFOSIZE(fs); 1407 if (fs->lfs_is64) { 1408 bp->b64 = (int64_t *)firstblock; 1409 } else { 1410 bp->b32 = (int32_t *)firstblock; 1411 } 1412 } 1413 1414 static __unused inline daddr_t 1415 lfs_blocks_get(STRUCT_LFS *fs, union lfs_blocks *bp, unsigned index) 1416 { 1417 if (fs->lfs_is64) { 1418 return bp->b64[index]; 1419 } else { 1420 return bp->b32[index]; 1421 } 1422 } 1423 1424 static __unused inline void 1425 lfs_blocks_set(STRUCT_LFS *fs, union lfs_blocks *bp, unsigned index, daddr_t val) 1426 { 1427 if (fs->lfs_is64) { 1428 bp->b64[index] = val; 1429 } else { 1430 bp->b32[index] = val; 1431 } 1432 } 1433 1434 static __unused inline void 1435 lfs_blocks_inc(STRUCT_LFS *fs, union lfs_blocks *bp) 1436 { 1437 if (fs->lfs_is64) { 1438 bp->b64++; 1439 } else { 1440 bp->b32++; 1441 } 1442 } 1443 1444 static __unused inline int 1445 lfs_blocks_eq(STRUCT_LFS *fs, union lfs_blocks *bp1, union lfs_blocks *bp2) 1446 { 1447 if (fs->lfs_is64) { 1448 return bp1->b64 == bp2->b64; 1449 } else { 1450 return bp1->b32 == bp2->b32; 1451 } 1452 } 1453 1454 static __unused inline int 1455 lfs_blocks_sub(STRUCT_LFS *fs, union lfs_blocks *bp1, union lfs_blocks *bp2) 1456 { 1457 /* (remember that the pointers are typed) */ 1458 if (fs->lfs_is64) { 1459 return bp1->b64 - bp2->b64; 1460 } else { 1461 return bp1->b32 - bp2->b32; 1462 } 1463 } 1464 1465 /* 1466 * struct segment 1467 */ 1468 1469 1470 /* 1471 * Macros for determining free space on the disk, with the variable metadata 1472 * of segment summaries and inode blocks taken into account. 1473 */ 1474 /* 1475 * Estimate number of clean blocks not available for writing because 1476 * they will contain metadata or overhead. This is calculated as 1477 * 1478 * E = ((C * M / D) * D + (0) * (T - D)) / T 1479 * or more simply 1480 * E = (C * M) / T 1481 * 1482 * where 1483 * C is the clean space, 1484 * D is the dirty space, 1485 * M is the dirty metadata, and 1486 * T = C + D is the total space on disk. 1487 * 1488 * This approximates the old formula of E = C * M / D when D is close to T, 1489 * but avoids falsely reporting "disk full" when the sample size (D) is small. 1490 */ 1491 #define LFS_EST_CMETA(F) (( \ 1492 (lfs_sb_getdmeta(F) * (int64_t)lfs_sb_getnclean(F)) / \ 1493 (lfs_sb_getnseg(F)))) 1494 1495 /* Estimate total size of the disk not including metadata */ 1496 #define LFS_EST_NONMETA(F) (lfs_sb_getdsize(F) - lfs_sb_getdmeta(F) - LFS_EST_CMETA(F)) 1497 1498 /* Estimate number of blocks actually available for writing */ 1499 #define LFS_EST_BFREE(F) (lfs_sb_getbfree(F) > LFS_EST_CMETA(F) ? \ 1500 lfs_sb_getbfree(F) - LFS_EST_CMETA(F) : 0) 1501 1502 /* Amount of non-meta space not available to mortal man */ 1503 #define LFS_EST_RSVD(F) ((LFS_EST_NONMETA(F) * \ 1504 (u_int64_t)lfs_sb_getminfree(F)) / \ 1505 100) 1506 1507 /* Can credential C write BB blocks? XXX: kauth_cred_geteuid is abusive */ 1508 #define ISSPACE(F, BB, C) \ 1509 ((((C) == NOCRED || kauth_cred_geteuid(C) == 0) && \ 1510 LFS_EST_BFREE(F) >= (BB)) || \ 1511 (kauth_cred_geteuid(C) != 0 && IS_FREESPACE(F, BB))) 1512 1513 /* Can an ordinary user write BB blocks */ 1514 #define IS_FREESPACE(F, BB) \ 1515 (LFS_EST_BFREE(F) >= (BB) + LFS_EST_RSVD(F)) 1516 1517 /* 1518 * The minimum number of blocks to create a new inode. This is: 1519 * directory direct block (1) + ULFS_NIADDR indirect blocks + inode block (1) + 1520 * ifile direct block (1) + ULFS_NIADDR indirect blocks = 3 + 2 * ULFS_NIADDR blocks. 1521 */ 1522 #define LFS_NRESERVE(F) (lfs_btofsb((F), (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(F))) 1523 1524 1525 1526 #endif /* _UFS_LFS_LFS_ACCESSORS_H_ */ 1527
Indexes created Fri Oct 17 17:09:57 GMT 2025