CFsys*
fsamount(int fd, char *aname)
{
CFid *afid, *fid;
AuthInfo *ai;
CFsys *fs;
fs = fsinit(fd);
if(fs == nil)
return nil;
if((afid = fsauth(fs, getuser(), aname)) == nil)
goto noauth;
ai = fsauth_proxy(afid, amount_getkey, "proto=p9any role=client");
if(ai != nil)
auth_freeAI(ai);
noauth:
fid = fsattach(fs, afid, getuser(), aname);
fsclose(afid);
if(fid == nil){
_fsunmount(fs);
return nil;
}
fssetroot(fs, fid);
return fs;
}
void
mkfs(struct partition *pp, char *fsys)
{
int fragsperinode, optimalfpg, origdensity, minfpg, lastminfpg;
long i, j, csfrags;
uint cg;
time_t utime;
quad_t sizepb;
int width;
ino_t maxinum;
int minfragsperinode; /* minimum ratio of frags to inodes */
char tmpbuf[100]; /* XXX this will break in about 2,500 years */
union {
struct fs fdummy;
char cdummy[SBLOCKSIZE];
} dummy;
#define fsdummy dummy.fdummy
#define chdummy dummy.cdummy
/*
* Our blocks == sector size, and the version of UFS we are using is
* specified by Oflag.
*/
disk.d_bsize = sectorsize;
disk.d_ufs = Oflag;
if (Rflag) {
utime = 1000000000;
} else {
time(&utime);
arc4random_stir();
}
sblock.fs_old_flags = FS_FLAGS_UPDATED;
sblock.fs_flags = 0;
if (Uflag)
sblock.fs_flags |= FS_DOSOFTDEP;
if (Lflag)
strlcpy(sblock.fs_volname, volumelabel, MAXVOLLEN);
if (Jflag)
sblock.fs_flags |= FS_GJOURNAL;
if (lflag)
sblock.fs_flags |= FS_MULTILABEL;
if (tflag)
sblock.fs_flags |= FS_TRIM;
/*
* Validate the given file system size.
* Verify that its last block can actually be accessed.
* Convert to file system fragment sized units.
*/
if (fssize <= 0) {
printf("preposterous size %jd\n", (intmax_t)fssize);
exit(13);
}
wtfs(fssize - (realsectorsize / DEV_BSIZE), realsectorsize,
(char *)&sblock);
/*
* collect and verify the file system density info
*/
sblock.fs_avgfilesize = avgfilesize;
sblock.fs_avgfpdir = avgfilesperdir;
if (sblock.fs_avgfilesize <= 0)
printf("illegal expected average file size %d\n",
sblock.fs_avgfilesize), exit(14);
if (sblock.fs_avgfpdir <= 0)
printf("illegal expected number of files per directory %d\n",
sblock.fs_avgfpdir), exit(15);
restart:
/*
* 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(16);
}
if (!POWEROF2(sblock.fs_fsize)) {
printf("fragment size must be a power of 2, not %d\n",
sblock.fs_fsize);
exit(17);
}
if (sblock.fs_fsize < sectorsize) {
printf("increasing fragment size from %d to sector size (%d)\n",
sblock.fs_fsize, sectorsize);
sblock.fs_fsize = sectorsize;
}
if (sblock.fs_bsize > MAXBSIZE) {
printf("decreasing block size from %d to maximum (%d)\n",
sblock.fs_bsize, MAXBSIZE);
sblock.fs_bsize = MAXBSIZE;
}
if (sblock.fs_bsize < MINBSIZE) {
printf("increasing block size from %d to minimum (%d)\n",
sblock.fs_bsize, MINBSIZE);
sblock.fs_bsize = MINBSIZE;
}
if (sblock.fs_fsize > MAXBSIZE) {
printf("decreasing fragment size from %d to maximum (%d)\n",
sblock.fs_fsize, MAXBSIZE);
sblock.fs_fsize = MAXBSIZE;
}
if (sblock.fs_bsize < sblock.fs_fsize) {
printf("increasing block size from %d to fragment size (%d)\n",
sblock.fs_bsize, sblock.fs_fsize);
sblock.fs_bsize = sblock.fs_fsize;
}
if (sblock.fs_fsize * MAXFRAG < sblock.fs_bsize) {
printf(
"increasing fragment size from %d to block size / %d (%d)\n",
sblock.fs_fsize, MAXFRAG, sblock.fs_bsize / MAXFRAG);
sblock.fs_fsize = sblock.fs_bsize / MAXFRAG;
}
if (maxbsize == 0)
maxbsize = bsize;
if (maxbsize < bsize || !POWEROF2(maxbsize)) {
sblock.fs_maxbsize = sblock.fs_bsize;
printf("Extent size set to %d\n", sblock.fs_maxbsize);
} else if (sblock.fs_maxbsize > FS_MAXCONTIG * sblock.fs_bsize) {
sblock.fs_maxbsize = FS_MAXCONTIG * sblock.fs_bsize;
printf("Extent size reduced to %d\n", sblock.fs_maxbsize);
} else {
sblock.fs_maxbsize = maxbsize;
}
/*
* Maxcontig sets the default for the maximum number of blocks
* that may be allocated sequentially. With file system clustering
* it is possible to allocate contiguous blocks up to the maximum
* transfer size permitted by the controller or buffering.
*/
if (maxcontig == 0)
maxcontig = MAX(1, MAXPHYS / bsize);
sblock.fs_maxcontig = maxcontig;
if (sblock.fs_maxcontig < sblock.fs_maxbsize / sblock.fs_bsize) {
sblock.fs_maxcontig = sblock.fs_maxbsize / sblock.fs_bsize;
printf("Maxcontig raised to %d\n", sblock.fs_maxbsize);
}
if (sblock.fs_maxcontig > 1)
sblock.fs_contigsumsize = MIN(sblock.fs_maxcontig,FS_MAXCONTIG);
sblock.fs_bmask = ~(sblock.fs_bsize - 1);
sblock.fs_fmask = ~(sblock.fs_fsize - 1);
sblock.fs_qbmask = ~sblock.fs_bmask;
sblock.fs_qfmask = ~sblock.fs_fmask;
sblock.fs_bshift = ilog2(sblock.fs_bsize);
sblock.fs_fshift = ilog2(sblock.fs_fsize);
sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);
sblock.fs_fragshift = ilog2(sblock.fs_frag);
if (sblock.fs_frag > MAXFRAG) {
printf("fragment size %d is still too small (can't happen)\n",
sblock.fs_bsize / MAXFRAG);
exit(21);
}
sblock.fs_fsbtodb = ilog2(sblock.fs_fsize / sectorsize);
sblock.fs_size = fssize = dbtofsb(&sblock, fssize);
sblock.fs_providersize = dbtofsb(&sblock, mediasize / sectorsize);
/*
* Before the filesystem is finally initialized, mark it
* as incompletely initialized.
*/
sblock.fs_magic = FS_BAD_MAGIC;
if (Oflag == 1) {
sblock.fs_sblockloc = SBLOCK_UFS1;
sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs1_daddr_t);
sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode);
sblock.fs_maxsymlinklen = ((NDADDR + NIADDR) *
sizeof(ufs1_daddr_t));
sblock.fs_old_inodefmt = FS_44INODEFMT;
sblock.fs_old_cgoffset = 0;
sblock.fs_old_cgmask = 0xffffffff;
sblock.fs_old_size = sblock.fs_size;
sblock.fs_old_rotdelay = 0;
sblock.fs_old_rps = 60;
sblock.fs_old_nspf = sblock.fs_fsize / sectorsize;
sblock.fs_old_cpg = 1;
sblock.fs_old_interleave = 1;
sblock.fs_old_trackskew = 0;
sblock.fs_old_cpc = 0;
sblock.fs_old_postblformat = 1;
sblock.fs_old_nrpos = 1;
} else {
sblock.fs_sblockloc = SBLOCK_UFS2;
sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs2_daddr_t);
sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs2_dinode);
sblock.fs_maxsymlinklen = ((NDADDR + NIADDR) *
sizeof(ufs2_daddr_t));
}
sblock.fs_sblkno =
roundup(howmany(sblock.fs_sblockloc + SBLOCKSIZE, sblock.fs_fsize),
sblock.fs_frag);
sblock.fs_cblkno = sblock.fs_sblkno +
roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag);
sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;
sblock.fs_maxfilesize = sblock.fs_bsize * NDADDR - 1;
for (sizepb = sblock.fs_bsize, i = 0; i < NIADDR; i++) {
sizepb *= NINDIR(&sblock);
sblock.fs_maxfilesize += sizepb;
}
/*
* It's impossible to create a snapshot in case that fs_maxfilesize
* is smaller than the fssize.
*/
if (sblock.fs_maxfilesize < (u_quad_t)fssize) {
warnx("WARNING: You will be unable to create snapshots on this "
"file system. Correct by using a larger blocksize.");
}
/*
* Calculate the number of blocks to put into each cylinder group.
*
* This algorithm selects the number of blocks per cylinder
* group. The first goal is to have at least enough data blocks
* in each cylinder group to meet the density requirement. Once
* this goal is achieved we try to expand to have at least
* MINCYLGRPS cylinder groups. Once this goal is achieved, we
* pack as many blocks into each cylinder group map as will fit.
*
* We start by calculating the smallest number of blocks that we
* can put into each cylinder group. If this is too big, we reduce
* the density until it fits.
*/
maxinum = (((int64_t)(1)) << 32) - INOPB(&sblock);
minfragsperinode = 1 + fssize / maxinum;
if (density == 0) {
density = MAX(NFPI, minfragsperinode) * fsize;
} else if (density < minfragsperinode * fsize) {
origdensity = density;
density = minfragsperinode * fsize;
fprintf(stderr, "density increased from %d to %d\n",
origdensity, density);
}
origdensity = density;
for (;;) {
fragsperinode = MAX(numfrags(&sblock, density), 1);
if (fragsperinode < minfragsperinode) {
bsize <<= 1;
fsize <<= 1;
printf("Block size too small for a file system %s %d\n",
"of this size. Increasing blocksize to", bsize);
goto restart;
}
minfpg = fragsperinode * INOPB(&sblock);
if (minfpg > sblock.fs_size)
minfpg = sblock.fs_size;
sblock.fs_ipg = INOPB(&sblock);
sblock.fs_fpg = roundup(sblock.fs_iblkno +
sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);
if (sblock.fs_fpg < minfpg)
sblock.fs_fpg = minfpg;
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
INOPB(&sblock));
sblock.fs_fpg = roundup(sblock.fs_iblkno +
sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);
if (sblock.fs_fpg < minfpg)
sblock.fs_fpg = minfpg;
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
INOPB(&sblock));
if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize)
break;
density -= sblock.fs_fsize;
}
if (density != origdensity)
printf("density reduced from %d to %d\n", origdensity, density);
/*
* Start packing more blocks into the cylinder group until
* it cannot grow any larger, the number of cylinder groups
* drops below MINCYLGRPS, or we reach the size requested.
* For UFS1 inodes per cylinder group are stored in an int16_t
* so fs_ipg is limited to 2^15 - 1.
*/
for ( ; sblock.fs_fpg < maxblkspercg; sblock.fs_fpg += sblock.fs_frag) {
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
INOPB(&sblock));
if (Oflag > 1 || (Oflag == 1 && sblock.fs_ipg <= 0x7fff)) {
if (sblock.fs_size / sblock.fs_fpg < MINCYLGRPS)
break;
if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize)
continue;
if (CGSIZE(&sblock) == (unsigned long)sblock.fs_bsize)
break;
}
sblock.fs_fpg -= sblock.fs_frag;
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
INOPB(&sblock));
break;
}
/*
* Check to be sure that the last cylinder group has enough blocks
* to be viable. If it is too small, reduce the number of blocks
* per cylinder group which will have the effect of moving more
* blocks into the last cylinder group.
*/
optimalfpg = sblock.fs_fpg;
for (;;) {
sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg);
lastminfpg = roundup(sblock.fs_iblkno +
sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);
if (sblock.fs_size < lastminfpg) {
printf("Filesystem size %jd < minimum size of %d\n",
(intmax_t)sblock.fs_size, lastminfpg);
exit(28);
}
if (sblock.fs_size % sblock.fs_fpg >= lastminfpg ||
sblock.fs_size % sblock.fs_fpg == 0)
break;
sblock.fs_fpg -= sblock.fs_frag;
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
INOPB(&sblock));
}
if (optimalfpg != sblock.fs_fpg)
printf("Reduced frags per cylinder group from %d to %d %s\n",
optimalfpg, sblock.fs_fpg, "to enlarge last cyl group");
sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock));
sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);
if (Oflag == 1) {
sblock.fs_old_spc = sblock.fs_fpg * sblock.fs_old_nspf;
sblock.fs_old_nsect = sblock.fs_old_spc;
sblock.fs_old_npsect = sblock.fs_old_spc;
sblock.fs_old_ncyl = sblock.fs_ncg;
}
/*
* 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));
fscs = (struct csum *)calloc(1, sblock.fs_cssize);
if (fscs == NULL)
errx(31, "calloc failed");
sblock.fs_sbsize = fragroundup(&sblock, sizeof(struct fs));
if (sblock.fs_sbsize > SBLOCKSIZE)
sblock.fs_sbsize = SBLOCKSIZE;
sblock.fs_minfree = minfree;
if (metaspace > 0 && metaspace < sblock.fs_fpg / 2)
sblock.fs_metaspace = blknum(&sblock, metaspace);
else if (metaspace != -1)
/* reserve half of minfree for metadata blocks */
sblock.fs_metaspace = blknum(&sblock,
(sblock.fs_fpg * minfree) / 200);
if (maxbpg == 0)
sblock.fs_maxbpg = MAXBLKPG(sblock.fs_bsize);
else
sblock.fs_maxbpg = maxbpg;
sblock.fs_optim = opt;
sblock.fs_cgrotor = 0;
sblock.fs_pendingblocks = 0;
sblock.fs_pendinginodes = 0;
sblock.fs_fmod = 0;
sblock.fs_ronly = 0;
sblock.fs_state = 0;
sblock.fs_clean = 1;
sblock.fs_id[0] = (long)utime;
sblock.fs_id[1] = newfs_random();
sblock.fs_fsmnt[0] = '\0';
csfrags = howmany(sblock.fs_cssize, sblock.fs_fsize);
sblock.fs_dsize = sblock.fs_size - sblock.fs_sblkno -
sblock.fs_ncg * (sblock.fs_dblkno - sblock.fs_sblkno);
sblock.fs_cstotal.cs_nbfree =
fragstoblks(&sblock, sblock.fs_dsize) -
howmany(csfrags, sblock.fs_frag);
sblock.fs_cstotal.cs_nffree =
fragnum(&sblock, sblock.fs_size) +
(fragnum(&sblock, csfrags) > 0 ?
sblock.fs_frag - fragnum(&sblock, csfrags) : 0);
sblock.fs_cstotal.cs_nifree = sblock.fs_ncg * sblock.fs_ipg - ROOTINO;
sblock.fs_cstotal.cs_ndir = 0;
sblock.fs_dsize -= csfrags;
sblock.fs_time = utime;
if (Oflag == 1) {
sblock.fs_old_time = utime;
sblock.fs_old_dsize = sblock.fs_dsize;
sblock.fs_old_csaddr = sblock.fs_csaddr;
sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;
sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;
sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;
sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;
}
/*
* Dump out summary information about file system.
*/
# define B2MBFACTOR (1 / (1024.0 * 1024.0))
printf("%s: %.1fMB (%jd sectors) block size %d, fragment size %d\n",
fsys, (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,
(intmax_t)fsbtodb(&sblock, sblock.fs_size), sblock.fs_bsize,
sblock.fs_fsize);
printf("\tusing %d cylinder groups of %.2fMB, %d blks, %d inodes.\n",
sblock.fs_ncg, (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);
if (sblock.fs_flags & FS_DOSOFTDEP)
printf("\twith soft updates\n");
# undef B2MBFACTOR
if (Eflag && !Nflag) {
printf("Erasing sectors [%jd...%jd]\n",
sblock.fs_sblockloc / disk.d_bsize,
fsbtodb(&sblock, sblock.fs_size) - 1);
berase(&disk, sblock.fs_sblockloc / disk.d_bsize,
sblock.fs_size * sblock.fs_fsize - sblock.fs_sblockloc);
}
/*
* Wipe out old UFS1 superblock(s) if necessary.
*/
if (!Nflag && Oflag != 1) {
i = bread(&disk, part_ofs + SBLOCK_UFS1 / disk.d_bsize, chdummy, SBLOCKSIZE);
if (i == -1)
err(1, "can't read old UFS1 superblock: %s", disk.d_error);
if (fsdummy.fs_magic == FS_UFS1_MAGIC) {
fsdummy.fs_magic = 0;
bwrite(&disk, part_ofs + SBLOCK_UFS1 / disk.d_bsize,
chdummy, SBLOCKSIZE);
for (cg = 0; cg < fsdummy.fs_ncg; cg++) {
if (fsbtodb(&fsdummy, cgsblock(&fsdummy, cg)) > fssize)
break;
bwrite(&disk, part_ofs + fsbtodb(&fsdummy,
cgsblock(&fsdummy, cg)), chdummy, SBLOCKSIZE);
}
}
}
if (!Nflag)
do_sbwrite(&disk);
if (Xflag == 1) {
printf("** Exiting on Xflag 1\n");
exit(0);
}
if (Xflag == 2)
printf("** Leaving BAD MAGIC on Xflag 2\n");
else
sblock.fs_magic = (Oflag != 1) ? FS_UFS2_MAGIC : FS_UFS1_MAGIC;
/*
* Now build the cylinders group blocks and
* then print out indices of cylinder groups.
*/
printf("super-block backups (for fsck -b #) at:\n");
i = 0;
width = charsperline();
/*
* allocate space for superblock, cylinder group map, and
* two sets of inode blocks.
*/
if (sblock.fs_bsize < SBLOCKSIZE)
iobufsize = SBLOCKSIZE + 3 * sblock.fs_bsize;
else
iobufsize = 4 * sblock.fs_bsize;
if ((iobuf = calloc(1, iobufsize)) == 0) {
printf("Cannot allocate I/O buffer\n");
exit(38);
}
/*
* Make a copy of the superblock into the buffer that we will be
* writing out in each cylinder group.
*/
bcopy((char *)&sblock, iobuf, SBLOCKSIZE);
for (cg = 0; cg < sblock.fs_ncg; cg++) {
initcg(cg, utime);
j = snprintf(tmpbuf, sizeof(tmpbuf), " %jd%s",
(intmax_t)fsbtodb(&sblock, cgsblock(&sblock, cg)),
cg < (sblock.fs_ncg-1) ? "," : "");
if (j < 0)
tmpbuf[j = 0] = '\0';
if (i + j >= width) {
printf("\n");
i = 0;
}
i += j;
printf("%s", tmpbuf);
fflush(stdout);
}
printf("\n");
if (Nflag)
exit(0);
/*
* Now construct the initial file system,
* then write out the super-block.
*/
fsinit(utime);
if (Oflag == 1) {
sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;
sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;
sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;
sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;
}
if (Xflag == 3) {
printf("** Exiting on Xflag 3\n");
exit(0);
}
if (!Nflag) {
do_sbwrite(&disk);
/*
* For UFS1 filesystems with a blocksize of 64K, the first
* alternate superblock resides at the location used for
* the default UFS2 superblock. As there is a valid
* superblock at this location, the boot code will use
* it as its first choice. Thus we have to ensure that
* all of its statistcs on usage are correct.
*/
if (Oflag == 1 && sblock.fs_bsize == 65536)
wtfs(fsbtodb(&sblock, cgsblock(&sblock, 0)),
sblock.fs_bsize, (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);
/*
* Update information about this partition in pack
* label, to that it may be updated on disk.
*/
if (pp != NULL) {
pp->p_fstype = FS_BSDFFS;
pp->p_fsize = sblock.fs_fsize;
pp->p_frag = sblock.fs_frag;
pp->p_cpg = sblock.fs_fpg;
}
}
void
main(int argc, char *argv[])
{
Filsys *fs;
int ream, fsok;
int newbufsize, nocheck;
char buf[NAMELEN];
int pid, ctl;
progname = "kfs";
procname = "init";
/*
* insulate from invoker's environment and keep it from swapping
*/
rfork(RFNAMEG|RFNOTEG|RFREND);
confinit();
sfd = -1;
ream = 0;
newbufsize = 0;
nocheck = 0;
wrenfile = "/dev/sdC0/fs";
pid = getpid();
snprint(buf, sizeof buf, "/proc/%d/ctl", pid);
ctl = open(buf, OWRITE);
fprint(ctl, "noswap\n");
close(ctl);
buf[0] = '\0';
ARGBEGIN{
case 'b':
newbufsize = atol(ARGF());
break;
case 'c':
nocheck = 1;
break;
case 'f':
wrenfile = ARGF();
break;
case 'm':
nwren = atol(ARGF());
break;
case 'n':
strncpy(buf, ARGF(), NAMELEN-1);
buf[NAMELEN-1] = '\0';
break;
case 'p':
cmdmode = atol(ARGF());
break;
case 'r':
ream = 1;
break;
case 's':
sfd = 0;
rfd = dup(1, -1);
close(1);
if(open("/dev/cons", OWRITE) < 0)
open("#c/cons", OWRITE);
break;
case 'B':
conf.niobuf = strtoul(ARGF(), 0, 0);
break;
case 'C':
chat = 1;
break;
default:
usage();
}ARGEND
if(argc != 0)
usage();
cmdfd = 2;
if (access(wrenfile, AREAD|AWRITE) == -1)
sysfatal("%s cannot access device", wrenfile);
formatinit();
sublockinit();
if(buf[0])
sprint(service, "kfs.%s", buf);
else
strcpy(service, "kfs");
chan = chaninit(service);
consinit();
tlocks = ialloc(NTLOCK * sizeof *tlocks);
uid = ialloc(conf.nuid * sizeof(*uid));
uidspace = ialloc(conf.uidspace * sizeof(*uidspace));
gidspace = ialloc(conf.gidspace * sizeof(*gidspace));
/*
* init global locks
*/
wlock(&mainlock); wunlock(&mainlock);
/*
* init the file system, ream it if needed, and get the block sizes
*/
ream = fsinit(ream, newbufsize);
iobufinit();
for(fs=filesys; fs->name; fs++)
if(fs->flags & FREAM){ /* set by fsinit if reamed */
ream++;
rootream(fs->dev, getraddr(fs->dev));
superream(fs->dev, superaddr(fs->dev));
}
boottime = time(nil);
consserve();
fsok = superok(filesys[0].dev, superaddr(filesys[0].dev), 0);
if(!nocheck && !ream && !fsok)
cmd_exec("check fq");
startproc(forkserve, "srv");
startproc(syncproc, "sync");
exits(0);
}
void
mke2fs(const char *fsys, int fi, int fo)
{
struct timeval tv;
int64_t minfssize;
uint bcount, fbcount, ficount;
uint blocks_gd, blocks_per_cg, inodes_per_cg, iblocks_per_cg;
uint minblocks_per_cg, blocks_lastcg;
uint ncg, cylno, sboff;
uuid_t uuid;
uint32_t uustat;
int i, len, col, delta, fld_width, max_cols;
struct winsize winsize;
gettimeofday(&tv, NULL);
fsi = fi;
fso = fo;
/*
* collect and verify the block and fragment sizes
*/
if (!powerof2(bsize)) {
errx(EXIT_FAILURE,
"block size must be a power of 2, not %u\n",
bsize);
}
if (!powerof2(fsize)) {
errx(EXIT_FAILURE,
"fragment size must be a power of 2, not %u\n",
fsize);
}
if (fsize < sectorsize) {
errx(EXIT_FAILURE,
"fragment size %u is too small, minimum is %u\n",
fsize, sectorsize);
}
if (bsize < MINBSIZE) {
errx(EXIT_FAILURE,
"block size %u is too small, minimum is %u\n",
bsize, MINBSIZE);
}
if (bsize > EXT2_MAXBSIZE) {
errx(EXIT_FAILURE,
"block size %u is too large, maximum is %u\n",
bsize, MAXBSIZE);
}
if (bsize != fsize) {
/*
* There is no fragment support on current ext2fs (yet?),
* but some kernel code refers fsize or fpg as bsize or bpg
* and Linux seems to set the same values to them.
*/
errx(EXIT_FAILURE,
"block size (%u) can't be different from "
"fragment size (%u)\n",
bsize, fsize);
}
/* variable inodesize is REV1 feature */
if (Oflag == 0 && inodesize != EXT2_REV0_DINODE_SIZE) {
errx(EXIT_FAILURE, "GOOD_OLD_REV file system format"
" doesn't support %d byte inode\n", inodesize);
}
sblock.e2fs.e2fs_log_bsize = ilog2(bsize) - LOG_MINBSIZE;
/* Umm, why not e2fs_log_fsize? */
sblock.e2fs.e2fs_fsize = ilog2(fsize) - LOG_MINBSIZE;
sblock.e2fs_bsize = bsize;
sblock.e2fs_bshift = sblock.e2fs.e2fs_log_bsize + LOG_MINBSIZE;
sblock.e2fs_qbmask = sblock.e2fs_bsize - 1;
sblock.e2fs_bmask = ~sblock.e2fs_qbmask;
sblock.e2fs_fsbtodb = ilog2(sblock.e2fs_bsize) - ilog2(sectorsize);
sblock.e2fs_ipb = sblock.e2fs_bsize / inodesize;
/*
* Ext2fs preserves BBSIZE (1024 bytes) space at the top for
* bootloader (though it is not enough at all for our bootloader).
* If bsize == BBSIZE we have to preserve one block.
* If bsize > BBSIZE, the first block already contains BBSIZE space
* before superblock because superblock is allocated at SBOFF and
* bsize is a power of two (i.e. 2048 bytes or more).
*/
sblock.e2fs.e2fs_first_dblock = (sblock.e2fs_bsize > BBSIZE) ? 0 : 1;
minfssize = fsbtodb(&sblock,
sblock.e2fs.e2fs_first_dblock +
NBLOCK_SUPERBLOCK +
1 /* at least one group descriptor */ +
NBLOCK_BLOCK_BITMAP +
NBLOCK_INODE_BITMAP +
1 /* at least one inode table block */ +
1 /* at least one data block for rootdir */ +
1 /* at least one data block for data */
); /* XXX and more? */
if (fssize < minfssize)
errx(EXIT_FAILURE, "Filesystem size %" PRId64
" < minimum size of %" PRId64 "\n", fssize, minfssize);
bcount = dbtofsb(&sblock, fssize);
/*
* While many people claim that ext2fs is a (bad) clone of ufs/ffs,
* it isn't actual ffs so maybe we should call it "block group"
* as their native name rather than ffs derived "cylinder group."
* But we'll use the latter here since other kernel sources use it.
* (I also agree "cylinder" based allocation is obsolete though)
*/
/* maybe "simple is the best" */
blocks_per_cg = sblock.e2fs_bsize * NBBY;
ncg = howmany(bcount - sblock.e2fs.e2fs_first_dblock, blocks_per_cg);
blocks_gd = howmany(sizeof(struct ext2_gd) * ncg, bsize);
/* check range of inode number */
if (num_inodes < EXT2_FIRSTINO)
num_inodes = EXT2_FIRSTINO; /* needs reserved inodes + 1 */
if (num_inodes > UINT16_MAX * ncg)
num_inodes = UINT16_MAX * ncg; /* ext2bgd_nifree is uint16_t */
inodes_per_cg = num_inodes / ncg;
iblocks_per_cg = howmany(inodesize * inodes_per_cg, bsize);
/* Check that the last cylinder group has enough space for inodes */
minblocks_per_cg =
NBLOCK_BLOCK_BITMAP +
NBLOCK_INODE_BITMAP +
iblocks_per_cg +
1; /* at least one data block */
if (Oflag == 0 || cg_has_sb(ncg - 1) != 0)
minblocks_per_cg += NBLOCK_SUPERBLOCK + blocks_gd;
blocks_lastcg = bcount - sblock.e2fs.e2fs_first_dblock -
blocks_per_cg * (ncg - 1);
if (blocks_lastcg < minblocks_per_cg) {
/*
* Since we make all the cylinder groups the same size, the
* last will only be small if there are more than one
* cylinder groups. If the last one is too small to store
* filesystem data, just kill it.
*
* XXX: Does fsck_ext2fs(8) properly handle this case?
*/
bcount -= blocks_lastcg;
ncg--;
blocks_lastcg = blocks_per_cg;
blocks_gd = howmany(sizeof(struct ext2_gd) * ncg, bsize);
inodes_per_cg = num_inodes / ncg;
}
/* roundup inodes_per_cg to make it use whole inode table blocks */
inodes_per_cg = roundup(inodes_per_cg, sblock.e2fs_ipb);
num_inodes = inodes_per_cg * ncg;
iblocks_per_cg = inodes_per_cg / sblock.e2fs_ipb;
/* XXX: probably we should check these adjusted values again */
sblock.e2fs.e2fs_bcount = bcount;
sblock.e2fs.e2fs_icount = num_inodes;
sblock.e2fs_ncg = ncg;
sblock.e2fs_ngdb = blocks_gd;
sblock.e2fs_itpg = iblocks_per_cg;
sblock.e2fs.e2fs_rbcount = sblock.e2fs.e2fs_bcount * minfree / 100;
/* e2fs_fbcount will be accounted later */
/* e2fs_ficount will be accounted later */
sblock.e2fs.e2fs_bpg = blocks_per_cg;
sblock.e2fs.e2fs_fpg = blocks_per_cg;
sblock.e2fs.e2fs_ipg = inodes_per_cg;
sblock.e2fs.e2fs_mtime = 0;
sblock.e2fs.e2fs_wtime = tv.tv_sec;
sblock.e2fs.e2fs_mnt_count = 0;
/* XXX: should add some entropy to avoid checking all fs at once? */
sblock.e2fs.e2fs_max_mnt_count = EXT2_DEF_MAX_MNT_COUNT;
sblock.e2fs.e2fs_magic = E2FS_MAGIC;
sblock.e2fs.e2fs_state = E2FS_ISCLEAN;
sblock.e2fs.e2fs_beh = E2FS_BEH_DEFAULT;
sblock.e2fs.e2fs_minrev = 0;
sblock.e2fs.e2fs_lastfsck = tv.tv_sec;
sblock.e2fs.e2fs_fsckintv = EXT2_DEF_FSCKINTV;
/*
* Maybe we can use E2FS_OS_FREEBSD here and it would be more proper,
* but the purpose of this newfs_ext2fs(8) command is to provide
* a filesystem which can be recognized by firmware on some
* Linux based appliances that can load bootstrap files only from
* (their native) ext2fs, and anyway we will (and should) try to
* act like them as much as possible.
*
* Anyway, I hope that all newer such boxes will keep their support
* for the "GOOD_OLD_REV" ext2fs.
*/
sblock.e2fs.e2fs_creator = E2FS_OS_LINUX;
if (Oflag == 0) {
sblock.e2fs.e2fs_rev = E2FS_REV0;
sblock.e2fs.e2fs_features_compat = 0;
sblock.e2fs.e2fs_features_incompat = 0;
sblock.e2fs.e2fs_features_rocompat = 0;
} else {
sblock.e2fs.e2fs_rev = E2FS_REV1;
/*
* e2fsprogs say "REV1" is "dynamic" so
* it isn't quite a version and maybe it means
* "extended from REV0 so check compat features."
*
* XXX: We don't have any native tool to activate
* the EXT2F_COMPAT_RESIZE feature and
* fsck_ext2fs(8) might not fix structures for it.
*/
sblock.e2fs.e2fs_features_compat = EXT2F_COMPAT_RESIZE;
sblock.e2fs.e2fs_features_incompat = EXT2F_INCOMPAT_FTYPE;
sblock.e2fs.e2fs_features_rocompat =
EXT2F_ROCOMPAT_SPARSESUPER | EXT2F_ROCOMPAT_LARGEFILE;
}
sblock.e2fs.e2fs_ruid = geteuid();
sblock.e2fs.e2fs_rgid = getegid();
sblock.e2fs.e2fs_first_ino = EXT2_FIRSTINO;
sblock.e2fs.e2fs_inode_size = inodesize;
/* e2fs_block_group_nr is set on writing superblock to each group */
uuid_create(&uuid, &uustat);
if (uustat != uuid_s_ok)
errx(EXIT_FAILURE, "Failed to generate uuid\n");
uuid_enc_le(sblock.e2fs.e2fs_uuid, &uuid);
if (volname != NULL) {
if (strlen(volname) > sizeof(sblock.e2fs.e2fs_vname))
errx(EXIT_FAILURE, "Volume name is too long");
strlcpy(sblock.e2fs.e2fs_vname, volname,
sizeof(sblock.e2fs.e2fs_vname));
}
sblock.e2fs.e2fs_fsmnt[0] = '\0';
sblock.e2fs_fsmnt[0] = '\0';
sblock.e2fs.e2fs_algo = 0; /* XXX unsupported? */
sblock.e2fs.e2fs_prealloc = 0; /* XXX unsupported? */
sblock.e2fs.e2fs_dir_prealloc = 0; /* XXX unsupported? */
/* calculate blocks for reserved group descriptors for resize */
sblock.e2fs.e2fs_reserved_ngdb = 0;
if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
(sblock.e2fs.e2fs_features_compat & EXT2F_COMPAT_RESIZE) != 0) {
uint64_t target_blocks;
uint target_ncg, target_ngdb, reserved_ngdb;
/* reserve descriptors for size as 1024 times as current */
target_blocks =
(sblock.e2fs.e2fs_bcount - sblock.e2fs.e2fs_first_dblock)
* 1024ULL;
/* number of blocks must be in uint32_t */
if (target_blocks > UINT32_MAX)
target_blocks = UINT32_MAX;
target_ncg = howmany(target_blocks, sblock.e2fs.e2fs_bpg);
target_ngdb = howmany(sizeof(struct ext2_gd) * target_ncg,
sblock.e2fs_bsize);
/*
* Reserved group descriptor blocks are preserved as
* the second level double indirect reference blocks in
* the EXT2_RESIZEINO inode, so the maximum number of
* the blocks is NINDIR(fs).
* (see also descriptions in init_resizeino() function)
*
* We check a number including current e2fs_ngdb here
* because they will be moved into reserved gdb on
* possible future size shrink, though e2fsprogs don't
* seem to care about it.
*/
if (target_ngdb > NINDIR(&sblock))
target_ngdb = NINDIR(&sblock);
reserved_ngdb = target_ngdb - sblock.e2fs_ngdb;
/* make sure reserved_ngdb fits in the last cg */
if (reserved_ngdb >= blocks_lastcg - cgoverhead(ncg - 1))
reserved_ngdb = blocks_lastcg - cgoverhead(ncg - 1);
if (reserved_ngdb == 0) {
/* if no space for reserved gdb, disable the feature */
sblock.e2fs.e2fs_features_compat &=
~EXT2F_COMPAT_RESIZE;
}
sblock.e2fs.e2fs_reserved_ngdb = reserved_ngdb;
}
/*
* Initialize group descriptors
*/
gd = malloc(sblock.e2fs_ngdb * bsize);
if (gd == NULL)
errx(EXIT_FAILURE, "Can't allocate descriptors buffer");
memset(gd, 0, sblock.e2fs_ngdb * bsize);
fbcount = 0;
ficount = 0;
for (cylno = 0; cylno < ncg; cylno++) {
uint boffset;
boffset = cgbase(&sblock, cylno);
if (sblock.e2fs.e2fs_rev == E2FS_REV0 ||
(sblock.e2fs.e2fs_features_rocompat &
EXT2F_ROCOMPAT_SPARSESUPER) == 0 ||
cg_has_sb(cylno)) {
boffset += NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb;
if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
(sblock.e2fs.e2fs_features_compat &
EXT2F_COMPAT_RESIZE) != 0)
boffset += sblock.e2fs.e2fs_reserved_ngdb;
}
gd[cylno].ext2bgd_b_bitmap = boffset;
boffset += NBLOCK_BLOCK_BITMAP;
gd[cylno].ext2bgd_i_bitmap = boffset;
boffset += NBLOCK_INODE_BITMAP;
gd[cylno].ext2bgd_i_tables = boffset;
if (cylno == (ncg - 1))
gd[cylno].ext2bgd_nbfree =
blocks_lastcg - cgoverhead(cylno);
else
gd[cylno].ext2bgd_nbfree =
sblock.e2fs.e2fs_bpg - cgoverhead(cylno);
fbcount += gd[cylno].ext2bgd_nbfree;
gd[cylno].ext2bgd_nifree = sblock.e2fs.e2fs_ipg;
if (cylno == 0) {
/* take reserved inodes off nifree */
gd[cylno].ext2bgd_nifree -= EXT2_RESERVED_INODES;
}
ficount += gd[cylno].ext2bgd_nifree;
gd[cylno].ext2bgd_ndirs = 0;
}
sblock.e2fs.e2fs_fbcount = fbcount;
sblock.e2fs.e2fs_ficount = ficount;
/*
* Dump out summary information about file system.
*/
if (verbosity > 0) {
printf("%s: %u.%1uMB (%" PRId64 " sectors) "
"block size %u, fragment size %u\n",
fsys,
(uint)(((uint64_t)bcount * bsize) / (1024 * 1024)),
(uint)((uint64_t)bcount * bsize -
rounddown((uint64_t)bcount * bsize, 1024 * 1024))
/ 1024 / 100,
fssize, bsize, fsize);
printf("\tusing %u block groups of %u.0MB, %u blks, "
"%u inodes.\n",
ncg, bsize * sblock.e2fs.e2fs_bpg / (1024 * 1024),
sblock.e2fs.e2fs_bpg, sblock.e2fs.e2fs_ipg);
}
/*
* allocate space for superblock and group descriptors
*/
iobufsize = (NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb) * sblock.e2fs_bsize;
iobuf = mmap(0, iobufsize, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_PRIVATE, -1, 0);
if (iobuf == NULL)
errx(EXIT_FAILURE, "Cannot allocate I/O buffer\n");
memset(iobuf, 0, iobufsize);
/*
* We now start writing to the filesystem
*/
if (!Nflag) {
static const uint pbsize[] = { 1024, 2048, 4096, 0 };
uint pblock, epblock;
/*
* Validate the given file system size.
* Verify that its last block can actually be accessed.
* Convert to file system fragment sized units.
*/
if (fssize <= 0)
errx(EXIT_FAILURE, "Preposterous size %" PRId64 "\n",
fssize);
wtfs(fssize - 1, sectorsize, iobuf);
/*
* Ensure there is nothing that looks like a filesystem
* superblock anywhere other than where ours will be.
* If fsck_ext2fs finds the wrong one all hell breaks loose!
*
* XXX: needs to check how fsck_ext2fs programs even
* on other OSes determine alternate superblocks
*/
for (i = 0; pbsize[i] != 0; i++) {
epblock = (uint64_t)bcount * bsize / pbsize[i];
for (pblock = ((pbsize[i] == SBSIZE) ? 1 : 0);
pblock < epblock;
pblock += pbsize[i] * NBBY /* bpg */)
zap_old_sblock((daddr_t)pblock *
pbsize[i] / sectorsize);
}
}
if (verbosity >= 3)
printf("super-block backups (for fsck_ext2fs -b #) at:\n");
/* If we are printing more than one line of numbers, line up columns */
fld_width = verbosity < 4 ? 1 : snprintf(NULL, 0, "%" PRIu64,
(uint64_t)cgbase(&sblock, ncg - 1));
/* Get terminal width */
if (ioctl(fileno(stdout), TIOCGWINSZ, &winsize) == 0)
max_cols = winsize.ws_col;
else
max_cols = 80;
if (Nflag && verbosity == 3)
/* Leave space to add " ..." after one row of numbers */
max_cols -= 4;
#define BASE 0x10000 /* For some fixed-point maths */
col = 0;
delta = verbosity > 2 ? 0 : max_cols * BASE / ncg;
for (cylno = 0; cylno < ncg; cylno++) {
fflush(stdout);
initcg(cylno);
if (verbosity < 2)
continue;
/* the first one is a master, not backup */
if (cylno == 0)
continue;
/* skip if this cylinder doesn't have a backup */
if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
(sblock.e2fs.e2fs_features_rocompat &
EXT2F_ROCOMPAT_SPARSESUPER) != 0 &&
cg_has_sb(cylno) == 0)
continue;
if (delta > 0) {
if (Nflag)
/* No point doing dots for -N */
break;
/* Print dots scaled to end near RH margin */
for (col += delta; col > BASE; col -= BASE)
printf(".");
continue;
}
/* Print superblock numbers */
len = printf(" %*" PRIu64 "," + !col, fld_width,
(uint64_t)cgbase(&sblock, cylno));
col += len;
if (col + len < max_cols)
/* Next number fits */
continue;
/* Next number won't fit, need a newline */
if (verbosity <= 3) {
/* Print dots for subsequent cylinder groups */
delta = sblock.e2fs_ncg - cylno - 1;
if (delta != 0) {
if (Nflag) {
printf(" ...");
break;
}
delta = max_cols * BASE / delta;
}
}
col = 0;
printf("\n");
}
#undef BASE
if (col > 0)
printf("\n");
if (Nflag)
return;
/*
* Now construct the initial file system,
*/
if (fsinit(&tv) == 0)
errx(EXIT_FAILURE, "Error making filesystem");
/*
* Write out the superblock and group descriptors
*/
sblock.e2fs.e2fs_block_group_nr = 0;
sboff = 0;
if (cgbase(&sblock, 0) == 0) {
/*
* If the first block contains the boot block sectors,
* (i.e. in case of sblock.e2fs.e2fs_bsize > BBSIZE)
* we have to preserve data in it.
*/
sboff = SBOFF;
}
e2fs_sbsave(&sblock.e2fs, (struct ext2fs *)(iobuf + sboff));
e2fs_cgsave(gd, (struct ext2_gd *)(iobuf + sblock.e2fs_bsize),
sizeof(struct ext2_gd) * sblock.e2fs_ncg);
wtfs(fsbtodb(&sblock, cgbase(&sblock, 0)) + sboff / sectorsize,
iobufsize - sboff, iobuf + sboff);
munmap(iobuf, iobufsize);
}
