sbin/dump/cache.c

57

if ((BlockSize = sblock->fs_bsize * BLKFACTOR) > MAXBSIZE)

sbin/dump/cache.c

93

if (cachesize <= 0 || sblock->fs_bsize == 0)

sbin/dump/dump.h

84

extern struct fs *sblock; /* the file system super block */

sbin/dump/main.c

446

if ((ret = sbget(diskfd, &sblock, UFS_STDSB, UFS_NOCSUM)) != 0) {

sbin/dump/main.c

456

dev_bsize = sblock->fs_fsize / fsbtodb(sblock, 1);

sbin/dump/main.c

463

maxino = sblock->fs_ipg * sblock->fs_ncg;

sbin/dump/main.c

93

struct fs *sblock; /* the file system super block */

sbin/dump/tape.c

178

dblkno = fsbtodb(sblock, blkno);

sbin/dump/traverse.c

112

if (DIP(dp, di_size) > sblock->fs_bsize * UFS_NDADDR) {

sbin/dump/traverse.c

115

UFS_NDADDR * sblock->fs_bsize / TP_BSIZE, TP_NINDIR);

sbin/dump/traverse.c

150

if ((cgp = malloc(sblock->fs_cgsize)) == NULL)

sbin/dump/traverse.c

152

for (cg = 0; cg < sblock->fs_ncg; cg++) {

sbin/dump/traverse.c

153

ino = cg * sblock->fs_ipg;

sbin/dump/traverse.c

154

blkread(fsbtodb(sblock, cgtod(sblock, cg)), (char *)cgp,

sbin/dump/traverse.c

155

sblock->fs_cgsize);

sbin/dump/traverse.c

156

if (sblock->fs_magic == FS_UFS2_MAGIC)

sbin/dump/traverse.c

159

inosused = sblock->fs_ipg;

sbin/dump/traverse.c

167

if (sblock->fs_flags & FS_DOSOFTDEP) {

sbin/dump/traverse.c

272

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

280

(long)sblksize(sblock, DIP(&di, di_size),

sbin/dump/traverse.c

285

filesize -= sblock->fs_bsize;

sbin/dump/traverse.c

334

blkread(fsbtodb(sblock, blkno), (char *)&idblk, (int)sblock->fs_bsize);

sbin/dump/traverse.c

336

for (i = 0; *filesize > 0 && i < NINDIR(sblock); i++) {

sbin/dump/traverse.c

337

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

342

ret |= searchdir(ino, blkno, sblock->fs_bsize,

sbin/dump/traverse.c

347

*filesize -= sblock->fs_bsize;

sbin/dump/traverse.c

352

for (i = 0; *filesize > 0 && i < NINDIR(sblock); i++) {

sbin/dump/traverse.c

353

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

385

if (dblk == NULL && (dblk = malloc(sblock->fs_bsize)) == NULL)

sbin/dump/traverse.c

387

blkread(fsbtodb(sblock, blkno), dblk, (int)size);

sbin/dump/traverse.c

467

if (sblock->fs_magic == FS_UFS1_MAGIC) {

sbin/dump/traverse.c

511

DIP(dp, di_size) < sblock->fs_maxsymlinklen) {

sbin/dump/traverse.c

545

if (DIP(dp, di_size) > UFS_NDADDR * sblock->fs_bsize) {

sbin/dump/traverse.c

546

cnt = UFS_NDADDR * sblock->fs_frag;

sbin/dump/traverse.c

549

cnt = howmany(DIP(dp, di_size), sblock->fs_fsize);

sbin/dump/traverse.c

55

((sblock->fs_magic == FS_UFS1_MAGIC) ? \

sbin/dump/traverse.c

552

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

556

if ((size = DIP(dp, di_size) - UFS_NDADDR * sblock->fs_bsize) <= 0)

sbin/dump/traverse.c

579

blkread(fsbtodb(sblock, blk), (char *)&idblk,

sbin/dump/traverse.c

58

if (sblock->fs_magic == FS_UFS1_MAGIC) \

sbin/dump/traverse.c

580

(int)sblock->fs_bsize);

sbin/dump/traverse.c

582

memset(&idblk, 0, sblock->fs_bsize);

sbin/dump/traverse.c

584

if (*size > NINDIR(sblock) * sblock->fs_bsize) {

sbin/dump/traverse.c

585

cnt = NINDIR(sblock) * sblock->fs_frag;

sbin/dump/traverse.c

588

cnt = howmany(*size, sblock->fs_fsize);

sbin/dump/traverse.c

591

*size -= NINDIR(sblock) * sblock->fs_bsize;

sbin/dump/traverse.c

592

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

599

for (i = 0; i < NINDIR(sblock); i++) {

sbin/dump/traverse.c

600

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

618

blks = howmany(frags * sblock->fs_fsize, TP_BSIZE);

sbin/dump/traverse.c

619

tbperdb = sblock->fs_bsize >> tp_bshift;

sbin/dump/traverse.c

637

dumpblock(*bp, (int)sblock->fs_bsize);

sbin/dump/traverse.c

661

blks = howmany(frags * sblock->fs_fsize, TP_BSIZE);

sbin/dump/traverse.c

664

resid = howmany(fragoff(sblock, spcl.c_extsize),

sbin/dump/traverse.c

667

resid = howmany(fragoff(sblock, dp->dp2.di_size),

sbin/dump/traverse.c

670

blks -= howmany(sblock->fs_fsize, TP_BSIZE) - resid;

sbin/dump/traverse.c

672

tbperdb = sblock->fs_bsize >> tp_bshift;

sbin/dump/traverse.c

692

dumpblock(*bp, (int)sblock->fs_bsize);

sbin/dump/traverse.c

731

if (spcl.c_extsize > UFS_NXADDR * sblock->fs_bsize)

sbin/dump/traverse.c

732

blks = howmany(UFS_NXADDR * sblock->fs_bsize, TP_BSIZE);

sbin/dump/traverse.c

742

tbperdb = sblock->fs_bsize >> tp_bshift;

sbin/dump/traverse.c

776

if (spcl.c_extsize > UFS_NXADDR * sblock->fs_bsize) {

sbin/dump/traverse.c

777

frags = UFS_NXADDR * sblock->fs_frag;

sbin/dump/traverse.c

780

frags = howmany(spcl.c_extsize, sblock->fs_fsize);

sbin/dump/traverse.c

785

if (spcl.c_extsize > UFS_NXADDR * sblock->fs_bsize)

sbin/dump/traverse.c

786

blks = howmany(UFS_NXADDR * sblock->fs_bsize, TP_BSIZE);

sbin/dump/traverse.c

789

tbperdb = sblock->fs_bsize >> tp_bshift;

sbin/dump/traverse.c

794

dumpblock(*bp, (int)sblock->fs_bsize);

sbin/dump/traverse.c

812

if ((size = spcl.c_extsize - UFS_NXADDR * sblock->fs_bsize) > 0)

sbin/dump/traverse.c

869

if (inoblock == NULL && (inoblock = malloc(sblock->fs_bsize)) == NULL)

sbin/dump/traverse.c

874

blkread(fsbtodb(sblock, ino_to_fsba(sblock, inum)), inoblock,

sbin/dump/traverse.c

875

(int)sblock->fs_bsize);

sbin/dump/traverse.c

876

minino = inum - (inum % INOPB(sblock));

sbin/dump/traverse.c

877

maxino = minino + INOPB(sblock);

sbin/dump/traverse.c

879

if (sblock->fs_magic == FS_UFS1_MAGIC) {

sbin/dump/traverse.c

907

secsize = sblock->fs_fsize;

sbin/dump/traverse.c

950

if (blkno + (size / dev_bsize) > fsbtodb(sblock, sblock->fs_size)) {

sbin/ffsinfo/ffsinfo.c

212

DBG_DUMP_FS(&sblock, "primary sblock");

sbin/ffsinfo/ffsinfo.c

217

cg_stop = sblock.fs_ncg;

sbin/ffsinfo/ffsinfo.c

219

cg_start = sblock.fs_ncg - 1;

sbin/ffsinfo/ffsinfo.c

220

cg_stop = sblock.fs_ncg;

sbin/ffsinfo/ffsinfo.c

221

} else if (cfg_cg < sblock.fs_ncg) {

sbin/ffsinfo/ffsinfo.c

225

cg_start = sblock.fs_ncg;

sbin/ffsinfo/ffsinfo.c

226

cg_stop = sblock.fs_ncg;

sbin/ffsinfo/ffsinfo.c

231

(size_t)sblock.fs_cssize);

sbin/ffsinfo/ffsinfo.c

236

for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {

sbin/ffsinfo/ffsinfo.c

237

if (bread(&disk, fsbtodb(&sblock,

sbin/ffsinfo/ffsinfo.c

238

sblock.fs_csaddr + numfrags(&sblock, i)),

sbin/ffsinfo/ffsinfo.c

240

(size_t)(sblock.fs_cssize-i < sblock.fs_bsize ?

sbin/ffsinfo/ffsinfo.c

241

sblock.fs_cssize - i : sblock.fs_bsize)) == -1)

sbin/ffsinfo/ffsinfo.c

247

for (dbg_csc = 0; dbg_csc < sblock.fs_ncg; dbg_csc++) {

sbin/ffsinfo/ffsinfo.c

250

DBG_DUMP_CSUM(&sblock,

sbin/ffsinfo/ffsinfo.c

262

if (bread(&disk, fsbtodb(&sblock,

sbin/ffsinfo/ffsinfo.c

263

cgsblock(&sblock, cylno)),

sbin/ffsinfo/ffsinfo.c

273

if (bread(&disk, fsbtodb(&sblock,

sbin/ffsinfo/ffsinfo.c

274

cgtod(&sblock, cylno)), (void *)&acg,

sbin/ffsinfo/ffsinfo.c

275

(size_t)sblock.fs_cgsize) == -1)

sbin/ffsinfo/ffsinfo.c

279

DBG_DUMP_CG(&sblock, dbg_line, &acg);

sbin/ffsinfo/ffsinfo.c

281

DBG_DUMP_INMAP(&sblock, dbg_line, &acg);

sbin/ffsinfo/ffsinfo.c

283

DBG_DUMP_FRMAP(&sblock, dbg_line, &acg);

sbin/ffsinfo/ffsinfo.c

285

DBG_DUMP_CLMAP(&sblock, dbg_line, &acg);

sbin/ffsinfo/ffsinfo.c

286

DBG_DUMP_CLSUM(&sblock, dbg_line, &acg);

sbin/ffsinfo/ffsinfo.c

295

DBG_DUMP_SPTBL(&sblock, dbg_line, &acg);

sbin/ffsinfo/ffsinfo.c

305

for (in = cg_start * sblock.fs_ipg;

sbin/ffsinfo/ffsinfo.c

306

in < (ino_t)cg_stop * sblock.fs_ipg;

sbin/ffsinfo/ffsinfo.c

351

DBG_DUMP_INO(&sblock,

sbin/ffsinfo/ffsinfo.c

364

rb = howmany(dp.dp1->di_size, sblock.fs_bsize) - UFS_NDADDR;

sbin/ffsinfo/ffsinfo.c

369

if (bread(&disk, fsbtodb(&sblock, dp.dp1->di_ib[0]),

sbin/ffsinfo/ffsinfo.c

370

(void *)&i1blk, (size_t)sblock.fs_bsize) == -1) {

sbin/ffsinfo/ffsinfo.c

375

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

379

rb -= howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t));

sbin/ffsinfo/ffsinfo.c

385

if (bread(&disk, fsbtodb(&sblock, dp.dp1->di_ib[1]),

sbin/ffsinfo/ffsinfo.c

386

(void *)&i2blk, (size_t)sblock.fs_bsize) == -1) {

sbin/ffsinfo/ffsinfo.c

391

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

394

howmany(rb, howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t))));

sbin/ffsinfo/ffsinfo.c

395

for (ind2ctr = 0; ((ind2ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

399

if (bread(&disk, fsbtodb(&sblock, *ind2ptr),

sbin/ffsinfo/ffsinfo.c

400

(void *)&i1blk, (size_t)sblock.fs_bsize) == -1) {

sbin/ffsinfo/ffsinfo.c

406

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

410

rb -= howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t));

sbin/ffsinfo/ffsinfo.c

417

if (bread(&disk, fsbtodb(&sblock, dp.dp1->di_ib[2]),

sbin/ffsinfo/ffsinfo.c

418

(void *)&i3blk, (size_t)sblock.fs_bsize) == -1) {

sbin/ffsinfo/ffsinfo.c

424

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

428

SQUARE(howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t)))));

sbin/ffsinfo/ffsinfo.c

430

for (ind3ctr = 0; ((ind3ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

434

if (bread(&disk, fsbtodb(&sblock, *ind3ptr),

sbin/ffsinfo/ffsinfo.c

435

(void *)&i2blk, (size_t)sblock.fs_bsize) == -1) {

sbin/ffsinfo/ffsinfo.c

441

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

445

howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t))));

sbin/ffsinfo/ffsinfo.c

446

for (ind2ctr = 0; ((ind2ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

450

if (bread(&disk, fsbtodb(&sblock, *ind2ptr),

sbin/ffsinfo/ffsinfo.c

451

(void *)&i1blk, (size_t)sblock.fs_bsize)

sbin/ffsinfo/ffsinfo.c

458

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

462

rb -= howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

505

DBG_DUMP_INO(&sblock, comment, dp.dp2);

sbin/ffsinfo/ffsinfo.c

516

rb = howmany(dp.dp2->di_size, sblock.fs_bsize) - UFS_NDADDR;

sbin/ffsinfo/ffsinfo.c

521

if (bread(&disk, fsbtodb(&sblock, dp.dp2->di_ib[0]),

sbin/ffsinfo/ffsinfo.c

522

(void *)&i1blk, (size_t)sblock.fs_bsize) == -1) {

sbin/ffsinfo/ffsinfo.c

527

DBG_DUMP_IBLK(&sblock, comment, i1blk, (size_t)rb);

sbin/ffsinfo/ffsinfo.c

528

rb -= howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t));

sbin/ffsinfo/ffsinfo.c

534

if (bread(&disk, fsbtodb(&sblock, dp.dp2->di_ib[1]),

sbin/ffsinfo/ffsinfo.c

535

(void *)&i2blk, (size_t)sblock.fs_bsize) == -1) {

sbin/ffsinfo/ffsinfo.c

540

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

543

howmany(rb, howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t))));

sbin/ffsinfo/ffsinfo.c

544

for (ind2ctr = 0; ((ind2ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

548

if (bread(&disk, fsbtodb(&sblock, *ind2ptr),

sbin/ffsinfo/ffsinfo.c

549

(void *)&i1blk, (size_t)sblock.fs_bsize) == -1) {

sbin/ffsinfo/ffsinfo.c

555

DBG_DUMP_IBLK(&sblock, comment, i1blk, (size_t)rb);

sbin/ffsinfo/ffsinfo.c

556

rb -= howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t));

sbin/ffsinfo/ffsinfo.c

563

if (bread(&disk, fsbtodb(&sblock, dp.dp2->di_ib[2]),

sbin/ffsinfo/ffsinfo.c

564

(void *)&i3blk, (size_t)sblock.fs_bsize) == -1) {

sbin/ffsinfo/ffsinfo.c

570

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

574

SQUARE(howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t)))));

sbin/ffsinfo/ffsinfo.c

576

for (ind3ctr = 0; ((ind3ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

580

if (bread(&disk, fsbtodb(&sblock, *ind3ptr),

sbin/ffsinfo/ffsinfo.c

581

(void *)&i2blk, (size_t)sblock.fs_bsize) == -1) {

sbin/ffsinfo/ffsinfo.c

587

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

591

howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t))));

sbin/ffsinfo/ffsinfo.c

592

for (ind2ctr = 0; ((ind2ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

595

if (bread(&disk, fsbtodb(&sblock, *ind2ptr),

sbin/ffsinfo/ffsinfo.c

596

(void *)&i1blk, (size_t)sblock.fs_bsize)

sbin/ffsinfo/ffsinfo.c

603

DBG_DUMP_IBLK(&sblock, comment, i1blk, (size_t)rb);

sbin/ffsinfo/ffsinfo.c

604

rb -= howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t));

sbin/fsck_ffs/dir.c

206

blksiz = idesc->id_numfrags * sblock.fs_fsize;

sbin/fsck_ffs/dir.c

246

blksiz = idesc->id_numfrags * sblock.fs_fsize;

sbin/fsck_ffs/dir.c

794

cg = ino_to_cg(&sblock, ip->i_number);

sbin/fsck_ffs/dir.c

797

lastlbn = lblkno(&sblock, filesize);

sbin/fsck_ffs/dir.c

802

lastlbn >= UFS_NDADDR + NINDIR(&sblock))

sbin/fsck_ffs/dir.c

807

lastlbnsize = sblksize(&sblock, filesize, lastlbn);

sbin/fsck_ffs/dir.c

808

if (lastlbnsize > 0 && lastlbnsize < sblock.fs_bsize) {

sbin/fsck_ffs/dir.c

813

newblk = allocblk(cg, sblock.fs_frag, std_checkblkavail);

sbin/fsck_ffs/dir.c

816

nbp = getdatablk(newblk, sblock.fs_bsize, BT_DIRDATA);

sbin/fsck_ffs/dir.c

820

DIP_SET(dp, di_size, filesize + sblock.fs_bsize - lastlbnsize);

sbin/fsck_ffs/dir.c

822

btodb(sblock.fs_bsize - lastlbnsize));

sbin/fsck_ffs/dir.c

826

sblock.fs_bsize - lastlbnsize);

sbin/fsck_ffs/dir.c

828

cp < &nbp->b_un.b_buf[sblock.fs_bsize];

sbin/fsck_ffs/dir.c

835

idesc.id_numfrags = numfrags(&sblock, lastlbnsize);

sbin/fsck_ffs/dir.c

841

if ((newblk = allocblk(cg, sblock.fs_frag, std_checkblkavail)) == 0)

sbin/fsck_ffs/dir.c

843

bp = getdirblk(newblk, sblock.fs_bsize);

sbin/fsck_ffs/dir.c

846

memset(bp->b_un.b_buf, 0, sblock.fs_bsize);

sbin/fsck_ffs/dir.c

848

cp < &bp->b_un.b_buf[sblock.fs_bsize];

sbin/fsck_ffs/dir.c

859

indirblk = allocblk(cg, sblock.fs_frag,

sbin/fsck_ffs/dir.c

867

nbp = getdatablk(indirblk, sblock.fs_bsize, BT_LEVEL1);

sbin/fsck_ffs/dir.c

871

memset(nbp->b_un.b_buf, 0, sblock.fs_bsize);

sbin/fsck_ffs/dir.c

874

DIP(dp, di_blocks) + btodb(sblock.fs_bsize));

sbin/fsck_ffs/dir.c

881

DIP_SET(dp, di_size, filesize + sblock.fs_bsize);

sbin/fsck_ffs/dir.c

882

DIP_SET(dp, di_blocks, DIP(dp, di_blocks) + btodb(sblock.fs_bsize));

sbin/fsck_ffs/dir.c

895

idesc.id_numfrags = sblock.fs_frag;

sbin/fsck_ffs/dir.c

900

idesc.id_numfrags = sblock.fs_frag;

sbin/fsck_ffs/dir.c

928

bp = getdirblk(DIP(dp, di_db[0]), sblock.fs_fsize);

sbin/fsck_ffs/dir.c

936

cp < &bp->b_un.b_buf[sblock.fs_fsize];

sbin/fsck_ffs/ea.c

69

if (dp->di_extsize <= sblock.fs_fsize)

sbin/fsck_ffs/ea.c

70

blksiz = sblock.fs_fsize;

sbin/fsck_ffs/ea.c

72

blksiz = sblock.fs_bsize;

sbin/fsck_ffs/fsck.h

170

((sblock.fs_magic == FS_UFS1_MAGIC) ? \

sbin/fsck_ffs/fsck.h

174

if (sblock.fs_magic == FS_UFS1_MAGIC) \

sbin/fsck_ffs/fsck.h

386

if (sblock.fs_magic == FS_UFS1_MAGIC) { \

sbin/fsck_ffs/fsck.h

79

((sblock.fs_magic == FS_UFS1_MAGIC) ? \

sbin/fsck_ffs/fsck.h

83

if (sblock.fs_magic == FS_UFS1_MAGIC) \

sbin/fsck_ffs/fsutil.c

1006

if ((sblock.fs_metackhash & CK_CYLGRP) != 0 &&

sbin/fsck_ffs/fsutil.c

1010

calchash = calculate_crc32c(~0L, (void *)cgp, sblock.fs_cgsize);

sbin/fsck_ffs/fsutil.c

1017

CHK(cgp->cg_ndblk, >, sblock.fs_fpg, "%jd");

sbin/fsck_ffs/fsutil.c

1018

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/fsck_ffs/fsutil.c

1019

CHK(cgp->cg_old_niblk, !=, sblock.fs_ipg, "%jd");

sbin/fsck_ffs/fsutil.c

1020

} else if (sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/fsutil.c

1021

CHK(cgp->cg_niblk, !=, sblock.fs_ipg, "%jd");

sbin/fsck_ffs/fsutil.c

1022

CHK(cgp->cg_initediblk, >, sblock.fs_ipg, "%jd");

sbin/fsck_ffs/fsutil.c

1024

if (cgbase(&sblock, cg) + sblock.fs_fpg < sblock.fs_size) {

sbin/fsck_ffs/fsutil.c

1025

CHK(cgp->cg_ndblk, !=, sblock.fs_fpg, "%jd");

sbin/fsck_ffs/fsutil.c

1027

CHK(cgp->cg_ndblk, !=, sblock.fs_size - cgbase(&sblock, cg),

sbin/fsck_ffs/fsutil.c

1031

if (sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/fsutil.c

1033

} else if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/fsck_ffs/fsutil.c

1036

CHK(cgp->cg_old_niblk, !=, sblock.fs_ipg, "%jd");

sbin/fsck_ffs/fsutil.c

1039

sblock.fs_old_cpg * sizeof(int32_t), "%jd");

sbin/fsck_ffs/fsutil.c

1041

sblock.fs_old_cpg * sizeof(u_int16_t), "%jd");

sbin/fsck_ffs/fsutil.c

1044

cgp->cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT), "%jd");

sbin/fsck_ffs/fsutil.c

1045

if (sblock.fs_contigsumsize == 0) {

sbin/fsck_ffs/fsutil.c

1047

cgp->cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT), "%jd");

sbin/fsck_ffs/fsutil.c

1049

CHK(cgp->cg_nclusterblks, !=, cgp->cg_ndblk / sblock.fs_frag,

sbin/fsck_ffs/fsutil.c

1052

roundup(cgp->cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT),

sbin/fsck_ffs/fsutil.c

1055

(sblock.fs_contigsumsize + 1) * sizeof(u_int32_t), "%jd");

sbin/fsck_ffs/fsutil.c

1057

howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT),

sbin/fsck_ffs/fsutil.c

1080

memset(cgp, 0, (size_t)sblock.fs_cgsize);

sbin/fsck_ffs/fsutil.c

1083

cgp->cg_niblk = sblock.fs_ipg;

sbin/fsck_ffs/fsutil.c

1084

cgp->cg_initediblk = MIN(sblock.fs_ipg, 2 * INOPB(&sblock));

sbin/fsck_ffs/fsutil.c

1085

if (cgbase(&sblock, cg) + sblock.fs_fpg < sblock.fs_size)

sbin/fsck_ffs/fsutil.c

1086

cgp->cg_ndblk = sblock.fs_fpg;

sbin/fsck_ffs/fsutil.c

1088

cgp->cg_ndblk = sblock.fs_size - cgbase(&sblock, cg);

sbin/fsck_ffs/fsutil.c

1090

if (sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/fsutil.c

1092

} else if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/fsck_ffs/fsutil.c

1095

cgp->cg_old_ncyl = sblock.fs_old_cpg;

sbin/fsck_ffs/fsutil.c

1096

cgp->cg_old_niblk = sblock.fs_ipg;

sbin/fsck_ffs/fsutil.c

1099

sblock.fs_old_cpg * sizeof(int32_t);

sbin/fsck_ffs/fsutil.c

1101

sblock.fs_old_cpg * sizeof(u_int16_t);

sbin/fsck_ffs/fsutil.c

1103

cgp->cg_freeoff = cgp->cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);

sbin/fsck_ffs/fsutil.c

1104

cgp->cg_nextfreeoff = cgp->cg_freeoff + howmany(sblock.fs_fpg,CHAR_BIT);

sbin/fsck_ffs/fsutil.c

1105

if (sblock.fs_contigsumsize > 0) {

sbin/fsck_ffs/fsutil.c

1106

cgp->cg_nclusterblks = cgp->cg_ndblk / sblock.fs_frag;

sbin/fsck_ffs/fsutil.c

1111

(sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);

sbin/fsck_ffs/fsutil.c

1113

howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);

sbin/fsck_ffs/fsutil.c

1115

cgp->cg_ckhash = calculate_crc32c(~0L, (void *)cgp, sblock.fs_cgsize);

sbin/fsck_ffs/fsutil.c

1132

if (frags <= 0 || frags > sblock.fs_frag)

sbin/fsck_ffs/fsutil.c

1134

for (blkno = MAX(cgdata(&sblock, startcg), 0);

sbin/fsck_ffs/fsutil.c

1135

blkno < maxfsblock - sblock.fs_frag;

sbin/fsck_ffs/fsutil.c

1136

blkno += sblock.fs_frag) {

sbin/fsck_ffs/fsutil.c

1144

for (blkno = MAX(cgdata(&sblock, 0), 0);

sbin/fsck_ffs/fsutil.c

1145

blkno < cgbase(&sblock, startcg) - sblock.fs_frag;

sbin/fsck_ffs/fsutil.c

1146

blkno += sblock.fs_frag) {

sbin/fsck_ffs/fsutil.c

1165

if ((u_int64_t)blkno > sblock.fs_size)

sbin/fsck_ffs/fsutil.c

1167

for (j = 0; j <= sblock.fs_frag - frags; j++) {

sbin/fsck_ffs/fsutil.c

1177

cg = dtog(&sblock, blkno + j);

sbin/fsck_ffs/fsutil.c

1181

return (-((cg + 1) * sblock.fs_fpg - sblock.fs_frag));

sbin/fsck_ffs/fsutil.c

1182

baseblk = dtogd(&sblock, blkno + j);

sbin/fsck_ffs/fsutil.c

1188

if (frags == sblock.fs_frag)

sbin/fsck_ffs/fsutil.c

1209

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsck_ffs/fsutil.c

1210

kernmaxfilesize = (off_t)0x40000000 * sblock.fs_bsize - 1;

sbin/fsck_ffs/fsutil.c

1212

kernmaxfilesize = sblock.fs_maxfilesize;

sbin/fsck_ffs/fsutil.c

1214

filesize > sblock.fs_maxfilesize ||

sbin/fsck_ffs/fsutil.c

167

ilp = &inostathead[inum / sblock.fs_ipg];

sbin/fsck_ffs/fsutil.c

168

iloff = inum % sblock.fs_ipg;

sbin/fsck_ffs/fsutil.c

185

if ((cgblk.b_un.b_buf = Balloc((unsigned int)sblock.fs_bsize)) == NULL)

sbin/fsck_ffs/fsutil.c

186

errx(EEXIT, "Initial malloc(%d) failed", sblock.fs_bsize);

sbin/fsck_ffs/fsutil.c

207

bufp = Balloc((unsigned int)sblock.fs_bsize);

sbin/fsck_ffs/fsutil.c

234

if ((unsigned) cg >= sblock.fs_ncg)

sbin/fsck_ffs/fsutil.c

237

cgbufs = Calloc(sblock.fs_ncg, sizeof(struct bufarea));

sbin/fsck_ffs/fsutil.c

246

cgp = Balloc((unsigned int)sblock.fs_cgsize);

sbin/fsck_ffs/fsutil.c

251

getblk(&cgblk, cgtod(&sblock, cg), sblock.fs_cgsize);

sbin/fsck_ffs/fsutil.c

256

getblk(cgbp, cgtod(&sblock, cg), sblock.fs_cgsize);

sbin/fsck_ffs/fsutil.c

270

if ((sblock.fs_metackhash & CK_CYLGRP) != 0) {

sbin/fsck_ffs/fsutil.c

273

calculate_crc32c(~0L, (void *)cg, sblock.fs_cgsize);

sbin/fsck_ffs/fsutil.c

287

if (sujrecovery || flushtries == sblock.fs_ncg || cgbufs == NULL)

sbin/fsck_ffs/fsutil.c

314

if (type != BT_INODES && chkrange(blkno, size / sblock.fs_fsize)) {

sbin/fsck_ffs/fsutil.c

320

if (bp->b_bno == fsbtodb(&sblock, blkno)) {

sbin/fsck_ffs/fsutil.c

342

if (size > sblock.fs_bsize)

sbin/fsck_ffs/fsutil.c

344

sblock.fs_bsize);

sbin/fsck_ffs/fsutil.c

400

dblk = fsbtodb(&sblock, blk);

sbin/fsck_ffs/fsutil.c

477

if (cgput(fswritefd, &sblock, bp->b_un.b_cg) == 0)

sbin/fsck_ffs/fsutil.c

481

if (debug && sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/fsutil.c

486

if (ffs_verify_dinode_ckhash(&sblock, dp) == 0)

sbin/fsck_ffs/fsutil.c

496

ffs_update_dinode_ckhash(&sblock, dp);

sbin/fsck_ffs/fsutil.c

503

copyonwrite(&sblock, bp, std_checkblkavail);

sbin/fsck_ffs/fsutil.c

528

copyonwrite(&sblock, bp, checkblkavail);

sbin/fsck_ffs/fsutil.c

558

maxbno = fragstoblks(&sblock, sblock.fs_fpg);

sbin/fsck_ffs/fsutil.c

559

if (sblock.fs_contigsumsize > 0) {

sbin/fsck_ffs/fsutil.c

560

for (i = 1; i <= sblock.fs_contigsumsize; i++)

sbin/fsck_ffs/fsutil.c

566

if (ffs_isfreeblock(&sblock, blksfree, cgbno))

sbin/fsck_ffs/fsutil.c

568

if (ffs_isblock(&sblock, blksfree, cgbno)) {

sbin/fsck_ffs/fsutil.c

569

ffs_clusteracct(&sblock, cgp, cgbno, 1);

sbin/fsck_ffs/fsutil.c

573

fragno = blkstofrags(&sblock, cgbno);

sbin/fsck_ffs/fsutil.c

574

blk = blkmap(&sblock, blksfree, fragno);

sbin/fsck_ffs/fsutil.c

575

ffs_fragacct(&sblock, blk, cgp->cg_frsum, 1);

sbin/fsck_ffs/fsutil.c

576

for (i = 0; i < sblock.fs_frag; i++)

sbin/fsck_ffs/fsutil.c

584

csp = &sblock.fs_cs(&sblock, cgp->cg_cgx);

sbin/fsck_ffs/fsutil.c

585

sblock.fs_cstotal.cs_ndir += cgp->cg_cs.cs_ndir - csp->cs_ndir;

sbin/fsck_ffs/fsutil.c

586

sblock.fs_cstotal.cs_nbfree += cgp->cg_cs.cs_nbfree - csp->cs_nbfree;

sbin/fsck_ffs/fsutil.c

587

sblock.fs_cstotal.cs_nifree += cgp->cg_cs.cs_nifree - csp->cs_nifree;

sbin/fsck_ffs/fsutil.c

588

sblock.fs_cstotal.cs_nffree += cgp->cg_cs.cs_nffree - csp->cs_nffree;

sbin/fsck_ffs/fsutil.c

589

sblock.fs_cs(&sblock, cgp->cg_cgx) = cgp->cg_cs;

sbin/fsck_ffs/fsutil.c

612

if ((!(sblock.fs_flags & FS_UNCLEAN)) != markclean) {

sbin/fsck_ffs/fsutil.c

653

for (cnt = 0; cnt < sblock.fs_ncg; cnt++) {

sbin/fsck_ffs/fsutil.c

728

sblk.b_bno != sblock.fs_sblockloc / dev_bsize) {

sbin/fsck_ffs/fsutil.c

731

sblock.fs_sblockactualloc = sblock.fs_sblockloc;

sbin/fsck_ffs/fsutil.c

732

sblk.b_bno = sblock.fs_sblockloc / dev_bsize;

sbin/fsck_ffs/fsutil.c

739

if (cursnapshot == 0 && sblock.fs_clean != markclean) {

sbin/fsck_ffs/fsutil.c

740

if ((sblock.fs_clean = markclean) != 0) {

sbin/fsck_ffs/fsutil.c

741

sblock.fs_flags &= ~(FS_UNCLEAN | FS_NEEDSFSCK);

sbin/fsck_ffs/fsutil.c

742

sblock.fs_pendingblocks = 0;

sbin/fsck_ffs/fsutil.c

743

sblock.fs_pendinginodes = 0;

sbin/fsck_ffs/fsutil.c

770

for (cg = 0; cg < sblock.fs_ncg; cg++)

sbin/fsck_ffs/fsutil.c

989

sblock.fs_magic == FS_UFS1_MAGIC ? 1 : 2, cg, \

sbin/fsck_ffs/gjournal.c

75

fs = &sblock;

sbin/fsck_ffs/inode.c

1066

if (sblock.fs_magic == FS_UFS2_MAGIC && dp->dp2.di_extsize > 0) {

sbin/fsck_ffs/inode.c

1067

ndb = howmany(dp->dp2.di_extsize, sblock.fs_bsize);

sbin/fsck_ffs/inode.c

1070

(offset = blkoff(&sblock, dp->dp2.di_extsize)) != 0)

sbin/fsck_ffs/inode.c

1071

idesc.id_numfrags = numfrags(&sblock,

sbin/fsck_ffs/inode.c

1072

fragroundup(&sblock, offset));

sbin/fsck_ffs/inode.c

1074

idesc.id_numfrags = sblock.fs_frag;

sbin/fsck_ffs/inode.c

108

i * sblock.fs_bsize);

sbin/fsck_ffs/inode.c

1083

idesc.id_entryno *= btodb(sblock.fs_fsize);

sbin/fsck_ffs/inode.c

1151

if (howmany(DIP(dp, di_size), sblock.fs_bsize) > UFS_NDADDR)

sbin/fsck_ffs/inode.c

1154

blks = howmany(DIP(dp, di_size), sblock.fs_bsize);

sbin/fsck_ffs/inode.c

1254

if (sblock.fs_magic == FS_UFS2_MAGIC)

sbin/fsck_ffs/inode.c

1255

ffs_update_dinode_ckhash(&sblock,

sbin/fsck_ffs/inode.c

127

idesc->id_numfrags = sblock.fs_frag;

sbin/fsck_ffs/inode.c

128

remsize = DIP(&dino, di_size) - sblock.fs_bsize * UFS_NDADDR;

sbin/fsck_ffs/inode.c

129

sizepb = sblock.fs_bsize;

sbin/fsck_ffs/inode.c

131

sizepb *= NINDIR(&sblock);

sbin/fsck_ffs/inode.c

139

idesc->id_lbn += sizepb / sblock.fs_bsize;

sbin/fsck_ffs/inode.c

1421

cg = ino_to_cg(&sblock, ino);

sbin/fsck_ffs/inode.c

1427

request = (cg + 1) * sblock.fs_ipg;

sbin/fsck_ffs/inode.c

1430

setbit(cg_inosused(cgp), ino % sblock.fs_ipg);

sbin/fsck_ffs/inode.c

1447

memset(dp, 0, ((sblock.fs_magic == FS_UFS1_MAGIC) ?

sbin/fsck_ffs/inode.c

1449

DIP_SET(dp, di_db[0], allocblk(ino_to_cg(&sblock, ino), (long)1,

sbin/fsck_ffs/inode.c

1461

DIP_SET(dp, di_size, sblock.fs_fsize);

sbin/fsck_ffs/inode.c

1462

DIP_SET(dp, di_blocks, btodb(sblock.fs_fsize));

sbin/fsck_ffs/inode.c

181

bp = getdatablk(idesc->id_blkno, sblock.fs_bsize, type);

sbin/fsck_ffs/inode.c

188

for (sizepb = sblock.fs_bsize, i = 0; i < idesc->id_level; i++)

sbin/fsck_ffs/inode.c

189

sizepb *= NINDIR(&sblock);

sbin/fsck_ffs/inode.c

190

if (howmany(isize, sizepb) > NINDIR(&sblock))

sbin/fsck_ffs/inode.c

191

nif = NINDIR(&sblock);

sbin/fsck_ffs/inode.c

194

if (idesc->id_func == pass1check && nif < NINDIR(&sblock)) {

sbin/fsck_ffs/inode.c

195

for (i = nif; i < NINDIR(&sblock); i++) {

sbin/fsck_ffs/inode.c

225

idesc->id_lbn += sizepb / sblock.fs_bsize;

sbin/fsck_ffs/inode.c

275

if (lbn > lblkno(&sblock, dp->dp2.di_extsize - 1))

sbin/fsck_ffs/inode.c

277

*frags = numfrags(&sblock,

sbin/fsck_ffs/inode.c

278

sblksize(&sblock, dp->dp2.di_extsize, lbn));

sbin/fsck_ffs/inode.c

285

DIP(dp, di_size) < sblock.fs_maxsymlinklen)

sbin/fsck_ffs/inode.c

288

*frags = numfrags(&sblock,

sbin/fsck_ffs/inode.c

289

sblksize(&sblock, DIP(dp, di_size), lbn));

sbin/fsck_ffs/inode.c

292

*frags = sblock.fs_frag;

sbin/fsck_ffs/inode.c

294

for (i = 0, tmpval = NINDIR(&sblock), cur = UFS_NDADDR; i < UFS_NIADDR;

sbin/fsck_ffs/inode.c

295

i++, tmpval *= NINDIR(&sblock), cur = next) {

sbin/fsck_ffs/inode.c

339

lbnadd *= NINDIR(&sblock);

sbin/fsck_ffs/inode.c

344

if (i < 0 || i >= NINDIR(&sblock)) {

sbin/fsck_ffs/inode.c

353

bp = getdatablk(blk, sblock.fs_bsize, BT_LEVEL1 + level);

sbin/fsck_ffs/inode.c

385

(long)blk, (int)fragnum(&sblock, blk), cnt);

sbin/fsck_ffs/inode.c

388

if (cnt > sblock.fs_frag ||

sbin/fsck_ffs/inode.c

389

fragnum(&sblock, blk) + cnt > sblock.fs_frag) {

sbin/fsck_ffs/inode.c

392

(long)blk, (int)fragnum(&sblock, blk), cnt);

sbin/fsck_ffs/inode.c

395

c = dtog(&sblock, blk);

sbin/fsck_ffs/inode.c

396

if (blk < cgdmin(&sblock, c)) {

sbin/fsck_ffs/inode.c

397

if ((blk + cnt) > cgsblock(&sblock, c)) {

sbin/fsck_ffs/inode.c

400

(long)blk, (long)cgdmin(&sblock, c));

sbin/fsck_ffs/inode.c

403

(long)cgsblock(&sblock, c));

sbin/fsck_ffs/inode.c

408

if ((blk + cnt) > cgbase(&sblock, c+1)) {

sbin/fsck_ffs/inode.c

411

(long)blk, (long)cgdmin(&sblock, c));

sbin/fsck_ffs/inode.c

413

(long)(blk + cnt), (long)sblock.fs_fpg);

sbin/fsck_ffs/inode.c

447

inumber < icachebp->b_index + INOPB(&sblock)) {

sbin/fsck_ffs/inode.c

452

iblk = ino_to_fsba(&sblock, inumber);

sbin/fsck_ffs/inode.c

456

icachebp = getdatablk(iblk, sblock.fs_bsize, BT_INODES);

sbin/fsck_ffs/inode.c

465

icachebp->b_index = rounddown(inumber, INOPB(&sblock));

sbin/fsck_ffs/inode.c

468

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/fsck_ffs/inode.c

472

if (ffs_oldfscompat_inode_read(&sblock, dpp, now))

sbin/fsck_ffs/inode.c

480

if (dp->di_mode != 0 && ffs_verify_dinode_ckhash(&sblock, dp)) {

sbin/fsck_ffs/inode.c

486

ffs_update_dinode_ckhash(&sblock, dp);

sbin/fsck_ffs/inode.c

490

if (ffs_oldfscompat_inode_read(&sblock, dpp, now))

sbin/fsck_ffs/inode.c

504

if (debug && sblock.fs_magic == FS_UFS2_MAGIC &&

sbin/fsck_ffs/inode.c

505

ffs_verify_dinode_ckhash(&sblock, (struct ufs2_dinode *)ip->i_dp)) {

sbin/fsck_ffs/inode.c

540

blk = ino_to_fsba(&sblock, lastinum);

sbin/fsck_ffs/inode.c

561

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/fsck_ffs/inode.c

569

ffs_update_dinode_ckhash(&sblock, (struct ufs2_dinode *)dp);

sbin/fsck_ffs/inode.c

572

if (ffs_verify_dinode_ckhash(&sblock, (struct ufs2_dinode *)dp) != 0) {

sbin/fsck_ffs/inode.c

581

ffs_update_dinode_ckhash(&sblock,

sbin/fsck_ffs/inode.c

586

if (ffs_oldfscompat_inode_read(&sblock, dpp, now))

sbin/fsck_ffs/inode.c

605

ndb = howmany(DIP(dp, di_size), sblock.fs_bsize);

sbin/fsck_ffs/inode.c

615

if (DIP(dp, di_size) < (off_t)sblock.fs_maxsymlinklen) {

sbin/fsck_ffs/inode.c

621

ndb *= NINDIR(&sblock);

sbin/fsck_ffs/inode.c

630

ndb /= NINDIR(&sblock);

sbin/fsck_ffs/inode.c

653

now = sblock.fs_time;

sbin/fsck_ffs/inode.c

654

inum = cg * sblock.fs_ipg;

sbin/fsck_ffs/inode.c

663

inobufsize = blkroundup(&sblock,

sbin/fsck_ffs/inode.c

664

MAX(INOBUFSIZE, sblock.fs_bsize));

sbin/fsck_ffs/inode.c

669

fullcnt = inobufsize / ((sblock.fs_magic == FS_UFS1_MAGIC) ?

sbin/fsck_ffs/inode.c

673

partialsize = fragroundup(&sblock,

sbin/fsck_ffs/inode.c

674

partialcnt * ((sblock.fs_magic == FS_UFS1_MAGIC) ?

sbin/fsck_ffs/inode.c

698

size = lfragtosize(&sblock, idesc->id_numfrags);

sbin/fsck_ffs/inode.c

699

if (snapblkfree(&sblock, blkno, size, idesc->id_number,

sbin/fsck_ffs/inode.c

725

cgbp = cglookup(dtog(&sblock, idesc->id_blkno));

sbin/fsck_ffs/inode.c

727

if (idesc->id_numfrags == sblock.fs_frag)

sbin/fsck_ffs/inode.c

768

if (sblock.fs_snapinum[i] == 0)

sbin/fsck_ffs/inode.c

771

sblock.fs_snapinum[i - 1] = sblock.fs_snapinum[i];

sbin/fsck_ffs/inode.c

773

sblock.fs_snapinum[i - 1] = 0;

sbin/fsck_ffs/inode.c

79

DIP(dp, di_size) < (unsigned)sblock.fs_maxsymlinklen))

sbin/fsck_ffs/inode.c

81

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsck_ffs/inode.c

89

ndb = howmany(DIP(&dino, di_size), sblock.fs_bsize);

sbin/fsck_ffs/inode.c

93

(offset = blkoff(&sblock, DIP(&dino, di_size))) != 0)

sbin/fsck_ffs/inode.c

95

numfrags(&sblock, fragroundup(&sblock, offset));

sbin/fsck_ffs/inode.c

97

idesc->id_numfrags = sblock.fs_frag;

sbin/fsck_ffs/main.c

263

if ((sblock.fs_flags & FS_NEEDSFSCK) == FS_NEEDSFSCK)

sbin/fsck_ffs/main.c

265

if ((sblock.fs_flags & FS_SUJ) == FS_SUJ) {

sbin/fsck_ffs/main.c

266

maxino = sblock.fs_ncg * sblock.fs_ipg;

sbin/fsck_ffs/main.c

267

maxfsblock = sblock.fs_size;

sbin/fsck_ffs/main.c

273

if ((sblock.fs_flags & FS_DOSOFTDEP) == 0)

sbin/fsck_ffs/main.c

278

if ((mntp == NULL && sblock.fs_clean == 1) ||

sbin/fsck_ffs/main.c

279

(mntp != NULL && (sblock.fs_flags & FS_UNCLEAN) == 0))

sbin/fsck_ffs/main.c

296

if ((sblock.fs_flags & FS_GJOURNAL) != 0) {

sbin/fsck_ffs/main.c

297

if (sblock.fs_clean == 1) {

sbin/fsck_ffs/main.c

301

if ((sblock.fs_flags &

sbin/fsck_ffs/main.c

335

pwarn("clean, %ld free ", (long)(sblock.fs_cstotal.cs_nffree +

sbin/fsck_ffs/main.c

336

sblock.fs_frag * sblock.fs_cstotal.cs_nbfree));

sbin/fsck_ffs/main.c

338

(intmax_t)sblock.fs_cstotal.cs_nffree,

sbin/fsck_ffs/main.c

339

(intmax_t)sblock.fs_cstotal.cs_nbfree,

sbin/fsck_ffs/main.c

340

sblock.fs_cstotal.cs_nffree * 100.0 / sblock.fs_dsize);

sbin/fsck_ffs/main.c

346

if (bkgrdflag == 0 && (sblock.fs_flags & FS_SUJ) == FS_SUJ) {

sbin/fsck_ffs/main.c

347

if ((sblock.fs_flags & FS_NEEDSFSCK) != FS_NEEDSFSCK &&

sbin/fsck_ffs/main.c

367

sblock.fs_mtime = time(NULL);

sbin/fsck_ffs/main.c

379

if ((sblock.fs_flags & FS_METACKHASH) == 0)

sbin/fsck_ffs/main.c

380

sblock.fs_metackhash = 0;

sbin/fsck_ffs/main.c

388

if (preen == 0 && yflag == 0 && sblock.fs_magic != FS_UFS1_MAGIC &&

sbin/fsck_ffs/main.c

390

if ((sblock.fs_metackhash & CK_CYLGRP) == 0 &&

sbin/fsck_ffs/main.c

393

sblock.fs_metackhash |= CK_CYLGRP;

sbin/fsck_ffs/main.c

395

if ((sblock.fs_metackhash & CK_SUPERBLOCK) == 0 &&

sbin/fsck_ffs/main.c

399

sblock.fs_metackhash |= CK_SUPERBLOCK;

sbin/fsck_ffs/main.c

401

if ((sblock.fs_metackhash & CK_INODE) == 0 &&

sbin/fsck_ffs/main.c

405

sblock.fs_metackhash |= CK_INODE;

sbin/fsck_ffs/main.c

408

if ((sblock.fs_metackhash & CK_INDIR) == 0 &&

sbin/fsck_ffs/main.c

412

sblock.fs_metackhash |= CK_INDIR;

sbin/fsck_ffs/main.c

414

if ((sblock.fs_metackhash & CK_DIR) == 0 &&

sbin/fsck_ffs/main.c

418

sblock.fs_metackhash |= CK_DIR;

sbin/fsck_ffs/main.c

422

sblock.fs_flags |= FS_METACKHASH;

sbin/fsck_ffs/main.c

435

printf("** Last Mounted on %s\n", sblock.fs_fsmnt);

sbin/fsck_ffs/main.c

500

n_ffree = sblock.fs_cstotal.cs_nffree;

sbin/fsck_ffs/main.c

501

n_bfree = sblock.fs_cstotal.cs_nbfree;

sbin/fsck_ffs/main.c

502

files = maxino - UFS_ROOTINO - sblock.fs_cstotal.cs_nifree - n_files;

sbin/fsck_ffs/main.c

504

sblock.fs_ncg * (cgdmin(&sblock, 0) - cgsblock(&sblock, 0));

sbin/fsck_ffs/main.c

505

blks += cgsblock(&sblock, 0) - cgbase(&sblock, 0);

sbin/fsck_ffs/main.c

506

blks += howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/fsck_ffs/main.c

507

blks = maxfsblock - (n_ffree + sblock.fs_frag * n_bfree) - blks;

sbin/fsck_ffs/main.c

509

countdirs = sblock.fs_cstotal.cs_ndir - countdirs;

sbin/fsck_ffs/main.c

515

(uintmax_t)n_ffree + sblock.fs_frag * n_bfree);

sbin/fsck_ffs/main.c

518

n_ffree * 100.0 / sblock.fs_dsize);

sbin/fsck_ffs/main.c

535

sblock.fs_time = time(NULL);

sbin/fsck_ffs/main.c

542

if (sbput(fswritefd, &sblock, sblock.fs_ncg) == 0)

sbin/fsck_ffs/main.c

611

if ((sblock.fs_flags & FS_NEEDSFSCK) != 0) {

sbin/fsck_ffs/main.c

616

(sblock.fs_flags & (FS_UNCLEAN|FS_NEEDSFSCK)) == 0) {

sbin/fsck_ffs/main.c

705

free(sblock.fs_csp);

sbin/fsck_ffs/main.c

706

free(sblock.fs_si);

sbin/fsck_ffs/pass1.c

107

if (!rebuiltcg && sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/pass1.c

109

if (inosused > sblock.fs_ipg) {

sbin/fsck_ffs/pass1.c

112

(uintmax_t)inosused, sblock.fs_ipg, c,

sbin/fsck_ffs/pass1.c

113

sblock.fs_ipg);

sbin/fsck_ffs/pass1.c

114

inosused = sblock.fs_ipg;

sbin/fsck_ffs/pass1.c

117

inosused = sblock.fs_ipg;

sbin/fsck_ffs/pass1.c

121

cdevname, c, sblock.fs_ncg,

sbin/fsck_ffs/pass1.c

122

c * 100 / sblock.fs_ncg);

sbin/fsck_ffs/pass1.c

127

c * 100 / sblock.fs_ncg);

sbin/fsck_ffs/pass1.c

193

mininos = roundup(inosused + INOPB(&sblock), INOPB(&sblock));

sbin/fsck_ffs/pass1.c

195

sblock.fs_magic == FS_UFS2_MAGIC &&

sbin/fsck_ffs/pass1.c

196

cgp->cg_initediblk > 2 * INOPB(&sblock) &&

sbin/fsck_ffs/pass1.c

199

if (mininos < 2 * INOPB(&sblock))

sbin/fsck_ffs/pass1.c

200

cgp->cg_initediblk = 2 * INOPB(&sblock);

sbin/fsck_ffs/pass1.c

207

if (inosused < sblock.fs_ipg)

sbin/fsck_ffs/pass1.c

210

if (lastino < (c * sblock.fs_ipg))

sbin/fsck_ffs/pass1.c

213

inosused = lastino - (c * sblock.fs_ipg);

sbin/fsck_ffs/pass1.c

215

sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/pass1.c

216

cgp->cg_initediblk = roundup(inosused, INOPB(&sblock));

sbin/fsck_ffs/pass1.c

262

if ((sblock.fs_magic == FS_UFS1_MAGIC &&

sbin/fsck_ffs/pass1.c

268

(sblock.fs_magic == FS_UFS2_MAGIC &&

sbin/fsck_ffs/pass1.c

294

DIP_SET(dp, di_size, sblock.fs_fsize);

sbin/fsck_ffs/pass1.c

314

ndb = howmany(DIP(dp, di_size), sblock.fs_bsize);

sbin/fsck_ffs/pass1.c

329

if (DIP(dp, di_size) < (off_t)sblock.fs_maxsymlinklen) {

sbin/fsck_ffs/pass1.c

330

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsck_ffs/pass1.c

339

ndb *= NINDIR(&sblock);

sbin/fsck_ffs/pass1.c

360

ndb /= NINDIR(&sblock);

sbin/fsck_ffs/pass1.c

405

if (sblock.fs_magic == FS_UFS2_MAGIC && dp->dp2.di_extsize > 0) {

sbin/fsck_ffs/pass1.c

406

ndb = howmany(dp->dp2.di_extsize, sblock.fs_bsize);

sbin/fsck_ffs/pass1.c

409

(offset = blkoff(&sblock, dp->dp2.di_extsize)) != 0)

sbin/fsck_ffs/pass1.c

410

idesc->id_numfrags = numfrags(&sblock,

sbin/fsck_ffs/pass1.c

411

fragroundup(&sblock, offset));

sbin/fsck_ffs/pass1.c

413

idesc->id_numfrags = sblock.fs_frag;

sbin/fsck_ffs/pass1.c

422

if (sblock.fs_magic == FS_UFS2_MAGIC)

sbin/fsck_ffs/pass1.c

424

idesc->id_entryno *= btodb(sblock.fs_fsize);

sbin/fsck_ffs/pass1.c

469

if (idesc->id_lballoc < lblkno(&sblock, size - 1) &&

sbin/fsck_ffs/pass1.c

471

((mode != IFLNK) || size >= sblock.fs_maxsymlinklen)) {

sbin/fsck_ffs/pass1.c

472

fixsize = lblktosize(&sblock, idesc->id_lballoc + 1);

sbin/fsck_ffs/pass1.c

473

if (size > UFS_NDADDR * sblock.fs_bsize)

sbin/fsck_ffs/pass1.c

528

if (blkno == blkstofrags(&sblock, idesc->id_lbn))

sbin/fsck_ffs/pass1.c

531

blkno = blkstofrags(&sblock, idesc->id_lbn);

sbin/fsck_ffs/pass1.c

70

for (c = 0; c < sblock.fs_ncg; c++) {

sbin/fsck_ffs/pass1.c

71

cgd = cgdmin(&sblock, c);

sbin/fsck_ffs/pass1.c

73

i = cgbase(&sblock, c);

sbin/fsck_ffs/pass1.c

75

i = cgsblock(&sblock, c);

sbin/fsck_ffs/pass1.c

79

i = sblock.fs_csaddr;

sbin/fsck_ffs/pass1.c

80

cgd = i + howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/fsck_ffs/pass1.c

90

for (c = 0; c < sblock.fs_ncg; c++) {

sbin/fsck_ffs/pass1.c

91

inumber = c * sblock.fs_ipg;

sbin/fsck_ffs/pass1b.c

55

for (c = 0; c < sblock.fs_ncg; c++) {

sbin/fsck_ffs/pass1b.c

58

cdevname, c, sblock.fs_ncg,

sbin/fsck_ffs/pass1b.c

59

c * 100 / sblock.fs_ncg);

sbin/fsck_ffs/pass1b.c

64

c * 100 / sblock.fs_ncg);

sbin/fsck_ffs/pass1b.c

71

inumber = c * sblock.fs_ipg;

sbin/fsck_ffs/pass4.c

54

for (cg = 0; cg < sblock.fs_ncg; cg++) {

sbin/fsck_ffs/pass4.c

57

cdevname, cg, sblock.fs_ncg,

sbin/fsck_ffs/pass4.c

58

cg * 100 / sblock.fs_ncg);

sbin/fsck_ffs/pass4.c

63

cg * 100 / sblock.fs_ncg);

sbin/fsck_ffs/pass4.c

66

inumber = cg * sblock.fs_ipg;

sbin/fsck_ffs/pass5.c

111

if (sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/pass5.c

153

cdevname, c, sblock.fs_ncg,

sbin/fsck_ffs/pass5.c

154

c * 100 / sblock.fs_ncg);

sbin/fsck_ffs/pass5.c

159

c * 100 / sblock.fs_ncg);

sbin/fsck_ffs/pass5.c

469

struct fs *fs = &sblock;

sbin/fsck_ffs/pass5.c

54

struct fs *fs = &sblock;

sbin/fsck_ffs/pass5.c

636

blzero(fswritefd, fsbtodb(&sblock, start),

sbin/fsck_ffs/pass5.c

637

lfragtosize(&sblock, end - start + 1));

sbin/fsck_ffs/pass5.c

639

blerase(fswritefd, fsbtodb(&sblock, start),

sbin/fsck_ffs/pass5.c

640

lfragtosize(&sblock, end - start + 1));

sbin/fsck_ffs/setup.c

107

sblock.fs_clean = 0;

sbin/fsck_ffs/setup.c

111

if (skipclean && ckclean && sblock.fs_clean) {

sbin/fsck_ffs/setup.c

115

maxfsblock = sblock.fs_size;

sbin/fsck_ffs/setup.c

116

maxino = sblock.fs_ncg * sblock.fs_ipg;

sbin/fsck_ffs/setup.c

120

if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {

sbin/fsck_ffs/setup.c

123

sblock.fs_optim = FS_OPTTIME;

sbin/fsck_ffs/setup.c

127

if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {

sbin/fsck_ffs/setup.c

129

sblock.fs_minfree);

sbin/fsck_ffs/setup.c

131

sblock.fs_minfree = 10;

sbin/fsck_ffs/setup.c

135

if (sblock.fs_magic == FS_UFS1_MAGIC &&

sbin/fsck_ffs/setup.c

136

sblock.fs_old_inodefmt < FS_44INODEFMT) {

sbin/fsck_ffs/setup.c

142

if (preen == 0 && yflag == 0 && sblock.fs_magic == FS_UFS2_MAGIC &&

sbin/fsck_ffs/setup.c

157

inostathead = Calloc(sblock.fs_ncg, sizeof(struct inostatlist));

sbin/fsck_ffs/setup.c

160

(unsigned)(sizeof(struct inostatlist) * (sblock.fs_ncg)));

sbin/fsck_ffs/setup.c

163

numdirs = sblock.fs_cstotal.cs_ndir;

sbin/fsck_ffs/setup.c

174

if (sblock.fs_flags & FS_DOSOFTDEP)

sbin/fsck_ffs/setup.c

184

if (sblock.fs_snapinum[snapcnt] == 0)

sbin/fsck_ffs/setup.c

186

ginode(sblock.fs_snapinum[snapcnt], &ip);

sbin/fsck_ffs/setup.c

192

(intmax_t)sblock.fs_snapinum[snapcnt]);

sbin/fsck_ffs/setup.c

197

(uintmax_t)sblock.fs_snapinum[snapcnt]);

sbin/fsck_ffs/setup.c

200

if (sblock.fs_snapinum[i] == 0)

sbin/fsck_ffs/setup.c

202

sblock.fs_snapinum[i - 1] = sblock.fs_snapinum[i];

sbin/fsck_ffs/setup.c

204

sblock.fs_snapinum[i - 1] = 0;

sbin/fsck_ffs/setup.c

209

copybuf = Balloc(sblock.fs_bsize);

sbin/fsck_ffs/setup.c

254

sblock.fs_magic == FS_UFS1_MAGIC ? 1 : 2, \

sbin/fsck_ffs/setup.c

263

sblock.fs_magic == FS_UFS1_MAGIC ? 1 : 2, \

sbin/fsck_ffs/setup.c

282

fs = &sblock;

sbin/fsck_ffs/setup.c

458

memcpy(&sblock, fs, fs->fs_sbsize);

sbin/fsck_ffs/setup.c

465

dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);

sbin/fsck_ffs/setup.c

466

sblk.b_bno = sblock.fs_sblockactualloc / dev_bsize;

sbin/fsck_ffs/setup.c

471

if (sblock.fs_magic == FS_UFS1_MAGIC &&

sbin/fsck_ffs/setup.c

472

sblock.fs_maxbsize != sblock.fs_bsize) {

sbin/fsck_ffs/setup.c

473

sblock.fs_maxbsize = sblock.fs_bsize;

sbin/fsck_ffs/setup.c

474

sblock.fs_time = sblock.fs_old_time;

sbin/fsck_ffs/setup.c

475

sblock.fs_size = sblock.fs_old_size;

sbin/fsck_ffs/setup.c

476

sblock.fs_dsize = sblock.fs_old_dsize;

sbin/fsck_ffs/setup.c

477

sblock.fs_csaddr = sblock.fs_old_csaddr;

sbin/fsck_ffs/setup.c

478

sblock.fs_cstotal.cs_ndir = sblock.fs_old_cstotal.cs_ndir;

sbin/fsck_ffs/setup.c

479

sblock.fs_cstotal.cs_nbfree = sblock.fs_old_cstotal.cs_nbfree;

sbin/fsck_ffs/setup.c

480

sblock.fs_cstotal.cs_nifree = sblock.fs_old_cstotal.cs_nifree;

sbin/fsck_ffs/setup.c

481

sblock.fs_cstotal.cs_nffree = sblock.fs_old_cstotal.cs_nffree;

sbin/fsck_ffs/setup.c

519

rdsize = sblock.fs_fsize;

sbin/fsck_ffs/setup.c

557

rdsize = sblock.fs_fsize;

sbin/fsck_ffs/setup.c

558

if (sblock.fs_magic != FS_UFS2_MAGIC ||

sbin/fsck_ffs/setup.c

569

fsr->fsr_magic = sblock.fs_magic;

sbin/fsck_ffs/setup.c

570

fsr->fsr_fpg = sblock.fs_fpg;

sbin/fsck_ffs/setup.c

571

fsr->fsr_fsbtodb = sblock.fs_fsbtodb;

sbin/fsck_ffs/setup.c

572

fsr->fsr_sblkno = sblock.fs_sblkno;

sbin/fsck_ffs/setup.c

573

fsr->fsr_ncg = sblock.fs_ncg;

sbin/fsck_ffs/suj.c

2389

fs = &sblock;

sbin/fsck_ffs/suj.c

2440

sblock.fs_flags &= ~FS_SUJ;

sbin/fsck_ffs/suj.c

2441

sblock.fs_sujfree = 0;

sbin/fsck_ffs/suj.c

391

if ((u_int64_t)blkno > sblock.fs_size)

sbin/fsck_ffs/suj.c

393

cg = dtog(&sblock, blkno);

sbin/fsck_ffs/suj.c

397

return (-((cg + 1) * sblock.fs_fpg - sblock.fs_frag));

sbin/fsck_ffs/suj.c

398

baseblk = dtogd(&sblock, blkno);

sbin/fsck_ffs/suj.c

399

for (j = 0; j <= sblock.fs_frag - frags; j++) {

sbin/fsck_ffs/suj.c

412

if (frags == sblock.fs_frag)

sbin/fsck_ffs/suj.c

417

return ((cg * sblock.fs_fpg) + baseblk + j);

sbin/fsdb/fsdb.c

1225

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsdb/fsdb.c

1241

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsdb/fsdb.c

1258

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsdb/fsdb.c

1275

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsdb/fsdb.c

131

nflag? "Examining": "Editing", fsys, sblock.fs_fsmnt);

sbin/fsdb/fsdb.c

135

sblock.fs_clean = 0; /* mark it dirty */

sbin/fsdb/fsdb.c

138

ckfini(fscritmodified ? 0 : sblock.fs_clean);

sbin/fsdb/fsdb.c

407

sblock.fs_clean = 1;

sbin/fsdb/fsdb.c

496

is_ufs2 = sblock.fs_magic == FS_UFS2_MAGIC;

sbin/fsdb/fsdb.c

504

wantedblk64[i - 1] = dbtofsb(&sblock, strtoull(argv[i], NULL, 0));

sbin/fsdb/fsdb.c

510

wantedblk32[i - 1] = dbtofsb(&sblock, strtoull(argv[i], NULL, 0));

sbin/fsdb/fsdb.c

517

for (c = 0; c < sblock.fs_ncg; c++) {

sbin/fsdb/fsdb.c

522

inum = c * sblock.fs_ipg;

sbin/fsdb/fsdb.c

533

inosused = sblock.fs_ipg;

sbin/fsdb/fsdb.c

546

compare_blk64(wantedblk64, ino_to_fsba(&sblock, inum)) :

sbin/fsdb/fsdb.c

547

compare_blk32(wantedblk32, ino_to_fsba(&sblock, inum))) {

sbin/fsdb/fsdb.c

549

(unsigned long long)fsbtodb(&sblock,

sbin/fsdb/fsdb.c

550

ino_to_fsba(&sblock, inum)),

sbin/fsdb/fsdb.c

551

(uintmax_t)(inum / INOPB(&sblock)) * INOPB(&sblock),

sbin/fsdb/fsdb.c

552

(uintmax_t)(inum / INOPB(&sblock) + 1) * INOPB(&sblock));

sbin/fsdb/fsdb.c

569

if (size > 0 && size < sblock.fs_maxsymlinklen &&

sbin/fsdb/fsdb.c

651

(unsigned long long)fsbtodb(&sblock, blk), (uintmax_t)curinum);

sbin/fsdb/fsdb.c

680

blread(fsreadfd, (char *)idblk, fsbtodb(&sblock, blk), (int)sblock.fs_bsize);

sbin/fsdb/fsdb.c

682

if (find_blks32(idblk, sblock.fs_bsize / sizeof(uint32_t), wantedblk))

sbin/fsdb/fsdb.c

686

for (i = 0; i < sblock.fs_bsize / sizeof(uint32_t); i++) {

sbin/fsdb/fsdb.c

722

blread(fsreadfd, (char *)idblk, fsbtodb(&sblock, blk), (int)sblock.fs_bsize);

sbin/fsdb/fsdb.c

724

if (find_blks64(idblk, sblock.fs_bsize / sizeof(uint64_t), wantedblk))

sbin/fsdb/fsdb.c

728

for (i = 0; i < sblock.fs_bsize / sizeof(uint64_t); i++) {

sbin/fsdb/fsdbutil.c

132

DIP(dp, di_size) < sblock.fs_maxsymlinklen &&

sbin/fsdb/fsdbutil.c

149

if (sblock.fs_magic != FS_UFS1_MAGIC) {

sbin/fsdb/fsdbutil.c

155

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsdb/fsdbutil.c

162

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsdb/fsdbutil.c

169

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsdb/fsdbutil.c

231

prtblknos(&sblock, curinode);

sbin/fsirand/fsirand.c

107

struct fs *sblock;

sbin/fsirand/fsirand.c

122

if ((errno = sbget(devfd, &sblock, UFS_STDSB, UFS_NOCSUM)) != 0) {

sbin/fsirand/fsirand.c

135

if (sblock->fs_clean == 0 ||

sbin/fsirand/fsirand.c

136

(sblock->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) != 0)

sbin/fsirand/fsirand.c

139

if (sblock->fs_magic == FS_UFS1_MAGIC &&

sbin/fsirand/fsirand.c

140

sblock->fs_old_inodefmt < FS_44INODEFMT) {

sbin/fsirand/fsirand.c

144

if (!force && !printonly && sblock->fs_clean != 1) {

sbin/fsirand/fsirand.c

150

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/fsirand/fsirand.c

151

ibufsize = sizeof(struct ufs1_dinode) * sblock->fs_ipg;

sbin/fsirand/fsirand.c

153

ibufsize = sizeof(struct ufs2_dinode) * sblock->fs_ipg;

sbin/fsirand/fsirand.c

157

if (printonly && (sblock->fs_id[0] || sblock->fs_id[1])) {

sbin/fsirand/fsirand.c

158

if (sblock->fs_id[0])

sbin/fsirand/fsirand.c

160

ctime((void *)&(sblock->fs_id[0])));

sbin/fsirand/fsirand.c

161

(void)printf("fsid: %x %x\n", sblock->fs_id[0],

sbin/fsirand/fsirand.c

162

sblock->fs_id[1]);

sbin/fsirand/fsirand.c

168

sblock->fs_id[0] = (u_int32_t)time(NULL);

sbin/fsirand/fsirand.c

169

sblock->fs_id[1] = arc4random();

sbin/fsirand/fsirand.c

170

if (sbput(devfd, sblock, sblock->fs_ncg) != 0) {

sbin/fsirand/fsirand.c

177

for (cg = 0, inumber = UFS_ROOTINO; cg < (int)sblock->fs_ncg; cg++) {

sbin/fsirand/fsirand.c

179

dblk = fsbtodb(sblock, ino_to_fsba(sblock, inumber));

sbin/fsirand/fsirand.c

192

n < (int)sblock->fs_ipg;

sbin/fsirand/fsirand.c

197

sblock->fs_magic == FS_UFS1_MAGIC ?

sbin/fsirand/fsirand.c

199

} else if (sblock->fs_magic == FS_UFS1_MAGIC) {

sbin/fsirand/fsirand.c

204

ffs_update_dinode_ckhash(sblock, dp2);

sbin/growfs/growfs.c

1001

for (d = sblock.fs_csaddr; d + sblock.fs_frag <=

sbin/growfs/growfs.c

1002

sblock.fs_csaddr + (sblock.fs_cssize / sblock.fs_fsize);

sbin/growfs/growfs.c

1003

d += sblock.fs_frag) {

sbin/growfs/growfs.c

1004

clrblock(&sblock, cg_blksfree(&acg),

sbin/growfs/growfs.c

1005

(d % sblock.fs_fpg) / sblock.fs_frag);

sbin/growfs/growfs.c

1007

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1008

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1010

(d % sblock.fs_fpg) / sblock.fs_frag);

sbin/growfs/growfs.c

1018

if (d < sblock.fs_csaddr + (sblock.fs_cssize / sblock.fs_fsize)) {

sbin/growfs/growfs.c

1019

for (; d - sblock.fs_csaddr <

sbin/growfs/growfs.c

1020

sblock.fs_cssize/sblock.fs_fsize; d++) {

sbin/growfs/growfs.c

1021

clrbit(cg_blksfree(&acg), d % sblock.fs_fpg);

sbin/growfs/growfs.c

1023

sblock.fs_cstotal.cs_nffree--;

sbin/growfs/growfs.c

1026

acg.cg_cs.cs_nffree += sblock.fs_frag;

sbin/growfs/growfs.c

1027

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1028

sblock.fs_cstotal.cs_nffree += sblock.fs_frag;

sbin/growfs/growfs.c

1029

if (sblock.fs_contigsumsize > 0)

sbin/growfs/growfs.c

1031

(d % sblock.fs_fpg) / sblock.fs_frag);

sbin/growfs/growfs.c

1033

frag_adjust(d % sblock.fs_fpg, 1);

sbin/growfs/growfs.c

1055

wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),

sbin/growfs/growfs.c

1056

(size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);

sbin/growfs/growfs.c

1058

DBG_DUMP_CG(&sblock, "new summary cg", &acg);

sbin/growfs/growfs.c

1398

DBG_DUMP_FS(&sblock, "old sblock");

sbin/growfs/growfs.c

140

fscs = (struct csum *)calloc((size_t)1, (size_t)sblock.fs_cssize);

sbin/growfs/growfs.c

1438

sblock.fs_old_size = sblock.fs_size =

sbin/growfs/growfs.c

1440

sblock.fs_providersize = dbtofsb(&osblock, mediasize / DEV_BSIZE);

sbin/growfs/growfs.c

1445

if (osblock.fs_size >= sblock.fs_size) {

sbin/growfs/growfs.c

1447

(intmax_t)osblock.fs_size, (intmax_t)sblock.fs_size);

sbin/growfs/growfs.c

1455

if (sblock.fs_snapinum[j]) {

sbin/growfs/growfs.c

146

sblock.fs_csp = fscs;

sbin/growfs/growfs.c

1460

if (!sblock.fs_snapinum[j]) /* list is dense */

sbin/growfs/growfs.c

1479

sblock.fs_size * sblock.fs_fsize,

sbin/growfs/growfs.c

1515

testbuf = malloc(sblock.fs_fsize);

sbin/growfs/growfs.c

1518

rdfs((ufs2_daddr_t)((size - sblock.fs_fsize) / DEV_BSIZE),

sbin/growfs/growfs.c

1519

sblock.fs_fsize, testbuf, fsi);

sbin/growfs/growfs.c

1520

wtfs((ufs2_daddr_t)((size - sblock.fs_fsize) / DEV_BSIZE),

sbin/growfs/growfs.c

1521

sblock.fs_fsize, testbuf, fso, Nflag);

sbin/growfs/growfs.c

1537

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/growfs/growfs.c

1538

sblock.fs_old_ncyl =

sbin/growfs/growfs.c

1539

sblock.fs_size * sblock.fs_old_nspf / sblock.fs_old_spc;

sbin/growfs/growfs.c

1540

if (sblock.fs_size * sblock.fs_old_nspf >

sbin/growfs/growfs.c

1541

sblock.fs_old_ncyl * sblock.fs_old_spc)

sbin/growfs/growfs.c

1542

sblock.fs_old_ncyl++;

sbin/growfs/growfs.c

1544

sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg);

sbin/growfs/growfs.c

1550

if (sblock.fs_size % sblock.fs_fpg != 0 &&

sbin/growfs/growfs.c

1551

sblock.fs_size <= cgdmin(&sblock, sblock.fs_ncg - 1)) {

sbin/growfs/growfs.c

1553

(sblock.fs_size % sblock.fs_fpg) * sblock.fs_fsize,

sbin/growfs/growfs.c

1557

sblock.fs_ncg--;

sbin/growfs/growfs.c

1558

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/growfs/growfs.c

1559

sblock.fs_old_ncyl = sblock.fs_ncg * sblock.fs_old_cpg;

sbin/growfs/growfs.c

1560

sblock.fs_old_size = sblock.fs_size =

sbin/growfs/growfs.c

1561

sblock.fs_ncg * sblock.fs_fpg;

sbin/growfs/growfs.c

1568

sblock.fs_cssize =

sbin/growfs/growfs.c

1569

fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));

sbin/growfs/growfs.c

1571

if (osblock.fs_size >= sblock.fs_size)

sbin/growfs/growfs.c

1630

if (sblock.fs_contigsumsize < 1) /* no clustering */

sbin/growfs/growfs.c

1644

for (block--; lcs < sblock.fs_contigsumsize; block--, lcs++ ) {

sbin/growfs/growfs.c

1649

if (lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

1667

if ((sblock.fs_metackhash & CK_CYLGRP) == 0)

sbin/growfs/growfs.c

1670

cgp->cg_ckhash = calculate_crc32c(~0L, (void *)cgp, sblock.fs_cgsize);

sbin/growfs/growfs.c

176

(float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,

sbin/growfs/growfs.c

177

(intmax_t)fsbtodb(&sblock, sblock.fs_size), sblock.fs_bsize,

sbin/growfs/growfs.c

178

sblock.fs_fsize);

sbin/growfs/growfs.c

180

sblock.fs_ncg, (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,

sbin/growfs/growfs.c

181

sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);

sbin/growfs/growfs.c

182

if (sblock.fs_flags & FS_DOSOFTDEP)

sbin/growfs/growfs.c

198

for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) {

sbin/growfs/growfs.c

201

(intmax_t)fsbtodb(&sblock, cgsblock(&sblock, cylno)),

sbin/growfs/growfs.c

202

cylno < (sblock.fs_ncg - 1) ? "," : "" );

sbin/growfs/growfs.c

241

sblock.fs_time = modtime;

sbin/growfs/growfs.c

242

sblock.fs_fmod = 0;

sbin/growfs/growfs.c

243

sblock.fs_clean = 1;

sbin/growfs/growfs.c

244

sblock.fs_ronly = 0;

sbin/growfs/growfs.c

245

sblock.fs_cgrotor = 0;

sbin/growfs/growfs.c

246

sblock.fs_state = 0;

sbin/growfs/growfs.c

247

memset((void *)&sblock.fs_fsmnt, 0, sizeof(sblock.fs_fsmnt));

sbin/growfs/growfs.c

253

if (!Nflag && sbput(fso, &sblock, sblock.fs_ncg) != 0)

sbin/growfs/growfs.c

264

for (dbg_csc = 0; dbg_csc < sblock.fs_ncg; dbg_csc++) {

sbin/growfs/growfs.c

267

DBG_DUMP_CSUM(&sblock, dbg_line, dbg_csp++);

sbin/growfs/growfs.c

273

DBG_DUMP_FS(&sblock, "new initial sblock");

sbin/growfs/growfs.c

276

DBG_DUMP_FS(&sblock, "new other sblocks");

sbin/growfs/growfs.c

303

iobufsize = 2 * sblock.fs_bsize;

sbin/growfs/growfs.c

313

cbase = cgbase(&sblock, cylno);

sbin/growfs/growfs.c

314

dmax = cbase + sblock.fs_fpg;

sbin/growfs/growfs.c

315

if (dmax > sblock.fs_size)

sbin/growfs/growfs.c

316

dmax = sblock.fs_size;

sbin/growfs/growfs.c

317

dlower = cgsblock(&sblock, cylno) - cbase;

sbin/growfs/growfs.c

318

dupper = cgdmin(&sblock, cylno) - cbase;

sbin/growfs/growfs.c

320

dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/growfs/growfs.c

322

memset(&acg, 0, sblock.fs_cgsize);

sbin/growfs/growfs.c

326

acg.cg_niblk = sblock.fs_ipg;

sbin/growfs/growfs.c

327

acg.cg_initediblk = MIN(sblock.fs_ipg, 2 * INOPB(&sblock));

sbin/growfs/growfs.c

329

if (sblock.fs_contigsumsize > 0)

sbin/growfs/growfs.c

330

acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;

sbin/growfs/growfs.c

332

if (sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/growfs/growfs.c

335

acg.cg_old_ncyl = sblock.fs_old_cpg;

sbin/growfs/growfs.c

343

sblock.fs_old_cpg * sizeof(int32_t);

sbin/growfs/growfs.c

345

sblock.fs_old_cpg * sizeof(u_int16_t);

sbin/growfs/growfs.c

347

acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);

sbin/growfs/growfs.c

348

acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);

sbin/growfs/growfs.c

349

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

354

(sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);

sbin/growfs/growfs.c

356

howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);

sbin/growfs/growfs.c

358

if (acg.cg_nextfreeoff > (unsigned)sblock.fs_cgsize) {

sbin/growfs/growfs.c

365

acg.cg_cs.cs_nifree += sblock.fs_ipg;

sbin/growfs/growfs.c

377

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/growfs/growfs.c

385

wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno)), iobufsize, iobuf,

sbin/growfs/growfs.c

390

if (sblock.fs_magic == FS_UFS1_MAGIC &&

sbin/growfs/growfs.c

391

sblock.fs_ipg > 2 * INOPB(&sblock)) {

sbin/growfs/growfs.c

392

for (i = 2 * sblock.fs_frag;

sbin/growfs/growfs.c

393

i < sblock.fs_ipg / INOPF(&sblock);

sbin/growfs/growfs.c

394

i += sblock.fs_frag) {

sbin/growfs/growfs.c

396

for (j = 0; j < INOPB(&sblock); j++) {

sbin/growfs/growfs.c

400

wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),

sbin/growfs/growfs.c

401

sblock.fs_bsize, iobuf, fso, Nflag);

sbin/growfs/growfs.c

409

for (d = 0; d < dlower; d += sblock.fs_frag) {

sbin/growfs/growfs.c

410

blkno = d / sblock.fs_frag;

sbin/growfs/growfs.c

411

setblock(&sblock, cg_blksfree(&acg), blkno);

sbin/growfs/growfs.c

412

if (sblock.fs_contigsumsize > 0)

sbin/growfs/growfs.c

416

sblock.fs_dsize += dlower;

sbin/growfs/growfs.c

418

sblock.fs_dsize += acg.cg_ndblk - dupper;

sbin/growfs/growfs.c

419

sblock.fs_old_dsize = sblock.fs_dsize;

sbin/growfs/growfs.c

420

if ((i = dupper % sblock.fs_frag)) {

sbin/growfs/growfs.c

421

acg.cg_frsum[sblock.fs_frag - i]++;

sbin/growfs/growfs.c

422

for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {

sbin/growfs/growfs.c

427

for (d = dupper; d + sblock.fs_frag <= acg.cg_ndblk;

sbin/growfs/growfs.c

428

d += sblock.fs_frag) {

sbin/growfs/growfs.c

429

blkno = d / sblock.fs_frag;

sbin/growfs/growfs.c

430

setblock(&sblock, cg_blksfree(&acg), blkno);

sbin/growfs/growfs.c

431

if (sblock.fs_contigsumsize > 0)

sbin/growfs/growfs.c

442

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

453

if (run > sblock.fs_contigsumsize)

sbin/growfs/growfs.c

454

run = sblock.fs_contigsumsize;

sbin/growfs/growfs.c

466

if (run > sblock.fs_contigsumsize)

sbin/growfs/growfs.c

467

run = sblock.fs_contigsumsize;

sbin/growfs/growfs.c

471

sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;

sbin/growfs/growfs.c

472

sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;

sbin/growfs/growfs.c

473

sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;

sbin/growfs/growfs.c

474

sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;

sbin/growfs/growfs.c

478

wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), sblock.fs_cgsize, &acg,

sbin/growfs/growfs.c

480

DBG_DUMP_CG(&sblock, "new cg", &acg);

sbin/growfs/growfs.c

506

for (f = rounddown(frag, sblock.fs_frag);

sbin/growfs/growfs.c

507

f < roundup(frag + 1, sblock.fs_frag); f++) {

sbin/growfs/growfs.c

514

if (fragsize && fragsize < sblock.fs_frag) {

sbin/growfs/growfs.c

525

if (fragsize && fragsize < sblock.fs_frag) {

sbin/growfs/growfs.c

567

DBG_DUMP_CG(&sblock, "old joining cg", &aocg);

sbin/growfs/growfs.c

580

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/growfs/growfs.c

581

acg.cg_old_ncyl = sblock.fs_old_cpg;

sbin/growfs/growfs.c

584

wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),

sbin/growfs/growfs.c

585

(size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);

sbin/growfs/growfs.c

587

DBG_DUMP_CG(&sblock, "new joining cg", &acg);

sbin/growfs/growfs.c

596

cbase = cgbase(&sblock, cylno);

sbin/growfs/growfs.c

597

dmax = cbase + sblock.fs_fpg;

sbin/growfs/growfs.c

598

if (dmax > sblock.fs_size)

sbin/growfs/growfs.c

599

dmax = sblock.fs_size;

sbin/growfs/growfs.c

611

if ((unsigned)cylno == sblock.fs_ncg - 1) {

sbin/growfs/growfs.c

615

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/growfs/growfs.c

617

sblock.fs_old_ncyl % sblock.fs_old_cpg;

sbin/growfs/growfs.c

619

acg.cg_old_ncyl = sblock.fs_old_cpg;

sbin/growfs/growfs.c

621

DBG_PRINT2("jcg dbg: %d %u", cylno, sblock.fs_ncg);

sbin/growfs/growfs.c

623

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/growfs/growfs.c

624

DBG_PRINT2("%d %u", acg.cg_old_ncyl, sblock.fs_old_cpg);

sbin/growfs/growfs.c

628

sblock.fs_dsize += acg.cg_ndblk - aocg.cg_ndblk;

sbin/growfs/growfs.c

629

sblock.fs_old_dsize = sblock.fs_dsize;

sbin/growfs/growfs.c

630

if (sblock.fs_contigsumsize > 0)

sbin/growfs/growfs.c

631

acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;

sbin/growfs/growfs.c

645

if (osblock.fs_size % sblock.fs_frag) {

sbin/growfs/growfs.c

646

if (roundup(osblock.fs_size, sblock.fs_frag) <=

sbin/growfs/growfs.c

647

sblock.fs_size) {

sbin/growfs/growfs.c

654

sblock.fs_frag) - 1; i >= osblock.fs_size - cbase;

sbin/growfs/growfs.c

666

if (isblock(&sblock, cg_blksfree(&acg),

sbin/growfs/growfs.c

667

((osblock.fs_size - cgbase(&sblock, cylno)) /

sbin/growfs/growfs.c

668

sblock.fs_frag))) {

sbin/growfs/growfs.c

673

acg.cg_frsum[osblock.fs_size % sblock.fs_frag]--;

sbin/growfs/growfs.c

675

acg.cg_cs.cs_nffree -= sblock.fs_frag;

sbin/growfs/growfs.c

677

sblock.fs_frag);

sbin/growfs/growfs.c

679

sblock.fs_frag);

sbin/growfs/growfs.c

688

sblock.fs_frag))) {

sbin/growfs/growfs.c

701

for (i = sblock.fs_size - cbase - 1;

sbin/growfs/growfs.c

713

sblock.fs_frag))) {

sbin/growfs/growfs.c

726

for (i = roundup(osblock.fs_size - cbase, sblock.fs_frag);

sbin/growfs/growfs.c

727

i + sblock.fs_frag <= dmax - cbase; /* XXX <= or only < ? */

sbin/growfs/growfs.c

728

i += sblock.fs_frag) {

sbin/growfs/growfs.c

729

j = i / sblock.fs_frag;

sbin/growfs/growfs.c

730

setblock(&sblock, cg_blksfree(&acg), j);

sbin/growfs/growfs.c

748

sblock.fs_cstotal.cs_nffree +=

sbin/growfs/growfs.c

750

sblock.fs_cstotal.cs_nbfree +=

sbin/growfs/growfs.c

765

wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), (size_t)sblock.fs_cgsize,

sbin/growfs/growfs.c

768

DBG_DUMP_CG(&sblock, "new joining cg", &acg);

sbin/growfs/growfs.c

799

if (howmany(sblock.fs_cssize, sblock.fs_fsize) ==

sbin/growfs/growfs.c

808

sblock.fs_dsize -= howmany(sblock.fs_cssize, sblock.fs_fsize) -

sbin/growfs/growfs.c

810

sblock.fs_old_dsize = sblock.fs_dsize;

sbin/growfs/growfs.c

823

DBG_DUMP_CG(&sblock, "old summary cg", &aocg);

sbin/growfs/growfs.c

859

if (sblock.fs_ncg - osblock.fs_ncg < 2)

sbin/growfs/growfs.c

873

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

874

for (block = howmany(d % sblock.fs_fpg, sblock.fs_frag),

sbin/growfs/growfs.c

875

lcs = 0; lcs < sblock.fs_contigsumsize; block++, lcs++) {

sbin/growfs/growfs.c

887

if ((d + 1) % sblock.fs_frag) {

sbin/growfs/growfs.c

893

frag_adjust(d % sblock.fs_fpg, -1);

sbin/growfs/growfs.c

894

for (; (d + 1) % sblock.fs_frag; d--) {

sbin/growfs/growfs.c

896

setbit(cg_blksfree(&acg), d % sblock.fs_fpg);

sbin/growfs/growfs.c

898

sblock.fs_cstotal.cs_nffree++;

sbin/growfs/growfs.c

905

frag_adjust(d % sblock.fs_fpg, 1);

sbin/growfs/growfs.c

907

if (isblock(&sblock, cg_blksfree(&acg),

sbin/growfs/growfs.c

908

(d % sblock.fs_fpg) / sblock.fs_frag)) {

sbin/growfs/growfs.c

910

acg.cg_cs.cs_nffree -= sblock.fs_frag;

sbin/growfs/growfs.c

912

sblock.fs_cstotal.cs_nffree -= sblock.fs_frag;

sbin/growfs/growfs.c

913

sblock.fs_cstotal.cs_nbfree++;

sbin/growfs/growfs.c

914

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

916

(d % sblock.fs_fpg) / sblock.fs_frag);

sbin/growfs/growfs.c

917

if (lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

933

for (d = rounddown(d, sblock.fs_frag); d >= osblock.fs_csaddr;

sbin/growfs/growfs.c

934

d -= sblock.fs_frag) {

sbin/growfs/growfs.c

937

setblock(&sblock, cg_blksfree(&acg),

sbin/growfs/growfs.c

938

(d % sblock.fs_fpg) / sblock.fs_frag);

sbin/growfs/growfs.c

940

sblock.fs_cstotal.cs_nbfree++;

sbin/growfs/growfs.c

941

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

943

(d % sblock.fs_fpg) / sblock.fs_frag);

sbin/growfs/growfs.c

947

if (lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

962

wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)),

sbin/growfs/growfs.c

963

(size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);

sbin/growfs/growfs.c

965

DBG_DUMP_CG(&sblock, "old summary cg", &acg);

sbin/growfs/growfs.c

971

sblock.fs_csaddr = cgdmin(&sblock, osblock.fs_ncg);

sbin/growfs/growfs.c

972

ncscg = dtog(&sblock, sblock.fs_csaddr);

sbin/growfs/growfs.c

990

rdfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),

sbin/growfs/growfs.c

991

(size_t)sblock.fs_cgsize, (void *)&aocg, fsi);

sbin/growfs/growfs.c

993

DBG_DUMP_CG(&sblock, "new summary cg", &aocg);

sbin/newfs/mkfs.c

1020

bread(&disk, part_ofs + fsbtodb(&sblock, cgtod(&sblock, 0)), (char *)&acg,

sbin/newfs/mkfs.c

1021

sblock.fs_cgsize);

sbin/newfs/mkfs.c

1030

for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag)

sbin/newfs/mkfs.c

1031

if (isblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag))

sbin/newfs/mkfs.c

1036

blkno = fragstoblks(&sblock, d);

sbin/newfs/mkfs.c

1037

clrblock(&sblock, cg_blksfree(&acg), blkno);

sbin/newfs/mkfs.c

1038

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

1041

sblock.fs_cstotal.cs_nbfree--;

sbin/newfs/mkfs.c

1045

sblock.fs_cstotal.cs_ndir++;

sbin/newfs/mkfs.c

1048

if (size != sblock.fs_bsize) {

sbin/newfs/mkfs.c

1049

frag = howmany(size, sblock.fs_fsize);

sbin/newfs/mkfs.c

1050

fscs[0].cs_nffree += sblock.fs_frag - frag;

sbin/newfs/mkfs.c

1051

sblock.fs_cstotal.cs_nffree += sblock.fs_frag - frag;

sbin/newfs/mkfs.c

1052

acg.cg_cs.cs_nffree += sblock.fs_frag - frag;

sbin/newfs/mkfs.c

1053

acg.cg_frsum[sblock.fs_frag - frag]++;

sbin/newfs/mkfs.c

1054

for (i = frag; i < sblock.fs_frag; i++)

sbin/newfs/mkfs.c

1070

bread(&disk, part_ofs + fsbtodb(&sblock, cgtod(&sblock, 0)), (char *)&acg,

sbin/newfs/mkfs.c

1071

sblock.fs_cgsize);

sbin/newfs/mkfs.c

1080

sblock.fs_cstotal.cs_nifree--;

sbin/newfs/mkfs.c

1086

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/newfs/mkfs.c

142

if ((sblock.fs_si = malloc(sizeof(struct fs_summary_info))) == NULL) {

sbin/newfs/mkfs.c

146

sblock.fs_old_flags = FS_FLAGS_UPDATED;

sbin/newfs/mkfs.c

147

sblock.fs_flags = 0;

sbin/newfs/mkfs.c

149

sblock.fs_flags |= FS_DOSOFTDEP;

sbin/newfs/mkfs.c

151

strlcpy(sblock.fs_volname, volumelabel, MAXVOLLEN);

sbin/newfs/mkfs.c

153

sblock.fs_flags |= FS_GJOURNAL;

sbin/newfs/mkfs.c

155

sblock.fs_flags |= FS_MULTILABEL;

sbin/newfs/mkfs.c

157

sblock.fs_flags |= FS_TRIM;

sbin/newfs/mkfs.c

168

(char *)&sblock);

sbin/newfs/mkfs.c

172

sblock.fs_avgfilesize = avgfilesize;

sbin/newfs/mkfs.c

173

sblock.fs_avgfpdir = avgfilesperdir;

sbin/newfs/mkfs.c

174

if (sblock.fs_avgfilesize <= 0)

sbin/newfs/mkfs.c

176

sblock.fs_avgfilesize), exit(14);

sbin/newfs/mkfs.c

177

if (sblock.fs_avgfpdir <= 0)

sbin/newfs/mkfs.c

179

sblock.fs_avgfpdir), exit(15);

sbin/newfs/mkfs.c

185

sblock.fs_bsize = bsize;

sbin/newfs/mkfs.c

186

sblock.fs_fsize = fsize;

sbin/newfs/mkfs.c

187

if (!POWEROF2(sblock.fs_bsize)) {

sbin/newfs/mkfs.c

189

sblock.fs_bsize);

sbin/newfs/mkfs.c

192

if (!POWEROF2(sblock.fs_fsize)) {

sbin/newfs/mkfs.c

194

sblock.fs_fsize);

sbin/newfs/mkfs.c

197

if (sblock.fs_fsize < sectorsize) {

sbin/newfs/mkfs.c

199

sblock.fs_fsize, sectorsize);

sbin/newfs/mkfs.c

200

sblock.fs_fsize = sectorsize;

sbin/newfs/mkfs.c

202

if (sblock.fs_bsize > MAXBSIZE) {

sbin/newfs/mkfs.c

204

sblock.fs_bsize, MAXBSIZE);

sbin/newfs/mkfs.c

205

sblock.fs_bsize = MAXBSIZE;

sbin/newfs/mkfs.c

207

if (sblock.fs_bsize < MINBSIZE) {

sbin/newfs/mkfs.c

209

sblock.fs_bsize, MINBSIZE);

sbin/newfs/mkfs.c

210

sblock.fs_bsize = MINBSIZE;

sbin/newfs/mkfs.c

212

if (sblock.fs_fsize > MAXBSIZE) {

sbin/newfs/mkfs.c

214

sblock.fs_fsize, MAXBSIZE);

sbin/newfs/mkfs.c

215

sblock.fs_fsize = MAXBSIZE;

sbin/newfs/mkfs.c

217

if (sblock.fs_bsize < sblock.fs_fsize) {

sbin/newfs/mkfs.c

219

sblock.fs_bsize, sblock.fs_fsize);

sbin/newfs/mkfs.c

220

sblock.fs_bsize = sblock.fs_fsize;

sbin/newfs/mkfs.c

222

if (sblock.fs_fsize * MAXFRAG < sblock.fs_bsize) {

sbin/newfs/mkfs.c

225

sblock.fs_fsize, MAXFRAG, sblock.fs_bsize / MAXFRAG);

sbin/newfs/mkfs.c

226

sblock.fs_fsize = sblock.fs_bsize / MAXFRAG;

sbin/newfs/mkfs.c

231

sblock.fs_maxbsize = sblock.fs_bsize;

sbin/newfs/mkfs.c

232

printf("Extent size set to %d\n", sblock.fs_maxbsize);

sbin/newfs/mkfs.c

233

} else if (maxbsize > FS_MAXCONTIG * sblock.fs_bsize) {

sbin/newfs/mkfs.c

234

sblock.fs_maxbsize = FS_MAXCONTIG * sblock.fs_bsize;

sbin/newfs/mkfs.c

235

printf("Extent size reduced to %d\n", sblock.fs_maxbsize);

sbin/newfs/mkfs.c

237

sblock.fs_maxbsize = maxbsize;

sbin/newfs/mkfs.c

247

sblock.fs_maxcontig = maxcontig;

sbin/newfs/mkfs.c

248

if (sblock.fs_maxcontig < sblock.fs_maxbsize / sblock.fs_bsize) {

sbin/newfs/mkfs.c

249

sblock.fs_maxcontig = sblock.fs_maxbsize / sblock.fs_bsize;

sbin/newfs/mkfs.c

250

printf("Maxcontig raised to %d\n", sblock.fs_maxbsize);

sbin/newfs/mkfs.c

252

if (sblock.fs_maxcontig > 1)

sbin/newfs/mkfs.c

253

sblock.fs_contigsumsize = MIN(sblock.fs_maxcontig,FS_MAXCONTIG);

sbin/newfs/mkfs.c

254

sblock.fs_bmask = ~(sblock.fs_bsize - 1);

sbin/newfs/mkfs.c

255

sblock.fs_fmask = ~(sblock.fs_fsize - 1);

sbin/newfs/mkfs.c

256

sblock.fs_qbmask = ~sblock.fs_bmask;

sbin/newfs/mkfs.c

257

sblock.fs_qfmask = ~sblock.fs_fmask;

sbin/newfs/mkfs.c

258

sblock.fs_bshift = ilog2(sblock.fs_bsize);

sbin/newfs/mkfs.c

259

sblock.fs_fshift = ilog2(sblock.fs_fsize);

sbin/newfs/mkfs.c

260

sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);

sbin/newfs/mkfs.c

261

sblock.fs_fragshift = ilog2(sblock.fs_frag);

sbin/newfs/mkfs.c

262

if (sblock.fs_frag > MAXFRAG) {

sbin/newfs/mkfs.c

264

sblock.fs_bsize / MAXFRAG);

sbin/newfs/mkfs.c

267

sblock.fs_fsbtodb = ilog2(sblock.fs_fsize / sectorsize);

sbin/newfs/mkfs.c

268

sblock.fs_size = fssize = dbtofsb(&sblock, fssize);

sbin/newfs/mkfs.c

269

sblock.fs_providersize = dbtofsb(&sblock, mediasize / sectorsize);

sbin/newfs/mkfs.c

275

sblock.fs_magic = FS_BAD_MAGIC;

sbin/newfs/mkfs.c

278

sblock.fs_sblockloc = SBLOCK_UFS1;

sbin/newfs/mkfs.c

279

sblock.fs_sblockactualloc = SBLOCK_UFS1;

sbin/newfs/mkfs.c

280

sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs1_daddr_t);

sbin/newfs/mkfs.c

281

sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode);

sbin/newfs/mkfs.c

282

sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *

sbin/newfs/mkfs.c

284

sblock.fs_old_inodefmt = FS_44INODEFMT;

sbin/newfs/mkfs.c

285

sblock.fs_old_cgoffset = 0;

sbin/newfs/mkfs.c

286

sblock.fs_old_cgmask = 0xffffffff;

sbin/newfs/mkfs.c

287

sblock.fs_old_size = sblock.fs_size;

sbin/newfs/mkfs.c

288

sblock.fs_old_rotdelay = 0;

sbin/newfs/mkfs.c

289

sblock.fs_old_rps = 60;

sbin/newfs/mkfs.c

290

sblock.fs_old_nspf = sblock.fs_fsize / sectorsize;

sbin/newfs/mkfs.c

291

sblock.fs_old_cpg = 1;

sbin/newfs/mkfs.c

292

sblock.fs_old_interleave = 1;

sbin/newfs/mkfs.c

293

sblock.fs_old_trackskew = 0;

sbin/newfs/mkfs.c

294

sblock.fs_old_cpc = 0;

sbin/newfs/mkfs.c

295

sblock.fs_old_postblformat = 1;

sbin/newfs/mkfs.c

296

sblock.fs_old_nrpos = 1;

sbin/newfs/mkfs.c

298

sblock.fs_sblockloc = SBLOCK_UFS2;

sbin/newfs/mkfs.c

299

sblock.fs_sblockactualloc = SBLOCK_UFS2;

sbin/newfs/mkfs.c

300

sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs2_daddr_t);

sbin/newfs/mkfs.c

301

sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs2_dinode);

sbin/newfs/mkfs.c

302

sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *

sbin/newfs/mkfs.c

305

sblock.fs_sblkno =

sbin/newfs/mkfs.c

306

roundup(howmany(sblock.fs_sblockloc + SBLOCKSIZE, sblock.fs_fsize),

sbin/newfs/mkfs.c

307

sblock.fs_frag);

sbin/newfs/mkfs.c

308

sblock.fs_cblkno = sblock.fs_sblkno +

sbin/newfs/mkfs.c

309

roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag);

sbin/newfs/mkfs.c

310

sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;

sbin/newfs/mkfs.c

311

sblock.fs_maxfilesize = sblock.fs_bsize * UFS_NDADDR - 1;

sbin/newfs/mkfs.c

312

for (sizepb = sblock.fs_bsize, i = 0; i < UFS_NIADDR; i++) {

sbin/newfs/mkfs.c

313

sizepb *= NINDIR(&sblock);

sbin/newfs/mkfs.c

314

sblock.fs_maxfilesize += sizepb;

sbin/newfs/mkfs.c

321

if (sblock.fs_maxfilesize < (u_quad_t)fssize) {

sbin/newfs/mkfs.c

341

maxinum = (((int64_t)(1)) << 32) - INOPB(&sblock);

sbin/newfs/mkfs.c

353

fragsperinode = MAX(numfrags(&sblock, density), 1);

sbin/newfs/mkfs.c

361

minfpg = fragsperinode * INOPB(&sblock);

sbin/newfs/mkfs.c

362

if (minfpg > sblock.fs_size)

sbin/newfs/mkfs.c

363

minfpg = sblock.fs_size;

sbin/newfs/mkfs.c

364

sblock.fs_ipg = INOPB(&sblock);

sbin/newfs/mkfs.c

365

sblock.fs_fpg = roundup(sblock.fs_iblkno +

sbin/newfs/mkfs.c

366

sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);

sbin/newfs/mkfs.c

367

if (sblock.fs_fpg < minfpg)

sbin/newfs/mkfs.c

368

sblock.fs_fpg = minfpg;

sbin/newfs/mkfs.c

369

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

sbin/newfs/mkfs.c

370

INOPB(&sblock));

sbin/newfs/mkfs.c

371

sblock.fs_fpg = roundup(sblock.fs_iblkno +

sbin/newfs/mkfs.c

372

sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);

sbin/newfs/mkfs.c

373

if (sblock.fs_fpg < minfpg)

sbin/newfs/mkfs.c

374

sblock.fs_fpg = minfpg;

sbin/newfs/mkfs.c

375

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

sbin/newfs/mkfs.c

376

INOPB(&sblock));

sbin/newfs/mkfs.c

377

if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize -

sbin/newfs/mkfs.c

380

density -= sblock.fs_fsize;

sbin/newfs/mkfs.c

391

for ( ; sblock.fs_fpg < maxblkspercg; sblock.fs_fpg += sblock.fs_frag) {

sbin/newfs/mkfs.c

392

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

sbin/newfs/mkfs.c

393

INOPB(&sblock));

sbin/newfs/mkfs.c

394

if (Oflag > 1 || (Oflag == 1 && sblock.fs_ipg <= 0x7fff)) {

sbin/newfs/mkfs.c

395

if (sblock.fs_size / sblock.fs_fpg < MINCYLGRPS)

sbin/newfs/mkfs.c

397

if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize -

sbin/newfs/mkfs.c

400

if (CGSIZE(&sblock) == (unsigned long)sblock.fs_bsize -

sbin/newfs/mkfs.c

404

sblock.fs_fpg -= sblock.fs_frag;

sbin/newfs/mkfs.c

405

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

sbin/newfs/mkfs.c

406

INOPB(&sblock));

sbin/newfs/mkfs.c

415

optimalfpg = sblock.fs_fpg;

sbin/newfs/mkfs.c

417

sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg);

sbin/newfs/mkfs.c

418

lastminfpg = roundup(sblock.fs_iblkno +

sbin/newfs/mkfs.c

419

sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);

sbin/newfs/mkfs.c

420

if (sblock.fs_size < lastminfpg) {

sbin/newfs/mkfs.c

422

(intmax_t)sblock.fs_size, lastminfpg);

sbin/newfs/mkfs.c

425

if (sblock.fs_size % sblock.fs_fpg >= lastminfpg ||

sbin/newfs/mkfs.c

426

sblock.fs_size % sblock.fs_fpg == 0)

sbin/newfs/mkfs.c

428

sblock.fs_fpg -= sblock.fs_frag;

sbin/newfs/mkfs.c

429

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

sbin/newfs/mkfs.c

430

INOPB(&sblock));

sbin/newfs/mkfs.c

432

if (optimalfpg != sblock.fs_fpg)

sbin/newfs/mkfs.c

434

optimalfpg, sblock.fs_fpg, "to enlarge last cyl group");

sbin/newfs/mkfs.c

435

sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock));

sbin/newfs/mkfs.c

436

sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);

sbin/newfs/mkfs.c

438

sblock.fs_old_spc = sblock.fs_fpg * sblock.fs_old_nspf;

sbin/newfs/mkfs.c

439

sblock.fs_old_nsect = sblock.fs_old_spc;

sbin/newfs/mkfs.c

440

sblock.fs_old_npsect = sblock.fs_old_spc;

sbin/newfs/mkfs.c

441

sblock.fs_old_ncyl = sblock.fs_ncg;

sbin/newfs/mkfs.c

446

sblock.fs_csaddr = cgdmin(&sblock, 0);

sbin/newfs/mkfs.c

447

sblock.fs_cssize =

sbin/newfs/mkfs.c

448

fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));

sbin/newfs/mkfs.c

449

fscs = (struct csum *)calloc(1, sblock.fs_cssize);

sbin/newfs/mkfs.c

452

sblock.fs_sbsize = fragroundup(&sblock, sizeof(struct fs));

sbin/newfs/mkfs.c

453

if (sblock.fs_sbsize > SBLOCKSIZE)

sbin/newfs/mkfs.c

454

sblock.fs_sbsize = SBLOCKSIZE;

sbin/newfs/mkfs.c

455

if (sblock.fs_sbsize < realsectorsize)

sbin/newfs/mkfs.c

456

sblock.fs_sbsize = realsectorsize;

sbin/newfs/mkfs.c

457

sblock.fs_minfree = minfree;

sbin/newfs/mkfs.c

458

if (metaspace > 0 && metaspace < sblock.fs_fpg / 2)

sbin/newfs/mkfs.c

459

sblock.fs_metaspace = blknum(&sblock, metaspace);

sbin/newfs/mkfs.c

462

sblock.fs_metaspace = blknum(&sblock,

sbin/newfs/mkfs.c

463

(sblock.fs_fpg * minfree) / 200);

sbin/newfs/mkfs.c

465

sblock.fs_maxbpg = MAXBLKPG(sblock.fs_bsize);

sbin/newfs/mkfs.c

467

sblock.fs_maxbpg = maxbpg;

sbin/newfs/mkfs.c

468

sblock.fs_optim = opt;

sbin/newfs/mkfs.c

469

sblock.fs_cgrotor = 0;

sbin/newfs/mkfs.c

470

sblock.fs_pendingblocks = 0;

sbin/newfs/mkfs.c

471

sblock.fs_pendinginodes = 0;

sbin/newfs/mkfs.c

472

sblock.fs_fmod = 0;

sbin/newfs/mkfs.c

473

sblock.fs_ronly = 0;

sbin/newfs/mkfs.c

474

sblock.fs_state = 0;

sbin/newfs/mkfs.c

475

sblock.fs_clean = 1;

sbin/newfs/mkfs.c

476

sblock.fs_id[0] = (long)utime;

sbin/newfs/mkfs.c

477

sblock.fs_id[1] = newfs_random();

sbin/newfs/mkfs.c

478

sblock.fs_fsmnt[0] = '\0';

sbin/newfs/mkfs.c

479

csfrags = howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/newfs/mkfs.c

480

sblock.fs_dsize = sblock.fs_size - sblock.fs_sblkno -

sbin/newfs/mkfs.c

481

sblock.fs_ncg * (sblock.fs_dblkno - sblock.fs_sblkno);

sbin/newfs/mkfs.c

482

sblock.fs_cstotal.cs_nbfree =

sbin/newfs/mkfs.c

483

fragstoblks(&sblock, sblock.fs_dsize) -

sbin/newfs/mkfs.c

484

howmany(csfrags, sblock.fs_frag);

sbin/newfs/mkfs.c

485

sblock.fs_cstotal.cs_nffree =

sbin/newfs/mkfs.c

486

fragnum(&sblock, sblock.fs_size) +

sbin/newfs/mkfs.c

487

(fragnum(&sblock, csfrags) > 0 ?

sbin/newfs/mkfs.c

488

sblock.fs_frag - fragnum(&sblock, csfrags) : 0);

sbin/newfs/mkfs.c

489

sblock.fs_cstotal.cs_nifree =

sbin/newfs/mkfs.c

490

sblock.fs_ncg * sblock.fs_ipg - UFS_ROOTINO;

sbin/newfs/mkfs.c

491

sblock.fs_cstotal.cs_ndir = 0;

sbin/newfs/mkfs.c

492

sblock.fs_dsize -= csfrags;

sbin/newfs/mkfs.c

493

sblock.fs_time = utime;

sbin/newfs/mkfs.c

495

sblock.fs_old_time = utime;

sbin/newfs/mkfs.c

496

sblock.fs_old_dsize = sblock.fs_dsize;

sbin/newfs/mkfs.c

497

sblock.fs_old_csaddr = sblock.fs_csaddr;

sbin/newfs/mkfs.c

498

sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;

sbin/newfs/mkfs.c

499

sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;

sbin/newfs/mkfs.c

500

sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;

sbin/newfs/mkfs.c

501

sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;

sbin/newfs/mkfs.c

510

sblock.fs_flags |= FS_METACKHASH;

sbin/newfs/mkfs.c

512

sblock.fs_metackhash |= CK_CYLGRP;

sbin/newfs/mkfs.c

514

sblock.fs_metackhash |= CK_SUPERBLOCK;

sbin/newfs/mkfs.c

516

sblock.fs_metackhash |= CK_INODE;

sbin/newfs/mkfs.c

524

fsys, (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,

sbin/newfs/mkfs.c

525

(intmax_t)fsbtodb(&sblock, sblock.fs_size), sblock.fs_bsize,

sbin/newfs/mkfs.c

526

sblock.fs_fsize);

sbin/newfs/mkfs.c

528

sblock.fs_ncg, (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,

sbin/newfs/mkfs.c

529

sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);

sbin/newfs/mkfs.c

530

if (sblock.fs_flags & FS_DOSOFTDEP)

sbin/newfs/mkfs.c

536

sblock.fs_sblockloc / disk.d_bsize,

sbin/newfs/mkfs.c

537

fsbtodb(&sblock, sblock.fs_size) - 1);

sbin/newfs/mkfs.c

538

berase(&disk, sblock.fs_sblockloc / disk.d_bsize,

sbin/newfs/mkfs.c

539

sblock.fs_size * sblock.fs_fsize - sblock.fs_sblockloc);

sbin/newfs/mkfs.c

567

sblock.fs_csp = fscs;

sbin/newfs/mkfs.c

577

sblock.fs_magic = (Oflag != 1) ? FS_UFS2_MAGIC : FS_UFS1_MAGIC;

sbin/newfs/mkfs.c

589

iobufsize = 2 * sblock.fs_bsize;

sbin/newfs/mkfs.c

597

for (cg = 0; cg < sblock.fs_ncg; cg++) {

sbin/newfs/mkfs.c

601

(intmax_t)fsbtodb(&sblock, cgsblock(&sblock, cg)),

sbin/newfs/mkfs.c

602

cg < (sblock.fs_ncg-1) ? "," : "");

sbin/newfs/mkfs.c

622

sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;

sbin/newfs/mkfs.c

623

sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;

sbin/newfs/mkfs.c

624

sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;

sbin/newfs/mkfs.c

625

sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;

sbin/newfs/mkfs.c

641

if (Oflag == 1 && sblock.fs_bsize == 65536)

sbin/newfs/mkfs.c

642

wtfs(fsbtodb(&sblock, cgsblock(&sblock, 0)),

sbin/newfs/mkfs.c

643

sblock.fs_bsize, (char *)&sblock);

sbin/newfs/mkfs.c

656

if (sblock.fs_magic != FS_UFS2_MAGIC) {

sbin/newfs/mkfs.c

659

fsr->fsr_magic = sblock.fs_magic;

sbin/newfs/mkfs.c

660

fsr->fsr_fpg = sblock.fs_fpg;

sbin/newfs/mkfs.c

661

fsr->fsr_fsbtodb = sblock.fs_fsbtodb;

sbin/newfs/mkfs.c

662

fsr->fsr_sblkno = sblock.fs_sblkno;

sbin/newfs/mkfs.c

663

fsr->fsr_ncg = sblock.fs_ncg;

sbin/newfs/mkfs.c

674

pp->p_fsize = sblock.fs_fsize;

sbin/newfs/mkfs.c

675

pp->p_frag = sblock.fs_frag;

sbin/newfs/mkfs.c

676

pp->p_cpg = sblock.fs_fpg;

sbin/newfs/mkfs.c

682

if ((int32_t)CGSIZE(&sblock) > sblock.fs_bsize) {

sbin/newfs/mkfs.c

684

sblock.fs_ipg, sblock.fs_fpg, sblock.fs_contigsumsize);

sbin/newfs/mkfs.c

686

sblock.fs_old_cpg, sizeof(struct cg), CGSIZE(&sblock));

sbin/newfs/mkfs.c

689

maxblkspercg = fragstoblks(&sblock, sblock.fs_fpg) - 1;

sbin/newfs/mkfs.c

714

cbase = cgbase(&sblock, cylno);

sbin/newfs/mkfs.c

715

dmax = cbase + sblock.fs_fpg;

sbin/newfs/mkfs.c

716

if (dmax > sblock.fs_size)

sbin/newfs/mkfs.c

717

dmax = sblock.fs_size;

sbin/newfs/mkfs.c

718

dlower = cgsblock(&sblock, cylno) - cbase;

sbin/newfs/mkfs.c

719

dupper = cgdmin(&sblock, cylno) - cbase;

sbin/newfs/mkfs.c

721

dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/newfs/mkfs.c

723

memset(&acg, 0, sblock.fs_cgsize);

sbin/newfs/mkfs.c

727

acg.cg_niblk = sblock.fs_ipg;

sbin/newfs/mkfs.c

728

acg.cg_initediblk = MIN(sblock.fs_ipg, 2 * INOPB(&sblock));

sbin/newfs/mkfs.c

730

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

731

acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;

sbin/newfs/mkfs.c

736

acg.cg_old_ncyl = sblock.fs_old_cpg;

sbin/newfs/mkfs.c

744

sblock.fs_old_cpg * sizeof(int32_t);

sbin/newfs/mkfs.c

746

sblock.fs_old_cpg * sizeof(u_int16_t);

sbin/newfs/mkfs.c

748

acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);

sbin/newfs/mkfs.c

749

acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);

sbin/newfs/mkfs.c

750

if (sblock.fs_contigsumsize > 0) {

sbin/newfs/mkfs.c

755

(sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);

sbin/newfs/mkfs.c

757

howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);

sbin/newfs/mkfs.c

759

if (acg.cg_nextfreeoff > (unsigned)sblock.fs_cgsize) {

sbin/newfs/mkfs.c

761

acg.cg_nextfreeoff - (unsigned)sblock.fs_cgsize);

sbin/newfs/mkfs.c

764

acg.cg_cs.cs_nifree += sblock.fs_ipg;

sbin/newfs/mkfs.c

775

for (d = 0; d < dlower; d += sblock.fs_frag) {

sbin/newfs/mkfs.c

776

blkno = d / sblock.fs_frag;

sbin/newfs/mkfs.c

777

setblock(&sblock, cg_blksfree(&acg), blkno);

sbin/newfs/mkfs.c

778

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

783

if ((i = dupper % sblock.fs_frag)) {

sbin/newfs/mkfs.c

784

acg.cg_frsum[sblock.fs_frag - i]++;

sbin/newfs/mkfs.c

785

for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {

sbin/newfs/mkfs.c

790

for (d = dupper; d + sblock.fs_frag <= acg.cg_ndblk;

sbin/newfs/mkfs.c

791

d += sblock.fs_frag) {

sbin/newfs/mkfs.c

792

blkno = d / sblock.fs_frag;

sbin/newfs/mkfs.c

793

setblock(&sblock, cg_blksfree(&acg), blkno);

sbin/newfs/mkfs.c

794

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

805

if (sblock.fs_contigsumsize > 0) {

sbin/newfs/mkfs.c

816

if (run > sblock.fs_contigsumsize)

sbin/newfs/mkfs.c

817

run = sblock.fs_contigsumsize;

sbin/newfs/mkfs.c

829

if (run > sblock.fs_contigsumsize)

sbin/newfs/mkfs.c

830

run = sblock.fs_contigsumsize;

sbin/newfs/mkfs.c

839

savedactualloc = sblock.fs_sblockactualloc;

sbin/newfs/mkfs.c

840

sblock.fs_sblockactualloc =

sbin/newfs/mkfs.c

841

dbtob(fsbtodb(&sblock, cgsblock(&sblock, cylno)));

sbin/newfs/mkfs.c

844

sblock.fs_sblockactualloc = savedactualloc;

sbin/newfs/mkfs.c

851

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/newfs/mkfs.c

859

wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno)), iobufsize, iobuf);

sbin/newfs/mkfs.c

864

for (i = 2 * sblock.fs_frag;

sbin/newfs/mkfs.c

865

i < sblock.fs_ipg / INOPF(&sblock);

sbin/newfs/mkfs.c

866

i += sblock.fs_frag) {

sbin/newfs/mkfs.c

868

for (j = 0; j < INOPB(&sblock); j++) {

sbin/newfs/mkfs.c

872

wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),

sbin/newfs/mkfs.c

873

sblock.fs_bsize, &iobuf[start]);

sbin/newfs/mkfs.c

912

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/newfs/mkfs.c

925

node.dp1.di_db[0] = alloc(sblock.fs_fsize, node.dp1.di_mode);

sbin/newfs/mkfs.c

927

btodb(fragroundup(&sblock, node.dp1.di_size));

sbin/newfs/mkfs.c

928

wtfs(fsbtodb(&sblock, node.dp1.di_db[0]), sblock.fs_fsize,

sbin/newfs/mkfs.c

93

((sblock.fs_magic == FS_UFS1_MAGIC) ? \

sbin/newfs/mkfs.c

940

alloc(sblock.fs_fsize, node.dp1.di_mode);

sbin/newfs/mkfs.c

942

btodb(fragroundup(&sblock, node.dp1.di_size));

sbin/newfs/mkfs.c

944

wtfs(fsbtodb(&sblock, node.dp1.di_db[0]),

sbin/newfs/mkfs.c

945

sblock.fs_fsize, iobuf);

sbin/newfs/mkfs.c

962

node.dp2.di_db[0] = alloc(sblock.fs_fsize, node.dp2.di_mode);

sbin/newfs/mkfs.c

964

btodb(fragroundup(&sblock, node.dp2.di_size));

sbin/newfs/mkfs.c

965

wtfs(fsbtodb(&sblock, node.dp2.di_db[0]), sblock.fs_fsize,

sbin/newfs/mkfs.c

977

alloc(sblock.fs_fsize, node.dp2.di_mode);

sbin/newfs/mkfs.c

979

btodb(fragroundup(&sblock, node.dp2.di_size));

sbin/newfs/mkfs.c

981

wtfs(fsbtodb(&sblock, node.dp2.di_db[0]),

sbin/newfs/mkfs.c

982

sblock.fs_fsize, iobuf);

sbin/quotacheck/quotacheck.c

316

bcopy(fs, &sblock, fs->fs_sbsize);

sbin/quotacheck/quotacheck.c

318

dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);

sbin/quotacheck/quotacheck.c

319

maxino = sblock.fs_ncg * sblock.fs_ipg;

sbin/quotacheck/quotacheck.c

320

for (cg = 0; cg < sblock.fs_ncg; cg++) {

sbin/quotacheck/quotacheck.c

321

ino = cg * sblock.fs_ipg;

sbin/quotacheck/quotacheck.c

323

blkread(fsbtodb(&sblock, cgtod(&sblock, cg)), (char *)(&cgblk),

sbin/quotacheck/quotacheck.c

324

sblock.fs_cgsize);

sbin/quotacheck/quotacheck.c

325

if (sblock.fs_magic == FS_UFS2_MAGIC)

sbin/quotacheck/quotacheck.c

328

inosused = sblock.fs_ipg;

sbin/quotacheck/quotacheck.c

336

if (sblock.fs_flags & FS_DOSOFTDEP) {

sbin/quotacheck/quotacheck.c

590

dblk = fsbtodb(&sblock, ino_to_fsba(&sblock, lastinum));

sbin/quotacheck/quotacheck.c

606

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/quotacheck/quotacheck.c

620

if (inum % sblock.fs_ipg != 0)

sbin/quotacheck/quotacheck.c

622

lastvalidinum = inum + sblock.fs_ipg - 1;

sbin/quotacheck/quotacheck.c

628

inobufsize = blkroundup(&sblock, INOBUFSIZE);

sbin/quotacheck/quotacheck.c

629

fullcnt = inobufsize / ((sblock.fs_magic == FS_UFS1_MAGIC) ?

sbin/quotacheck/quotacheck.c

631

readpercg = sblock.fs_ipg / fullcnt;

sbin/quotacheck/quotacheck.c

632

partialcnt = sblock.fs_ipg % fullcnt;

sbin/quotacheck/quotacheck.c

633

partialsize = partialcnt * ((sblock.fs_magic == FS_UFS1_MAGIC) ?

sbin/quotacheck/quotacheck.c

81

((sblock.fs_magic == FS_UFS1_MAGIC) ? \

sbin/tunefs/tunefs.c

1021

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/tunefs/tunefs.c

1038

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/tunefs/tunefs.c

1046

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/tunefs/tunefs.c

1047

dp.dp1->di_blocks *= sblock.fs_bsize / disk.d_bsize;

sbin/tunefs/tunefs.c

1049

dp.dp2->di_blocks *= sblock.fs_bsize / disk.d_bsize;

sbin/tunefs/tunefs.c

1065

sblock.fs_sujfree = 0;

sbin/tunefs/tunefs.c

1090

(sblock.fs_flags & FS_ACLS)? "enabled" : "disabled");

sbin/tunefs/tunefs.c

1092

(sblock.fs_flags & FS_NFS4ACLS)? "enabled" : "disabled");

sbin/tunefs/tunefs.c

1094

(sblock.fs_flags & FS_MULTILABEL)? "enabled" : "disabled");

sbin/tunefs/tunefs.c

1096

(sblock.fs_flags & FS_DOSOFTDEP)? "enabled" : "disabled");

sbin/tunefs/tunefs.c

1098

(sblock.fs_flags & FS_SUJ)? "enabled" : "disabled");

sbin/tunefs/tunefs.c

1100

(sblock.fs_flags & FS_GJOURNAL)? "enabled" : "disabled");

sbin/tunefs/tunefs.c

1102

(sblock.fs_flags & FS_TRIM)? "enabled" : "disabled");

sbin/tunefs/tunefs.c

1104

sblock.fs_maxbpg);

sbin/tunefs/tunefs.c

1106

sblock.fs_avgfilesize);

sbin/tunefs/tunefs.c

1108

sblock.fs_avgfpdir);

sbin/tunefs/tunefs.c

1110

sblock.fs_minfree);

sbin/tunefs/tunefs.c

1112

sblock.fs_metaspace);

sbin/tunefs/tunefs.c

1114

sblock.fs_optim == FS_OPTSPACE ? "space" : "time");

sbin/tunefs/tunefs.c

1115

if (sblock.fs_minfree >= MINFREE &&

sbin/tunefs/tunefs.c

1116

sblock.fs_optim == FS_OPTSPACE)

sbin/tunefs/tunefs.c

1118

if (sblock.fs_minfree < MINFREE &&

sbin/tunefs/tunefs.c

1119

sblock.fs_optim == FS_OPTTIME)

sbin/tunefs/tunefs.c

1122

sblock.fs_volname);

sbin/tunefs/tunefs.c

306

if ((sblock.fs_clean == 0 ||

sbin/tunefs/tunefs.c

307

(sblock.fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) != 0) &&

sbin/tunefs/tunefs.c

316

strncpy(sblock.fs_volname, Lvalue, MAXVOLLEN);

sbin/tunefs/tunefs.c

321

if (sblock.fs_flags & FS_ACLS) {

sbin/tunefs/tunefs.c

323

} else if (sblock.fs_flags & FS_NFS4ACLS) {

sbin/tunefs/tunefs.c

327

sblock.fs_flags |= FS_ACLS;

sbin/tunefs/tunefs.c

331

if ((~sblock.fs_flags & FS_ACLS) ==

sbin/tunefs/tunefs.c

336

sblock.fs_flags &= ~FS_ACLS;

sbin/tunefs/tunefs.c

343

if (sblock.fs_maxbpg == evalue)

sbin/tunefs/tunefs.c

347

name, sblock.fs_maxbpg, evalue);

sbin/tunefs/tunefs.c

348

sblock.fs_maxbpg = evalue;

sbin/tunefs/tunefs.c

353

if (sblock.fs_avgfilesize == (unsigned)fvalue) {

sbin/tunefs/tunefs.c

358

name, sblock.fs_avgfilesize, fvalue);

sbin/tunefs/tunefs.c

359

sblock.fs_avgfilesize = fvalue;

sbin/tunefs/tunefs.c

365

if ((sblock.fs_flags & (FS_DOSOFTDEP | FS_SUJ)) ==

sbin/tunefs/tunefs.c

368

} else if (sblock.fs_flags & FS_GJOURNAL) {

sbin/tunefs/tunefs.c

371

} else if (sblock.fs_clean == 0) {

sbin/tunefs/tunefs.c

377

sblock.fs_flags |= FS_DOSOFTDEP | FS_SUJ;

sbin/tunefs/tunefs.c

381

if ((~sblock.fs_flags & FS_SUJ) == FS_SUJ) {

sbin/tunefs/tunefs.c

385

sblock.fs_flags &= ~FS_SUJ;

sbin/tunefs/tunefs.c

386

sblock.fs_sujfree = 0;

sbin/tunefs/tunefs.c

397

if (sblock.fs_flags & FS_GJOURNAL) {

sbin/tunefs/tunefs.c

399

} if (sblock.fs_flags & FS_DOSOFTDEP) {

sbin/tunefs/tunefs.c

403

sblock.fs_flags |= FS_GJOURNAL;

sbin/tunefs/tunefs.c

407

if ((~sblock.fs_flags & FS_GJOURNAL) ==

sbin/tunefs/tunefs.c

412

sblock.fs_flags &= ~FS_GJOURNAL;

sbin/tunefs/tunefs.c

419

if (sblock.fs_metaspace == kvalue) {

sbin/tunefs/tunefs.c

422

kvalue = blknum(&sblock, kvalue);

sbin/tunefs/tunefs.c

423

if (kvalue > sblock.fs_fpg / 2) {

sbin/tunefs/tunefs.c

424

kvalue = blknum(&sblock, sblock.fs_fpg / 2);

sbin/tunefs/tunefs.c

429

name, sblock.fs_metaspace, kvalue);

sbin/tunefs/tunefs.c

430

sblock.fs_metaspace = kvalue;

sbin/tunefs/tunefs.c

436

if (sblock.fs_flags & FS_MULTILABEL) {

sbin/tunefs/tunefs.c

439

sblock.fs_flags |= FS_MULTILABEL;

sbin/tunefs/tunefs.c

443

if ((~sblock.fs_flags & FS_MULTILABEL) ==

sbin/tunefs/tunefs.c

448

sblock.fs_flags &= ~FS_MULTILABEL;

sbin/tunefs/tunefs.c

455

if (sblock.fs_minfree == mvalue)

sbin/tunefs/tunefs.c

459

name, sblock.fs_minfree, mvalue);

sbin/tunefs/tunefs.c

460

sblock.fs_minfree = mvalue;

sbin/tunefs/tunefs.c

461

if (mvalue >= MINFREE && sblock.fs_optim == FS_OPTSPACE)

sbin/tunefs/tunefs.c

463

if (mvalue < MINFREE && sblock.fs_optim == FS_OPTTIME)

sbin/tunefs/tunefs.c

470

if (sblock.fs_flags & FS_NFS4ACLS) {

sbin/tunefs/tunefs.c

472

} else if (sblock.fs_flags & FS_ACLS) {

sbin/tunefs/tunefs.c

476

sblock.fs_flags |= FS_NFS4ACLS;

sbin/tunefs/tunefs.c

480

if ((~sblock.fs_flags & FS_NFS4ACLS) ==

sbin/tunefs/tunefs.c

485

sblock.fs_flags &= ~FS_NFS4ACLS;

sbin/tunefs/tunefs.c

493

if (sblock.fs_flags & FS_DOSOFTDEP) {

sbin/tunefs/tunefs.c

495

} else if (sblock.fs_flags & FS_GJOURNAL) {

sbin/tunefs/tunefs.c

498

} else if (sblock.fs_clean == 0) {

sbin/tunefs/tunefs.c

502

sblock.fs_flags |= FS_DOSOFTDEP;

sbin/tunefs/tunefs.c

506

if ((~sblock.fs_flags & FS_DOSOFTDEP) == FS_DOSOFTDEP)

sbin/tunefs/tunefs.c

509

sblock.fs_flags &= ~FS_DOSOFTDEP;

sbin/tunefs/tunefs.c

518

if (sblock.fs_optim == ovalue)

sbin/tunefs/tunefs.c

522

name, chg[sblock.fs_optim], chg[ovalue]);

sbin/tunefs/tunefs.c

523

sblock.fs_optim = ovalue;

sbin/tunefs/tunefs.c

524

if (sblock.fs_minfree >= MINFREE &&

sbin/tunefs/tunefs.c

527

if (sblock.fs_minfree < MINFREE && ovalue == FS_OPTTIME)

sbin/tunefs/tunefs.c

533

if (sblock.fs_avgfpdir == (unsigned)svalue) {

sbin/tunefs/tunefs.c

538

name, sblock.fs_avgfpdir, svalue);

sbin/tunefs/tunefs.c

539

sblock.fs_avgfpdir = svalue;

sbin/tunefs/tunefs.c

545

if (sblock.fs_flags & FS_TRIM)

sbin/tunefs/tunefs.c

548

sblock.fs_flags |= FS_TRIM;

sbin/tunefs/tunefs.c

552

if ((~sblock.fs_flags & FS_TRIM) == FS_TRIM)

sbin/tunefs/tunefs.c

555

sblock.fs_flags &= ~FS_TRIM;

sbin/tunefs/tunefs.c

627

if (bwrite(&disk, fsbtodb(&sblock, blk), clrbuf,

sbin/tunefs/tunefs.c

628

sblock.fs_bsize) <= 0) {

sbin/tunefs/tunefs.c

645

if (bread(&disk, fsbtodb(&sblock, blk), &block, bytes) <= 0) {

sbin/tunefs/tunefs.c

681

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/tunefs/tunefs.c

682

if ((off_t)dp.dp1->di_size >= lblktosize(&sblock, UFS_NDADDR)) {

sbin/tunefs/tunefs.c

690

sblksize(&sblock, (off_t)dp.dp1->di_size, i))) != 0)

sbin/tunefs/tunefs.c

694

if ((off_t)dp.dp2->di_size >= lblktosize(&sblock, UFS_NDADDR)) {

sbin/tunefs/tunefs.c

702

sblksize(&sblock, (off_t)dp.dp2->di_size, i))) != 0)

sbin/tunefs/tunefs.c

715

for (; off < sblock.fs_bsize; off += DIRBLKSIZ) {

sbin/tunefs/tunefs.c

735

assert((size_t)sblock.fs_bsize <= sizeof(block));

sbin/tunefs/tunefs.c

736

if (bread(&disk, fsbtodb(&sblock, blk), &block, sblock.fs_bsize) <= 0) {

sbin/tunefs/tunefs.c

741

bzero(block.buf + off, sblock.fs_bsize - off);

sbin/tunefs/tunefs.c

749

if (bwrite(&disk, fsbtodb(&sblock, blk), &block, sblock.fs_bsize) <= 0) {

sbin/tunefs/tunefs.c

765

assert((size_t)sblock.fs_bsize <= sizeof(block));

sbin/tunefs/tunefs.c

766

if (bread(&disk, fsbtodb(&sblock, blk), &block,

sbin/tunefs/tunefs.c

767

roundup(size, sblock.fs_fsize)) <= 0) {

sbin/tunefs/tunefs.c

772

if (bwrite(&disk, fsbtodb(&sblock, nblk), &block, sblock.fs_bsize)

sbin/tunefs/tunefs.c

811

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/tunefs/tunefs.c

812

lbn = lblkno(&sblock, dp.dp1->di_size);

sbin/tunefs/tunefs.c

813

off = blkoff(&sblock, dp.dp1->di_size);

sbin/tunefs/tunefs.c

815

size = sblksize(&sblock, (off_t)dp.dp1->di_size, lbn);

sbin/tunefs/tunefs.c

817

lbn = lblkno(&sblock, dp.dp2->di_size);

sbin/tunefs/tunefs.c

818

off = blkoff(&sblock, dp.dp2->di_size);

sbin/tunefs/tunefs.c

820

size = sblksize(&sblock, (off_t)dp.dp2->di_size, lbn);

sbin/tunefs/tunefs.c

830

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/tunefs/tunefs.c

831

dp.dp1->di_blocks += (sblock.fs_bsize - size) / DEV_BSIZE;

sbin/tunefs/tunefs.c

833

dp.dp1->di_size = lblktosize(&sblock, lbn+1);

sbin/tunefs/tunefs.c

835

dp.dp2->di_blocks += (sblock.fs_bsize - size) / DEV_BSIZE;

sbin/tunefs/tunefs.c

837

dp.dp2->di_size = lblktosize(&sblock, lbn+1);

sbin/tunefs/tunefs.c

871

for (int i = 0; i < NINDIR(&sblock) && *resid != 0; i++) {

sbin/tunefs/tunefs.c

876

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/tunefs/tunefs.c

888

if (bwrite(&disk, fsbtodb(&sblock, blk), indir.buf,

sbin/tunefs/tunefs.c

889

sblock.fs_bsize) <= 0) {

sbin/tunefs/tunefs.c

915

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/tunefs/tunefs.c

960

size = (sblock.fs_size * sblock.fs_bsize) / 1024;

sbin/tunefs/tunefs.c

961

if (size / sblock.fs_fsize > sblock.fs_fpg)

sbin/tunefs/tunefs.c

962

size = sblock.fs_fpg * sblock.fs_fsize;

sbin/tunefs/tunefs.c

966

size = roundup(size, sblock.fs_bsize);

sbin/tunefs/tunefs.c

967

resid = blocks = size / sblock.fs_bsize;

sbin/tunefs/tunefs.c

968

if (sblock.fs_cstotal.cs_nbfree < blocks) {

sbin/tunefs/tunefs.c

995

if (sblock.fs_magic == FS_UFS1_MAGIC) {

stand/libsa/ufs.c

149

int ffs_sbget(void *devfd, struct fs **fsp, off_t sblock, int flags,

stand/uboot/copy.c

102

sblock = roundup2((uint64_t)si->mr[i].start,

stand/uboot/copy.c

107

sblock += KERN_MINADDR;

stand/uboot/copy.c

108

if (subldr >= sblock && subldr < eblock) {

stand/uboot/copy.c

109

if (subldr - sblock > eblock - eubldr) {

stand/uboot/copy.c

110

this_block = sblock;

stand/uboot/copy.c

111

this_size = subldr - sblock;

stand/uboot/copy.c

116

} else if (subldr < sblock && eubldr < eblock) {

stand/uboot/copy.c

118

this_block = (eubldr < sblock) ? sblock : eubldr;

stand/uboot/copy.c

67

uint64_t sblock, eblock, subldr, eubldr;

sys/ufs/ffs/ffs_subr.c

152

ffs_sbget(void *devfd, struct fs **fsp, off_t sblock, int flags,

sys/ufs/ffs/ffs_subr.c

166

if (sblock != UFS_STDSB) {

sys/ufs/ffs/ffs_subr.c

167

if ((error = readsuper(devfd, &fs, sblock,

tools/test/stress2/tools/zapsb.c

34

char *fs, sblock[SBLOCKSIZE];

tools/test/stress2/tools/zapsb.c

49

if (read(fd, sblock, sizeof(sblock)) != sizeof(sblock))

tools/test/stress2/tools/zapsb.c

51

sbp = (struct fs *)sblock;

tools/test/stress2/tools/zapsb.c

71

if (write(fd, sblock, sizeof(sblock)) != sizeof(sblock))

tools/tools/find-sb/find-sb.c

108

} else if (u.sblock.fs_magic == FS_UFS2_MAGIC) {

tools/tools/find-sb/find-sb.c

25

struct fs sblock;

tools/tools/find-sb/find-sb.c

93

if (u.sblock.fs_magic == FS_UFS1_MAGIC) {

usr.sbin/makefs/ffs/mkfs.c

163

strlcpy((char *)sblock.fs_volname, ffs_opts->label,

usr.sbin/makefs/ffs/mkfs.c

164

sizeof(sblock.fs_volname));

usr.sbin/makefs/ffs/mkfs.c

167

sblock.fs_old_inodefmt = FS_42INODEFMT;

usr.sbin/makefs/ffs/mkfs.c

168

sblock.fs_maxsymlinklen = 0;

usr.sbin/makefs/ffs/mkfs.c

169

sblock.fs_old_flags = 0;

usr.sbin/makefs/ffs/mkfs.c

171

sblock.fs_old_inodefmt = FS_44INODEFMT;

usr.sbin/makefs/ffs/mkfs.c

172

sblock.fs_maxsymlinklen = (Oflag == 1 ? UFS1_MAXSYMLINKLEN :

usr.sbin/makefs/ffs/mkfs.c

174

sblock.fs_old_flags = FS_FLAGS_UPDATED;

usr.sbin/makefs/ffs/mkfs.c

175

sblock.fs_flags = 0;

usr.sbin/makefs/ffs/mkfs.c

186

ffs_wtfs(fssize - 1, sectorsize, (char *)&sblock, fsopts);

usr.sbin/makefs/ffs/mkfs.c

191

sblock.fs_avgfilesize = avgfilesize;

usr.sbin/makefs/ffs/mkfs.c

192

sblock.fs_avgfpdir = avgfpdir;

usr.sbin/makefs/ffs/mkfs.c

193

if (sblock.fs_avgfilesize <= 0)

usr.sbin/makefs/ffs/mkfs.c

195

sblock.fs_avgfilesize), exit(14);

usr.sbin/makefs/ffs/mkfs.c

196

if (sblock.fs_avgfpdir <= 0)

usr.sbin/makefs/ffs/mkfs.c

198

sblock.fs_avgfpdir), exit(15);

usr.sbin/makefs/ffs/mkfs.c

202

sblock.fs_bsize = bsize;

usr.sbin/makefs/ffs/mkfs.c

203

sblock.fs_fsize = fsize;

usr.sbin/makefs/ffs/mkfs.c

204

if (!POWEROF2(sblock.fs_bsize)) {

usr.sbin/makefs/ffs/mkfs.c

206

sblock.fs_bsize);

usr.sbin/makefs/ffs/mkfs.c

209

if (!POWEROF2(sblock.fs_fsize)) {

usr.sbin/makefs/ffs/mkfs.c

211

sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

214

if (sblock.fs_fsize < sectorsize) {

usr.sbin/makefs/ffs/mkfs.c

216

sblock.fs_fsize, sectorsize);

usr.sbin/makefs/ffs/mkfs.c

219

if (sblock.fs_bsize < MINBSIZE) {

usr.sbin/makefs/ffs/mkfs.c

221

sblock.fs_bsize, MINBSIZE);

usr.sbin/makefs/ffs/mkfs.c

224

if (sblock.fs_bsize > FFS_MAXBSIZE) {

usr.sbin/makefs/ffs/mkfs.c

226

sblock.fs_bsize, FFS_MAXBSIZE);

usr.sbin/makefs/ffs/mkfs.c

229

if (sblock.fs_bsize < sblock.fs_fsize) {

usr.sbin/makefs/ffs/mkfs.c

231

sblock.fs_bsize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

236

sblock.fs_maxbsize = sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

237

printf("Extent size set to %d\n", sblock.fs_maxbsize);

usr.sbin/makefs/ffs/mkfs.c

238

} else if (sblock.fs_maxbsize > FS_MAXCONTIG * sblock.fs_bsize) {

usr.sbin/makefs/ffs/mkfs.c

239

sblock.fs_maxbsize = FS_MAXCONTIG * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

240

printf("Extent size reduced to %d\n", sblock.fs_maxbsize);

usr.sbin/makefs/ffs/mkfs.c

242

sblock.fs_maxbsize = maxbsize;

usr.sbin/makefs/ffs/mkfs.c

244

sblock.fs_maxcontig = maxcontig;

usr.sbin/makefs/ffs/mkfs.c

245

if (sblock.fs_maxcontig < sblock.fs_maxbsize / sblock.fs_bsize) {

usr.sbin/makefs/ffs/mkfs.c

246

sblock.fs_maxcontig = sblock.fs_maxbsize / sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

247

printf("Maxcontig raised to %d\n", sblock.fs_maxbsize);

usr.sbin/makefs/ffs/mkfs.c

250

if (sblock.fs_maxcontig > 1)

usr.sbin/makefs/ffs/mkfs.c

251

sblock.fs_contigsumsize = MIN(sblock.fs_maxcontig,FS_MAXCONTIG);

usr.sbin/makefs/ffs/mkfs.c

253

sblock.fs_bmask = ~(sblock.fs_bsize - 1);

usr.sbin/makefs/ffs/mkfs.c

254

sblock.fs_fmask = ~(sblock.fs_fsize - 1);

usr.sbin/makefs/ffs/mkfs.c

255

sblock.fs_qbmask = ~sblock.fs_bmask;

usr.sbin/makefs/ffs/mkfs.c

256

sblock.fs_qfmask = ~sblock.fs_fmask;

usr.sbin/makefs/ffs/mkfs.c

257

for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1)

usr.sbin/makefs/ffs/mkfs.c

258

sblock.fs_bshift++;

usr.sbin/makefs/ffs/mkfs.c

259

for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1)

usr.sbin/makefs/ffs/mkfs.c

260

sblock.fs_fshift++;

usr.sbin/makefs/ffs/mkfs.c

261

sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);

usr.sbin/makefs/ffs/mkfs.c

262

for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1)

usr.sbin/makefs/ffs/mkfs.c

263

sblock.fs_fragshift++;

usr.sbin/makefs/ffs/mkfs.c

264

if (sblock.fs_frag > MAXFRAG) {

usr.sbin/makefs/ffs/mkfs.c

267

sblock.fs_fsize, sblock.fs_bsize,

usr.sbin/makefs/ffs/mkfs.c

268

sblock.fs_bsize / MAXFRAG);

usr.sbin/makefs/ffs/mkfs.c

271

sblock.fs_fsbtodb = ilog2(sblock.fs_fsize / sectorsize);

usr.sbin/makefs/ffs/mkfs.c

272

sblock.fs_size = sblock.fs_providersize = fssize =

usr.sbin/makefs/ffs/mkfs.c

273

dbtofsb(&sblock, fssize);

usr.sbin/makefs/ffs/mkfs.c

276

sblock.fs_magic = FS_UFS1_MAGIC;

usr.sbin/makefs/ffs/mkfs.c

277

sblock.fs_sblockloc = SBLOCK_UFS1;

usr.sbin/makefs/ffs/mkfs.c

278

sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs1_daddr_t);

usr.sbin/makefs/ffs/mkfs.c

279

sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode);

usr.sbin/makefs/ffs/mkfs.c

280

sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *

usr.sbin/makefs/ffs/mkfs.c

282

sblock.fs_old_inodefmt = FS_44INODEFMT;

usr.sbin/makefs/ffs/mkfs.c

283

sblock.fs_old_cgoffset = 0;

usr.sbin/makefs/ffs/mkfs.c

284

sblock.fs_old_cgmask = 0xffffffff;

usr.sbin/makefs/ffs/mkfs.c

285

sblock.fs_old_size = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

286

sblock.fs_old_rotdelay = 0;

usr.sbin/makefs/ffs/mkfs.c

287

sblock.fs_old_rps = 60;

usr.sbin/makefs/ffs/mkfs.c

288

sblock.fs_old_nspf = sblock.fs_fsize / sectorsize;

usr.sbin/makefs/ffs/mkfs.c

289

sblock.fs_old_cpg = 1;

usr.sbin/makefs/ffs/mkfs.c

290

sblock.fs_old_interleave = 1;

usr.sbin/makefs/ffs/mkfs.c

291

sblock.fs_old_trackskew = 0;

usr.sbin/makefs/ffs/mkfs.c

292

sblock.fs_old_cpc = 0;

usr.sbin/makefs/ffs/mkfs.c

293

sblock.fs_old_postblformat = 1;

usr.sbin/makefs/ffs/mkfs.c

294

sblock.fs_old_nrpos = 1;

usr.sbin/makefs/ffs/mkfs.c

296

sblock.fs_magic = FS_UFS2_MAGIC;

usr.sbin/makefs/ffs/mkfs.c

297

sblock.fs_sblockloc = SBLOCK_UFS2;

usr.sbin/makefs/ffs/mkfs.c

298

sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs2_daddr_t);

usr.sbin/makefs/ffs/mkfs.c

299

sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs2_dinode);

usr.sbin/makefs/ffs/mkfs.c

300

sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *

usr.sbin/makefs/ffs/mkfs.c

303

sblock.fs_flags |= FS_DOSOFTDEP;

usr.sbin/makefs/ffs/mkfs.c

306

sblock.fs_sblkno =

usr.sbin/makefs/ffs/mkfs.c

307

roundup(howmany(sblock.fs_sblockloc + SBLOCKSIZE, sblock.fs_fsize),

usr.sbin/makefs/ffs/mkfs.c

308

sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

309

sblock.fs_cblkno = (daddr_t)(sblock.fs_sblkno +

usr.sbin/makefs/ffs/mkfs.c

310

roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag));

usr.sbin/makefs/ffs/mkfs.c

311

sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

312

sblock.fs_maxfilesize = sblock.fs_bsize * UFS_NDADDR - 1;

usr.sbin/makefs/ffs/mkfs.c

313

for (sizepb = sblock.fs_bsize, i = 0; i < UFS_NIADDR; i++) {

usr.sbin/makefs/ffs/mkfs.c

314

sizepb *= NINDIR(&sblock);

usr.sbin/makefs/ffs/mkfs.c

315

sblock.fs_maxfilesize += sizepb;

usr.sbin/makefs/ffs/mkfs.c

332

maxinum = (((int64_t)(1)) << 32) - INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

347

fragsperinode = MAX(numfrags(&sblock, density), 1);

usr.sbin/makefs/ffs/mkfs.c

348

minfpg = fragsperinode * INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

349

if (minfpg > sblock.fs_size)

usr.sbin/makefs/ffs/mkfs.c

350

minfpg = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

351

sblock.fs_ipg = INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

352

sblock.fs_fpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

353

sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

354

if (sblock.fs_fpg < minfpg)

usr.sbin/makefs/ffs/mkfs.c

355

sblock.fs_fpg = minfpg;

usr.sbin/makefs/ffs/mkfs.c

356

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

usr.sbin/makefs/ffs/mkfs.c

357

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

358

sblock.fs_fpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

359

sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

360

if (sblock.fs_fpg < minfpg)

usr.sbin/makefs/ffs/mkfs.c

361

sblock.fs_fpg = minfpg;

usr.sbin/makefs/ffs/mkfs.c

362

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

usr.sbin/makefs/ffs/mkfs.c

363

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

364

if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize -

usr.sbin/makefs/ffs/mkfs.c

367

density -= sblock.fs_fsize;

usr.sbin/makefs/ffs/mkfs.c

379

for ( ; sblock.fs_fpg < maxblkspercg; sblock.fs_fpg += sblock.fs_frag) {

usr.sbin/makefs/ffs/mkfs.c

380

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

usr.sbin/makefs/ffs/mkfs.c

381

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

382

if (sblock.fs_size / sblock.fs_fpg < 1)

usr.sbin/makefs/ffs/mkfs.c

384

if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize -

usr.sbin/makefs/ffs/mkfs.c

387

if (CGSIZE(&sblock) == (unsigned long)sblock.fs_bsize -

usr.sbin/makefs/ffs/mkfs.c

390

sblock.fs_fpg -= sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

391

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

usr.sbin/makefs/ffs/mkfs.c

392

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

401

optimalfpg = sblock.fs_fpg;

usr.sbin/makefs/ffs/mkfs.c

403

sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg);

usr.sbin/makefs/ffs/mkfs.c

404

lastminfpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

405

sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

406

if (sblock.fs_size < lastminfpg) {

usr.sbin/makefs/ffs/mkfs.c

408

(long long)sblock.fs_size, lastminfpg);

usr.sbin/makefs/ffs/mkfs.c

411

if (sblock.fs_size % sblock.fs_fpg >= lastminfpg ||

usr.sbin/makefs/ffs/mkfs.c

412

sblock.fs_size % sblock.fs_fpg == 0)

usr.sbin/makefs/ffs/mkfs.c

414

sblock.fs_fpg -= sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

415

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

usr.sbin/makefs/ffs/mkfs.c

416

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

418

if (optimalfpg != sblock.fs_fpg)

usr.sbin/makefs/ffs/mkfs.c

420

optimalfpg, sblock.fs_fpg, "to enlarge last cyl group");

usr.sbin/makefs/ffs/mkfs.c

421

sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock));

usr.sbin/makefs/ffs/mkfs.c

422

sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);

usr.sbin/makefs/ffs/mkfs.c

424

sblock.fs_old_spc = sblock.fs_fpg * sblock.fs_old_nspf;

usr.sbin/makefs/ffs/mkfs.c

425

sblock.fs_old_nsect = sblock.fs_old_spc;

usr.sbin/makefs/ffs/mkfs.c

426

sblock.fs_old_npsect = sblock.fs_old_spc;

usr.sbin/makefs/ffs/mkfs.c

427

sblock.fs_old_ncyl = sblock.fs_ncg;

usr.sbin/makefs/ffs/mkfs.c

433

sblock.fs_csaddr = cgdmin(&sblock, 0);

usr.sbin/makefs/ffs/mkfs.c

434

sblock.fs_cssize =

usr.sbin/makefs/ffs/mkfs.c

435

fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));

usr.sbin/makefs/ffs/mkfs.c

441

size = sblock.fs_cssize;

usr.sbin/makefs/ffs/mkfs.c

442

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

443

size += sblock.fs_ncg * sizeof(int32_t);

usr.sbin/makefs/ffs/mkfs.c

445

sblock.fs_si = ecalloc(1, sizeof(struct fs_summary_info));

usr.sbin/makefs/ffs/mkfs.c

446

sblock.fs_csp = space;

usr.sbin/makefs/ffs/mkfs.c

447

space = (char *)space + sblock.fs_cssize;

usr.sbin/makefs/ffs/mkfs.c

448

if (sblock.fs_contigsumsize > 0) {

usr.sbin/makefs/ffs/mkfs.c

451

sblock.fs_maxcluster = lp = space;

usr.sbin/makefs/ffs/mkfs.c

452

for (i = 0; i < sblock.fs_ncg; i++)

usr.sbin/makefs/ffs/mkfs.c

453

*lp++ = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

456

sblock.fs_sbsize = fragroundup(&sblock, sizeof(struct fs));

usr.sbin/makefs/ffs/mkfs.c

457

if (sblock.fs_sbsize > SBLOCKSIZE)

usr.sbin/makefs/ffs/mkfs.c

458

sblock.fs_sbsize = SBLOCKSIZE;

usr.sbin/makefs/ffs/mkfs.c

459

sblock.fs_minfree = minfree;

usr.sbin/makefs/ffs/mkfs.c

460

sblock.fs_maxcontig = maxcontig;

usr.sbin/makefs/ffs/mkfs.c

461

sblock.fs_maxbpg = maxbpg;

usr.sbin/makefs/ffs/mkfs.c

462

sblock.fs_optim = opt;

usr.sbin/makefs/ffs/mkfs.c

463

sblock.fs_cgrotor = 0;

usr.sbin/makefs/ffs/mkfs.c

464

sblock.fs_pendingblocks = 0;

usr.sbin/makefs/ffs/mkfs.c

465

sblock.fs_pendinginodes = 0;

usr.sbin/makefs/ffs/mkfs.c

466

sblock.fs_cstotal.cs_ndir = 0;

usr.sbin/makefs/ffs/mkfs.c

467

sblock.fs_cstotal.cs_nbfree = 0;

usr.sbin/makefs/ffs/mkfs.c

468

sblock.fs_cstotal.cs_nifree = 0;

usr.sbin/makefs/ffs/mkfs.c

469

sblock.fs_cstotal.cs_nffree = 0;

usr.sbin/makefs/ffs/mkfs.c

470

sblock.fs_fmod = 0;

usr.sbin/makefs/ffs/mkfs.c

471

sblock.fs_ronly = 0;

usr.sbin/makefs/ffs/mkfs.c

472

sblock.fs_state = 0;

usr.sbin/makefs/ffs/mkfs.c

473

sblock.fs_clean = FS_ISCLEAN;

usr.sbin/makefs/ffs/mkfs.c

474

sblock.fs_ronly = 0;

usr.sbin/makefs/ffs/mkfs.c

475

sblock.fs_id[0] = tstamp;

usr.sbin/makefs/ffs/mkfs.c

476

sblock.fs_id[1] = random();

usr.sbin/makefs/ffs/mkfs.c

477

sblock.fs_fsmnt[0] = '\0';

usr.sbin/makefs/ffs/mkfs.c

478

csfrags = howmany(sblock.fs_cssize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

479

sblock.fs_dsize = sblock.fs_size - sblock.fs_sblkno -

usr.sbin/makefs/ffs/mkfs.c

480

sblock.fs_ncg * (sblock.fs_dblkno - sblock.fs_sblkno);

usr.sbin/makefs/ffs/mkfs.c

481

sblock.fs_cstotal.cs_nbfree =

usr.sbin/makefs/ffs/mkfs.c

482

fragstoblks(&sblock, sblock.fs_dsize) -

usr.sbin/makefs/ffs/mkfs.c

483

howmany(csfrags, sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

484

sblock.fs_cstotal.cs_nffree =

usr.sbin/makefs/ffs/mkfs.c

485

fragnum(&sblock, sblock.fs_size) +

usr.sbin/makefs/ffs/mkfs.c

486

(fragnum(&sblock, csfrags) > 0 ?

usr.sbin/makefs/ffs/mkfs.c

487

sblock.fs_frag - fragnum(&sblock, csfrags) : 0);

usr.sbin/makefs/ffs/mkfs.c

488

sblock.fs_cstotal.cs_nifree =

usr.sbin/makefs/ffs/mkfs.c

489

sblock.fs_ncg * sblock.fs_ipg - UFS_ROOTINO;

usr.sbin/makefs/ffs/mkfs.c

490

sblock.fs_cstotal.cs_ndir = 0;

usr.sbin/makefs/ffs/mkfs.c

491

sblock.fs_dsize -= csfrags;

usr.sbin/makefs/ffs/mkfs.c

492

sblock.fs_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

494

sblock.fs_old_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

495

sblock.fs_old_dsize = sblock.fs_dsize;

usr.sbin/makefs/ffs/mkfs.c

496

sblock.fs_old_csaddr = sblock.fs_csaddr;

usr.sbin/makefs/ffs/mkfs.c

497

sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;

usr.sbin/makefs/ffs/mkfs.c

498

sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;

usr.sbin/makefs/ffs/mkfs.c

499

sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;

usr.sbin/makefs/ffs/mkfs.c

500

sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;

usr.sbin/makefs/ffs/mkfs.c

508

fsys, (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,

usr.sbin/makefs/ffs/mkfs.c

509

(long long)fsbtodb(&sblock, sblock.fs_size),

usr.sbin/makefs/ffs/mkfs.c

510

sblock.fs_bsize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

513

sblock.fs_ncg,

usr.sbin/makefs/ffs/mkfs.c

514

(float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,

usr.sbin/makefs/ffs/mkfs.c

515

sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);

usr.sbin/makefs/ffs/mkfs.c

523

fsbtodb(&sblock, cgsblock(&sblock, sblock.fs_ncg -1)));

usr.sbin/makefs/ffs/mkfs.c

530

if (sblock.fs_bsize < SBLOCKSIZE)

usr.sbin/makefs/ffs/mkfs.c

531

iobufsize = SBLOCKSIZE + 3 * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

533

iobufsize = 4 * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

539

memcpy(writebuf, &sblock, sbsize);

usr.sbin/makefs/ffs/mkfs.c

541

ffs_sb_swap(&sblock, (struct fs*)writebuf);

usr.sbin/makefs/ffs/mkfs.c

545

for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {

usr.sbin/makefs/ffs/mkfs.c

550

(long long)fsbtodb(&sblock, cgsblock(&sblock, cylno)),

usr.sbin/makefs/ffs/mkfs.c

551

cylno == sblock.fs_ncg - 1 ? "" : ",");

usr.sbin/makefs/ffs/mkfs.c

560

sblock.fs_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

562

sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;

usr.sbin/makefs/ffs/mkfs.c

563

sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;

usr.sbin/makefs/ffs/mkfs.c

564

sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;

usr.sbin/makefs/ffs/mkfs.c

565

sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;

usr.sbin/makefs/ffs/mkfs.c

568

sblock.fs_flags |= FS_SWAPPED;

usr.sbin/makefs/ffs/mkfs.c

569

ffs_write_superblock(&sblock, fsopts);

usr.sbin/makefs/ffs/mkfs.c

570

return (&sblock);

usr.sbin/makefs/ffs/mkfs.c

645

cbase = cgbase(&sblock, cylno);

usr.sbin/makefs/ffs/mkfs.c

646

dmax = cbase + sblock.fs_fpg;

usr.sbin/makefs/ffs/mkfs.c

647

if (dmax > sblock.fs_size)

usr.sbin/makefs/ffs/mkfs.c

648

dmax = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

649

dlower = cgsblock(&sblock, cylno) - cbase;

usr.sbin/makefs/ffs/mkfs.c

650

dupper = cgdmin(&sblock, cylno) - cbase;

usr.sbin/makefs/ffs/mkfs.c

652

dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

653

memset(&acg, 0, sblock.fs_cgsize);

usr.sbin/makefs/ffs/mkfs.c

657

acg.cg_niblk = sblock.fs_ipg;

usr.sbin/makefs/ffs/mkfs.c

658

acg.cg_initediblk = MIN(sblock.fs_ipg, 2 * INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

660

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

661

acg.cg_nclusterblks = acg.cg_ndblk >> sblock.fs_fragshift;

usr.sbin/makefs/ffs/mkfs.c

666

if (cylno == sblock.fs_ncg - 1)

usr.sbin/makefs/ffs/mkfs.c

668

sblock.fs_fpg / sblock.fs_old_cpg);

usr.sbin/makefs/ffs/mkfs.c

670

acg.cg_old_ncyl = sblock.fs_old_cpg;

usr.sbin/makefs/ffs/mkfs.c

678

sblock.fs_old_cpg * sizeof(int32_t);

usr.sbin/makefs/ffs/mkfs.c

680

sblock.fs_old_cpg * sizeof(u_int16_t);

usr.sbin/makefs/ffs/mkfs.c

682

acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);

usr.sbin/makefs/ffs/mkfs.c

683

if (sblock.fs_contigsumsize <= 0) {

usr.sbin/makefs/ffs/mkfs.c

685

howmany(sblock.fs_fpg, CHAR_BIT);

usr.sbin/makefs/ffs/mkfs.c

688

howmany(sblock.fs_fpg, CHAR_BIT) - sizeof(int32_t);

usr.sbin/makefs/ffs/mkfs.c

692

(sblock.fs_contigsumsize + 1) * sizeof(int32_t);

usr.sbin/makefs/ffs/mkfs.c

694

howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);

usr.sbin/makefs/ffs/mkfs.c

696

if (acg.cg_nextfreeoff > (uint32_t)sblock.fs_cgsize) {

usr.sbin/makefs/ffs/mkfs.c

700

acg.cg_cs.cs_nifree += sblock.fs_ipg;

usr.sbin/makefs/ffs/mkfs.c

712

ffs_setblock(&sblock, cg_blksfree_swap(&acg, 0), blkno);

usr.sbin/makefs/ffs/mkfs.c

713

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

716

d += sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

720

if ((i = (dupper & (sblock.fs_frag - 1))) != 0) {

usr.sbin/makefs/ffs/mkfs.c

721

acg.cg_frsum[sblock.fs_frag - i]++;

usr.sbin/makefs/ffs/mkfs.c

722

for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {

usr.sbin/makefs/ffs/mkfs.c

727

for (d = dupper, blkno = dupper >> sblock.fs_fragshift;

usr.sbin/makefs/ffs/mkfs.c

728

d + sblock.fs_frag <= acg.cg_ndblk; ) {

usr.sbin/makefs/ffs/mkfs.c

729

ffs_setblock(&sblock, cg_blksfree_swap(&acg, 0), blkno);

usr.sbin/makefs/ffs/mkfs.c

730

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

733

d += sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

743

if (sblock.fs_contigsumsize > 0) {

usr.sbin/makefs/ffs/mkfs.c

754

if (run > sblock.fs_contigsumsize)

usr.sbin/makefs/ffs/mkfs.c

755

run = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

767

if (run > sblock.fs_contigsumsize)

usr.sbin/makefs/ffs/mkfs.c

768

run = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

772

sblock.fs_cs(&sblock, cylno) = acg.cg_cs;

usr.sbin/makefs/ffs/mkfs.c

777

start = MAX(sblock.fs_bsize, SBLOCKSIZE);

usr.sbin/makefs/ffs/mkfs.c

778

memcpy(&iobuf[start], &acg, sblock.fs_cgsize);

usr.sbin/makefs/ffs/mkfs.c

780

ffs_cg_swap(&acg, (struct cg*)&iobuf[start], &sblock);

usr.sbin/makefs/ffs/mkfs.c

781

start += sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

785

if (sblock.fs_magic == FS_UFS1_MAGIC) {

usr.sbin/makefs/ffs/mkfs.c

794

ffs_wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf,

usr.sbin/makefs/ffs/mkfs.c

800

for (i = 2 * sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

801

i < sblock.fs_ipg / INOPF(&sblock);

usr.sbin/makefs/ffs/mkfs.c

802

i += sblock.fs_frag) {

usr.sbin/makefs/ffs/mkfs.c

804

for (j = 0; j < INOPB(&sblock); j++) {

usr.sbin/makefs/ffs/mkfs.c

808

ffs_wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),

usr.sbin/makefs/ffs/mkfs.c

809

sblock.fs_bsize, &iobuf[start], fsopts);