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