xref: /illumos-gate/usr/src/grub/grub-0.97/stage2/jfs.h (revision 1b8adde7)
1 /* jfs.h - an extractions from linux/include/linux/jfs/jfs* into one file */
2 /*
3  *  GRUB  --  GRand Unified Bootloader
4  *  Copyright (C) 2000  International Business Machines  Corp.
5  *  Copyright (C) 2001  Free Software Foundation, Inc.
6  *
7  *  This program is free software;  you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; either version 2 of the License, or
10  *  (at your option) any later version.
11  *
12  *  This program is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY;  without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
15  *  the GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program;  if not, write to the Free Software
19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  */
21 
22 #ifndef _JFS_H_
23 #define _JFS_H_
24 
25 /* those are from jfs_filsys.h */
26 
27 /*
28  *	 file system option (superblock flag)
29  */
30 /* platform option (conditional compilation) */
31 #define JFS_AIX		0x80000000	/* AIX support */
32 /*	POSIX name/directory  support */
33 
34 #define JFS_OS2		0x40000000	/* OS/2 support */
35 /*	case-insensitive name/directory support */
36 
37 #define JFS_LINUX      	0x10000000	/* Linux support */
38 /*	case-sensitive name/directory support */
39 
40 /* directory option */
41 #define JFS_UNICODE	0x00000001	/* unicode name */
42 
43 /* bba */
44 #define	JFS_SWAP_BYTES		0x00100000	/* running on big endian computer */
45 
46 
47 /*
48  *	buffer cache configuration
49  */
50 /* page size */
51 #ifdef PSIZE
52 #undef PSIZE
53 #endif
54 #define	PSIZE		4096	/* page size (in byte) */
55 
56 /*
57  *	fs fundamental size
58  *
59  * PSIZE >= file system block size >= PBSIZE >= DISIZE
60  */
61 #define	PBSIZE		512	/* physical block size (in byte) */
62 #define DISIZE		512	/* on-disk inode size (in byte) */
63 #define L2DISIZE	9
64 #define	INOSPERIAG	4096	/* number of disk inodes per iag */
65 #define	L2INOSPERIAG	12
66 #define INOSPEREXT	32	/* number of disk inode per extent */
67 #define L2INOSPEREXT	5
68 
69 /* Minimum number of bytes supported for a JFS partition */
70 #define MINJFS			(0x1000000)
71 
72 /*
73  * fixed byte offset address
74  */
75 #define SUPER1_OFF	0x8000	/* primary superblock */
76 
77 #define AITBL_OFF	(SUPER1_OFF + PSIZE + (PSIZE << 1))
78 
79 /*
80  *	fixed reserved inode number
81  */
82 /* aggregate inode */
83 #define	AGGREGATE_I	1	/* aggregate inode map inode */
84 #define	FILESYSTEM_I	16	/* 1st/only fileset inode in ait:
85 				 * fileset inode map inode
86 				 */
87 
88 /* per fileset inode */
89 #define	ROOT_I		2	/* fileset root inode */
90 
91 /*
92  *	directory configuration
93  */
94 #define JFS_NAME_MAX	255
95 #define JFS_PATH_MAX	PSIZE
96 
97 typedef unsigned char u8;
98 typedef char s8;
99 typedef unsigned short u16;
100 typedef short s16;
101 typedef unsigned int u32;
102 typedef int s32;
103 typedef unsigned long long u64;
104 typedef long long s64;
105 
106 typedef u16 UniChar;
107 
108 /* these from jfs_btree.h */
109 
110 /* btpaget_t flag */
111 #define BT_TYPE		0x07	/* B+-tree index */
112 #define	BT_ROOT		0x01	/* root page */
113 #define	BT_LEAF		0x02	/* leaf page */
114 #define	BT_INTERNAL	0x04	/* internal page */
115 #define	BT_RIGHTMOST	0x10	/* rightmost page */
116 #define	BT_LEFTMOST	0x20	/* leftmost page */
117 
118 /* those are from jfs_types.h */
119 
120 struct timestruc_t {
121 	u32 tv_sec;
122 	u32 tv_nsec;
123 };
124 
125 /*
126  *	physical xd (pxd)
127  */
128 typedef struct {
129 	unsigned len:24;
130 	unsigned addr1:8;
131 	u32 addr2;
132 } pxd_t;
133 
134 /* xd_t field extraction */
135 #define	lengthPXD(pxd)	((pxd)->len)
136 #define	addressPXD(pxd)	(((s64)((pxd)->addr1)) << 32 | ((pxd)->addr2))
137 
138 /*
139  *	data extent descriptor (dxd)
140  */
141 typedef struct {
142 	unsigned flag:8;	/* 1: flags */
143 	unsigned rsrvd:24;	/* 3: */
144 	u32 size;		/* 4: size in byte */
145 	unsigned len:24;	/* 3: length in unit of fsblksize */
146 	unsigned addr1:8;	/* 1: address in unit of fsblksize */
147 	u32 addr2;		/* 4: address in unit of fsblksize */
148 } dxd_t;			/* - 16 - */
149 
150 /*
151  *	DASD limit information - stored in directory inode
152  */
153 typedef struct dasd {
154 	u8 thresh;		/* Alert Threshold (in percent) */
155 	u8 delta;		/* Alert Threshold delta (in percent)   */
156 	u8 rsrvd1;
157 	u8 limit_hi;		/* DASD limit (in logical blocks)       */
158 	u32 limit_lo;		/* DASD limit (in logical blocks)       */
159 	u8 rsrvd2[3];
160 	u8 used_hi;		/* DASD usage (in logical blocks)       */
161 	u32 used_lo;		/* DASD usage (in logical blocks)       */
162 } dasd_t;
163 
164 
165 /* from jfs_superblock.h */
166 
167 #define JFS_MAGIC 	0x3153464A	/* "JFS1" */
168 
169 struct jfs_superblock
170 {
171 	u32 s_magic;		/* 4: magic number */
172 	u32 s_version;		/* 4: version number */
173 
174 	s64 s_size;		/* 8: aggregate size in hardware/LVM blocks;
175 				 * VFS: number of blocks
176 				 */
177 	s32 s_bsize;		/* 4: aggregate block size in bytes;
178 				 * VFS: fragment size
179 				 */
180 	s16 s_l2bsize;		/* 2: log2 of s_bsize */
181 	s16 s_l2bfactor;	/* 2: log2(s_bsize/hardware block size) */
182 	s32 s_pbsize;		/* 4: hardware/LVM block size in bytes */
183 	s16 s_l2pbsize;		/* 2: log2 of s_pbsize */
184 	s16 pad;		/* 2: padding necessary for alignment */
185 
186 	u32 s_agsize;		/* 4: allocation group size in aggr. blocks */
187 
188 	u32 s_flag;		/* 4: aggregate attributes:
189 				 *    see jfs_filsys.h
190 				 */
191 	u32 s_state;		/* 4: mount/unmount/recovery state:
192 				 *    see jfs_filsys.h
193 				 */
194 	s32 s_compress;		/* 4: > 0 if data compression */
195 
196 	pxd_t s_ait2;		/* 8: first extent of secondary
197 				 *    aggregate inode table
198 				 */
199 
200 	pxd_t s_aim2;		/* 8: first extent of secondary
201 				 *    aggregate inode map
202 				 */
203 	u32 s_logdev;		/* 4: device address of log */
204 	s32 s_logserial;	/* 4: log serial number at aggregate mount */
205 	pxd_t s_logpxd;		/* 8: inline log extent */
206 
207 	pxd_t s_fsckpxd;	/* 8: inline fsck work space extent */
208 
209 	struct timestruc_t s_time;	/* 8: time last updated */
210 
211 	s32 s_fsckloglen;	/* 4: Number of filesystem blocks reserved for
212 				 *    the fsck service log.
213 				 *    N.B. These blocks are divided among the
214 				 *         versions kept.  This is not a per
215 				 *         version size.
216 				 *    N.B. These blocks are included in the
217 				 *         length field of s_fsckpxd.
218 				 */
219 	s8 s_fscklog;		/* 1: which fsck service log is most recent
220 				 *    0 => no service log data yet
221 				 *    1 => the first one
222 				 *    2 => the 2nd one
223 				 */
224 	char s_fpack[11];	/* 11: file system volume name
225 				 *     N.B. This must be 11 bytes to
226 				 *          conform with the OS/2 BootSector
227 				 *          requirements
228 				 */
229 
230 	/* extendfs() parameter under s_state & FM_EXTENDFS */
231 	s64 s_xsize;		/* 8: extendfs s_size */
232 	pxd_t s_xfsckpxd;	/* 8: extendfs fsckpxd */
233 	pxd_t s_xlogpxd;	/* 8: extendfs logpxd */
234 	/* - 128 byte boundary - */
235 
236 	/*
237 	 *      DFS VFS support (preliminary)
238 	 */
239 	char s_attach;		/* 1: VFS: flag: set when aggregate is attached
240 				 */
241 	u8 rsrvd4[7];		/* 7: reserved - set to 0 */
242 
243 	u64 totalUsable;	/* 8: VFS: total of 1K blocks which are
244 				 * available to "normal" (non-root) users.
245 				 */
246 	u64 minFree;		/* 8: VFS: # of 1K blocks held in reserve for
247 				 * exclusive use of root.  This value can be 0,
248 				 * and if it is then totalUsable will be equal
249 				 * to # of blocks in aggregate.  I believe this
250 				 * means that minFree + totalUsable = # blocks.
251 				 * In that case, we don't need to store both
252 				 * totalUsable and minFree since we can compute
253 				 * one from the other.  I would guess minFree
254 				 * would be the one we should store, and
255 				 * totalUsable would be the one we should
256 				 * compute.  (Just a guess...)
257 				 */
258 
259 	u64 realFree;		/* 8: VFS: # of free 1K blocks can be used by
260 				 * "normal" users.  It may be this is something
261 				 * we should compute when asked for instead of
262 				 * storing in the superblock.  I don't know how
263 				 * often this information is needed.
264 				 */
265 	/*
266 	 *      graffiti area
267 	 */
268 };
269 
270 /* from jfs_dtree.h */
271 
272 /*
273  *      entry segment/slot
274  *
275  * an entry consists of type dependent head/only segment/slot and
276  * additional segments/slots linked vi next field;
277  * N.B. last/only segment of entry is terminated by next = -1;
278  */
279 /*
280  *	directory page slot
281  */
282 typedef struct {
283 	s8 next;		/* 1: */
284 	s8 cnt;			/* 1: */
285 	UniChar name[15];	/* 30: */
286 } dtslot_t;			/* (32) */
287 
288 #define DTSLOTDATALEN	15
289 
290 /*
291  *	 internal node entry head/only segment
292  */
293 typedef struct {
294 	pxd_t xd;		/* 8: child extent descriptor */
295 
296 	s8 next;		/* 1: */
297 	u8 namlen;		/* 1: */
298 	UniChar name[11];	/* 22: 2-byte aligned */
299 } idtentry_t;			/* (32) */
300 
301 /*
302  *	leaf node entry head/only segment
303  *
304  * 	For legacy filesystems, name contains 13 unichars -- no index field
305  */
306 typedef struct {
307 	u32 inumber;		/* 4: 4-byte aligned */
308 	s8 next;		/* 1: */
309 	u8 namlen;		/* 1: */
310 	UniChar name[11];	/* 22: 2-byte aligned */
311 	u32 index;		/* 4: index into dir_table */
312 } ldtentry_t;			/* (32) */
313 
314 #define DTLHDRDATALEN	11
315 
316 /*
317  * dir_table used for directory traversal during readdir
318 */
319 
320 /*
321  * Maximum entry in inline directory table
322  */
323 
324 typedef struct dir_table_slot {
325 	u8 rsrvd;	/* 1: */
326 	u8 flag;	/* 1: 0 if free */
327 	u8 slot;	/* 1: slot within leaf page of entry */
328 	u8 addr1;	/* 1: upper 8 bits of leaf page address */
329 	u32 addr2;	/* 4: lower 32 bits of leaf page address -OR-
330 			      index of next entry when this entry was deleted */
331 } dir_table_slot_t;	/* (8) */
332 
333 /*
334  *	directory root page (in-line in on-disk inode):
335  *
336  * cf. dtpage_t below.
337  */
338 typedef union {
339 	struct {
340 		dasd_t DASD;	/* 16: DASD limit/usage info  F226941 */
341 
342 		u8 flag;	/* 1: */
343 		s8 nextindex;	/* 1: next free entry in stbl */
344 		s8 freecnt;	/* 1: free count */
345 		s8 freelist;	/* 1: freelist header */
346 
347 		u32 idotdot;	/* 4: parent inode number */
348 
349 		s8 stbl[8];	/* 8: sorted entry index table */
350 	} header;		/* (32) */
351 
352 	dtslot_t slot[9];
353 } dtroot_t;
354 
355 /*
356  *	directory regular page:
357  *
358  *	entry slot array of 32 byte slot
359  *
360  * sorted entry slot index table (stbl):
361  * contiguous slots at slot specified by stblindex,
362  * 1-byte per entry
363  *   512 byte block:  16 entry tbl (1 slot)
364  *  1024 byte block:  32 entry tbl (1 slot)
365  *  2048 byte block:  64 entry tbl (2 slot)
366  *  4096 byte block: 128 entry tbl (4 slot)
367  *
368  * data area:
369  *   512 byte block:  16 - 2 =  14 slot
370  *  1024 byte block:  32 - 2 =  30 slot
371  *  2048 byte block:  64 - 3 =  61 slot
372  *  4096 byte block: 128 - 5 = 123 slot
373  *
374  * N.B. index is 0-based; index fields refer to slot index
375  * except nextindex which refers to entry index in stbl;
376  * end of entry stot list or freelist is marked with -1.
377  */
378 typedef union {
379 	struct {
380 		s64 next;	/* 8: next sibling */
381 		s64 prev;	/* 8: previous sibling */
382 
383 		u8 flag;	/* 1: */
384 		s8 nextindex;	/* 1: next entry index in stbl */
385 		s8 freecnt;	/* 1: */
386 		s8 freelist;	/* 1: slot index of head of freelist */
387 
388 		u8 maxslot;	/* 1: number of slots in page slot[] */
389 		s8 stblindex;	/* 1: slot index of start of stbl */
390 		u8 rsrvd[2];	/* 2: */
391 
392 		pxd_t self;	/* 8: self pxd */
393 	} header;		/* (32) */
394 
395 	dtslot_t slot[128];
396 } dtpage_t;
397 
398 /* from jfs_xtree.h */
399 
400 /*
401  *      extent allocation descriptor (xad)
402  */
403 typedef struct xad {
404 	unsigned flag:8;	/* 1: flag */
405 	unsigned rsvrd:16;	/* 2: reserved */
406 	unsigned off1:8;	/* 1: offset in unit of fsblksize */
407 	u32 off2;		/* 4: offset in unit of fsblksize */
408 	unsigned len:24;	/* 3: length in unit of fsblksize */
409 	unsigned addr1:8;	/* 1: address in unit of fsblksize */
410 	u32 addr2;		/* 4: address in unit of fsblksize */
411 } xad_t;			/* (16) */
412 
413 /* xad_t field extraction */
414 #define offsetXAD(xad)	(((s64)((xad)->off1)) << 32 | ((xad)->off2))
415 #define addressXAD(xad)	(((s64)((xad)->addr1)) << 32 | ((xad)->addr2))
416 #define lengthXAD(xad)	((xad)->len)
417 
418 /* possible values for maxentry */
419 #define XTPAGEMAXSLOT   256
420 #define XTENTRYSTART    2
421 
422 /*
423  *      xtree page:
424  */
425 typedef union {
426 	struct xtheader {
427 		s64 next;	/* 8: */
428 		s64 prev;	/* 8: */
429 
430 		u8 flag;	/* 1: */
431 		u8 rsrvd1;	/* 1: */
432 		s16 nextindex;	/* 2: next index = number of entries */
433 		s16 maxentry;	/* 2: max number of entries */
434 		s16 rsrvd2;	/* 2: */
435 
436 		pxd_t self;	/* 8: self */
437 	} header;		/* (32) */
438 
439 	xad_t xad[XTPAGEMAXSLOT];	/* 16 * maxentry: xad array */
440 } xtpage_t;
441 
442 /* from jfs_dinode.h */
443 
444 struct dinode {
445 	/*
446 	 *      I. base area (128 bytes)
447 	 *      ------------------------
448 	 *
449 	 * define generic/POSIX attributes
450 	 */
451 	u32 di_inostamp;	/* 4: stamp to show inode belongs to fileset */
452 	s32 di_fileset;		/* 4: fileset number */
453 	u32 di_number;		/* 4: inode number, aka file serial number */
454 	u32 di_gen;		/* 4: inode generation number */
455 
456 	pxd_t di_ixpxd;		/* 8: inode extent descriptor */
457 
458 	s64 di_size;		/* 8: size */
459 	s64 di_nblocks;		/* 8: number of blocks allocated */
460 
461 	u32 di_nlink;		/* 4: number of links to the object */
462 
463 	u32 di_uid;		/* 4: user id of owner */
464 	u32 di_gid;		/* 4: group id of owner */
465 
466 	u32 di_mode;		/* 4: attribute, format and permission */
467 
468 	struct timestruc_t di_atime;	/* 8: time last data accessed */
469 	struct timestruc_t di_ctime;	/* 8: time last status changed */
470 	struct timestruc_t di_mtime;	/* 8: time last data modified */
471 	struct timestruc_t di_otime;	/* 8: time created */
472 
473 	dxd_t di_acl;		/* 16: acl descriptor */
474 
475 	dxd_t di_ea;		/* 16: ea descriptor */
476 
477 	s32 di_next_index;  /* 4: Next available dir_table index */
478 
479 	s32 di_acltype;		/* 4: Type of ACL */
480 
481 	/*
482 	 * 	Extension Areas.
483 	 *
484 	 *	Historically, the inode was partitioned into 4 128-byte areas,
485 	 *	the last 3 being defined as unions which could have multiple
486 	 *	uses.  The first 96 bytes had been completely unused until
487 	 *	an index table was added to the directory.  It is now more
488 	 *	useful to describe the last 3/4 of the inode as a single
489 	 *	union.  We would probably be better off redesigning the
490 	 *	entire structure from scratch, but we don't want to break
491 	 *	commonality with OS/2's JFS at this time.
492 	 */
493 	union {
494 		struct {
495 			/*
496 			 * This table contains the information needed to
497 			 * find a directory entry from a 32-bit index.
498 			 * If the index is small enough, the table is inline,
499 			 * otherwise, an x-tree root overlays this table
500 			 */
501 			dir_table_slot_t _table[12];	/* 96: inline */
502 
503 			dtroot_t _dtroot;		/* 288: dtree root */
504 		} _dir;					/* (384) */
505 #define di_dirtable	u._dir._table
506 #define di_dtroot	u._dir._dtroot
507 #define di_parent       di_dtroot.header.idotdot
508 #define di_DASD		di_dtroot.header.DASD
509 
510 		struct {
511 			union {
512 				u8 _data[96];		/* 96: unused */
513 				struct {
514 					void *_imap;	/* 4: unused */
515 					u32 _gengen;	/* 4: generator */
516 				} _imap;
517 			} _u1;				/* 96: */
518 #define di_gengen	u._file._u1._imap._gengen
519 
520 			union {
521 				xtpage_t _xtroot;
522 				struct {
523 					u8 unused[16];	/* 16: */
524 					dxd_t _dxd;	/* 16: */
525 					union {
526 						u32 _rdev;	/* 4: */
527 						u8 _fastsymlink[128];
528 					} _u;
529 					u8 _inlineea[128];
530 				} _special;
531 			} _u2;
532 		} _file;
533 #define di_xtroot	u._file._u2._xtroot
534 #define di_dxd		u._file._u2._special._dxd
535 #define di_btroot	di_xtroot
536 #define di_inlinedata	u._file._u2._special._u
537 #define di_rdev		u._file._u2._special._u._rdev
538 #define di_fastsymlink	u._file._u2._special._u._fastsymlink
539 #define di_inlineea     u._file._u2._special._inlineea
540 	} u;
541 };
542 
543 typedef struct dinode dinode_t;
544 
545 /* di_mode */
546 #define IFMT	0xF000		/* S_IFMT - mask of file type */
547 #define IFDIR	0x4000		/* S_IFDIR - directory */
548 #define IFREG	0x8000		/* S_IFREG - regular file */
549 #define IFLNK	0xA000		/* S_IFLNK - symbolic link */
550 
551 /* extended mode bits (on-disk inode di_mode) */
552 #define INLINEEA        0x00040000	/* inline EA area free */
553 
554 /* from jfs_imap.h */
555 
556 #define	EXTSPERIAG	128	/* number of disk inode extent per iag  */
557 #define SMAPSZ		4	/* number of words per summary map      */
558 #define	MAXAG		128	/* maximum number of allocation groups  */
559 
560 /*
561  *	inode allocation map:
562  *
563  * inode allocation map consists of
564  * . the inode map control page and
565  * . inode allocation group pages (per 4096 inodes)
566  * which are addressed by standard JFS xtree.
567  */
568 /*
569  *	inode allocation group page (per 4096 inodes of an AG)
570  */
571 typedef struct {
572 	s64 agstart;		/* 8: starting block of ag              */
573 	s32 iagnum;		/* 4: inode allocation group number     */
574 	s32 inofreefwd;		/* 4: ag inode free list forward        */
575 	s32 inofreeback;	/* 4: ag inode free list back           */
576 	s32 extfreefwd;		/* 4: ag inode extent free list forward */
577 	s32 extfreeback;	/* 4: ag inode extent free list back    */
578 	s32 iagfree;		/* 4: iag free list                     */
579 
580 	/* summary map: 1 bit per inode extent */
581 	s32 inosmap[SMAPSZ];	/* 16: sum map of mapwords w/ free inodes;
582 				 *      note: this indicates free and backed
583 				 *      inodes, if the extent is not backed the
584 				 *      value will be 1.  if the extent is
585 				 *      backed but all inodes are being used the
586 				 *      value will be 1.  if the extent is
587 				 *      backed but at least one of the inodes is
588 				 *      free the value will be 0.
589 				 */
590 	s32 extsmap[SMAPSZ];	/* 16: sum map of mapwords w/ free extents */
591 	s32 nfreeinos;		/* 4: number of free inodes             */
592 	s32 nfreeexts;		/* 4: number of free extents            */
593 	/* (72) */
594 	u8 pad[1976];		/* 1976: pad to 2048 bytes */
595 	/* allocation bit map: 1 bit per inode (0 - free, 1 - allocated) */
596 	u32 wmap[EXTSPERIAG];	/* 512: working allocation map  */
597 	u32 pmap[EXTSPERIAG];	/* 512: persistent allocation map */
598 	pxd_t inoext[EXTSPERIAG];	/* 1024: inode extent addresses */
599 } iag_t;			/* (4096) */
600 
601 #endif /* _JFS_H_ */
602