* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
static char sccsid
[] = "@(#)mkfs.c 6.6 (Berkeley) %G%";
* make file system for cylinder-group style file systems
#include <sys/disklabel.h>
#define MAXINOPB (MAXBSIZE / sizeof(struct dinode))
#define POWEROF2(num) (((num) & ((num) - 1)) == 0)
* variables set up by front end.
extern int Nflag
; /* run mkfs without writing file system */
extern int fssize
; /* file system size */
extern int ntracks
; /* # tracks/cylinder */
extern int nsectors
; /* # sectors/track */
extern int nphyssectors
; /* # sectors/track including spares */
extern int secpercyl
; /* sectors per cylinder */
extern int sectorsize
; /* bytes/sector */
extern int rpm
; /* revolutions/minute of drive */
extern int interleave
; /* hardware sector interleave */
extern int trackskew
; /* sector 0 skew, per track */
extern int headswitch
; /* head switch time, usec */
extern int trackseek
; /* track-to-track seek, usec */
extern int fsize
; /* fragment size */
extern int bsize
; /* block size */
extern int cpg
; /* cylinders/cylinder group */
extern int cpgflg
; /* cylinders/cylinder group flag was given */
extern int minfree
; /* free space threshold */
extern int opt
; /* optimization preference (space or time) */
extern int density
; /* number of bytes per inode */
extern int maxcontig
; /* max contiguous blocks to allocate */
extern int rotdelay
; /* rotational delay between blocks */
extern int maxbpg
; /* maximum blocks per file in a cyl group */
extern int bbsize
; /* boot block size */
extern int sbsize
; /* superblock size */
struct dinode zino
[MAXIPG
];
register long i
, mincpc
, mincpg
, inospercg
;
long cylno
, rpos
, blk
, j
, warn
= 0;
long used
, mincpgcnt
, bpcg
;
long mapcramped
, inodecramped
;
* Validate the given file system size.
* Verify that its last block can actually be accessed.
printf("preposterous size %d\n", fssize
), exit(1);
wtfs(fssize
- 1, sectorsize
, (char *)&sblock
);
* collect and verify the sector and track info
sblock
.fs_nsect
= nsectors
;
sblock
.fs_ntrak
= ntracks
;
if (sblock
.fs_ntrak
<= 0)
printf("preposterous ntrak %d\n", sblock
.fs_ntrak
), exit(1);
if (sblock
.fs_nsect
<= 0)
printf("preposterous nsect %d\n", sblock
.fs_nsect
), exit(1);
* collect and verify the block and fragment sizes
if (!POWEROF2(sblock
.fs_bsize
)) {
printf("block size must be a power of 2, not %d\n",
if (!POWEROF2(sblock
.fs_fsize
)) {
printf("fragment size must be a power of 2, not %d\n",
if (sblock
.fs_fsize
< sectorsize
) {
printf("fragment size %d is too small, minimum is %d\n",
sblock
.fs_fsize
, sectorsize
);
if (sblock
.fs_bsize
< MINBSIZE
) {
printf("block size %d is too small, minimum is %d\n",
sblock
.fs_bsize
, MINBSIZE
);
if (sblock
.fs_bsize
< sblock
.fs_fsize
) {
printf("block size (%d) cannot be smaller than fragment size (%d)\n",
sblock
.fs_bsize
, sblock
.fs_fsize
);
sblock
.fs_bmask
= ~(sblock
.fs_bsize
- 1);
sblock
.fs_fmask
= ~(sblock
.fs_fsize
- 1);
for (sblock
.fs_bshift
= 0, i
= sblock
.fs_bsize
; i
> 1; i
>>= 1)
for (sblock
.fs_fshift
= 0, i
= sblock
.fs_fsize
; i
> 1; i
>>= 1)
sblock
.fs_frag
= numfrags(&sblock
, sblock
.fs_bsize
);
for (sblock
.fs_fragshift
= 0, i
= sblock
.fs_frag
; i
> 1; i
>>= 1)
if (sblock
.fs_frag
> MAXFRAG
) {
printf("fragment size %d is too small, minimum with block size %d is %d\n",
sblock
.fs_fsize
, sblock
.fs_bsize
,
sblock
.fs_bsize
/ MAXFRAG
);
sblock
.fs_nindir
= sblock
.fs_bsize
/ sizeof(daddr_t
);
sblock
.fs_inopb
= sblock
.fs_bsize
/ sizeof(struct dinode
);
sblock
.fs_nspf
= sblock
.fs_fsize
/ sectorsize
;
for (sblock
.fs_fsbtodb
= 0, i
= NSPF(&sblock
); i
> 1; i
>>= 1)
roundup(howmany(bbsize
+ sbsize
, sblock
.fs_fsize
), sblock
.fs_frag
);
sblock
.fs_cblkno
= (daddr_t
)(sblock
.fs_sblkno
+
roundup(howmany(sbsize
, sblock
.fs_fsize
), sblock
.fs_frag
));
sblock
.fs_iblkno
= sblock
.fs_cblkno
+ sblock
.fs_frag
;
sblock
.fs_cgoffset
= roundup(
howmany(sblock
.fs_nsect
, NSPF(&sblock
)), sblock
.fs_frag
);
for (sblock
.fs_cgmask
= 0xffffffff, i
= sblock
.fs_ntrak
; i
> 1; i
>>= 1)
if (!POWEROF2(sblock
.fs_ntrak
))
* Validate specified/determined secpercyl
* and calculate minimum cylinders per group.
sblock
.fs_spc
= secpercyl
;
for (sblock
.fs_cpc
= NSPB(&sblock
), i
= sblock
.fs_spc
;
sblock
.fs_cpc
> 1 && (i
& 1) == 0;
sblock
.fs_cpc
>>= 1, i
>>= 1)
printf("Maximum frag size with %d sectors per cylinder is %d\n",
sblock
.fs_spc
, sblock
.fs_fsize
/ (mincpc
/ MAXCPG
));
bpcg
= sblock
.fs_spc
* sectorsize
;
inospercg
= roundup(bpcg
/ sizeof(struct dinode
), INOPB(&sblock
));
used
= (sblock
.fs_iblkno
+ inospercg
/ INOPF(&sblock
)) * NSPF(&sblock
);
mincpgcnt
= howmany(sblock
.fs_cgoffset
* (~sblock
.fs_cgmask
) + used
,
mincpg
= roundup(mincpgcnt
, mincpc
);
* Insure that cylinder group with mincpg has enough space
while (mincpg
* sblock
.fs_spc
> MAXBPG(&sblock
) * NSPB(&sblock
)) {
if (sblock
.fs_bsize
< MAXBSIZE
) {
mincpg
= roundup(mincpgcnt
, mincpc
);
sblock
.fs_fragshift
+= 1;
if (sblock
.fs_frag
<= MAXFRAG
)
if (sblock
.fs_fsize
== sblock
.fs_bsize
) {
printf("There is no block size that");
printf(" can support this disk\n");
sblock
.fs_fragshift
-= 1;
* Insure that cylinder group with mincpg has enough space for inodes
inospercg
= (mincpg
* bpcg
- used
) / density
;
while (inospercg
> MAXIPG
) {
if (mincpc
== 1 || sblock
.fs_frag
== 1 ||
sblock
.fs_bsize
== MINBSIZE
)
printf("With a block size of %d %s %d\n", sblock
.fs_bsize
,
"minimum bytes per inode is",
(mincpg
* bpcg
- used
) / MAXIPG
+ 1);
sblock
.fs_fragshift
-= 1;
i
= roundup(mincpgcnt
, mincpc
);
if (i
* sblock
.fs_spc
> MAXBPG(&sblock
) * NSPB(&sblock
)) {
inospercg
= (mincpg
* bpcg
- used
) / density
;
if (inospercg
> MAXIPG
) {
printf("Minimum bytes per inode is %d\n",
(mincpg
* bpcg
- used
) / MAXIPG
+ 1);
} else if (!mapcramped
) {
printf("With %d bytes per inode, ", density
);
printf("minimum cylinders per group is %d\n", mincpg
);
printf("With %d sectors per cylinder, ", sblock
.fs_spc
);
printf("minimum cylinders per group is %d\n", mincpg
);
if (inodecramped
|| mapcramped
) {
if (sblock
.fs_bsize
!= bsize
)
printf("%s to be changed from %d to %d\n",
"This requires the block size",
if (sblock
.fs_fsize
!= fsize
)
printf("\t%s to be changed from %d to %d\n",
* Calculate the number of cylinders per group
if (sblock
.fs_cpg
% mincpc
!= 0) {
printf("%s groups must have a multiple of %d cylinders\n",
cpgflg
? "Cylinder" : "Warning: cylinder", mincpc
);
sblock
.fs_cpg
= roundup(sblock
.fs_cpg
, mincpc
);
* Must insure there is enough space to hold block map
sblock
.fs_fpg
= (sblock
.fs_cpg
* sblock
.fs_spc
) / NSPF(&sblock
);
while (sblock
.fs_fpg
> MAXBPG(&sblock
) * sblock
.fs_frag
) {
sblock
.fs_fpg
= (sblock
.fs_cpg
* sblock
.fs_spc
) / NSPF(&sblock
);
* Must insure there is enough space for inodes
inospercg
= (sblock
.fs_cpg
* bpcg
- used
) / density
;
while (inospercg
> MAXIPG
) {
sblock
.fs_fpg
= (sblock
.fs_cpg
* sblock
.fs_spc
) / NSPF(&sblock
);
inospercg
= (sblock
.fs_cpg
* bpcg
- used
) / density
;
if ((sblock
.fs_cpg
* sblock
.fs_spc
) % NSPB(&sblock
) != 0) {
printf("newfs: panic (fs_cpg * fs_spc) % NSPF != 0");
if (sblock
.fs_cpg
< mincpg
) {
printf("cylinder groups must have at least %d cylinders\n",
} else if (sblock
.fs_cpg
> MAXCPG
) {
printf("cylinder groups are limited to %d cylinders\n", MAXCPG
);
} else if (sblock
.fs_cpg
!= cpg
) {
if (mapcramped
&& inodecramped
)
printf("Block size and bytes per inode restrict");
printf("Block size restricts");
printf("Bytes per inode restrict");
printf(" cylinders per group to %d.\n", sblock
.fs_cpg
);
sblock
.fs_cgsize
= fragroundup(&sblock
,
sizeof(struct cg
) + howmany(sblock
.fs_fpg
, NBBY
));
* Now have size for file system and nsect and ntrak.
* Determine number of cylinders and blocks in the file system.
sblock
.fs_size
= fssize
= dbtofsb(&sblock
, fssize
);
sblock
.fs_ncyl
= fssize
* NSPF(&sblock
) / sblock
.fs_spc
;
if (fssize
* NSPF(&sblock
) > sblock
.fs_ncyl
* sblock
.fs_spc
) {
if (sblock
.fs_ncyl
< 1) {
printf("file systems must have at least one cylinder\n");
* determine feasability/values of rotational layout tables
sblock
.fs_interleave
= interleave
;
sblock
.fs_trackskew
= trackskew
;
sblock
.fs_npsect
= nphyssectors
;
if (sblock
.fs_ntrak
== 1) {
if (sblock
.fs_spc
* sblock
.fs_cpc
> MAXBPC
* NSPB(&sblock
) ||
sblock
.fs_nsect
> (1 << NBBY
) * NSPB(&sblock
)) {
printf("%s %s %d %s %d.%s",
"Warning: insufficient space in super block for\n",
"rotational layout tables with nsect", sblock
.fs_nsect
,
"and ntrak", sblock
.fs_ntrak
,
"\nFile system performance may be impared.\n");
* calculate the available blocks for each rotational position
for (cylno
= 0; cylno
< MAXCPG
; cylno
++)
for (rpos
= 0; rpos
< NRPOS
; rpos
++)
sblock
.fs_postbl
[cylno
][rpos
] = -1;
blk
= sblock
.fs_spc
* sblock
.fs_cpc
/ NSPF(&sblock
);
for (i
= 0; i
< blk
; i
+= sblock
.fs_frag
)
for (i
-= sblock
.fs_frag
; i
>= 0; i
-= sblock
.fs_frag
) {
cylno
= cbtocylno(&sblock
, i
);
rpos
= cbtorpos(&sblock
, i
);
blk
= i
/ sblock
.fs_frag
;
if (sblock
.fs_postbl
[cylno
][rpos
] == -1)
sblock
.fs_rotbl
[blk
] = 0;
sblock
.fs_postbl
[cylno
][rpos
] - blk
;
sblock
.fs_postbl
[cylno
][rpos
] = blk
;
* Compute/validate number of cylinder groups.
sblock
.fs_ncg
= sblock
.fs_ncyl
/ sblock
.fs_cpg
;
if (sblock
.fs_ncyl
% sblock
.fs_cpg
)
* Compute number of inode blocks per cylinder group.
sblock
.fs_ipg
= roundup(inospercg
, INOPB(&sblock
));
if (sblock
.fs_ipg
> MAXIPG
) {
printf("newfs: panic fs_ipg > MAXIPG");
sblock
.fs_dblkno
= sblock
.fs_iblkno
+ sblock
.fs_ipg
/ INOPF(&sblock
);
i
= MIN(~sblock
.fs_cgmask
, sblock
.fs_ncg
- 1);
if (cgdmin(&sblock
, i
) - cgbase(&sblock
, i
) >= sblock
.fs_fpg
) {
printf("inode blocks/cyl group (%d) >= data blocks (%d)\n",
cgdmin(&sblock
, i
) - cgbase(&sblock
, i
) / sblock
.fs_frag
,
sblock
.fs_fpg
/ sblock
.fs_frag
);
printf("number of cylinders per cylinder group (%d) %s.\n",
sblock
.fs_ncg
, "must be increased");
if ((i
= fssize
- j
* sblock
.fs_fpg
) < sblock
.fs_fpg
&&
cgdmin(&sblock
, j
) - cgbase(&sblock
, j
) > i
) {
printf("Warning: inode blocks/cyl group (%d) >= data blocks (%d) in last\n",
(cgdmin(&sblock
, j
) - cgbase(&sblock
, j
)) / sblock
.fs_frag
,
printf(" cylinder group. This implies %d sector(s) cannot be allocated.\n",
sblock
.fs_ncyl
-= sblock
.fs_ncyl
% sblock
.fs_cpg
;
sblock
.fs_size
= fssize
= sblock
.fs_ncyl
* sblock
.fs_spc
/
printf("Warning: %d sector(s) in last cylinder unallocated\n",
(fssize
* NSPF(&sblock
) - (sblock
.fs_ncyl
- 1)
* fill in remaining fields of the super block
sblock
.fs_csaddr
= cgdmin(&sblock
, 0);
fragroundup(&sblock
, sblock
.fs_ncg
* sizeof(struct csum
));
i
= sblock
.fs_bsize
/ sizeof(struct csum
);
sblock
.fs_csmask
= ~(i
- 1);
for (sblock
.fs_csshift
= 0; i
> 1; i
>>= 1)
howmany(sblock
.fs_spc
* sblock
.fs_cpc
, NSPB(&sblock
));
sblock
.fs_sbsize
= fragroundup(&sblock
, i
);
fscs
= (struct csum
*)calloc(1, sblock
.fs_cssize
);
sblock
.fs_magic
= FS_MAGIC
;
sblock
.fs_rotdelay
= rotdelay
;
sblock
.fs_minfree
= minfree
;
sblock
.fs_maxcontig
= maxcontig
;
sblock
.fs_headswitch
= headswitch
;
sblock
.fs_trkseek
= trackseek
;
sblock
.fs_maxbpg
= maxbpg
;
sblock
.fs_rps
= rpm
/ 60;
sblock
.fs_cstotal
.cs_ndir
= 0;
sblock
.fs_cstotal
.cs_nbfree
= 0;
sblock
.fs_cstotal
.cs_nifree
= 0;
sblock
.fs_cstotal
.cs_nffree
= 0;
* Dump out summary information about file system.
printf("%s:\t%d sectors in %d cylinders of %d tracks, %d sectors\n",
fsys
, sblock
.fs_size
* NSPF(&sblock
), sblock
.fs_ncyl
,
sblock
.fs_ntrak
, sblock
.fs_nsect
);
printf("\t%.1fMb in %d cyl groups (%d c/g, %.2fMb/g, %d i/g)\n",
(float)sblock
.fs_size
* sblock
.fs_fsize
* 1e-6, sblock
.fs_ncg
,
sblock
.fs_cpg
, (float)sblock
.fs_fpg
* sblock
.fs_fsize
* 1e-6,
* Now build the cylinders group blocks and
* then print out indices of cylinder groups.
printf("super-block backups (for fsck -b#) at:");
for (cylno
= 0; cylno
< sblock
.fs_ncg
; cylno
++) {
printf(" %d,", fsbtodb(&sblock
, cgsblock(&sblock
, cylno
)));
* Now construct the initial file system,
* then write out the super-block.
wtfs(SBOFF
/ sectorsize
, sbsize
, (char *)&sblock
);
for (i
= 0; i
< sblock
.fs_cssize
; i
+= sblock
.fs_bsize
)
wtfs(fsbtodb(&sblock
, sblock
.fs_csaddr
+ numfrags(&sblock
, i
)),
sblock
.fs_cssize
- i
< sblock
.fs_bsize
?
sblock
.fs_cssize
- i
: sblock
.fs_bsize
,
* Write out the duplicate super blocks
for (cylno
= 0; cylno
< sblock
.fs_ncg
; cylno
++)
wtfs(fsbtodb(&sblock
, cgsblock(&sblock
, cylno
)),
sbsize
, (char *)&sblock
);
* Update information about this partion in pack
* label, to that it may be updated on disk.
pp
->p_fstype
= FS_BSDFFS
;
pp
->p_fsize
= sblock
.fs_fsize
;
pp
->p_frag
= sblock
.fs_frag
;
pp
->p_cpg
= sblock
.fs_cpg
;
* Initialize a cylinder group.
daddr_t cbase
, d
, dlower
, dupper
, dmax
;
register struct csum
*cs
;
* Determine block bounds for cylinder group.
* Allow space for super block summary information in first
cbase
= cgbase(&sblock
, cylno
);
dmax
= cbase
+ sblock
.fs_fpg
;
if (dmax
> sblock
.fs_size
)
dlower
= cgsblock(&sblock
, cylno
) - cbase
;
dupper
= cgdmin(&sblock
, cylno
) - cbase
;
if (cylno
== sblock
.fs_ncg
- 1)
acg
.cg_ncyl
= sblock
.fs_ncyl
% sblock
.fs_cpg
;
acg
.cg_ncyl
= sblock
.fs_cpg
;
acg
.cg_niblk
= sblock
.fs_ipg
;
acg
.cg_ndblk
= dmax
- cbase
;
for (i
= 0; i
< sblock
.fs_frag
; i
++) {
for (i
= 0; i
< sblock
.fs_ipg
; ) {
for (j
= INOPB(&sblock
); j
> 0; j
--) {
acg
.cg_cs
.cs_nifree
+= INOPB(&sblock
);
for (i
= 0; i
< ROOTINO
; i
++) {
wtfs(fsbtodb(&sblock
, cgimin(&sblock
, cylno
)),
sblock
.fs_ipg
* sizeof (struct dinode
), (char *)zino
);
for (i
= 0; i
< MAXCPG
; i
++) {
for (j
= 0; j
< NRPOS
; j
++)
* reserve space for summary info and Boot block
dupper
+= howmany(sblock
.fs_cssize
, sblock
.fs_fsize
);
for (d
= 0; d
< dlower
; d
+= sblock
.fs_frag
)
clrblock(&sblock
, acg
.cg_free
, d
/sblock
.fs_frag
);
for (d
= 0; d
< dlower
; d
+= sblock
.fs_frag
) {
setblock(&sblock
, acg
.cg_free
, d
/sblock
.fs_frag
);
acg
.cg_btot
[cbtocylno(&sblock
, d
)]++;
acg
.cg_b
[cbtocylno(&sblock
, d
)][cbtorpos(&sblock
, d
)]++;
sblock
.fs_dsize
+= dlower
;
sblock
.fs_dsize
+= acg
.cg_ndblk
- dupper
;
for (; d
< dupper
; d
+= sblock
.fs_frag
)
clrblock(&sblock
, acg
.cg_free
, d
/sblock
.fs_frag
);
acg
.cg_frsum
[d
- dupper
]++;
for (i
= d
- 1; i
>= dupper
; i
--) {
while ((d
+ sblock
.fs_frag
) <= dmax
- cbase
) {
setblock(&sblock
, acg
.cg_free
, d
/sblock
.fs_frag
);
acg
.cg_btot
[cbtocylno(&sblock
, d
)]++;
acg
.cg_b
[cbtocylno(&sblock
, d
)][cbtorpos(&sblock
, d
)]++;
acg
.cg_frsum
[dmax
- cbase
- d
]++;
for (; d
< dmax
- cbase
; d
++) {
for (; d
% sblock
.fs_frag
!= 0; d
++)
for (d
/= sblock
.fs_frag
; d
< MAXBPG(&sblock
); d
++)
clrblock(&sblock
, acg
.cg_free
, d
);
sblock
.fs_cstotal
.cs_ndir
+= acg
.cg_cs
.cs_ndir
;
sblock
.fs_cstotal
.cs_nffree
+= acg
.cg_cs
.cs_nffree
;
sblock
.fs_cstotal
.cs_nbfree
+= acg
.cg_cs
.cs_nbfree
;
sblock
.fs_cstotal
.cs_nifree
+= acg
.cg_cs
.cs_nifree
;
wtfs(fsbtodb(&sblock
, cgtod(&sblock
, cylno
)),
sblock
.fs_bsize
, (char *)&acg
);
* initialize the file system
struct direct root_dir
[] = {
{ ROOTINO
, sizeof(struct direct
), 1, "." },
{ ROOTINO
, sizeof(struct direct
), 2, ".." },
{ LOSTFOUNDINO
, sizeof(struct direct
), 10, "lost+found" },
struct direct lost_found_dir
[] = {
{ LOSTFOUNDINO
, sizeof(struct direct
), 1, "." },
{ ROOTINO
, sizeof(struct direct
), 2, ".." },
* create the lost+found directory
(void)makedir(lost_found_dir
, 2);
for (i
= DIRBLKSIZ
; i
< sblock
.fs_bsize
; i
+= DIRBLKSIZ
)
bcopy(&lost_found_dir
[2], &buf
[i
], DIRSIZ(&lost_found_dir
[2]));
node
.i_number
= LOSTFOUNDINO
;
node
.i_mode
= IFDIR
| UMASK
;
node
.i_size
= sblock
.fs_bsize
;
node
.i_db
[0] = alloc(node
.i_size
, node
.i_mode
);
node
.i_blocks
= btodb(fragroundup(&sblock
, node
.i_size
));
wtfs(fsbtodb(&sblock
, node
.i_db
[0]), node
.i_size
, buf
);
* create the root directory
node
.i_mode
= IFDIR
| UMASK
;
node
.i_nlink
= PREDEFDIR
;
node
.i_size
= makedir(root_dir
, PREDEFDIR
);
node
.i_db
[0] = alloc(sblock
.fs_fsize
, node
.i_mode
);
node
.i_blocks
= btodb(fragroundup(&sblock
, node
.i_size
));
wtfs(fsbtodb(&sblock
, node
.i_db
[0]), sblock
.fs_fsize
, buf
);
* construct a set of directory entries in "buf".
* return size of directory.
makedir(protodir
, entries
)
register struct direct
*protodir
;
for (cp
= buf
, i
= 0; i
< entries
- 1; i
++) {
protodir
[i
].d_reclen
= DIRSIZ(&protodir
[i
]);
bcopy(&protodir
[i
], cp
, protodir
[i
].d_reclen
);
cp
+= protodir
[i
].d_reclen
;
spcleft
-= protodir
[i
].d_reclen
;
protodir
[i
].d_reclen
= spcleft
;
bcopy(&protodir
[i
], cp
, DIRSIZ(&protodir
[i
]));
* allocate a block or frag
rdfs(fsbtodb(&sblock
, cgtod(&sblock
, 0)), sblock
.fs_cgsize
,
if (acg
.cg_magic
!= CG_MAGIC
) {
printf("cg 0: bad magic number\n");
if (acg
.cg_cs
.cs_nbfree
== 0) {
printf("first cylinder group ran out of space\n");
for (d
= 0; d
< acg
.cg_ndblk
; d
+= sblock
.fs_frag
)
if (isblock(&sblock
, acg
.cg_free
, d
/ sblock
.fs_frag
))
printf("internal error: can't find block in cyl 0\n");
clrblock(&sblock
, acg
.cg_free
, d
/ sblock
.fs_frag
);
sblock
.fs_cstotal
.cs_nbfree
--;
sblock
.fs_cstotal
.cs_ndir
++;
acg
.cg_btot
[cbtocylno(&sblock
, d
)]--;
acg
.cg_b
[cbtocylno(&sblock
, d
)][cbtorpos(&sblock
, d
)]--;
if (size
!= sblock
.fs_bsize
) {
frag
= howmany(size
, sblock
.fs_fsize
);
fscs
[0].cs_nffree
+= sblock
.fs_frag
- frag
;
sblock
.fs_cstotal
.cs_nffree
+= sblock
.fs_frag
- frag
;
acg
.cg_cs
.cs_nffree
+= sblock
.fs_frag
- frag
;
acg
.cg_frsum
[sblock
.fs_frag
- frag
]++;
for (i
= frag
; i
< sblock
.fs_frag
; i
++)
setbit(acg
.cg_free
, d
+ i
);
wtfs(fsbtodb(&sblock
, cgtod(&sblock
, 0)), sblock
.fs_cgsize
,
* Allocate an inode on the disk
register struct inode
*ip
;
struct dinode buf
[MAXINOPB
];
c
= itog(&sblock
, ip
->i_number
);
rdfs(fsbtodb(&sblock
, cgtod(&sblock
, 0)), sblock
.fs_cgsize
,
if (acg
.cg_magic
!= CG_MAGIC
) {
printf("cg 0: bad magic number\n");
setbit(acg
.cg_iused
, ip
->i_number
);
wtfs(fsbtodb(&sblock
, cgtod(&sblock
, 0)), sblock
.fs_cgsize
,
sblock
.fs_cstotal
.cs_nifree
--;
if(ip
->i_number
>= sblock
.fs_ipg
* sblock
.fs_ncg
) {
printf("fsinit: inode value out of range (%d).\n",
d
= fsbtodb(&sblock
, itod(&sblock
, ip
->i_number
));
rdfs(d
, sblock
.fs_bsize
, buf
);
buf
[itoo(&sblock
, ip
->i_number
)].di_ic
= ip
->i_ic
;
wtfs(d
, sblock
.fs_bsize
, buf
);
* read a block from the file system
if (lseek(fsi
, bno
* sectorsize
, 0) < 0) {
printf("seek error: %ld\n", bno
);
printf("read error: %ld\n", bno
);
* write a block to the file system
if (lseek(fso
, bno
* sectorsize
, 0) < 0) {
printf("seek error: %ld\n", bno
);
n
= write(fso
, bf
, size
);
printf("write error: %D\n", bno
);
* check if a block is available
mask
= 0x0f << ((h
& 0x1) << 2);
return ((cp
[h
>> 1] & mask
) == mask
);
mask
= 0x03 << ((h
& 0x3) << 1);
return ((cp
[h
>> 2] & mask
) == mask
);
mask
= 0x01 << (h
& 0x7);
return ((cp
[h
>> 3] & mask
) == mask
);
printf("isblock bad fs_frag %d\n", fs
->fs_frag
);
fprintf(stderr
, "isblock bad fs_frag %d\n", fs
->fs_frag
);
* take a block out of the map
cp
[h
>> 1] &= ~(0x0f << ((h
& 0x1) << 2));
cp
[h
>> 2] &= ~(0x03 << ((h
& 0x3) << 1));
cp
[h
>> 3] &= ~(0x01 << (h
& 0x7));
printf("clrblock bad fs_frag %d\n", fs
->fs_frag
);
fprintf(stderr
, "clrblock bad fs_frag %d\n", fs
->fs_frag
);
* put a block into the map
cp
[h
>> 1] |= (0x0f << ((h
& 0x1) << 2));
cp
[h
>> 2] |= (0x03 << ((h
& 0x3) << 1));
cp
[h
>> 3] |= (0x01 << (h
& 0x7));
printf("setblock bad fs_frag %d\n", fs
->fs_frag
);
fprintf(stderr
, "setblock bad fs_frag %d\n", fs
->fs_frag
);