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
288static __inline char *
289lfs_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
298static __inline uint64_t
299lfs_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
308static __inline uint16_t
309lfs_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
318static __inline uint8_t
319lfs_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
331static __inline uint8_t
332lfs_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
345static __inline void
346lfs_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
355static __inline void
356lfs_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
365static __inline void
366lfs_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
379static __inline void
380lfs_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
393static __inline void
394lfs_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
409static __inline LFS_DIRHEADER *
410lfs_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
420static __inline char *
421lfs_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
448static __inline void
449lfs_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
489LFS_DEF_DINO_ACCESSOR(uint16_t, uint16_t, mode)
490LFS_DEF_DINO_ACCESSOR(int16_t, int16_t, nlink)
491LFS_DEF_DINO_ACCESSOR(uint64_t, uint32_t, inumber)
492LFS_DEF_DINO_ACCESSOR(uint64_t, uint64_t, size)
493LFS_DEF_DINO_ACCESSOR(int64_t, int32_t, atime)
494LFS_DEF_DINO_ACCESSOR(int32_t, int32_t, atimensec)
495LFS_DEF_DINO_ACCESSOR(int64_t, int32_t, mtime)
496LFS_DEF_DINO_ACCESSOR(int32_t, int32_t, mtimensec)
497LFS_DEF_DINO_ACCESSOR(int64_t, int32_t, ctime)
498LFS_DEF_DINO_ACCESSOR(int32_t, int32_t, ctimensec)
499LFS_DEF_DINO_ACCESSOR(uint32_t, uint32_t, flags)
500LFS_DEF_DINO_ACCESSOR(uint64_t, uint32_t, blocks)
501LFS_DEF_DINO_ACCESSOR(int32_t, int32_t, gen)
502LFS_DEF_DINO_ACCESSOR(uint32_t, uint32_t, uid)
503LFS_DEF_DINO_ACCESSOR(uint32_t, uint32_t, gid)
504
505/* XXX this should be done differently (it's a fake field) */
506LFS_DEF_DINO_ACCESSOR(int64_t, int32_t, rdev)
507
508static __inline daddr_t
509lfs_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
520static __inline daddr_t
521lfs_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
532static __inline void
533lfs_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
543static __inline void
544lfs_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 */
555static __inline void
556lfs_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
571static __inline daddr_t
572lfs_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
585static __inline void
586lfs_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
750LFS_DEF_FI_ACCESSOR(uint32_t, uint32_t, nblocks)
751LFS_DEF_FI_ACCESSOR(uint32_t, uint32_t, version)
752LFS_DEF_FI_ACCESSOR(uint64_t, uint32_t, ino)
753LFS_DEF_FI_ACCESSOR(uint32_t, uint32_t, lastlength)
754
755static __inline daddr_t
756lfs_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
769static __inline void
770lfs_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
799static __inline uint64_t
800lfs_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
809static __inline void
810lfs_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
885LFS_DEF_IF_ACCESSOR(uint32_t, uint32_t, version)
886LFS_DEF_IF_ACCESSOR(int64_t, int32_t, daddr)
887LFS_DEF_IF_ACCESSOR(uint64_t, uint32_t, nextfree)
888LFS_DEF_IF_ACCESSOR(uint64_t, uint32_t, atime_sec)
889LFS_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
924LFS_DEF_CI_ACCESSOR(uint32_t, uint32_t, clean)
925LFS_DEF_CI_ACCESSOR(uint32_t, uint32_t, dirty)
926LFS_DEF_CI_ACCESSOR(int64_t, int32_t, bfree)
927LFS_DEF_CI_ACCESSOR(int64_t, int32_t, avail)
928LFS_DEF_CI_ACCESSOR(uint64_t, uint32_t, free_head)
929LFS_DEF_CI_ACCESSOR(uint64_t, uint32_t, free_tail)
930LFS_DEF_CI_ACCESSOR(uint32_t, uint32_t, flags)
931
932static __inline void
933lfs_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
939static __inline void
940lfs_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
1036static __inline FINFO *
1037segsum_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
1070LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, sumsum)
1071LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, datasum)
1072LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, magic)
1073LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, ident)
1074LFS_DEF_SS_ACCESSOR(int64_t, int32_t, next)
1075LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, nfinfo)
1076LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, ninos)
1077LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, flags)
1078LFS_DEF_SS_ACCESSOR(uint64_t, uint32_t, reclino)
1079LFS_DEF_SS_ACCESSOR(uint64_t, uint64_t, serial)
1080LFS_DEF_SS_ACCESSOR(uint64_t, uint64_t, create)
1081
1082static __inline size_t
1083lfs_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
1099static __inline uint32_t
1100lfs_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
1109static __inline void
1110lfs_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
1183LFS_DEF_SB_ACCESSOR(uint32_t, version)
1184LFS_DEF_SB_ACCESSOR_FULL(uint64_t, uint32_t, size)
1185LFS_DEF_SB_ACCESSOR(uint32_t, ssize)
1186LFS_DEF_SB_ACCESSOR_FULL(uint64_t, uint32_t, dsize)
1187LFS_DEF_SB_ACCESSOR(uint32_t, bsize)
1188LFS_DEF_SB_ACCESSOR(uint32_t, fsize)
1189LFS_DEF_SB_ACCESSOR(uint32_t, frag)
1190LFS_DEF_SB_ACCESSOR_FULL(uint64_t, uint32_t, freehd)
1191LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, bfree)
1192LFS_DEF_SB_ACCESSOR_FULL(uint64_t, uint32_t, nfiles)
1193LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, avail)
1194LFS_DEF_SB_ACCESSOR(int32_t, uinodes)
1195LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, idaddr)
1196LFS_DEF_SB_ACCESSOR_32ONLY(uint32_t, ifile, LFS_IFILE_INUM)
1197LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, lastseg)
1198LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, nextseg)
1199LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, curseg)
1200LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, offset)
1201LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, lastpseg)
1202LFS_DEF_SB_ACCESSOR(uint32_t, inopf)
1203LFS_DEF_SB_ACCESSOR(uint32_t, minfree)
1204LFS_DEF_SB_ACCESSOR(uint64_t, maxfilesize)
1205LFS_DEF_SB_ACCESSOR(uint32_t, fsbpseg)
1206LFS_DEF_SB_ACCESSOR(uint32_t, inopb)
1207LFS_DEF_SB_ACCESSOR(uint32_t, ifpb)
1208LFS_DEF_SB_ACCESSOR(uint32_t, sepb)
1209LFS_DEF_SB_ACCESSOR(uint32_t, nindir)
1210LFS_DEF_SB_ACCESSOR(uint32_t, nseg)
1211LFS_DEF_SB_ACCESSOR(uint32_t, nspf)
1212LFS_DEF_SB_ACCESSOR(uint32_t, cleansz)
1213LFS_DEF_SB_ACCESSOR(uint32_t, segtabsz)
1214LFS_DEF_SB_ACCESSOR_32ONLY(uint32_t, segmask, 0)
1215LFS_DEF_SB_ACCESSOR_32ONLY(uint32_t, segshift, 0)
1216LFS_DEF_SB_ACCESSOR(uint64_t, bmask)
1217LFS_DEF_SB_ACCESSOR(uint32_t, bshift)
1218LFS_DEF_SB_ACCESSOR(uint64_t, ffmask)
1219LFS_DEF_SB_ACCESSOR(uint32_t, ffshift)
1220LFS_DEF_SB_ACCESSOR(uint64_t, fbmask)
1221LFS_DEF_SB_ACCESSOR(uint32_t, fbshift)
1222LFS_DEF_SB_ACCESSOR(uint32_t, blktodb)
1223LFS_DEF_SB_ACCESSOR(uint32_t, fsbtodb)
1224LFS_DEF_SB_ACCESSOR(uint32_t, sushift)
1225LFS_DEF_SB_ACCESSOR(int32_t, maxsymlinklen)
1226LFS_DEF_SB_ACCESSOR(uint32_t, cksum)
1227LFS_DEF_SB_ACCESSOR(uint16_t, pflags)
1228LFS_DEF_SB_ACCESSOR(uint32_t, nclean)
1229LFS_DEF_SB_ACCESSOR(int32_t, dmeta)
1230LFS_DEF_SB_ACCESSOR(uint32_t, minfreeseg)
1231LFS_DEF_SB_ACCESSOR(uint32_t, sumsize)
1232LFS_DEF_SB_ACCESSOR(uint64_t, serial)
1233LFS_DEF_SB_ACCESSOR(uint32_t, ibsize)
1234LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, s0addr)
1235LFS_DEF_SB_ACCESSOR(uint64_t, tstamp)
1236LFS_DEF_SB_ACCESSOR(uint32_t, inodefmt)
1237LFS_DEF_SB_ACCESSOR(uint32_t, interleave)
1238LFS_DEF_SB_ACCESSOR(uint32_t, ident)
1239LFS_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 */
1252static __inline int32_t
1253lfs_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}
1264static __inline void
1265lfs_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 */
1280static __inline const char *
1281lfs_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
1290static __inline void
1291lfs_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 */
1320static __inline uint64_t
1321LFS_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 */
1330static __inline uint64_t
1331LFS_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 */
1344static __inline uint64_t
1345lfs_fsbtob(STRUCT_LFS *fs, uint64_t b)
1346{
1347 return b << lfs_sb_getffshift(fs);
1348}
1349/* Bytes to frags */
1350static __inline uint64_t
1351lfs_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_
1387static __inline uint32_t
1388lfs_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
1402static __inline void
1403lfs_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
1412static __inline void
1413lfs_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
1425static __inline daddr_t
1426lfs_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
1435static __inline void
1436lfs_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
1445static __inline void
1446lfs_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
1455static __inline int
1456lfs_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
1465static __inline int
1466lfs_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_ */