projects / unix-history / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
add trackskew, interleave, npsect, headswitch, and trackseek
[unix-history] / usr / src / sbin / newfs / mkfs.c
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*/
#ifndef lint
static char sccsid[] = "@(#)mkfs.c 6.2 (Berkeley) %G%";
#endif not lint
/*
* make file system for cylinder-group style file systems
*/
#ifndef STANDALONE
#include <stdio.h>
#include <a.out.h>
#endif
#include <sys/param.h>
#include <sys/inode.h>
#include <sys/fs.h>
#include <sys/dir.h>
#include <sys/disklabel.h>
/*
* MAXBLKPG determines the maximum number of data blocks which are
* placed in a single cylinder group. This is currently a function
* of the block and fragment size of the file system.
*/
#define MAXBLKPG(fs) ((fs)->fs_fsize / sizeof(daddr_t))
#define UMASK 0755
#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 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 */
union {
struct fs fs;
char pad[MAXBSIZE];
} fsun;
#define sblock fsun.fs
struct csum *fscs;
union {
struct cg cg;
char pad[MAXBSIZE];
} cgun;
#define acg cgun.cg
struct dinode zino[MAXIPG];
int fsi, fso;
time_t utime;
daddr_t alloc();
mkfs(pp, fsys, fi, fo)
struct partition *pp;
char *fsys;
int fi, fo;
{
long cylno, rpos, blk, i, j, warn = 0;
#ifndef STANDALONE
time(&utime);
#endif
fsi = fi;
fso = fo;
/*
* Validate the given file system size.
* Verify that its last block can actually be accessed.
*/
if (fssize <= 0)
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);
sblock.fs_spc = secpercyl;
/*
* collect and verify the block and fragment sizes
*/
sblock.fs_bsize = bsize;
sblock.fs_fsize = fsize;
if (!POWEROF2(sblock.fs_bsize)) {
printf("block size must be a power of 2, not %d\n",
sblock.fs_bsize);
exit(1);
}
if (!POWEROF2(sblock.fs_fsize)) {
printf("fragment size must be a power of 2, not %d\n",
sblock.fs_fsize);
exit(1);
}
if (sblock.fs_fsize < sectorsize) {
printf("fragment size %d is too small, minimum is %d\n",
sblock.fs_fsize, sectorsize);
exit(1);
}
if (sblock.fs_bsize < MINBSIZE) {
printf("block size %d is too small, minimum is %d\n",
sblock.fs_bsize, MINBSIZE);
exit(1);
}
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);
exit(1);
}
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)
sblock.fs_bshift++;
for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1)
sblock.fs_fshift++;
sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);
for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1)
sblock.fs_fragshift++;
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);
exit(1);
}
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)
sblock.fs_fsbtodb++;
sblock.fs_sblkno =
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)
sblock.fs_cgmask <<= 1;
if (!POWEROF2(sblock.fs_ntrak))
sblock.fs_cgmask <<= 1;
for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc;
sblock.fs_cpc > 1 && (i & 1) == 0;
sblock.fs_cpc >>= 1, i >>= 1)
/* void */;
if (sblock.fs_cpc > MAXCPG) {
printf("maximum block size with nsect %d and ntrak %d is %d\n",
sblock.fs_nsect, sblock.fs_ntrak,
sblock.fs_bsize / (sblock.fs_cpc / MAXCPG));
exit(1);
}
/*
* collect and verify the number of cylinders per group
*/
sblock.fs_cpg = cpg;
if (sblock.fs_cpg % sblock.fs_cpc != 0) {
sblock.fs_cpg -= sblock.fs_cpg % sblock.fs_cpc;
printf("%s groups must have a multiple of %d cylinders\n",
"Warning: cylinder", sblock.fs_cpc);
}
sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
while (sblock.fs_fpg / sblock.fs_frag > MAXBPG(&sblock) &&
sblock.fs_cpg > sblock.fs_cpc) {
sblock.fs_cpg -= sblock.fs_cpc;
sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
}
if (sblock.fs_cpg < 1) {
printf("cylinder groups must have at least 1 cylinder\n");
exit(1);
} else if (sblock.fs_cpg > MAXCPG) {
printf("cylinder groups are limited to %d cylinders\n", MAXCPG);
exit(1);
} else if (sblock.fs_cpg < cpg) {
printf("%s: block size restricts cylinders per group to %d\n",
"Warning", sblock.fs_cpg);
}
/*
* 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) {
sblock.fs_ncyl++;
warn = 1;
}
if (sblock.fs_ncyl < 1) {
printf("file systems must have at least one cylinder\n");
exit(1);
}
/*
* determine feasability/values of rotational layout tables
*/
if (sblock.fs_ntrak == 1) {
sblock.fs_cpc = 0;
goto next;
}
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");
sblock.fs_cpc = 0;
goto next;
}
/*
* calculate the available blocks for each rotational position
*/
sblock.fs_interleave = interleave;
sblock.fs_trackskew = trackskew;
sblock.fs_npsect = nphyssectors;
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)
/* void */;
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;
else
sblock.fs_rotbl[blk] =
sblock.fs_postbl[cylno][rpos] - blk;
sblock.fs_postbl[cylno][rpos] = blk;
}
next:
/*
* Validate specified/determined cpg.
*/
if (sblock.fs_spc > MAXBPG(&sblock) * NSPB(&sblock)) {
printf("too many sectors per cylinder (%d sectors)\n",
sblock.fs_spc);
while(sblock.fs_spc > MAXBPG(&sblock) * NSPB(&sblock)) {
sblock.fs_bsize <<= 1;
if (sblock.fs_frag < MAXFRAG)
sblock.fs_frag <<= 1;
else
sblock.fs_fsize <<= 1;
}
printf("nsect %d, and ntrak %d, requires block size of %d,\n",
sblock.fs_nsect, sblock.fs_ntrak, sblock.fs_bsize);
printf("\tand fragment size of %d\n", sblock.fs_fsize);
exit(1);
}
if (sblock.fs_fpg > MAXBPG(&sblock) * sblock.fs_frag) {
printf("cylinder group too large (%d cylinders); ",
sblock.fs_cpg);
printf("max: %d cylinders per group\n",
MAXBPG(&sblock) * sblock.fs_frag /
(sblock.fs_fpg / sblock.fs_cpg));
exit(1);
}
sblock.fs_cgsize = fragroundup(&sblock,
sizeof(struct cg) + howmany(sblock.fs_fpg, NBBY));
/*
* Compute/validate number of cylinder groups.
*/
sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;
if (sblock.fs_ncyl % sblock.fs_cpg)
sblock.fs_ncg++;
if ((sblock.fs_spc * sblock.fs_cpg) % NSPF(&sblock)) {
printf("mkfs: nsect %d, ntrak %d, cpg %d is not tolerable\n",
sblock.fs_nsect, sblock.fs_ntrak, sblock.fs_cpg);
printf("as this would would have cyl groups whose size\n");
printf("is not a multiple of %d; choke!\n", sblock.fs_fsize);
exit(1);
}
/*
* Compute number of inode blocks per cylinder group.
* Start with one inode per density bytes; adjust as necessary.
*/
i = sblock.fs_iblkno + MAXIPG / INOPF(&sblock);
density = (fssize - sblock.fs_ncg * i) * sblock.fs_fsize / density /
INOPB(&sblock);
if (density <= 0)
density = 1;
sblock.fs_ipg = ((density / sblock.fs_ncg) + 1) * INOPB(&sblock);
if (sblock.fs_ipg > MAXIPG)
sblock.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 must be increased\n");
exit(1);
}
j = sblock.fs_ncg - 1;
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,
i / sblock.fs_frag);
printf(" cylinder group. This implies %d sector(s) cannot be allocated.\n",
i * NSPF(&sblock));
sblock.fs_ncg--;
sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;
sblock.fs_size = fssize = sblock.fs_ncyl * sblock.fs_spc /
NSPF(&sblock);
warn = 0;
}
if (warn) {
printf("Warning: %d sector(s) in last cylinder unallocated\n",
sblock.fs_spc -
(fssize * NSPF(&sblock) - (sblock.fs_ncyl - 1)
* sblock.fs_spc));
}
/*
* fill in remaining fields of the super block
*/
sblock.fs_csaddr = cgdmin(&sblock, 0);
sblock.fs_cssize =
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)
sblock.fs_csshift++;
i = sizeof(struct fs) +
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 = MAXBLKPG(&sblock);
sblock.fs_rps = rpm / 60;
sblock.fs_optim = opt;
sblock.fs_cgrotor = 0;
sblock.fs_cstotal.cs_ndir = 0;
sblock.fs_cstotal.cs_nbfree = 0;
sblock.fs_cstotal.cs_nifree = 0;
sblock.fs_cstotal.cs_nffree = 0;
sblock.fs_fmod = 0;
sblock.fs_ronly = 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,
sblock.fs_ipg);
/*
* 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++) {
initcg(cylno);
if (cylno % 10 == 0)
printf("\n");
printf(" %d,", fsbtodb(&sblock, cgsblock(&sblock, cylno)));
}
printf("\n");
if (Nflag)
exit(0);
/*
* Now construct the initial file system,
* then write out the super-block.
*/
fsinit();
sblock.fs_time = utime;
wtfs(SBLOCK, 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,
((char *)fscs) + i);
/*
* 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.
*/
initcg(cylno)
int cylno;
{
daddr_t cbase, d, dlower, dupper, dmax;
long i, j, s;
register struct csum *cs;
/*
* Determine block bounds for cylinder group.
* Allow space for super block summary information in first
* cylinder group.
*/
cbase = cgbase(&sblock, cylno);
dmax = cbase + sblock.fs_fpg;
if (dmax > sblock.fs_size)
dmax = sblock.fs_size;
dlower = cgsblock(&sblock, cylno) - cbase;
dupper = cgdmin(&sblock, cylno) - cbase;
cs = fscs + cylno;
acg.cg_time = utime;
acg.cg_magic = CG_MAGIC;
acg.cg_cgx = cylno;
if (cylno == sblock.fs_ncg - 1)
acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
else
acg.cg_ncyl = sblock.fs_cpg;
acg.cg_niblk = sblock.fs_ipg;
acg.cg_ndblk = dmax - cbase;
acg.cg_cs.cs_ndir = 0;
acg.cg_cs.cs_nffree = 0;
acg.cg_cs.cs_nbfree = 0;
acg.cg_cs.cs_nifree = 0;
acg.cg_rotor = 0;
acg.cg_frotor = 0;
acg.cg_irotor = 0;
for (i = 0; i < sblock.fs_frag; i++) {
acg.cg_frsum[i] = 0;
}
for (i = 0; i < sblock.fs_ipg; ) {
for (j = INOPB(&sblock); j > 0; j--) {
clrbit(acg.cg_iused, i);
i++;
}
acg.cg_cs.cs_nifree += INOPB(&sblock);
}
if (cylno == 0)
for (i = 0; i < ROOTINO; i++) {
setbit(acg.cg_iused, i);
acg.cg_cs.cs_nifree--;
}
while (i < MAXIPG) {
clrbit(acg.cg_iused, i);
i++;
}
wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno)),
sblock.fs_ipg * sizeof (struct dinode), (char *)zino);
for (i = 0; i < MAXCPG; i++) {
acg.cg_btot[i] = 0;
for (j = 0; j < NRPOS; j++)
acg.cg_b[i][j] = 0;
}
if (cylno == 0) {
/*
* 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);
} else {
for (d = 0; d < dlower; d += sblock.fs_frag) {
setblock(&sblock, acg.cg_free, d/sblock.fs_frag);
acg.cg_cs.cs_nbfree++;
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);
if (d > dupper) {
acg.cg_frsum[d - dupper]++;
for (i = d - 1; i >= dupper; i--) {
setbit(acg.cg_free, i);
acg.cg_cs.cs_nffree++;
}
}
while ((d + sblock.fs_frag) <= dmax - cbase) {
setblock(&sblock, acg.cg_free, d/sblock.fs_frag);
acg.cg_cs.cs_nbfree++;
acg.cg_btot[cbtocylno(&sblock, d)]++;
acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]++;
d += sblock.fs_frag;
}
if (d < dmax - cbase) {
acg.cg_frsum[dmax - cbase - d]++;
for (; d < dmax - cbase; d++) {
setbit(acg.cg_free, d);
acg.cg_cs.cs_nffree++;
}
for (; d % sblock.fs_frag != 0; d++)
clrbit(acg.cg_free, 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;
*cs = acg.cg_cs;
wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
sblock.fs_bsize, (char *)&acg);
}
/*
* initialize the file system
*/
struct inode node;
#ifdef LOSTDIR
#define PREDEFDIR 3
#else
#define PREDEFDIR 2
#endif
struct direct root_dir[] = {
{ ROOTINO, sizeof(struct direct), 1, "." },
{ ROOTINO, sizeof(struct direct), 2, ".." },
#ifdef LOSTDIR
{ LOSTFOUNDINO, sizeof(struct direct), 10, "lost+found" },
#endif
};
#ifdef LOSTDIR
struct direct lost_found_dir[] = {
{ LOSTFOUNDINO, sizeof(struct direct), 1, "." },
{ ROOTINO, sizeof(struct direct), 2, ".." },
{ 0, DIRBLKSIZ, 0, 0 },
};
#endif
char buf[MAXBSIZE];
fsinit()
{
int i;
/*
* initialize the node
*/
node.i_atime = utime;
node.i_mtime = utime;
node.i_ctime = utime;
#ifdef LOSTDIR
/*
* 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_nlink = 2;
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);
iput(&node);
#endif
/*
* create the root directory
*/
node.i_number = ROOTINO;
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);
iput(&node);
}
/*
* construct a set of directory entries in "buf".
* return size of directory.
*/
makedir(protodir, entries)
register struct direct *protodir;
int entries;
{
char *cp;
int i, spcleft;
spcleft = DIRBLKSIZ;
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]));
return (DIRBLKSIZ);
}
/*
* allocate a block or frag
*/
daddr_t
alloc(size, mode)
int size;
int mode;
{
int i, frag;
daddr_t d;
rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
(char *)&acg);
if (acg.cg_magic != CG_MAGIC) {
printf("cg 0: bad magic number\n");
return (0);
}
if (acg.cg_cs.cs_nbfree == 0) {
printf("first cylinder group ran out of space\n");
return (0);
}
for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag)
if (isblock(&sblock, acg.cg_free, d / sblock.fs_frag))
goto goth;
printf("internal error: can't find block in cyl 0\n");
return (0);
goth:
clrblock(&sblock, acg.cg_free, d / sblock.fs_frag);
acg.cg_cs.cs_nbfree--;
sblock.fs_cstotal.cs_nbfree--;
fscs[0].cs_nbfree--;
if (mode & IFDIR) {
acg.cg_cs.cs_ndir++;
sblock.fs_cstotal.cs_ndir++;
fscs[0].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,
(char *)&acg);
return (d);
}
/*
* Allocate an inode on the disk
*/
iput(ip)
register struct inode *ip;
{
struct dinode buf[MAXINOPB];
daddr_t d;
int c;
c = itog(&sblock, ip->i_number);
rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
(char *)&acg);
if (acg.cg_magic != CG_MAGIC) {
printf("cg 0: bad magic number\n");
exit(1);
}
acg.cg_cs.cs_nifree--;
setbit(acg.cg_iused, ip->i_number);
wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
(char *)&acg);
sblock.fs_cstotal.cs_nifree--;
fscs[0].cs_nifree--;
if(ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {
printf("fsinit: inode value out of range (%d).\n",
ip->i_number);
exit(1);
}
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
*/
rdfs(bno, size, bf)
daddr_t bno;
int size;
char *bf;
{
int n;
if (lseek(fsi, bno * sectorsize, 0) < 0) {
printf("seek error: %ld\n", bno);
perror("rdfs");
exit(1);
}
n = read(fsi, bf, size);
if(n != size) {
printf("read error: %ld\n", bno);
perror("rdfs");
exit(1);
}
}
/*
* write a block to the file system
*/
wtfs(bno, size, bf)
daddr_t bno;
int size;
char *bf;
{
int n;
if (Nflag)
return;
if (lseek(fso, bno * sectorsize, 0) < 0) {
printf("seek error: %ld\n", bno);
perror("wtfs");
exit(1);
}
n = write(fso, bf, size);
if(n != size) {
printf("write error: %D\n", bno);
perror("wtfs");
exit(1);
}
}
/*
* check if a block is available
*/
isblock(fs, cp, h)
struct fs *fs;
unsigned char *cp;
int h;
{
unsigned char mask;
switch (fs->fs_frag) {
case 8:
return (cp[h] == 0xff);
case 4:
mask = 0x0f << ((h & 0x1) << 2);
return ((cp[h >> 1] & mask) == mask);
case 2:
mask = 0x03 << ((h & 0x3) << 1);
return ((cp[h >> 2] & mask) == mask);
case 1:
mask = 0x01 << (h & 0x7);
return ((cp[h >> 3] & mask) == mask);
default:
#ifdef STANDALONE
printf("isblock bad fs_frag %d\n", fs->fs_frag);
#else
fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
#endif
return;
}
}
/*
* take a block out of the map
*/
clrblock(fs, cp, h)
struct fs *fs;
unsigned char *cp;
int h;
{
switch ((fs)->fs_frag) {
case 8:
cp[h] = 0;
return;
case 4:
cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
return;
case 2:
cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
return;
case 1:
cp[h >> 3] &= ~(0x01 << (h & 0x7));
return;
default:
#ifdef STANDALONE
printf("clrblock bad fs_frag %d\n", fs->fs_frag);
#else
fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag);
#endif
return;
}
}
/*
* put a block into the map
*/
setblock(fs, cp, h)
struct fs *fs;
unsigned char *cp;
int h;
{
switch (fs->fs_frag) {
case 8:
cp[h] = 0xff;
return;
case 4:
cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
return;
case 2:
cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
return;
case 1:
cp[h >> 3] |= (0x01 << (h & 0x7));
return;
default:
#ifdef STANDALONE
printf("setblock bad fs_frag %d\n", fs->fs_frag);
#else
fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);
#endif
return;
}
}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.