![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fs.5 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / man / man5|
Return to fs.5 CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / man / man5 |
1.1 root 1: .TH FS 5 "18 July 1983"
2: .UC 4
3: .SH NAME
4: fs, inode \- format of file system volume
5: .SH SYNOPSIS
6: .B #include <sys/types.h>
7: .br
8: .B #include <sys/fs.h>
9: .br
10: .B #include <sys/inode.h>
11: .SH DESCRIPTION
12: Every file system storage volume (disk, nine-track tape, for instance)
13: has a common format for certain vital information.
14: Every such volume is divided into a certain number of blocks.
15: The block size is a parameter of the file system.
16: Sectors 0 to 15 on a file system are used to contain primary
17: and secondary bootstrapping programs.
18: .PP
19: The actual file system begins at sector 16 with the
20: .I "super block."
21: The layout of the super block as defined by the include file
22: .RI < sys/fs.h >
23: is:
24: .PP
25: .nf
26: #define FS_MAGIC 0x011954
27: struct fs {
28: struct fs *fs_link; /* linked list of file systems */
29: struct fs *fs_rlink; /* used for incore super blocks */
30: daddr_t fs_sblkno; /* addr of super-block in filesys */
31: daddr_t fs_cblkno; /* offset of cyl-block in filesys */
32: daddr_t fs_iblkno; /* offset of inode-blocks in filesys */
33: daddr_t fs_dblkno; /* offset of first data after cg */
34: long fs_cgoffset; /* cylinder group offset in cylinder */
35: long fs_cgmask; /* used to calc mod fs_ntrak */
36: time_t fs_time; /* last time written */
37: long fs_size; /* number of blocks in fs */
38: long fs_dsize; /* number of data blocks in fs */
39: long fs_ncg; /* number of cylinder groups */
40: long fs_bsize; /* size of basic blocks in fs */
41: long fs_fsize; /* size of frag blocks in fs */
42: long fs_frag; /* number of frags in a block in fs */
43: /* these are configuration parameters */
44: long fs_minfree; /* minimum percentage of free blocks */
45: long fs_rotdelay; /* num of ms for optimal next block */
46: long fs_rps; /* disk revolutions per second */
47: /* these fields can be computed from the others */
48: long fs_bmask; /* ``blkoff'' calc of blk offsets */
49: long fs_fmask; /* ``fragoff'' calc of frag offsets */
50: long fs_bshift; /* ``lblkno'' calc of logical blkno */
51: long fs_fshift; /* ``numfrags'' calc number of frags */
52: /* these are configuration parameters */
53: long fs_maxcontig; /* max number of contiguous blks */
54: long fs_maxbpg; /* max number of blks per cyl group */
55: /* these fields can be computed from the others */
56: long fs_fragshift; /* block to frag shift */
57: long fs_fsbtodb; /* fsbtodb and dbtofsb shift constant */
58: long fs_sbsize; /* actual size of super block */
59: long fs_csmask; /* csum block offset */
60: long fs_csshift; /* csum block number */
61: long fs_nindir; /* value of NINDIR */
62: long fs_inopb; /* value of INOPB */
63: long fs_nspf; /* value of NSPF */
64: long fs_sparecon[6]; /* reserved for future constants */
65: /* sizes determined by number of cylinder groups and their sizes */
66: daddr_t fs_csaddr; /* blk addr of cyl grp summary area */
67: long fs_cssize; /* size of cyl grp summary area */
68: long fs_cgsize; /* cylinder group size */
69: /* these fields should be derived from the hardware */
70: long fs_ntrak; /* tracks per cylinder */
71: long fs_nsect; /* sectors per track */
72: long fs_spc; /* sectors per cylinder */
73: /* this comes from the disk driver partitioning */
74: long fs_ncyl; /* cylinders in file system */
75: /* these fields can be computed from the others */
76: long fs_cpg; /* cylinders per group */
77: long fs_ipg; /* inodes per group */
78: long fs_fpg; /* blocks per group * fs_frag */
79: /* this data must be re-computed after crashes */
80: struct csum fs_cstotal; /* cylinder summary information */
81: /* these fields are cleared at mount time */
82: char fs_fmod; /* super block modified flag */
83: char fs_clean; /* file system is clean flag */
84: char fs_ronly; /* mounted read-only flag */
85: char fs_flags; /* currently unused flag */
86: char fs_fsmnt[MAXMNTLEN]; /* name mounted on */
87: /* these fields retain the current block allocation info */
88: long fs_cgrotor; /* last cg searched */
89: struct csum *fs_csp[MAXCSBUFS];/* list of fs_cs info buffers */
90: long fs_cpc; /* cyl per cycle in postbl */
91: short fs_postbl[MAXCPG][NRPOS];/* head of blocks for each rotation */
92: long fs_magic; /* magic number */
93: u_char fs_rotbl[1]; /* list of blocks for each rotation */
94: /* actually longer */
95: };
96: .fi
97: .LP
98: Each disk drive contains some number of file systems.
99: A file system consists of a number of cylinder groups.
100: Each cylinder group has inodes and data.
101: .LP
102: A file system is described by its super-block, which in turn
103: describes the cylinder groups. The super-block is critical
104: data and is replicated in each cylinder group to protect against
105: catastrophic loss. This is done at file system creation
106: time and the critical
107: super-block data does not change, so the copies need not be
108: referenced further unless disaster strikes.
109: .LP
110: Addresses stored in inodes are capable of addressing fragments
111: of `blocks'. File system blocks of at most size MAXBSIZE can
112: be optionally broken into 2, 4, or 8 pieces, each of which is
113: addressable; these pieces may be DEV_BSIZE, or some multiple of
114: a DEV_BSIZE unit.
115: .LP
116: Large files consist of exclusively large data blocks. To avoid
117: undue wasted disk space, the last data block of a small file is
118: allocated as only as many fragments of a large block as are
119: necessary. The file system format retains only a single pointer
120: to such a fragment, which is a piece of a single large block that
121: has been divided. The size of such a fragment is determinable from
122: information in the inode, using the ``blksize(fs, ip, lbn)'' macro.
123: .LP
124: The file system records space availability at the fragment level;
125: to determine block availability, aligned fragments are examined.
126: .LP
127: The root inode is the root of the file system.
128: Inode 0 can't be used for normal purposes and
129: historically bad blocks were linked to inode 1,
130: thus the root inode is 2 (inode 1 is no longer used for
131: this purpose, however numerous dump tapes make this
132: assumption, so we are stuck with it).
133: The
134: .I lost+found
135: directory is given the next available
136: inode when it is initially created by
137: .IR mkfs .
138: .LP
139: .I fs_minfree
140: gives the minimum acceptable percentage of file system
141: blocks which may be free. If the freelist drops below this level
142: only the super-user may continue to allocate blocks. This may
143: be set to 0 if no reserve of free blocks is deemed necessary,
144: however severe performance degradations will be observed if the
145: file system is run at greater than 90% full; thus the default
146: value of
147: .I fs_minfree
148: is 10%.
149: .LP
150: Empirically the best trade-off between block fragmentation and
151: overall disk utilization at a loading of 90% comes with a
152: fragmentation of 4, thus the default fragment size is a fourth
153: of the block size.
154: .LP
155: .I Cylinder group related
156: .IR limits :
157: Each cylinder keeps track of the availability of blocks at different
158: rotational positions, so that sequential blocks can be laid out
159: with minimum rotational latency. NRPOS is the number of rotational
160: positions which are distinguished. With NRPOS 8 the resolution of the
161: summary information is 2ms for a typical 3600 rpm drive.
162: .LP
163: .I fs_rotdelay
164: gives the minimum number of milliseconds to initiate
165: another disk transfer on the same cylinder. It is used in
166: determining the rotationally optimal layout for disk blocks
167: within a file; the default value for
168: .I fs_rotdelay
169: is 2ms.
170: .LP
171: Each file system has a statically allocated number of inodes.
172: An inode is allocated for each NBPI bytes of disk space.
173: The inode allocation strategy is extremely conservative.
174: .LP
175: MAXIPG bounds the number of inodes per cylinder group, and
176: is needed only to keep the structure simpler by having the
177: only a single variable size element (the free bit map).
178: .LP
179: .B N.B.:
180: MAXIPG must be a multiple of INOPB(fs).
181: .LP
182: MINBSIZE is the smallest allowable block size.
183: With a MINBSIZE of 4096
184: it is possible to create files of size
185: 2^32 with only two levels of indirection.
186: MINBSIZE must be big enough to hold a cylinder group block,
187: thus changes to (struct cg) must keep its size within MINBSIZE.
188: MAXCPG is limited only to dimension an array in (struct cg);
189: it can be made larger as long as that structure's size remains
190: within the bounds dictated by MINBSIZE.
191: Note that super blocks are never more than size SBSIZE.
192: .LP
193: The path name on which the file system is mounted is maintained
194: in
195: .IR fs_fsmnt .
196: MAXMNTLEN defines the amount of space allocated in
197: the super block for this name.
198: The limit on the amount of summary information per file system
199: is defined by MAXCSBUFS. It is currently parameterized for a
200: maximum of two million cylinders.
201: .LP
202: Per cylinder group information is summarized in blocks allocated
203: from the first cylinder group's data blocks.
204: These blocks are read in from
205: .I fs_csaddr
206: (size
207: .IR fs_cssize )
208: in addition to the super block.
209: .LP
210: .B N.B.:
211: sizeof (struct csum) must be a power of two in order for
212: the ``fs_cs'' macro to work.
213: .LP
214: .I Super block for a file
215: .IR system :
216: MAXBPC bounds the size of the rotational layout tables and
217: is limited by the fact that the super block is of size SBSIZE.
218: The size of these tables is
219: .B inversely
220: proportional to the block
221: size of the file system. The size of the tables is
222: increased when sector sizes are not powers of two,
223: as this increases the number of cylinders
224: included before the rotational pattern repeats (
225: .IR fs_cpc ).
226: The size of the rotational layout
227: tables is derived from the number of bytes remaining in (struct fs).
228: .LP
229: MAXBPG bounds the number of blocks of data per cylinder group,
230: and is limited by the fact that cylinder groups are at most one block.
231: The size of the free block table
232: is derived from the size of blocks and the number
233: of remaining bytes in the cylinder group structure (struct cg).
234: .LP
235: .IR Inode :
236: The inode is the focus of all file activity in the
237: UNIX file system. There is a unique inode allocated
238: for each active file,
239: each current directory, each mounted-on file,
240: text file, and the root.
241: An inode is `named' by its device/i-number pair.
242: For further information, see the include file
243: .RI < sys/inode.h >.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.