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