bin/df/ext2fs_df.c

65

if (bread(rfd, (off_t)SBOFF, &sblock, SBSIZE) == 0) {

bin/df/ext2fs_df.c

68

if ((sblock.e2fs_magic != E2FS_MAGIC) ||

bin/df/ext2fs_df.c

69

(sblock.e2fs_rev != E2FS_REV0 && sblock.e2fs_rev != E2FS_REV1)) {

bin/df/ext2fs_df.c

73

sfsp->f_bsize = 1024 << sblock.e2fs_log_bsize;

bin/df/ext2fs_df.c

74

sfsp->f_iosize = 1024 << sblock.e2fs_log_bsize;

bin/df/ext2fs_df.c

78

itpg = sblock.e2fs_ipg / ipb;

bin/df/ext2fs_df.c

80

ncg = howmany(sblock.e2fs_bcount - sblock.e2fs_first_dblock,

bin/df/ext2fs_df.c

81

sblock.e2fs_bpg);

bin/df/ext2fs_df.c

88

overhead = sblock.e2fs_first_dblock + ncg * overhead_per_group;

bin/df/ext2fs_df.c

90

sfsp->f_blocks = sblock.e2fs_bcount - overhead;

bin/df/ext2fs_df.c

91

sfsp->f_bfree = sblock.e2fs_fbcount;

bin/df/ext2fs_df.c

92

sfsp->f_bavail = sfsp->f_bfree - sblock.e2fs_rbcount;

bin/df/ext2fs_df.c

93

sfsp->f_files = sblock.e2fs_icount;

bin/df/ext2fs_df.c

94

sfsp->f_ffree = sblock.e2fs_ficount;

bin/df/ffs_df.c

60

if (!((bread(rfd, (off_t)SBLOCK_UFS1, &sblock, SBSIZE) == 1 &&

bin/df/ffs_df.c

61

sblock.fs_magic == FS_UFS1_MAGIC) ||

bin/df/ffs_df.c

62

(bread(rfd, (off_t)SBLOCK_UFS2, &sblock, SBSIZE) == 1 &&

bin/df/ffs_df.c

63

sblock.fs_magic == FS_UFS2_MAGIC))) {

bin/df/ffs_df.c

68

sfsp->f_bsize = sblock.fs_fsize;

bin/df/ffs_df.c

69

sfsp->f_iosize = sblock.fs_bsize;

bin/df/ffs_df.c

70

if (sblock.fs_magic == FS_UFS1_MAGIC) {

bin/df/ffs_df.c

71

sfsp->f_blocks = sblock.fs_ffs1_dsize;

bin/df/ffs_df.c

72

sfsp->f_bfree = sblock.fs_ffs1_cstotal.cs_nbfree *

bin/df/ffs_df.c

73

sblock.fs_frag + sblock.fs_ffs1_cstotal.cs_nffree;

bin/df/ffs_df.c

75

((int64_t)sblock.fs_ffs1_dsize * sblock.fs_minfree / 100);

bin/df/ffs_df.c

76

sfsp->f_files = sblock.fs_ncg * sblock.fs_ipg - ROOTINO;

bin/df/ffs_df.c

77

sfsp->f_ffree = sblock.fs_ffs1_cstotal.cs_nifree;

bin/df/ffs_df.c

79

sfsp->f_blocks = sblock.fs_dsize;

bin/df/ffs_df.c

80

sfsp->f_bfree = sblock.fs_cstotal.cs_nbfree *

bin/df/ffs_df.c

81

sblock.fs_frag + sblock.fs_cstotal.cs_nffree;

bin/df/ffs_df.c

83

((int64_t)sblock.fs_dsize * sblock.fs_minfree / 100);

bin/df/ffs_df.c

84

sfsp->f_files = sblock.fs_ncg * sblock.fs_ipg - ROOTINO;

bin/df/ffs_df.c

85

sfsp->f_ffree = sblock.fs_cstotal.cs_nifree;

sbin/badsect/badsect.c

124

fs = &sblock;

sbin/badsect/badsect.c

166

rdfs(fsbtodb(fs, cgtod(fs, cg)), (int)sblock.fs_cgsize,

sbin/clri/clri.c

115

if (pwrite(fd, sblock, sizeof(sblock), offset) != sizeof(sblock))

sbin/clri/clri.c

68

char *fs, sblock[SBLOCKSIZE];

sbin/clri/clri.c

89

if (pread(fd, sblock, sizeof(sblock), offset) != sizeof(sblock))

sbin/clri/clri.c

91

sbp = (struct fs *)sblock;

sbin/dump/dump.h

81

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

sbin/dump/main.c

444

sblock = (struct fs *)sblock_buf;

sbin/dump/main.c

446

ssize_t n = pread(diskfd, sblock, SBLOCKSIZE,

sbin/dump/main.c

448

if (n == SBLOCKSIZE && (sblock->fs_magic == FS_UFS1_MAGIC ||

sbin/dump/main.c

449

(sblock->fs_magic == FS_UFS2_MAGIC &&

sbin/dump/main.c

450

sblock->fs_sblockloc == sblock_try[i])) &&

sbin/dump/main.c

451

sblock->fs_bsize <= MAXBSIZE &&

sbin/dump/main.c

452

sblock->fs_bsize >= sizeof(struct fs))

sbin/dump/main.c

460

if (sblock->fs_magic == FS_UFS2_MAGIC ||

sbin/dump/main.c

461

sblock->fs_inodefmt >= FS_44INODEFMT)

sbin/dump/main.c

463

maxino = (ino_t)sblock->fs_ipg * sblock->fs_ncg;

sbin/dump/main.c

88

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

sbin/dump/tape.c

179

dblkno = fsbtodb(sblock, blkno);

sbin/dump/tape.c

688

if (sblock->fs_magic != FS_UFS2_MAGIC)

sbin/dump/tape.c

691

if (sblock->fs_magic != FS_UFS2_MAGIC)

sbin/dump/traverse.c

102

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

sbin/dump/traverse.c

105

howmany(sizeest - NDADDR * sblock->fs_bsize / TP_BSIZE,

sbin/dump/traverse.c

154

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

sbin/dump/traverse.c

157

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

sbin/dump/traverse.c

158

ino = cg * (ino_t)sblock->fs_ipg;

sbin/dump/traverse.c

159

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

sbin/dump/traverse.c

160

sblock->fs_cgsize);

sbin/dump/traverse.c

161

if (sblock->fs_magic == FS_UFS2_MAGIC)

sbin/dump/traverse.c

164

inosused = sblock->fs_ipg;

sbin/dump/traverse.c

313

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

321

sblksize(sblock, DIP(dp, di_size), i),

sbin/dump/traverse.c

326

filesize -= sblock->fs_bsize;

sbin/dump/traverse.c

367

bread(fsbtodb(sblock, blkno), idblk, (int)sblock->fs_bsize);

sbin/dump/traverse.c

369

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

sbin/dump/traverse.c

370

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

375

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

sbin/dump/traverse.c

380

*filesize -= sblock->fs_bsize;

sbin/dump/traverse.c

385

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

sbin/dump/traverse.c

386

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

412

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

sbin/dump/traverse.c

414

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

sbin/dump/traverse.c

481

if (sblock->fs_magic == FS_UFS1_MAGIC) {

sbin/dump/traverse.c

525

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

sbin/dump/traverse.c

531

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

560

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

sbin/dump/traverse.c

561

cnt = NDADDR * sblock->fs_frag;

sbin/dump/traverse.c

563

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

sbin/dump/traverse.c

564

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

568

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

sbin/dump/traverse.c

587

bread(fsbtodb(sblock, blk), idblk, (int) sblock->fs_bsize);

sbin/dump/traverse.c

589

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

sbin/dump/traverse.c

591

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

sbin/dump/traverse.c

592

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

sbin/dump/traverse.c

594

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

sbin/dump/traverse.c

595

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

sbin/dump/traverse.c

596

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

603

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

sbin/dump/traverse.c

604

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/dump/traverse.c

61

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

sbin/dump/traverse.c

624

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

sbin/dump/traverse.c

625

tbperdb = sblock->fs_bsize >> tp_bshift;

sbin/dump/traverse.c

642

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

sbin/dump/traverse.c

659

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

sbin/dump/traverse.c

660

tbperdb = sblock->fs_bsize >> tp_bshift;

sbin/dump/traverse.c

677

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

sbin/dump/traverse.c

710

if (sblock->fs_magic == FS_UFS2_MAGIC) {

sbin/dump/traverse.c

741

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

sbin/dump/traverse.c

746

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

sbin/dump/traverse.c

747

(int)sblock->fs_bsize);

sbin/dump/traverse.c

748

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

sbin/dump/traverse.c

749

maxino = minino + INOPB(sblock);

sbin/dump/traverse.c

751

if (sblock->fs_magic == FS_UFS1_MAGIC) {

sbin/dump/traverse.c

816

fsbtodb(sblock, sblock->fs_ffs1_size)) {

sbin/fsck_ext2fs/dir.c

117

if ((dbuf = malloc(sblock.e2fs_bsize)) == NULL) {

sbin/fsck_ext2fs/dir.c

125

(idesc->id_filesize & (sblock.e2fs_bsize - 1)) != 0)

sbin/fsck_ext2fs/dir.c

126

idesc->id_filesize = roundup(idesc->id_filesize, sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

127

blksiz = idesc->id_numfrags * sblock.e2fs_bsize;

sbin/fsck_ext2fs/dir.c

164

blksiz = idesc->id_numfrags * sblock.e2fs_bsize;

sbin/fsck_ext2fs/dir.c

166

if (idesc->id_loc % sblock.e2fs_bsize == 0 && idesc->id_filesize > 0 &&

sbin/fsck_ext2fs/dir.c

176

dp->e2d_reclen = htole16(sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

183

idesc->id_loc += sblock.e2fs_bsize;

sbin/fsck_ext2fs/dir.c

184

idesc->id_filesize -= sblock.e2fs_bsize;

sbin/fsck_ext2fs/dir.c

194

if ((idesc->id_loc % sblock.e2fs_bsize) == 0)

sbin/fsck_ext2fs/dir.c

199

size = sblock.e2fs_bsize - (idesc->id_loc % sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

226

spaceleft = sblock.e2fs_bsize - (idesc->id_loc % sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

234

if (sblock.e2fs.e2fs_rev < E2FS_REV1 ||

sbin/fsck_ext2fs/dir.c

235

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE) == 0)

sbin/fsck_ext2fs/dir.c

316

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/dir.c

317

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/dir.c

347

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/dir.c

348

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/dir.c

498

if (inosize(dp) % sblock.e2fs_bsize) {

sbin/fsck_ext2fs/dir.c

499

inossize(dp, roundup(inosize(dp), sblock.e2fs_bsize));

sbin/fsck_ext2fs/dir.c

521

lastbn = lblkno(&sblock, inosize(dp));

sbin/fsck_ext2fs/dir.c

529

inossize(dp, inosize(dp) + sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

532

sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

535

if ((firstblk = malloc(sblock.e2fs_bsize)) == NULL) {

sbin/fsck_ext2fs/dir.c

539

memcpy(firstblk, bp->b_un.b_buf, sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

540

bp = getdirblk(newblk, sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

545

memcpy(bp->b_un.b_buf, firstblk, sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

549

sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

552

emptydir.dot_reclen = htole16(sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

565

dp->e2di_size = htole32(letoh32(dp->e2di_size) - sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

566

inossize(dp, inosize(dp) - sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

585

dirhead.dotdot_reclen = htole16(sblock.e2fs_bsize - 12); /* XXX */

sbin/fsck_ext2fs/dir.c

587

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/dir.c

588

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/dir.c

593

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/dir.c

594

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/dir.c

602

bp = getdirblk(letoh32(dp->e2di_blocks[0]), sblock.e2fs_bsize);

sbin/fsck_ext2fs/fsck.h

77

extern struct m_ext2fs sblock;

sbin/fsck_ext2fs/inode.c

132

memcpy(&dino, dp, MIN(EXT2_DINODE_SIZE(&sblock), sizeof(dino)));

sbin/fsck_ext2fs/inode.c

133

ndb = howmany(inosize(&dino), sblock.e2fs_bsize);

sbin/fsck_ext2fs/inode.c

148

sblock.e2fs_bsize);

sbin/fsck_ext2fs/inode.c

166

remsize = inosize(&dino) - sblock.e2fs_bsize * NDADDR;

sbin/fsck_ext2fs/inode.c

167

sizepb = sblock.e2fs_bsize;

sbin/fsck_ext2fs/inode.c

193

sizepb *= NINDIR(&sblock);

sbin/fsck_ext2fs/inode.c

219

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

sbin/fsck_ext2fs/inode.c

221

for (sizepb = sblock.e2fs_bsize, i = 0; i < ilevel; i++)

sbin/fsck_ext2fs/inode.c

222

sizepb *= NINDIR(&sblock);

sbin/fsck_ext2fs/inode.c

223

if (isize > sizepb * NINDIR(&sblock))

sbin/fsck_ext2fs/inode.c

224

nif = NINDIR(&sblock);

sbin/fsck_ext2fs/inode.c

228

nif < NINDIR(&sblock)) {

sbin/fsck_ext2fs/inode.c

229

aplim = &bp->b_un.b_indir[NINDIR(&sblock)];

sbin/fsck_ext2fs/inode.c

292

c = dtog(&sblock, blk);

sbin/fsck_ext2fs/inode.c

294

if (blk < sblock.e2fs.e2fs_bpg * c + overh +

sbin/fsck_ext2fs/inode.c

295

sblock.e2fs.e2fs_first_dblock) {

sbin/fsck_ext2fs/inode.c

296

if ((blk + cnt) > sblock.e2fs.e2fs_bpg * c + overh +

sbin/fsck_ext2fs/inode.c

297

sblock.e2fs.e2fs_first_dblock) {

sbin/fsck_ext2fs/inode.c

300

blk, sblock.e2fs.e2fs_bpg * c + overh +

sbin/fsck_ext2fs/inode.c

301

sblock.e2fs.e2fs_first_dblock);

sbin/fsck_ext2fs/inode.c

303

blk + cnt, sblock.e2fs.e2fs_bpg * c +

sbin/fsck_ext2fs/inode.c

304

overh + sblock.e2fs.e2fs_first_dblock);

sbin/fsck_ext2fs/inode.c

309

if ((blk + cnt) > sblock.e2fs.e2fs_bpg * (c + 1) + overh +

sbin/fsck_ext2fs/inode.c

310

sblock.e2fs.e2fs_first_dblock) {

sbin/fsck_ext2fs/inode.c

313

blk, sblock.e2fs.e2fs_bpg * c + overh +

sbin/fsck_ext2fs/inode.c

314

sblock.e2fs.e2fs_first_dblock);

sbin/fsck_ext2fs/inode.c

316

blk+cnt, sblock.e2fs.e2fs_bpg * (c + 1) +

sbin/fsck_ext2fs/inode.c

317

overh + sblock.e2fs.e2fs_first_dblock);

sbin/fsck_ext2fs/inode.c

338

inumber < startinum || inumber >= startinum + sblock.e2fs_ipb) {

sbin/fsck_ext2fs/inode.c

339

iblk = fsck_ino_to_fsba(&sblock, inumber);

sbin/fsck_ext2fs/inode.c

342

pbp = getdatablk(iblk, sblock.e2fs_bsize);

sbin/fsck_ext2fs/inode.c

343

startinum = ((inumber -1) / sblock.e2fs_ipb) * sblock.e2fs_ipb + 1;

sbin/fsck_ext2fs/inode.c

345

return (&pbp->b_un.b_dinode[(inumber-1) % sblock.e2fs_ipb]);

sbin/fsck_ext2fs/inode.c

369

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

sbin/fsck_ext2fs/inode.c

382

bp += EXT2_DINODE_SIZE(&sblock);

sbin/fsck_ext2fs/inode.c

395

inobufsize = blkroundup(&sblock, INOBUFSIZE);

sbin/fsck_ext2fs/inode.c

396

fullcnt = inobufsize / EXT2_DINODE_SIZE(&sblock);

sbin/fsck_ext2fs/inode.c

397

readpercg = sblock.e2fs.e2fs_ipg / fullcnt;

sbin/fsck_ext2fs/inode.c

398

partialcnt = sblock.e2fs.e2fs_ipg % fullcnt;

sbin/fsck_ext2fs/inode.c

399

partialsize = partialcnt * EXT2_DINODE_SIZE(&sblock);

sbin/fsck_ext2fs/inode.c

436

blks = howmany(inosize(dp), sblock.e2fs_bsize);

sbin/fsck_ext2fs/inode.c

660

inossize(dp, sblock.e2fs_bsize);

sbin/fsck_ext2fs/inode.c

661

dp->e2di_nblock = htole32(btodb(sblock.e2fs_bsize));

sbin/fsck_ext2fs/inode.c

71

if (sblock.e2fs.e2fs_rev < E2FS_REV1) {

sbin/fsck_ext2fs/inode.c

75

if (!(sblock.e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_LARGE_FILE)) {

sbin/fsck_ext2fs/inode.c

80

sblock.e2fs.e2fs_features_rocompat |= EXT2F_ROCOMPAT_LARGE_FILE;

sbin/fsck_ext2fs/main.c

216

if (sblock.e2fs.e2fs_rev > E2FS_REV0) {

sbin/fsck_ext2fs/main.c

218

sblock.e2fs.e2fs_fsmnt);

sbin/fsck_ext2fs/main.c

267

n_bfree = sblock.e2fs.e2fs_fbcount;

sbin/fsck_ext2fs/main.c

273

(n_files -= maxino - 9 - sblock.e2fs.e2fs_ficount))

sbin/fsck_ext2fs/main.c

276

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

sbin/fsck_ext2fs/main.c

278

n_blks += sblock.e2fs.e2fs_first_dblock;

sbin/fsck_ext2fs/main.c

302

sblock.e2fs.e2fs_wtime = t;

sbin/fsck_ext2fs/main.c

303

sblock.e2fs.e2fs_lastfsck = t;

sbin/fsck_ext2fs/main.c

67

struct m_ext2fs sblock;

sbin/fsck_ext2fs/pass1.c

109

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

sbin/fsck_ext2fs/pass1.c

111

i < sblock.e2fs.e2fs_ipg && inumber <= sblock.e2fs.e2fs_icount;

sbin/fsck_ext2fs/pass1.c

185

if (inosize(dp) + sblock.e2fs_bsize - 1 < inosize(dp)) {

sbin/fsck_ext2fs/pass1.c

193

inossize(dp, sblock.e2fs_bsize);

sbin/fsck_ext2fs/pass1.c

196

ndb = howmany(inosize(dp), sblock.e2fs_bsize);

sbin/fsck_ext2fs/pass1.c

216

ndb *= NINDIR(&sblock);

sbin/fsck_ext2fs/pass1.c

231

ndb /= NINDIR(&sblock);

sbin/fsck_ext2fs/pass1.c

270

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

sbin/fsck_ext2fs/pass1.c

66

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

sbin/fsck_ext2fs/pass1.c

67

dbase = c * sblock.e2fs.e2fs_bpg +

sbin/fsck_ext2fs/pass1.c

68

sblock.e2fs.e2fs_first_dblock;

sbin/fsck_ext2fs/pass1.c

70

if (letoh32(sblock.e2fs_gd[c].ext2bgd_i_tables) >= dbase) {

sbin/fsck_ext2fs/pass1.c

71

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

sbin/fsck_ext2fs/pass1.c

73

letoh32(sblock.e2fs_gd[c].ext2bgd_i_tables)

sbin/fsck_ext2fs/pass1.c

77

if (letoh32(sblock.e2fs_gd[c].ext2bgd_b_bitmap) >= dbase)

sbin/fsck_ext2fs/pass1.c

78

setbmap(letoh32(sblock.e2fs_gd[c].ext2bgd_b_bitmap));

sbin/fsck_ext2fs/pass1.c

80

if (letoh32(sblock.e2fs_gd[c].ext2bgd_i_bitmap) >= dbase)

sbin/fsck_ext2fs/pass1.c

81

setbmap(letoh32(sblock.e2fs_gd[c].ext2bgd_i_bitmap));

sbin/fsck_ext2fs/pass1.c

83

if (sblock.e2fs.e2fs_rev == E2FS_REV0 ||

sbin/fsck_ext2fs/pass1.c

84

(sblock.e2fs.e2fs_features_rocompat &

sbin/fsck_ext2fs/pass1.c

89

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

sbin/fsck_ext2fs/pass1b.c

58

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

sbin/fsck_ext2fs/pass1b.c

59

for (i = 0; i < sblock.e2fs.e2fs_ipg; i++, inumber++) {

sbin/fsck_ext2fs/pass2.c

128

inp->i_isize = roundup(MINDIRSIZE, sblock.e2fs_bsize);

sbin/fsck_ext2fs/pass2.c

134

} else if ((inp->i_isize & (sblock.e2fs_bsize - 1)) != 0) {

sbin/fsck_ext2fs/pass2.c

138

pathbuf, (u_long)inp->i_isize, sblock.e2fs_bsize);

sbin/fsck_ext2fs/pass2.c

141

inp->i_isize = roundup(inp->i_isize, sblock.e2fs_bsize);

sbin/fsck_ext2fs/pass2.c

216

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/pass2.c

217

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)

sbin/fsck_ext2fs/pass2.c

229

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/pass2.c

230

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/pass2.c

264

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/pass2.c

265

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/pass2.c

287

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/pass2.c

288

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)

sbin/fsck_ext2fs/pass2.c

403

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/pass2.c

404

(sblock.e2fs.e2fs_features_incompat &

sbin/fsck_ext2fs/pass5.c

143

dbase = c * sblock.e2fs.e2fs_bpg +

sbin/fsck_ext2fs/pass5.c

144

sblock.e2fs.e2fs_first_dblock;

sbin/fsck_ext2fs/pass5.c

145

dmax = (c+1) * sblock.e2fs.e2fs_bpg +

sbin/fsck_ext2fs/pass5.c

146

sblock.e2fs.e2fs_first_dblock;

sbin/fsck_ext2fs/pass5.c

151

if (testbmap(d) || d >= sblock.e2fs.e2fs_bcount) {

sbin/fsck_ext2fs/pass5.c

54

struct m_ext2fs *fs = &sblock;

sbin/fsck_ext2fs/setup.c

163

printf("state = %d\n", sblock.e2fs.e2fs_state);

sbin/fsck_ext2fs/setup.c

164

if (sblock.e2fs.e2fs_state == E2FS_ISCLEAN) {

sbin/fsck_ext2fs/setup.c

173

maxfsblock = sblock.e2fs.e2fs_bcount;

sbin/fsck_ext2fs/setup.c

174

maxino = sblock.e2fs_ncg * sblock.e2fs.e2fs_ipg;

sbin/fsck_ext2fs/setup.c

175

sizepb = sblock.e2fs_bsize;

sbin/fsck_ext2fs/setup.c

176

maxfilesize = sblock.e2fs_bsize * NDADDR - 1;

sbin/fsck_ext2fs/setup.c

178

sizepb *= NINDIR(&sblock);

sbin/fsck_ext2fs/setup.c

185

(sblock.e2fs.e2fs_rbcount > sblock.e2fs.e2fs_bcount)) {

sbin/fsck_ext2fs/setup.c

187

sblock.e2fs.e2fs_rbcount);

sbin/fsck_ext2fs/setup.c

189

sblock.e2fs.e2fs_rbcount = sblock.e2fs.e2fs_bcount * 0.1;

sbin/fsck_ext2fs/setup.c

194

if (sblock.e2fs.e2fs_bpg != sblock.e2fs.e2fs_fpg) {

sbin/fsck_ext2fs/setup.c

196

sblock.e2fs.e2fs_fpg, sblock.e2fs.e2fs_bpg);

sbin/fsck_ext2fs/setup.c

207

sblock.e2fs_gd = calloc(sblock.e2fs_ngdb, sblock.e2fs_bsize);

sbin/fsck_ext2fs/setup.c

208

if (sblock.e2fs_gd == NULL)

sbin/fsck_ext2fs/setup.c

211

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

sbin/fsck_ext2fs/setup.c

213

&sblock.e2fs_gd[i* sblock.e2fs_bsize / sizeof(struct ext2_gd)],

sbin/fsck_ext2fs/setup.c

214

fsbtodb(&sblock, ((sblock.e2fs_bsize>1024)?0:1)+i+1),

sbin/fsck_ext2fs/setup.c

215

sblock.e2fs_bsize) != 0 && !asked) {

sbin/fsck_ext2fs/setup.c

250

for (numdirs = 0, cg = 0; cg < sblock.e2fs_ncg; cg++) {

sbin/fsck_ext2fs/setup.c

251

numdirs += letoh16(sblock.e2fs_gd[cg].ext2bgd_ndirs);

sbin/fsck_ext2fs/setup.c

284

e2fs_sbload(sblk.b_un.b_fs, &sblock.e2fs);

sbin/fsck_ext2fs/setup.c

289

if (sblock.e2fs.e2fs_magic != E2FS_MAGIC) {

sbin/fsck_ext2fs/setup.c

292

if (sblock.e2fs.e2fs_log_bsize > 2) {

sbin/fsck_ext2fs/setup.c

295

if (sblock.e2fs.e2fs_bpg == 0) {

sbin/fsck_ext2fs/setup.c

301

sblock.e2fs_ncg =

sbin/fsck_ext2fs/setup.c

302

howmany(sblock.e2fs.e2fs_bcount - sblock.e2fs.e2fs_first_dblock,

sbin/fsck_ext2fs/setup.c

303

sblock.e2fs.e2fs_bpg);

sbin/fsck_ext2fs/setup.c

305

sblock.e2fs_fsbtodb = sblock.e2fs.e2fs_log_bsize + 1;

sbin/fsck_ext2fs/setup.c

306

sblock.e2fs_bsize = 1024 << sblock.e2fs.e2fs_log_bsize;

sbin/fsck_ext2fs/setup.c

307

sblock.e2fs_bshift = LOG_MINBSIZE + sblock.e2fs.e2fs_log_bsize;

sbin/fsck_ext2fs/setup.c

308

sblock.e2fs_qbmask = sblock.e2fs_bsize - 1;

sbin/fsck_ext2fs/setup.c

309

sblock.e2fs_bmask = ~sblock.e2fs_qbmask;

sbin/fsck_ext2fs/setup.c

310

sblock.e2fs_ngdb = howmany(sblock.e2fs_ncg,

sbin/fsck_ext2fs/setup.c

311

sblock.e2fs_bsize / sizeof(struct ext2_gd));

sbin/fsck_ext2fs/setup.c

312

sblock.e2fs_ipb = sblock.e2fs_bsize / EXT2_DINODE_SIZE(&sblock);

sbin/fsck_ext2fs/setup.c

313

sblock.e2fs_itpg = sblock.e2fs.e2fs_ipg/sblock.e2fs_ipb;

sbin/fsck_ext2fs/setup.c

322

if (sblock.e2fs_ncg == 1) {

sbin/fsck_ext2fs/setup.c

328

getblk(&asblk, 1 * sblock.e2fs.e2fs_bpg + sblock.e2fs.e2fs_first_dblock,

sbin/fsck_ext2fs/setup.c

364

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/setup.c

365

((sblock.e2fs.e2fs_features_incompat & ~EXT2F_INCOMPAT_SUPP) ||

sbin/fsck_ext2fs/setup.c

366

(sblock.e2fs.e2fs_features_rocompat & ~EXT2F_ROCOMPAT_SUPP))) {

sbin/fsck_ext2fs/setup.c

370

sblock.e2fs.e2fs_features_compat,

sbin/fsck_ext2fs/setup.c

371

sblock.e2fs.e2fs_features_incompat,

sbin/fsck_ext2fs/setup.c

372

sblock.e2fs.e2fs_features_rocompat);

sbin/fsck_ext2fs/setup.c

406

bp->b_un.b_fs->e2fs_icount = letoh32(sblock.e2fs.e2fs_icount);

sbin/fsck_ext2fs/setup.c

407

bp->b_un.b_fs->e2fs_bcount = letoh32(sblock.e2fs.e2fs_bcount);

sbin/fsck_ext2fs/setup.c

408

bp->b_un.b_fs->e2fs_rbcount = letoh32(sblock.e2fs.e2fs_rbcount);

sbin/fsck_ext2fs/setup.c

409

bp->b_un.b_fs->e2fs_fbcount = letoh32(sblock.e2fs.e2fs_fbcount);

sbin/fsck_ext2fs/setup.c

410

bp->b_un.b_fs->e2fs_ficount = letoh32(sblock.e2fs.e2fs_ficount);

sbin/fsck_ext2fs/setup.c

412

letoh32(sblock.e2fs.e2fs_first_dblock);

sbin/fsck_ext2fs/setup.c

413

bp->b_un.b_fs->e2fs_log_bsize = letoh32(sblock.e2fs.e2fs_log_bsize);

sbin/fsck_ext2fs/setup.c

414

bp->b_un.b_fs->e2fs_log_fsize = letoh32(sblock.e2fs.e2fs_log_fsize);

sbin/fsck_ext2fs/setup.c

415

bp->b_un.b_fs->e2fs_bpg = letoh32(sblock.e2fs.e2fs_bpg);

sbin/fsck_ext2fs/setup.c

416

bp->b_un.b_fs->e2fs_fpg = letoh32(sblock.e2fs.e2fs_fpg);

sbin/fsck_ext2fs/setup.c

417

bp->b_un.b_fs->e2fs_ipg = letoh32(sblock.e2fs.e2fs_ipg);

sbin/fsck_ext2fs/setup.c

418

bp->b_un.b_fs->e2fs_mtime = letoh32(sblock.e2fs.e2fs_mtime);

sbin/fsck_ext2fs/setup.c

419

bp->b_un.b_fs->e2fs_wtime = letoh32(sblock.e2fs.e2fs_wtime);

sbin/fsck_ext2fs/setup.c

420

bp->b_un.b_fs->e2fs_lastfsck = letoh32(sblock.e2fs.e2fs_lastfsck);

sbin/fsck_ext2fs/setup.c

421

bp->b_un.b_fs->e2fs_fsckintv = letoh32(sblock.e2fs.e2fs_fsckintv);

sbin/fsck_ext2fs/setup.c

422

bp->b_un.b_fs->e2fs_creator = letoh32(sblock.e2fs.e2fs_creator);

sbin/fsck_ext2fs/setup.c

423

bp->b_un.b_fs->e2fs_rev = letoh32(sblock.e2fs.e2fs_rev);

sbin/fsck_ext2fs/setup.c

424

bp->b_un.b_fs->e2fs_mnt_count = letoh16(sblock.e2fs.e2fs_mnt_count);

sbin/fsck_ext2fs/setup.c

426

letoh16(sblock.e2fs.e2fs_max_mnt_count);

sbin/fsck_ext2fs/setup.c

427

bp->b_un.b_fs->e2fs_magic = letoh16(sblock.e2fs.e2fs_magic);

sbin/fsck_ext2fs/setup.c

428

bp->b_un.b_fs->e2fs_state = letoh16(sblock.e2fs.e2fs_state);

sbin/fsck_ext2fs/setup.c

429

bp->b_un.b_fs->e2fs_beh = letoh16(sblock.e2fs.e2fs_beh);

sbin/fsck_ext2fs/setup.c

430

bp->b_un.b_fs->e2fs_ruid = letoh16(sblock.e2fs.e2fs_ruid);

sbin/fsck_ext2fs/setup.c

431

bp->b_un.b_fs->e2fs_rgid = letoh16(sblock.e2fs.e2fs_rgid);

sbin/fsck_ext2fs/setup.c

519

sblock.e2fs_itpg;

sbin/fsck_ext2fs/setup.c

520

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/setup.c

521

sblock.e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSE_SUPER) {

sbin/fsck_ext2fs/setup.c

525

overh += 1 + sblock.e2fs_ngdb;

sbin/fsck_ext2fs/utilities.c

126

bufcnt = MAXBUFSPACE / sblock.e2fs_bsize;

sbin/fsck_ext2fs/utilities.c

131

bufp = malloc((unsigned int)sblock.e2fs_bsize);

sbin/fsck_ext2fs/utilities.c

158

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

sbin/fsck_ext2fs/utilities.c

185

dblk = fsbtodb(&sblock, blk);

sbin/fsck_ext2fs/utilities.c

211

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

sbin/fsck_ext2fs/utilities.c

213

&sblock.e2fs_gd[i* sblock.e2fs_bsize / sizeof(struct ext2_gd)],

sbin/fsck_ext2fs/utilities.c

214

fsbtodb(&sblock, ((sblock.e2fs_bsize>1024)?0:1)+i+1),

sbin/fsck_ext2fs/utilities.c

215

sblock.e2fs_bsize);

sbin/fsck_ext2fs/utilities.c

260

if (markclean && (sblock.e2fs.e2fs_state & E2FS_ISCLEAN) == 0) {

sbin/fsck_ext2fs/utilities.c

269

sblock.e2fs.e2fs_state = E2FS_ISCLEAN;

sbin/fsck_ffs/dir.c

106

blksiz = idesc->id_numfrags * sblock.fs_fsize;

sbin/fsck_ffs/dir.c

139

blksiz = idesc->id_numfrags * sblock.fs_fsize;

sbin/fsck_ffs/dir.c

497

dis = lblkno(&sblock, DIP(dp, di_size));

sbin/fsck_ffs/dir.c

504

if ((newblk = allocblk(sblock.fs_frag)) == 0)

sbin/fsck_ffs/dir.c

508

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

sbin/fsck_ffs/dir.c

509

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

sbin/fsck_ffs/dir.c

511

sblksize(&sblock, DIP(dp, di_size), lastbn + 1));

sbin/fsck_ffs/dir.c

515

bp = getdirblk(newblk, sblock.fs_bsize);

sbin/fsck_ffs/dir.c

520

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

sbin/fsck_ffs/dir.c

525

sblksize(&sblock, DIP(dp, di_size), lastbn + 1));

sbin/fsck_ffs/dir.c

540

DIP_SET(dp, di_size, DIP(dp, di_size) - sblock.fs_bsize);

sbin/fsck_ffs/dir.c

541

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

sbin/fsck_ffs/dir.c

542

freeblk(newblk, sblock.fs_frag);

sbin/fsck_ffs/dir.c

566

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

sbin/fsck_ffs/dir.c

573

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

sbin/fsck_ffs/fsck.h

123

((sblock.fs_magic == FS_UFS1_MAGIC) ? \

sbin/fsck_ffs/fsck.h

127

if (sblock.fs_magic == FS_UFS1_MAGIC) \

sbin/fsck_ffs/fsck.h

254

if (sblock.fs_magic == FS_UFS1_MAGIC) { \

sbin/fsck_ffs/fsck.h

55

((sblock.fs_magic == FS_UFS1_MAGIC) ? \

sbin/fsck_ffs/fsck.h

59

if (sblock.fs_magic == FS_UFS1_MAGIC) \

sbin/fsck_ffs/inode.c

115

idesc->id_numfrags = sblock.fs_frag;

sbin/fsck_ffs/inode.c

116

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

sbin/fsck_ffs/inode.c

117

sizepb = sblock.fs_bsize;

sbin/fsck_ffs/inode.c

144

sizepb *= NINDIR(&sblock);

sbin/fsck_ffs/inode.c

168

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

sbin/fsck_ffs/inode.c

170

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

sbin/fsck_ffs/inode.c

171

sizepb *= NINDIR(&sblock);

sbin/fsck_ffs/inode.c

172

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

sbin/fsck_ffs/inode.c

173

nif = NINDIR(&sblock);

sbin/fsck_ffs/inode.c

176

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

sbin/fsck_ffs/inode.c

177

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

sbin/fsck_ffs/inode.c

242

if (cnt > sblock.fs_frag ||

sbin/fsck_ffs/inode.c

243

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

sbin/fsck_ffs/inode.c

246

(long long)blk, (long long)fragnum(&sblock, blk),

sbin/fsck_ffs/inode.c

250

c = dtog(&sblock, blk);

sbin/fsck_ffs/inode.c

251

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

sbin/fsck_ffs/inode.c

252

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

sbin/fsck_ffs/inode.c

256

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

sbin/fsck_ffs/inode.c

259

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

sbin/fsck_ffs/inode.c

264

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

sbin/fsck_ffs/inode.c

268

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

sbin/fsck_ffs/inode.c

270

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

sbin/fsck_ffs/inode.c

290

inumber < startinum || inumber >= startinum + INOPB(&sblock)) {

sbin/fsck_ffs/inode.c

291

iblk = ino_to_fsba(&sblock, inumber);

sbin/fsck_ffs/inode.c

294

pbp = getdatablk(iblk, sblock.fs_bsize);

sbin/fsck_ffs/inode.c

295

startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);

sbin/fsck_ffs/inode.c

297

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsck_ffs/inode.c

299

&pbp->b_un.b_dinode1[inumber % INOPB(&sblock)]);

sbin/fsck_ffs/inode.c

300

return ((union dinode *)&pbp->b_un.b_dinode2[inumber % INOPB(&sblock)]);

sbin/fsck_ffs/inode.c

325

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

sbin/fsck_ffs/inode.c

337

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsck_ffs/inode.c

354

inobufsize = blkroundup(&sblock, INOBUFSIZE);

sbin/fsck_ffs/inode.c

355

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsck_ffs/inode.c

359

readpercg = sblock.fs_ipg / fullcnt;

sbin/fsck_ffs/inode.c

360

partialcnt = sblock.fs_ipg % fullcnt;

sbin/fsck_ffs/inode.c

361

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsck_ffs/inode.c

400

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

sbin/fsck_ffs/inode.c

602

cg = ino_to_cg(&sblock, ino);

sbin/fsck_ffs/inode.c

604

if ((ino % sblock.fs_ipg) >= (uint64_t)inostathead[cg].il_numalloced) {

sbin/fsck_ffs/inode.c

606

newalloced = MINIMUM(sblock.fs_ipg,

sbin/fsck_ffs/inode.c

629

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

sbin/fsck_ffs/inode.c

662

DIP_SET(dp, di_size, sblock.fs_fsize);

sbin/fsck_ffs/inode.c

663

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

sbin/fsck_ffs/inode.c

74

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

sbin/fsck_ffs/inode.c

76

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsck_ffs/inode.c

80

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

sbin/fsck_ffs/inode.c

82

if (--ndb == 0 && (offset = blkoff(&sblock,

sbin/fsck_ffs/inode.c

85

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

sbin/fsck_ffs/inode.c

87

idesc->id_numfrags = sblock.fs_frag;

sbin/fsck_ffs/inode.c

98

i * sblock.fs_bsize);

sbin/fsck_ffs/main.c

248

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

sbin/fsck_ffs/main.c

296

n_ffree = sblock.fs_cstotal.cs_nffree;

sbin/fsck_ffs/main.c

297

n_bfree = sblock.fs_cstotal.cs_nbfree;

sbin/fsck_ffs/main.c

300

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

sbin/fsck_ffs/main.c

303

(long long)((n_ffree * 100) / sblock.fs_dsize),

sbin/fsck_ffs/main.c

304

(long long)(((n_ffree * 1000 + sblock.fs_dsize / 2) /

sbin/fsck_ffs/main.c

305

sblock.fs_dsize) % 10));

sbin/fsck_ffs/main.c

307

(n_files -= maxino - ROOTINO - sblock.fs_cstotal.cs_nifree))

sbin/fsck_ffs/main.c

310

n_blks += sblock.fs_ncg *

sbin/fsck_ffs/main.c

311

(cgdmin(&sblock, 0) - cgsblock(&sblock, 0));

sbin/fsck_ffs/main.c

312

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

sbin/fsck_ffs/main.c

313

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

sbin/fsck_ffs/main.c

314

if (n_blks -= maxfsblock - (n_ffree + sblock.fs_frag * n_bfree))

sbin/fsck_ffs/main.c

335

sblock.fs_time = (time_t)time(NULL);

sbin/fsck_ffs/main.c

342

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

sbin/fsck_ffs/main.c

343

bwrite(fswritefd, (char *)&sblock,

sbin/fsck_ffs/main.c

344

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

sbin/fsck_ffs/main.c

350

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

sbin/fsck_ffs/main.c

357

free(sblock.fs_csp);

sbin/fsck_ffs/pass1.c

100

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

sbin/fsck_ffs/pass1.c

101

inumber = c * sblock.fs_ipg;

sbin/fsck_ffs/pass1.c

105

if (sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/pass1.c

107

if (inosused > sblock.fs_ipg)

sbin/fsck_ffs/pass1.c

108

inosused = sblock.fs_ipg;

sbin/fsck_ffs/pass1.c

110

inosused = sblock.fs_ipg;

sbin/fsck_ffs/pass1.c

137

if (inosused < sblock.fs_ipg || inumber == lastino)

sbin/fsck_ffs/pass1.c

145

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

sbin/fsck_ffs/pass1.c

148

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

sbin/fsck_ffs/pass1.c

188

if ((sblock.fs_magic == FS_UFS1_MAGIC &&

sbin/fsck_ffs/pass1.c

194

(sblock.fs_magic == FS_UFS2_MAGIC &&

sbin/fsck_ffs/pass1.c

213

kernmaxfilesize = FS_KERNMAXFILESIZE(getpagesize(), &sblock);

sbin/fsck_ffs/pass1.c

215

DIP(dp, di_size) > sblock.fs_maxfilesize ||

sbin/fsck_ffs/pass1.c

224

DIP_SET(dp, di_size, sblock.fs_fsize);

sbin/fsck_ffs/pass1.c

228

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

sbin/fsck_ffs/pass1.c

243

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

sbin/fsck_ffs/pass1.c

244

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/fsck_ffs/pass1.c

253

ndb *= NINDIR(&sblock);

sbin/fsck_ffs/pass1.c

266

ndb /= NINDIR(&sblock);

sbin/fsck_ffs/pass1.c

304

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

sbin/fsck_ffs/pass1.c

60

(unsigned long long)sblock.fs_ipg * sblock.fs_ncg) > 0);

sbin/fsck_ffs/pass1.c

78

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

sbin/fsck_ffs/pass1.c

79

cgd = cgdmin(&sblock, c);

sbin/fsck_ffs/pass1.c

81

i = cgbase(&sblock, c);

sbin/fsck_ffs/pass1.c

83

i = cgsblock(&sblock, c);

sbin/fsck_ffs/pass1.c

87

i = sblock.fs_csaddr;

sbin/fsck_ffs/pass1.c

88

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

sbin/fsck_ffs/pass1b.c

52

(unsigned long long)sblock.fs_ipg * sblock.fs_ncg) > 0);

sbin/fsck_ffs/pass1b.c

69

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

sbin/fsck_ffs/pass1b.c

70

for (i = 0; i < sblock.fs_ipg; i++, inumber++) {

sbin/fsck_ffs/pass4.c

69

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

sbin/fsck_ffs/pass4.c

70

inumber = c * sblock.fs_ipg;

sbin/fsck_ffs/pass5.c

137

if (sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/pass5.c

67

struct fs *fs = &sblock;

sbin/fsck_ffs/setup.c

179

proto.fs_fsize == sblock.fs_fsize &&

sbin/fsck_ffs/setup.c

180

proto.fs_bsize == sblock.fs_bsize)

sbin/fsck_ffs/setup.c

186

proto.fs_fsize == sblock.fs_fsize &&

sbin/fsck_ffs/setup.c

187

proto.fs_bsize == sblock.fs_bsize)

sbin/fsck_ffs/setup.c

194

proto.fs_fsize == sblock.fs_fsize &&

sbin/fsck_ffs/setup.c

195

proto.fs_bsize == sblock.fs_bsize)

sbin/fsck_ffs/setup.c

213

printf("clean = %d\n", sblock.fs_clean);

sbin/fsck_ffs/setup.c

214

if (sblock.fs_clean & FS_ISCLEAN) {

sbin/fsck_ffs/setup.c

223

maxfsblock = sblock.fs_size;

sbin/fsck_ffs/setup.c

224

maxino = sblock.fs_ncg * sblock.fs_ipg;

sbin/fsck_ffs/setup.c

225

sizepb = sblock.fs_bsize;

sbin/fsck_ffs/setup.c

226

maxfilesize = sblock.fs_bsize * NDADDR - 1;

sbin/fsck_ffs/setup.c

228

sizepb *= NINDIR(&sblock);

sbin/fsck_ffs/setup.c

234

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

sbin/fsck_ffs/setup.c

237

sblock.fs_optim = FS_OPTTIME;

sbin/fsck_ffs/setup.c

241

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

sbin/fsck_ffs/setup.c

243

sblock.fs_minfree);

sbin/fsck_ffs/setup.c

245

sblock.fs_minfree = 10;

sbin/fsck_ffs/setup.c

249

if (sblock.fs_npsect < sblock.fs_nsect ||

sbin/fsck_ffs/setup.c

250

sblock.fs_npsect > sblock.fs_nsect*2) {

sbin/fsck_ffs/setup.c

252

sblock.fs_npsect);

sbin/fsck_ffs/setup.c

253

sblock.fs_npsect = sblock.fs_nsect;

sbin/fsck_ffs/setup.c

261

if (sblock.fs_bmask != ~(sblock.fs_bsize - 1)) {

sbin/fsck_ffs/setup.c

263

sblock.fs_bmask);

sbin/fsck_ffs/setup.c

264

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

sbin/fsck_ffs/setup.c

272

if (sblock.fs_fmask != ~(sblock.fs_fsize - 1)) {

sbin/fsck_ffs/setup.c

274

sblock.fs_fmask);

sbin/fsck_ffs/setup.c

275

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

sbin/fsck_ffs/setup.c

283

if (1 << sblock.fs_bshift != sblock.fs_bsize) {

sbin/fsck_ffs/setup.c

284

pwarn("INCORRECT BSHIFT=%d IN SUPERBLOCK", sblock.fs_bshift);

sbin/fsck_ffs/setup.c

285

sblock.fs_bshift = ffs(sblock.fs_bsize) - 1;

sbin/fsck_ffs/setup.c

293

if (1 << sblock.fs_fshift != sblock.fs_fsize) {

sbin/fsck_ffs/setup.c

294

pwarn("INCORRECT FSHIFT=%d IN SUPERBLOCK", sblock.fs_fshift);

sbin/fsck_ffs/setup.c

295

sblock.fs_fshift = ffs(sblock.fs_fsize) - 1;

sbin/fsck_ffs/setup.c

303

if (sblock.fs_inodefmt < FS_44INODEFMT) {

sbin/fsck_ffs/setup.c

309

if (sblock.fs_maxfilesize != maxfilesize) {

sbin/fsck_ffs/setup.c

311

(unsigned long long)sblock.fs_maxfilesize);

sbin/fsck_ffs/setup.c

312

sblock.fs_maxfilesize = maxfilesize;

sbin/fsck_ffs/setup.c

320

maxsymlinklen = sblock.fs_magic == FS_UFS1_MAGIC ?

sbin/fsck_ffs/setup.c

322

if (sblock.fs_maxsymlinklen != maxsymlinklen) {

sbin/fsck_ffs/setup.c

324

sblock.fs_maxsymlinklen);

sbin/fsck_ffs/setup.c

325

sblock.fs_maxsymlinklen = maxsymlinklen;

sbin/fsck_ffs/setup.c

333

if (sblock.fs_qbmask != ~sblock.fs_bmask) {

sbin/fsck_ffs/setup.c

335

(unsigned long)sblock.fs_qbmask);

sbin/fsck_ffs/setup.c

336

sblock.fs_qbmask = ~sblock.fs_bmask;

sbin/fsck_ffs/setup.c

344

if (sblock.fs_qfmask != ~sblock.fs_fmask) {

sbin/fsck_ffs/setup.c

346

(unsigned long)sblock.fs_qfmask);

sbin/fsck_ffs/setup.c

347

sblock.fs_qfmask = ~sblock.fs_fmask;

sbin/fsck_ffs/setup.c

355

if (sblock.fs_cgsize != fragroundup(&sblock, CGSIZE(&sblock))) {

sbin/fsck_ffs/setup.c

356

pwarn("INCONSISTENT CGSIZE=%d\n", sblock.fs_cgsize);

sbin/fsck_ffs/setup.c

357

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

sbin/fsck_ffs/setup.c

365

if (sblock.fs_magic == FS_UFS2_MAGIC)

sbin/fsck_ffs/setup.c

366

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

sbin/fsck_ffs/setup.c

368

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

sbin/fsck_ffs/setup.c

369

if (INOPB(&sblock) != inopb) {

sbin/fsck_ffs/setup.c

370

pwarn("INCONSISTENT INOPB=%u\n", INOPB(&sblock));

sbin/fsck_ffs/setup.c

371

sblock.fs_inopb = inopb;

sbin/fsck_ffs/setup.c

379

if (sblock.fs_magic == FS_UFS2_MAGIC)

sbin/fsck_ffs/setup.c

380

nindir = sblock.fs_bsize / sizeof(int64_t);

sbin/fsck_ffs/setup.c

382

nindir = sblock.fs_bsize / sizeof(int32_t);

sbin/fsck_ffs/setup.c

383

if (NINDIR(&sblock) != nindir) {

sbin/fsck_ffs/setup.c

384

pwarn("INCONSISTENT NINDIR=%d\n", NINDIR(&sblock));

sbin/fsck_ffs/setup.c

385

sblock.fs_nindir = nindir;

sbin/fsck_ffs/setup.c

394

memcpy(&altsblock, &sblock, (size_t)sblock.fs_sbsize);

sbin/fsck_ffs/setup.c

401

sblock.fs_csp = calloc(1, sblock.fs_cssize);

sbin/fsck_ffs/setup.c

402

if (sblock.fs_csp == NULL) {

sbin/fsck_ffs/setup.c

404

(unsigned)sblock.fs_cssize);

sbin/fsck_ffs/setup.c

407

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

sbin/fsck_ffs/setup.c

408

size = sblock.fs_cssize - i < sblock.fs_bsize ?

sbin/fsck_ffs/setup.c

409

sblock.fs_cssize - i : sblock.fs_bsize;

sbin/fsck_ffs/setup.c

410

if (bread(fsreadfd, (char *)sblock.fs_csp + i,

sbin/fsck_ffs/setup.c

411

fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),

sbin/fsck_ffs/setup.c

430

inostathead = calloc((unsigned)(sblock.fs_ncg),

sbin/fsck_ffs/setup.c

434

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

sbin/fsck_ffs/setup.c

437

numdirs = MAXIMUM(sblock.fs_cstotal.cs_ndir, 128);

sbin/fsck_ffs/setup.c

472

if (bread(fsreadfd, (char *)&sblock, super, (long)SBSIZE) != 0)

sbin/fsck_ffs/setup.c

475

if (sblock.fs_magic != FS_UFS1_MAGIC &&

sbin/fsck_ffs/setup.c

476

sblock.fs_magic != FS_UFS2_MAGIC) {

sbin/fsck_ffs/setup.c

484

if (bread(fsreadfd, (char *)&sblock, super,

sbin/fsck_ffs/setup.c

488

if (sblock.fs_magic != FS_UFS1_MAGIC &&

sbin/fsck_ffs/setup.c

489

sblock.fs_magic != FS_UFS2_MAGIC)

sbin/fsck_ffs/setup.c

497

if (sblock.fs_magic == FS_UFS1_MAGIC &&

sbin/fsck_ffs/setup.c

501

if (sblock.fs_magic == FS_UFS2_MAGIC &&

sbin/fsck_ffs/setup.c

502

sblock.fs_sblockloc != sbtry[i])

sbin/fsck_ffs/setup.c

520

if (sblock.fs_ncg < 1) {

sbin/fsck_ffs/setup.c

524

if (sblock.fs_cpg < 1) {

sbin/fsck_ffs/setup.c

528

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/fsck_ffs/setup.c

529

if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||

sbin/fsck_ffs/setup.c

530

(sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl) {

sbin/fsck_ffs/setup.c

535

if (sblock.fs_sbsize > SBSIZE) {

sbin/fsck_ffs/setup.c

540

if (!POWEROF2(sblock.fs_bsize) || sblock.fs_bsize < MINBSIZE ||

sbin/fsck_ffs/setup.c

541

sblock.fs_bsize > MAXBSIZE) {

sbin/fsck_ffs/setup.c

546

if (!POWEROF2(sblock.fs_fsize) || sblock.fs_fsize > sblock.fs_bsize ||

sbin/fsck_ffs/setup.c

547

sblock.fs_fsize < sblock.fs_bsize / MAXFRAG) {

sbin/fsck_ffs/setup.c

554

getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);

sbin/fsck_ffs/setup.c

557

if (cmpsb(&sblock, &altsblock)) {

sbin/fsck_ffs/setup.c

563

olp = (long *)&sblock;

sbin/fsck_ffs/setup.c

564

endlp = olp + (sblock.fs_sbsize / sizeof *olp);

sbin/fsck_ffs/setup.c

569

(int)(olp - (long *)&sblock), *olp, *nlp);

sbin/fsck_ffs/setup.c

577

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/fsck_ffs/setup.c

578

sblock.fs_time = sblock.fs_ffs1_time;

sbin/fsck_ffs/setup.c

579

sblock.fs_size = sblock.fs_ffs1_size;

sbin/fsck_ffs/setup.c

580

sblock.fs_dsize = sblock.fs_ffs1_dsize;

sbin/fsck_ffs/setup.c

581

sblock.fs_csaddr = sblock.fs_ffs1_csaddr;

sbin/fsck_ffs/setup.c

582

sblock.fs_cstotal.cs_ndir = sblock.fs_ffs1_cstotal.cs_ndir;

sbin/fsck_ffs/setup.c

583

sblock.fs_cstotal.cs_nbfree = sblock.fs_ffs1_cstotal.cs_nbfree;

sbin/fsck_ffs/setup.c

584

sblock.fs_cstotal.cs_nifree = sblock.fs_ffs1_cstotal.cs_nifree;

sbin/fsck_ffs/setup.c

585

sblock.fs_cstotal.cs_nffree = sblock.fs_ffs1_cstotal.cs_nffree;

sbin/fsck_ffs/utilities.c

132

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

sbin/fsck_ffs/utilities.c

133

iloff = inum % sblock.fs_ipg;

sbin/fsck_ffs/utilities.c

150

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

sbin/fsck_ffs/utilities.c

156

bufcnt = MAXBUFSPACE / sblock.fs_bsize;

sbin/fsck_ffs/utilities.c

161

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

sbin/fsck_ffs/utilities.c

191

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

sbin/fsck_ffs/utilities.c

200

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

sbin/fsck_ffs/utilities.c

202

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

sbin/fsck_ffs/utilities.c

207

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

sbin/fsck_ffs/utilities.c

221

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

sbin/fsck_ffs/utilities.c

247

dblk = fsbtodb(&sblock, blk);

sbin/fsck_ffs/utilities.c

273

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

sbin/fsck_ffs/utilities.c

274

bwrite(fswritefd, (char *)sblock.fs_csp + i,

sbin/fsck_ffs/utilities.c

275

fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),

sbin/fsck_ffs/utilities.c

276

sblock.fs_cssize - i < sblock.fs_bsize ?

sbin/fsck_ffs/utilities.c

277

sblock.fs_cssize - i : sblock.fs_bsize);

sbin/fsck_ffs/utilities.c

310

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/fsck_ffs/utilities.c

312

sblock.fs_ffs1_time = sblock.fs_time;

sbin/fsck_ffs/utilities.c

313

sblock.fs_ffs1_size = sblock.fs_size;

sbin/fsck_ffs/utilities.c

314

sblock.fs_ffs1_dsize = sblock.fs_dsize;

sbin/fsck_ffs/utilities.c

315

sblock.fs_ffs1_csaddr = sblock.fs_csaddr;

sbin/fsck_ffs/utilities.c

316

sblock.fs_ffs1_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;

sbin/fsck_ffs/utilities.c

317

sblock.fs_ffs1_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;

sbin/fsck_ffs/utilities.c

318

sblock.fs_ffs1_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;

sbin/fsck_ffs/utilities.c

319

sblock.fs_ffs1_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;

sbin/fsck_ffs/utilities.c

321

sblock.fs_ffs1_flags &= ~FS_FLAGS_UPDATED;

sbin/fsck_ffs/utilities.c

343

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

sbin/fsck_ffs/utilities.c

352

if (markclean && (sblock.fs_clean & FS_ISCLEAN) == 0) {

sbin/fsck_ffs/utilities.c

361

sblock.fs_clean = FS_ISCLEAN;

sbin/fsck_ffs/utilities.c

449

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

sbin/fsck_ffs/utilities.c

451

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

sbin/fsck_ffs/utilities.c

452

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

sbin/fsck_ffs/utilities.c

462

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

sbin/fsck_ffs/utilities.c

467

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

sbin/fsck_ffs/utilities.c

474

if (frags == sblock.fs_frag)

sbin/fsck_ffs/utilities.c

668

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

sbin/fsdb/fsdb.c

156

sblock.fs_fsmnt);

sbin/fsdb/fsdb.c

158

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

sbin/fsdb/fsdbutil.c

109

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

sbin/fsdb/fsdbutil.c

111

char *p = sblock.fs_magic == FS_UFS1_MAGIC ?

sbin/fsirand/fsirand.c

100

struct fs *sblock, *tmpsblock;

sbin/fsirand/fsirand.c

130

sblock = (struct fs *)&sbuf;

sbin/fsirand/fsirand.c

141

if ((n = read(devfd, sblock, SBSIZE)) != SBSIZE) {

sbin/fsirand/fsirand.c

148

if (sblock->fs_magic != FS_UFS1_MAGIC &&

sbin/fsirand/fsirand.c

149

sblock->fs_magic != FS_UFS2_MAGIC)

sbin/fsirand/fsirand.c

157

if (sblock->fs_magic == FS_UFS1_MAGIC &&

sbin/fsirand/fsirand.c

161

if (sblock->fs_magic == FS_UFS2_MAGIC &&

sbin/fsirand/fsirand.c

162

sblock->fs_sblockloc != sbtry[i])

sbin/fsirand/fsirand.c

174

if (sblock->fs_sbsize > SBSIZE) {

sbin/fsirand/fsirand.c

179

if (sblock->fs_postblformat == FS_42POSTBLFMT) {

sbin/fsirand/fsirand.c

184

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

sbin/fsirand/fsirand.c

191

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

sbin/fsirand/fsirand.c

192

dblk = fsbtodb(sblock, cgsblock(sblock, cg));

sbin/fsirand/fsirand.c

216

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/fsirand/fsirand.c

221

if ((ib = reallocarray(inodebuf, sblock->fs_ipg, isize)) == NULL)

sbin/fsirand/fsirand.c

224

ibufsize = sblock->fs_ipg * isize;

sbin/fsirand/fsirand.c

226

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

sbin/fsirand/fsirand.c

227

if (sblock->fs_inodefmt >= FS_44INODEFMT && sblock->fs_id[0]) {

sbin/fsirand/fsirand.c

228

time_t t = sblock->fs_id[0]; /* XXX 2038 */

sbin/fsirand/fsirand.c

237

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

sbin/fsirand/fsirand.c

238

sblock->fs_id[1]);

sbin/fsirand/fsirand.c

242

if ((sblock->fs_inodefmt >= FS_44INODEFMT) && !printonly) {

sbin/fsirand/fsirand.c

244

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

sbin/fsirand/fsirand.c

245

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

sbin/fsirand/fsirand.c

252

if ((n = write(devfd, sblock, SBSIZE)) != SBSIZE) {

sbin/fsirand/fsirand.c

260

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

sbin/fsirand/fsirand.c

262

if ((sblock->fs_inodefmt >= FS_44INODEFMT) && !printonly) {

sbin/fsirand/fsirand.c

263

dblk = fsbtodb(sblock, cgsblock(sblock, cg));

sbin/fsirand/fsirand.c

269

} else if ((n = write(devfd, sblock, SBSIZE)) !=

sbin/fsirand/fsirand.c

279

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

sbin/fsirand/fsirand.c

289

for (n = 0; n < sblock->fs_ipg; n++, inumber++) {

sbin/fsirand/fsirand.c

290

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/fsirand/fsirand.c

298

sblock->fs_magic == FS_UFS1_MAGIC ?

sbin/fsirand/fsirand.c

300

else if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/growfs/growfs.c

1008

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

sbin/growfs/growfs.c

1009

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

sbin/growfs/growfs.c

1015

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

sbin/growfs/growfs.c

1016

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

sbin/growfs/growfs.c

1032

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

sbin/growfs/growfs.c

1033

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

sbin/growfs/growfs.c

104

((sblock.fs_magic == FS_UFS1_MAGIC) ? \

sbin/growfs/growfs.c

1041

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

sbin/growfs/growfs.c

1042

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

sbin/growfs/growfs.c

1043

d += sblock.fs_frag) {

sbin/growfs/growfs.c

1044

clrblock(&sblock, cg_blksfree(&acg),

sbin/growfs/growfs.c

1045

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

sbin/growfs/growfs.c

1047

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1048

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1050

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

sbin/growfs/growfs.c

1058

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

sbin/growfs/growfs.c

1059

for (; d - sblock.fs_csaddr <

sbin/growfs/growfs.c

1060

sblock.fs_cssize/sblock.fs_fsize;

sbin/growfs/growfs.c

1062

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

sbin/growfs/growfs.c

1064

sblock.fs_cstotal.cs_nffree--;

sbin/growfs/growfs.c

1067

acg.cg_cs.cs_nffree += sblock.fs_frag;

sbin/growfs/growfs.c

1068

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1069

sblock.fs_cstotal.cs_nffree += sblock.fs_frag;

sbin/growfs/growfs.c

107

if (sblock.fs_magic == FS_UFS1_MAGIC) \

sbin/growfs/growfs.c

1070

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1072

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

sbin/growfs/growfs.c

1075

frag_adjust(d % sblock.fs_fpg, 1);

sbin/growfs/growfs.c

1096

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

sbin/growfs/growfs.c

1097

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

sbin/growfs/growfs.c

1106

dupper = sblock.fs_csaddr - cbase +

sbin/growfs/growfs.c

1107

howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/growfs/growfs.c

1111

sblock.fs_dsize -= dupper-odupper;

sbin/growfs/growfs.c

1116

bp = calloc(((dupper-odupper) / sblock.fs_frag + 2),

sbin/growfs/growfs.c

1131

for (d = odupper; ((d < dupper) && (d % sblock.fs_frag)); d++) {

sbin/growfs/growfs.c

1134

bp[ind].old = d / sblock.fs_frag;

sbin/growfs/growfs.c

1136

if (roundup(d, sblock.fs_frag) >= dupper)

sbin/growfs/growfs.c

1143

sblock.fs_cstotal.cs_nffree--;

sbin/growfs/growfs.c

1158

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

sbin/growfs/growfs.c

1159

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

sbin/growfs/growfs.c

1160

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

sbin/growfs/growfs.c

1163

sblock.fs_cstotal.cs_nffree--;

sbin/growfs/growfs.c

1166

clrblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag);

sbin/growfs/growfs.c

1167

bp[ind].old = d / sblock.fs_frag;

sbin/growfs/growfs.c

1170

clrblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag);

sbin/growfs/growfs.c

1172

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1173

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1174

clrbit(cg_clustersfree(&acg), d / sblock.fs_frag);

sbin/growfs/growfs.c

1175

for (lcs = 0, l = (d / sblock.fs_frag) + 1;

sbin/growfs/growfs.c

1176

lcs < sblock.fs_contigsumsize;

sbin/growfs/growfs.c

1181

if (lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

1200

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

sbin/growfs/growfs.c

1202

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1203

acg.cg_cs.cs_nffree+=sblock.fs_frag;

sbin/growfs/growfs.c

1204

sblock.fs_cstotal.cs_nffree+=sblock.fs_frag;

sbin/growfs/growfs.c

1205

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1206

clrbit(cg_clustersfree(&acg), d / sblock.fs_frag);

sbin/growfs/growfs.c

1207

for (lcs = 0, l = (d / sblock.fs_frag) + 1;

sbin/growfs/growfs.c

1208

lcs < sblock.fs_contigsumsize;

sbin/growfs/growfs.c

1213

if (lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

1223

bp[ind].old = d / sblock.fs_frag;

sbin/growfs/growfs.c

1228

sblock.fs_cstotal.cs_nffree--;

sbin/growfs/growfs.c

1253

bp[i].new = alloc() / sblock.fs_frag;

sbin/growfs/growfs.c

1259

for (f = bp[i].old * sblock.fs_frag,

sbin/growfs/growfs.c

1260

g = bp[i].new * sblock.fs_frag;

sbin/growfs/growfs.c

1261

f < (bp[i].old + 1) * sblock.fs_frag;

sbin/growfs/growfs.c

1266

sblock.fs_cstotal.cs_nffree++;

sbin/growfs/growfs.c

1279

for (f = bp[i].old * sblock.fs_frag,

sbin/growfs/growfs.c

1280

g = bp[i].new * sblock.fs_frag;

sbin/growfs/growfs.c

1285

sblock.fs_cstotal.cs_nffree++;

sbin/growfs/growfs.c

1288

frag_adjust(bp[i].new * sblock.fs_frag, 1);

sbin/growfs/growfs.c

1296

frag_adjust(bp[i].new * sblock.fs_frag, 1);

sbin/growfs/growfs.c

1297

frag_adjust(bp[i].old * sblock.fs_frag, -1);

sbin/growfs/growfs.c

1299

f < roundup(dupper, sblock.fs_frag);

sbin/growfs/growfs.c

1304

sblock.fs_cstotal.cs_nffree++;

sbin/growfs/growfs.c

1307

frag_adjust(bp[i].old * sblock.fs_frag, 1);

sbin/growfs/growfs.c

1313

bp[i].old += cbase / sblock.fs_frag;

sbin/growfs/growfs.c

1314

bp[i].new += cbase / sblock.fs_frag;

sbin/growfs/growfs.c

1323

rdfs(fsbtodb(&sblock, bp[i].old * sblock.fs_frag),

sbin/growfs/growfs.c

1324

(size_t)sblock.fs_bsize, (void *)&ablk, fsi);

sbin/growfs/growfs.c

1325

wtfs(fsbtodb(&sblock, bp[i].new * sblock.fs_frag),

sbin/growfs/growfs.c

1326

(size_t)sblock.fs_bsize, (void *)&ablk, fso, Nflag);

sbin/growfs/growfs.c

1346

if (!bp[i].found || (bp[i].found > sblock.fs_frag)) {

sbin/growfs/growfs.c

1369

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

sbin/growfs/growfs.c

1440

dlower = cgsblock(&sblock, acg.cg_cgx) - cgbase(&sblock, acg.cg_cgx);

sbin/growfs/growfs.c

1441

dupper = cgdmin(&sblock, acg.cg_cgx) - cgbase(&sblock, acg.cg_cgx);

sbin/growfs/growfs.c

1442

dmax = cgbase(&sblock, acg.cg_cgx) + sblock.fs_fpg;

sbin/growfs/growfs.c

1443

if (dmax > sblock.fs_size) {

sbin/growfs/growfs.c

1444

dmax = sblock.fs_size;

sbin/growfs/growfs.c

1446

dmax -= cgbase(&sblock, acg.cg_cgx); /* retransform into cg */

sbin/growfs/growfs.c

1447

csmin=sblock.fs_csaddr-cgbase(&sblock, acg.cg_cgx);

sbin/growfs/growfs.c

1448

csmax = csmin + howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/growfs/growfs.c

1450

for (d = 0; (d < dlower && blkno == -1); d += sblock.fs_frag) {

sbin/growfs/growfs.c

1454

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

sbin/growfs/growfs.c

1456

blkno = fragstoblks(&sblock, d);/* Yeah found a block */

sbin/growfs/growfs.c

1460

for (d = dupper; (d < dmax && blkno == -1); d += sblock.fs_frag) {

sbin/growfs/growfs.c

1464

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

sbin/growfs/growfs.c

1466

blkno = fragstoblks(&sblock, d);/* Yeah found a block */

sbin/growfs/growfs.c

1478

d = blkstofrags(&sblock, blkno);

sbin/growfs/growfs.c

1480

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

sbin/growfs/growfs.c

1481

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1493

for (lcs1 = 0, l = blkno - 1; lcs1 < sblock.fs_contigsumsize;

sbin/growfs/growfs.c

1502

for (lcs2 = 0, l = blkno + 1; lcs2 < sblock.fs_contigsumsize;

sbin/growfs/growfs.c

1511

cg_clustersum(&acg)[MINIMUM(lcs1 + lcs2 + 1, sblock.fs_contigsumsize)]--;

sbin/growfs/growfs.c

1521

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1631

inumber += (cg * sblock.fs_ipg);

sbin/growfs/growfs.c

1639

inumber < startinum || inumber >= startinum + INOPB(&sblock)) {

sbin/growfs/growfs.c

1640

inoblk = fsbtodb(&sblock, ino_to_fsba(&sblock, inumber));

sbin/growfs/growfs.c

1641

rdfs(inoblk, (size_t)sblock.fs_bsize, inobuf, fsi);

sbin/growfs/growfs.c

1642

startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);

sbin/growfs/growfs.c

1644

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/growfs/growfs.c

1646

(inumber % INOPB(&sblock)) * sizeof(struct ufs1_dinode));

sbin/growfs/growfs.c

1648

(inumber % INOPB(&sblock)) * sizeof(struct ufs2_dinode));

sbin/growfs/growfs.c

180

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

sbin/growfs/growfs.c

1810

if (sblock.fs_magic == FS_UFS1_MAGIC &&

sbin/growfs/growfs.c

1811

(sblock.fs_ffs1_flags & FS_FLAGS_UPDATED) == 0)

sbin/growfs/growfs.c

1812

ffs1_sb_update(&sblock, sblock_try[i]);

sbin/growfs/growfs.c

1814

maxino = sblock.fs_ncg * sblock.fs_ipg;

sbin/growfs/growfs.c

1820

sblock.fs_size = dbtofsb(&osblock, DL_SECTOBLK(lp, DL_GETPSIZE(pp)));

sbin/growfs/growfs.c

1826

sblock.fs_size = dbtofsb(&osblock, DL_SECTOBLK(lp, size));

sbin/growfs/growfs.c

1832

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

sbin/growfs/growfs.c

1834

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

sbin/growfs/growfs.c

1844

if (sblock.fs_snapinum[j]) {

sbin/growfs/growfs.c

1849

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

sbin/growfs/growfs.c

1868

(intmax_t)sblock.fs_size);

sbin/growfs/growfs.c

1895

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/growfs/growfs.c

1896

sblock.fs_ncyl = sblock.fs_size * NSPF(&sblock) / sblock.fs_spc;

sbin/growfs/growfs.c

1897

if (sblock.fs_size * NSPF(&sblock) >

sbin/growfs/growfs.c

1898

sblock.fs_ncyl * sblock.fs_spc)

sbin/growfs/growfs.c

1899

sblock.fs_ncyl++;

sbin/growfs/growfs.c

1901

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

sbin/growfs/growfs.c

1902

if ((ino_t)sblock.fs_ncg * sblock.fs_ipg > UINT_MAX)

sbin/growfs/growfs.c

1904

maxino = sblock.fs_ncg * sblock.fs_ipg;

sbin/growfs/growfs.c

1906

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

sbin/growfs/growfs.c

1907

sblock.fs_size % sblock.fs_fpg < cgdmin(&sblock, sblock.fs_ncg)) {

sbin/growfs/growfs.c

1912

sblock.fs_ncg--;

sbin/growfs/growfs.c

1913

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/growfs/growfs.c

1914

sblock.fs_ncyl = sblock.fs_ncg * sblock.fs_cpg;

sbin/growfs/growfs.c

1917

(intmax_t)fsbtodb(&sblock,

sbin/growfs/growfs.c

1918

sblock.fs_size % sblock.fs_fpg));

sbin/growfs/growfs.c

1919

sblock.fs_size = sblock.fs_ncg * sblock.fs_fpg;

sbin/growfs/growfs.c

1926

sblock.fs_cssize =

sbin/growfs/growfs.c

1927

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

sbin/growfs/growfs.c

1929

if (osblock.fs_size >= sblock.fs_size)

sbin/growfs/growfs.c

1941

DISKLABELV1_FFS_FRAGBLOCK(sblock.fs_fsize, sblock.fs_frag);

sbin/growfs/growfs.c

1942

pp->p_cpg = sblock.fs_fpg;

sbin/growfs/growfs.c

199

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

sbin/growfs/growfs.c

200

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

sbin/growfs/growfs.c

201

sblock.fs_fsize);

sbin/growfs/growfs.c

2022

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

sbin/growfs/growfs.c

203

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

sbin/growfs/growfs.c

2037

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

sbin/growfs/growfs.c

204

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

sbin/growfs/growfs.c

2042

if (lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

2072

DIP(ino, di_size) < (u_int64_t) sblock.fs_maxsymlinklen)

sbin/growfs/growfs.c

2074

numblks = howmany(DIP(ino, di_size), sblock.fs_bsize);

sbin/growfs/growfs.c

2107

blksperindir *= NINDIR(&sblock);

sbin/growfs/growfs.c

2112

wtfs(inoblk, sblock.fs_bsize, inobuf, fso, Nflag);

sbin/growfs/growfs.c

2127

ibuf = malloc(sblock.fs_bsize);

sbin/growfs/growfs.c

2130

rdfs(fsbtodb(&sblock, blkno), (size_t)sblock.fs_bsize, ibuf, fsi);

sbin/growfs/growfs.c

2131

last = howmany(lastlbn - lbn, blksperindir) < NINDIR(&sblock) ?

sbin/growfs/growfs.c

2132

howmany(lastlbn - lbn, blksperindir) : NINDIR(&sblock);

sbin/growfs/growfs.c

2134

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/growfs/growfs.c

2141

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/growfs/growfs.c

2148

indirchk(blksperindir / NINDIR(&sblock), lbn + blksperindir * i,

sbin/growfs/growfs.c

218

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

sbin/growfs/growfs.c

223

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

sbin/growfs/growfs.c

224

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

sbin/growfs/growfs.c

247

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

sbin/growfs/growfs.c

248

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

sbin/growfs/growfs.c

249

(size_t)MINIMUM(sblock.fs_cssize - i, sblock.fs_bsize),

sbin/growfs/growfs.c

256

sblock.fs_time = utime;

sbin/growfs/growfs.c

257

sblock.fs_clean = 0;

sbin/growfs/growfs.c

258

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/growfs/growfs.c

259

sblock.fs_ffs1_time = (int32_t)sblock.fs_time;

sbin/growfs/growfs.c

260

sblock.fs_ffs1_size = (int32_t)sblock.fs_size;

sbin/growfs/growfs.c

261

sblock.fs_ffs1_dsize = (int32_t)sblock.fs_dsize;

sbin/growfs/growfs.c

262

sblock.fs_ffs1_csaddr = (int32_t)sblock.fs_csaddr;

sbin/growfs/growfs.c

263

sblock.fs_ffs1_cstotal.cs_ndir =

sbin/growfs/growfs.c

264

(int32_t)sblock.fs_cstotal.cs_ndir;

sbin/growfs/growfs.c

265

sblock.fs_ffs1_cstotal.cs_nbfree =

sbin/growfs/growfs.c

266

(int32_t)sblock.fs_cstotal.cs_nbfree;

sbin/growfs/growfs.c

267

sblock.fs_ffs1_cstotal.cs_nifree =

sbin/growfs/growfs.c

268

(int32_t)sblock.fs_cstotal.cs_nifree;

sbin/growfs/growfs.c

269

sblock.fs_ffs1_cstotal.cs_nffree =

sbin/growfs/growfs.c

270

(int32_t)sblock.fs_cstotal.cs_nffree;

sbin/growfs/growfs.c

272

wtfs(sblockloc, (size_t)SBLOCKSIZE, (void *)&sblock, fso, Nflag);

sbin/growfs/growfs.c

277

sblock.fs_fmod = 0;

sbin/growfs/growfs.c

278

sblock.fs_clean = 1;

sbin/growfs/growfs.c

279

sblock.fs_ronly = 0;

sbin/growfs/growfs.c

280

sblock.fs_cgrotor = 0;

sbin/growfs/growfs.c

281

sblock.fs_state = 0;

sbin/growfs/growfs.c

282

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

sbin/growfs/growfs.c

308

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

sbin/growfs/growfs.c

309

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

sbin/growfs/growfs.c

310

(size_t)SBLOCKSIZE, (void *)&sblock, fso, Nflag);

sbin/growfs/growfs.c

332

if (sblock.fs_bsize < SBLOCKSIZE)

sbin/growfs/growfs.c

333

iobufsize = SBLOCKSIZE + 3 * sblock.fs_bsize;

sbin/growfs/growfs.c

335

iobufsize = 4 * sblock.fs_bsize;

sbin/growfs/growfs.c

346

cbase = cgbase(&sblock, cg);

sbin/growfs/growfs.c

347

dmax = cbase + sblock.fs_fpg;

sbin/growfs/growfs.c

348

if (dmax > sblock.fs_size)

sbin/growfs/growfs.c

349

dmax = sblock.fs_size;

sbin/growfs/growfs.c

350

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

sbin/growfs/growfs.c

351

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

sbin/growfs/growfs.c

353

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

sbin/growfs/growfs.c

355

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

sbin/growfs/growfs.c

359

acg.cg_ffs2_niblk = sblock.fs_ipg;

sbin/growfs/growfs.c

360

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

sbin/growfs/growfs.c

362

if (sblock.fs_contigsumsize > 0)

sbin/growfs/growfs.c

363

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

sbin/growfs/growfs.c

365

if (sblock.fs_magic == FS_UFS2_MAGIC) {

sbin/growfs/growfs.c

368

if (cg == sblock.fs_ncg - 1)

sbin/growfs/growfs.c

369

acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;

sbin/growfs/growfs.c

371

acg.cg_ncyl = sblock.fs_cpg;

sbin/growfs/growfs.c

379

sblock.fs_cpg * sizeof(int32_t);

sbin/growfs/growfs.c

381

sblock.fs_cpg * sizeof(u_int16_t);

sbin/growfs/growfs.c

383

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

sbin/growfs/growfs.c

384

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

sbin/growfs/growfs.c

385

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

390

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

sbin/growfs/growfs.c

392

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

sbin/growfs/growfs.c

394

if (acg.cg_nextfreeoff > sblock.fs_cgsize) {

sbin/growfs/growfs.c

401

acg.cg_cs.cs_nifree += sblock.fs_ipg;

sbin/growfs/growfs.c

413

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

sbin/growfs/growfs.c

414

blkno = d / sblock.fs_frag;

sbin/growfs/growfs.c

415

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

sbin/growfs/growfs.c

416

if (sblock.fs_contigsumsize > 0)

sbin/growfs/growfs.c

420

sblock.fs_dsize += dlower;

sbin/growfs/growfs.c

422

sblock.fs_dsize += acg.cg_ndblk - dupper;

sbin/growfs/growfs.c

423

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

sbin/growfs/growfs.c

424

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

sbin/growfs/growfs.c

425

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

sbin/growfs/growfs.c

430

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

sbin/growfs/growfs.c

431

d += sblock.fs_frag) {

sbin/growfs/growfs.c

432

blkno = d / sblock.fs_frag;

sbin/growfs/growfs.c

433

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

sbin/growfs/growfs.c

434

if (sblock.fs_contigsumsize > 0)

sbin/growfs/growfs.c

445

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

456

if (run > sblock.fs_contigsumsize)

sbin/growfs/growfs.c

457

run = sblock.fs_contigsumsize;

sbin/growfs/growfs.c

469

if (run > sblock.fs_contigsumsize)

sbin/growfs/growfs.c

470

run = sblock.fs_contigsumsize;

sbin/growfs/growfs.c

474

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

sbin/growfs/growfs.c

475

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

sbin/growfs/growfs.c

476

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

sbin/growfs/growfs.c

477

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

sbin/growfs/growfs.c

484

bcopy(&sblock, iobuf, SBLOCKSIZE);

sbin/growfs/growfs.c

485

start = sblock.fs_bsize > SBLOCKSIZE ? sblock.fs_bsize : SBLOCKSIZE;

sbin/growfs/growfs.c

486

bcopy(&acg, &iobuf[start], sblock.fs_cgsize);

sbin/growfs/growfs.c

487

start += sblock.fs_bsize;

sbin/growfs/growfs.c

490

for (i = MINIMUM(sblock.fs_ipg, 2 * INOPB(&sblock)); i != 0; i--) {

sbin/growfs/growfs.c

491

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/growfs/growfs.c

499

wtfs(fsbtodb(&sblock, cgsblock(&sblock, cg)), iobufsize,

sbin/growfs/growfs.c

503

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/growfs/growfs.c

504

for (i = 2 * sblock.fs_frag; i < sblock.fs_ipg / INOPF(&sblock);

sbin/growfs/growfs.c

505

i += sblock.fs_frag) {

sbin/growfs/growfs.c

507

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

sbin/growfs/growfs.c

511

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

sbin/growfs/growfs.c

512

(size_t)sblock.fs_bsize, &iobuf[start], fso, Nflag);

sbin/growfs/growfs.c

534

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

sbin/growfs/growfs.c

535

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

sbin/growfs/growfs.c

543

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

sbin/growfs/growfs.c

552

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

sbin/growfs/growfs.c

579

if (fragstoblks(&sblock, src) != f->old)

sbin/growfs/growfs.c

584

dst = blkstofrags(&sblock, f->new);

sbin/growfs/growfs.c

585

fragnum = fragnum(&sblock, src);

sbin/growfs/growfs.c

596

ibuf = malloc(sblock.fs_bsize);

sbin/growfs/growfs.c

600

rdfs(fsbtodb(&sblock, src), (size_t)sblock.fs_bsize, ibuf, fsi);

sbin/growfs/growfs.c

601

wtfs(dst, (size_t)sblock.fs_bsize, ibuf, fso, Nflag);

sbin/growfs/growfs.c

648

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/growfs/growfs.c

649

acg.cg_ncyl = sblock.fs_cpg;

sbin/growfs/growfs.c

651

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

sbin/growfs/growfs.c

652

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

sbin/growfs/growfs.c

660

cbase = cgbase(&sblock, cg);

sbin/growfs/growfs.c

661

dmax = cbase + sblock.fs_fpg;

sbin/growfs/growfs.c

662

if (dmax > sblock.fs_size)

sbin/growfs/growfs.c

663

dmax = sblock.fs_size;

sbin/growfs/growfs.c

664

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

sbin/growfs/growfs.c

666

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

sbin/growfs/growfs.c

678

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/growfs/growfs.c

679

if (cg == sblock.fs_ncg - 1) {

sbin/growfs/growfs.c

683

acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;

sbin/growfs/growfs.c

685

acg.cg_ncyl = sblock.fs_cpg;

sbin/growfs/growfs.c

689

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

sbin/growfs/growfs.c

690

if (sblock.fs_contigsumsize > 0)

sbin/growfs/growfs.c

691

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

sbin/growfs/growfs.c

705

if (osblock.fs_size % sblock.fs_frag) {

sbin/growfs/growfs.c

706

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

sbin/growfs/growfs.c

712

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

sbin/growfs/growfs.c

724

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

sbin/growfs/growfs.c

725

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

sbin/growfs/growfs.c

726

sblock.fs_frag))) {

sbin/growfs/growfs.c

730

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

sbin/growfs/growfs.c

732

acg.cg_cs.cs_nffree-=sblock.fs_frag;

sbin/growfs/growfs.c

734

sblock.fs_frag);

sbin/growfs/growfs.c

735

updclst((osblock.fs_size-cbase)/sblock.fs_frag);

sbin/growfs/growfs.c

744

sblock.fs_frag))) {

sbin/growfs/growfs.c

757

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

sbin/growfs/growfs.c

769

sblock.fs_frag))) {

sbin/growfs/growfs.c

782

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

sbin/growfs/growfs.c

783

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

sbin/growfs/growfs.c

784

i += sblock.fs_frag) {

sbin/growfs/growfs.c

785

j = i / sblock.fs_frag;

sbin/growfs/growfs.c

786

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

sbin/growfs/growfs.c

804

sblock.fs_cstotal.cs_nffree +=

sbin/growfs/growfs.c

806

sblock.fs_cstotal.cs_nbfree +=

sbin/growfs/growfs.c

820

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

sbin/growfs/growfs.c

854

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

sbin/growfs/growfs.c

863

blocks = 1+howmany(sblock.fs_cssize, sblock.fs_bsize)-

sbin/growfs/growfs.c

909

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

sbin/growfs/growfs.c

923

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

924

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

sbin/growfs/growfs.c

925

lcs = 0; lcs < sblock.fs_contigsumsize;

sbin/growfs/growfs.c

937

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

sbin/growfs/growfs.c

942

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

sbin/growfs/growfs.c

943

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

sbin/growfs/growfs.c

944

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

sbin/growfs/growfs.c

946

sblock.fs_cstotal.cs_nffree++;

sbin/growfs/growfs.c

953

frag_adjust(d % sblock.fs_fpg, 1);

sbin/growfs/growfs.c

955

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

sbin/growfs/growfs.c

956

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

sbin/growfs/growfs.c

957

acg.cg_cs.cs_nffree -= sblock.fs_frag;

sbin/growfs/growfs.c

959

sblock.fs_cstotal.cs_nffree -= sblock.fs_frag;

sbin/growfs/growfs.c

960

sblock.fs_cstotal.cs_nbfree++;

sbin/growfs/growfs.c

961

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

963

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

sbin/growfs/growfs.c

964

if (lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

981

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

sbin/growfs/growfs.c

982

d -= sblock.fs_frag) {

sbin/growfs/growfs.c

983

setblock(&sblock, cg_blksfree(&acg),

sbin/growfs/growfs.c

984

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

sbin/growfs/growfs.c

986

sblock.fs_cstotal.cs_nbfree++;

sbin/growfs/growfs.c

987

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

989

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

sbin/growfs/growfs.c

993

if (lcs < sblock.fs_contigsumsize) {

sbin/ncheck_ffs/ncheck_ffs.c

176

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/ncheck_ffs/ncheck_ffs.c

193

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/ncheck_ffs/ncheck_ffs.c

241

if (inum < ROOTINO || inum >= sblock->fs_ncg * sblock->fs_ipg)

sbin/ncheck_ffs/ncheck_ffs.c

245

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/ncheck_ffs/ncheck_ffs.c

249

if ((inum / sblock->fs_ipg) != iblk || itab == NULL) {

sbin/ncheck_ffs/ncheck_ffs.c

250

iblk = inum / sblock->fs_ipg;

sbin/ncheck_ffs/ncheck_ffs.c

252

(itab = reallocarray(NULL, sblock->fs_ipg, dsize)) == NULL)

sbin/ncheck_ffs/ncheck_ffs.c

254

bread(fsbtodb(sblock, cgimin(sblock, iblk)), itab,

sbin/ncheck_ffs/ncheck_ffs.c

255

sblock->fs_ipg * dsize);

sbin/ncheck_ffs/ncheck_ffs.c

257

return itab + (inum % sblock->fs_ipg) * dsize;

sbin/ncheck_ffs/ncheck_ffs.c

282

fsbtodb(sblock, sblock->fs_ffs1_size)) {

sbin/ncheck_ffs/ncheck_ffs.c

357

sblksize(sblock, DIP(dp, di_size), i),

sbin/ncheck_ffs/ncheck_ffs.c

360

filesize -= sblock->fs_bsize;

sbin/ncheck_ffs/ncheck_ffs.c

379

if ((idblk = malloc(sblock->fs_bsize)) == NULL)

sbin/ncheck_ffs/ncheck_ffs.c

381

bread(fsbtodb(sblock, blkno), idblk, (int)sblock->fs_bsize);

sbin/ncheck_ffs/ncheck_ffs.c

383

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

sbin/ncheck_ffs/ncheck_ffs.c

384

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/ncheck_ffs/ncheck_ffs.c

389

searchdir(ino, blkno, sblock->fs_bsize,

sbin/ncheck_ffs/ncheck_ffs.c

391

*filesizep -= sblock->fs_bsize;

sbin/ncheck_ffs/ncheck_ffs.c

395

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

sbin/ncheck_ffs/ncheck_ffs.c

396

if (sblock->fs_magic == FS_UFS1_MAGIC)

sbin/ncheck_ffs/ncheck_ffs.c

425

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

sbin/ncheck_ffs/ncheck_ffs.c

427

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

sbin/ncheck_ffs/ncheck_ffs.c

597

sblock = (struct fs *)sblock_buf;

sbin/ncheck_ffs/ncheck_ffs.c

599

n = pread(diskfd, sblock, SBLOCKSIZE, (off_t)sblock_try[i]);

sbin/ncheck_ffs/ncheck_ffs.c

600

if (n == SBLOCKSIZE && (sblock->fs_magic == FS_UFS1_MAGIC ||

sbin/ncheck_ffs/ncheck_ffs.c

601

(sblock->fs_magic == FS_UFS2_MAGIC &&

sbin/ncheck_ffs/ncheck_ffs.c

602

sblock->fs_sblockloc == sblock_try[i])) &&

sbin/ncheck_ffs/ncheck_ffs.c

603

sblock->fs_bsize <= MAXBSIZE &&

sbin/ncheck_ffs/ncheck_ffs.c

604

sblock->fs_bsize >= sizeof(struct fs))

sbin/ncheck_ffs/ncheck_ffs.c

610

findinodes(sblock->fs_ipg * sblock->fs_ncg);

sbin/ncheck_ffs/ncheck_ffs.c

80

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

sbin/ncheck_ffs/ncheck_ffs.c

87

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

sbin/newfs/mkfs.c

1001

((struct ufs1_dinode *)iobuf)[ino_to_fsbo(&sblock, ino)] =

sbin/newfs/mkfs.c

1004

((struct ufs2_dinode *)iobuf)[ino_to_fsbo(&sblock, ino)] =

sbin/newfs/mkfs.c

1007

wtfs(d, sblock.fs_bsize, iobuf);

sbin/newfs/mkfs.c

1196

maxino = sblock.fs_ncg * (unsigned long long)sblock.fs_ipg;

sbin/newfs/mkfs.c

1197

maxfsblock = sblock.fs_size;

sbin/newfs/mkfs.c

1202

allocate += sblock.fs_ncg * sizeof(long);

sbin/newfs/mkfs.c

159

cur_fsys, (long)cur_cylno, sblock.fs_ncg);

sbin/newfs/mkfs.c

210

wtfs(fssize - (sectorsize / DEV_BSIZE), sectorsize, (char *)&sblock);

sbin/newfs/mkfs.c

212

sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;

sbin/newfs/mkfs.c

213

sblock.fs_avgfilesize = avgfilesize;

sbin/newfs/mkfs.c

214

sblock.fs_avgfpdir = avgfilesperdir;

sbin/newfs/mkfs.c

242

sblock.fs_bsize = bsize;

sbin/newfs/mkfs.c

243

sblock.fs_fsize = fsize;

sbin/newfs/mkfs.c

248

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

sbin/newfs/mkfs.c

249

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

sbin/newfs/mkfs.c

250

sblock.fs_qbmask = ~sblock.fs_bmask;

sbin/newfs/mkfs.c

251

sblock.fs_qfmask = ~sblock.fs_fmask;

sbin/newfs/mkfs.c

252

sblock.fs_bshift = ilog2(sblock.fs_bsize);

sbin/newfs/mkfs.c

253

sblock.fs_fshift = ilog2(sblock.fs_fsize);

sbin/newfs/mkfs.c

254

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

sbin/newfs/mkfs.c

255

if (sblock.fs_frag > MAXFRAG) {

sbin/newfs/mkfs.c

257

"size %d is %d", sblock.fs_fsize, sblock.fs_bsize,

sbin/newfs/mkfs.c

258

sblock.fs_bsize / MAXFRAG);

sbin/newfs/mkfs.c

260

sblock.fs_fragshift = ilog2(sblock.fs_frag);

sbin/newfs/mkfs.c

261

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

sbin/newfs/mkfs.c

262

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

sbin/newfs/mkfs.c

263

sblock.fs_nspf = sblock.fs_fsize / DEV_BSIZE;

sbin/newfs/mkfs.c

264

sblock.fs_maxcontig = 1;

sbin/newfs/mkfs.c

265

sblock.fs_nrpos = 1;

sbin/newfs/mkfs.c

266

sblock.fs_cpg = 1;

sbin/newfs/mkfs.c

271

sblock.fs_magic = FS_BAD_MAGIC;

sbin/newfs/mkfs.c

279

sblock.fs_sblockloc = SBLOCK_UFS1;

sbin/newfs/mkfs.c

280

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

sbin/newfs/mkfs.c

281

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

sbin/newfs/mkfs.c

282

sblock.fs_maxsymlinklen = MAXSYMLINKLEN_UFS1;

sbin/newfs/mkfs.c

283

sblock.fs_inodefmt = FS_44INODEFMT;

sbin/newfs/mkfs.c

284

sblock.fs_cgoffset = 0;

sbin/newfs/mkfs.c

285

sblock.fs_cgmask = 0xffffffff;

sbin/newfs/mkfs.c

286

sblock.fs_ffs1_size = sblock.fs_size;

sbin/newfs/mkfs.c

287

sblock.fs_rotdelay = 0;

sbin/newfs/mkfs.c

288

sblock.fs_rps = 60;

sbin/newfs/mkfs.c

289

sblock.fs_interleave = 1;

sbin/newfs/mkfs.c

290

sblock.fs_trackskew = 0;

sbin/newfs/mkfs.c

291

sblock.fs_cpc = 0;

sbin/newfs/mkfs.c

293

sblock.fs_inodefmt = FS_44INODEFMT;

sbin/newfs/mkfs.c

294

sblock.fs_sblockloc = SBLOCK_UFS2;

sbin/newfs/mkfs.c

295

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

sbin/newfs/mkfs.c

296

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

sbin/newfs/mkfs.c

297

sblock.fs_maxsymlinklen = MAXSYMLINKLEN_UFS2;

sbin/newfs/mkfs.c

299

sblock.fs_sblkno =

sbin/newfs/mkfs.c

300

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

sbin/newfs/mkfs.c

301

sblock.fs_frag);

sbin/newfs/mkfs.c

302

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

sbin/newfs/mkfs.c

303

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

sbin/newfs/mkfs.c

304

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

sbin/newfs/mkfs.c

305

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

sbin/newfs/mkfs.c

306

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

sbin/newfs/mkfs.c

307

sizepb *= NINDIR(&sblock);

sbin/newfs/mkfs.c

308

sblock.fs_maxfilesize += sizepb;

sbin/newfs/mkfs.c

315

if (sblock.fs_maxfilesize < (u_quad_t)fssize)

sbin/newfs/mkfs.c

333

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

sbin/newfs/mkfs.c

335

minfpg = fragsperinode * INOPB(&sblock);

sbin/newfs/mkfs.c

336

if (minfpg > sblock.fs_size)

sbin/newfs/mkfs.c

337

minfpg = sblock.fs_size;

sbin/newfs/mkfs.c

339

sblock.fs_ipg = INOPB(&sblock);

sbin/newfs/mkfs.c

340

sblock.fs_fpg = roundup(sblock.fs_iblkno +

sbin/newfs/mkfs.c

341

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

sbin/newfs/mkfs.c

342

if (sblock.fs_fpg < minfpg)

sbin/newfs/mkfs.c

343

sblock.fs_fpg = minfpg;

sbin/newfs/mkfs.c

345

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

sbin/newfs/mkfs.c

346

INOPB(&sblock));

sbin/newfs/mkfs.c

347

sblock.fs_fpg = roundup(sblock.fs_iblkno +

sbin/newfs/mkfs.c

348

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

sbin/newfs/mkfs.c

349

if (sblock.fs_fpg < minfpg)

sbin/newfs/mkfs.c

350

sblock.fs_fpg = minfpg;

sbin/newfs/mkfs.c

352

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

sbin/newfs/mkfs.c

353

INOPB(&sblock));

sbin/newfs/mkfs.c

355

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

sbin/newfs/mkfs.c

358

density -= sblock.fs_fsize;

sbin/newfs/mkfs.c

371

i = sblock.fs_size / maxfrgspercg;

sbin/newfs/mkfs.c

382

sblock.fs_fpg += sblock.fs_frag;

sbin/newfs/mkfs.c

383

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

sbin/newfs/mkfs.c

384

INOPB(&sblock));

sbin/newfs/mkfs.c

386

if (sblock.fs_fpg > maxfrgspercg ||

sbin/newfs/mkfs.c

387

sblock.fs_size / sblock.fs_fpg < mincylgrps ||

sbin/newfs/mkfs.c

388

CGSIZE(&sblock) > (unsigned long)sblock.fs_bsize)

sbin/newfs/mkfs.c

391

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 (sblock.fs_fpg > maxfrgspercg)

sbin/newfs/mkfs.c

395

warnx("can't honour -c: minimum is %d", sblock.fs_fpg);

sbin/newfs/mkfs.c

403

optimalfpg = sblock.fs_fpg;

sbin/newfs/mkfs.c

405

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

sbin/newfs/mkfs.c

406

lastminfpg = roundup(sblock.fs_iblkno +

sbin/newfs/mkfs.c

407

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

sbin/newfs/mkfs.c

408

if (sblock.fs_size < lastminfpg)

sbin/newfs/mkfs.c

410

"fragments", (intmax_t)sblock.fs_size, lastminfpg);

sbin/newfs/mkfs.c

412

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

sbin/newfs/mkfs.c

413

sblock.fs_size % sblock.fs_fpg == 0)

sbin/newfs/mkfs.c

416

sblock.fs_fpg -= sblock.fs_frag;

sbin/newfs/mkfs.c

417

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

sbin/newfs/mkfs.c

418

INOPB(&sblock));

sbin/newfs/mkfs.c

421

if (optimalfpg != sblock.fs_fpg)

sbin/newfs/mkfs.c

424

sblock.fs_fpg);

sbin/newfs/mkfs.c

426

if ((ino_t)sblock.fs_ipg * sblock.fs_ncg > UINT_MAX)

sbin/newfs/mkfs.c

434

sblock.fs_spc = sblock.fs_fpg * sblock.fs_nspf;

sbin/newfs/mkfs.c

435

sblock.fs_nsect = sblock.fs_spc;

sbin/newfs/mkfs.c

436

sblock.fs_npsect = sblock.fs_spc;

sbin/newfs/mkfs.c

437

sblock.fs_ncyl = sblock.fs_ncg;

sbin/newfs/mkfs.c

439

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

sbin/newfs/mkfs.c

440

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

sbin/newfs/mkfs.c

441

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

sbin/newfs/mkfs.c

442

sblock.fs_cssize =

sbin/newfs/mkfs.c

443

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

sbin/newfs/mkfs.c

445

fscs = calloc(1, sblock.fs_cssize);

sbin/newfs/mkfs.c

449

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

sbin/newfs/mkfs.c

450

if (sblock.fs_sbsize > SBLOCKSIZE)

sbin/newfs/mkfs.c

451

sblock.fs_sbsize = SBLOCKSIZE;

sbin/newfs/mkfs.c

453

sblock.fs_minfree = minfree;

sbin/newfs/mkfs.c

454

sblock.fs_maxbpg = maxbpg;

sbin/newfs/mkfs.c

455

sblock.fs_optim = opt;

sbin/newfs/mkfs.c

456

sblock.fs_cgrotor = 0;

sbin/newfs/mkfs.c

457

sblock.fs_pendingblocks = 0;

sbin/newfs/mkfs.c

458

sblock.fs_pendinginodes = 0;

sbin/newfs/mkfs.c

459

sblock.fs_fmod = 0;

sbin/newfs/mkfs.c

460

sblock.fs_ronly = 0;

sbin/newfs/mkfs.c

461

sblock.fs_state = 0;

sbin/newfs/mkfs.c

462

sblock.fs_clean = 1;

sbin/newfs/mkfs.c

463

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

sbin/newfs/mkfs.c

464

sblock.fs_id[1] = (u_int32_t)arc4random();

sbin/newfs/mkfs.c

465

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

sbin/newfs/mkfs.c

467

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

sbin/newfs/mkfs.c

468

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

sbin/newfs/mkfs.c

469

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

sbin/newfs/mkfs.c

471

sblock.fs_cstotal.cs_nbfree = fragstoblks(&sblock, sblock.fs_dsize) -

sbin/newfs/mkfs.c

472

howmany(csfrags, sblock.fs_frag);

sbin/newfs/mkfs.c

473

sblock.fs_cstotal.cs_nffree = fragnum(&sblock, sblock.fs_size) +

sbin/newfs/mkfs.c

474

(fragnum(&sblock, csfrags) > 0 ?

sbin/newfs/mkfs.c

475

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

sbin/newfs/mkfs.c

476

sblock.fs_cstotal.cs_nifree = sblock.fs_ncg * sblock.fs_ipg - ROOTINO;

sbin/newfs/mkfs.c

477

sblock.fs_cstotal.cs_ndir = 0;

sbin/newfs/mkfs.c

479

sblock.fs_dsize -= csfrags;

sbin/newfs/mkfs.c

480

sblock.fs_time = utime;

sbin/newfs/mkfs.c

483

sblock.fs_ffs1_time = sblock.fs_time;

sbin/newfs/mkfs.c

484

sblock.fs_ffs1_dsize = sblock.fs_dsize;

sbin/newfs/mkfs.c

485

sblock.fs_ffs1_csaddr = sblock.fs_csaddr;

sbin/newfs/mkfs.c

486

sblock.fs_ffs1_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;

sbin/newfs/mkfs.c

487

sblock.fs_ffs1_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;

sbin/newfs/mkfs.c

488

sblock.fs_ffs1_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;

sbin/newfs/mkfs.c

489

sblock.fs_ffs1_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;

sbin/newfs/mkfs.c

498

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

sbin/newfs/mkfs.c

499

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

sbin/newfs/mkfs.c

502

" inodes each\n", sblock.fs_ncg,

sbin/newfs/mkfs.c

503

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

sbin/newfs/mkfs.c

504

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

sbin/newfs/mkfs.c

528

wtfs((int)sblock.fs_sblockloc / DEV_BSIZE, SBSIZE, (char *)&sblock);

sbin/newfs/mkfs.c

529

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

sbin/newfs/mkfs.c

549

if (sblock.fs_bsize < SBLOCKSIZE)

sbin/newfs/mkfs.c

550

iobufsize = SBLOCKSIZE + 3 * sblock.fs_bsize;

sbin/newfs/mkfs.c

552

iobufsize = 4 * sblock.fs_bsize;

sbin/newfs/mkfs.c

560

bcopy((char *)&sblock, iobuf, SBLOCKSIZE);

sbin/newfs/mkfs.c

561

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

sbin/newfs/mkfs.c

567

(long long)fsbtodb(&sblock, cgsblock(&sblock, cg)));

sbin/newfs/mkfs.c

588

sblock.fs_ffs1_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;

sbin/newfs/mkfs.c

589

sblock.fs_ffs1_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;

sbin/newfs/mkfs.c

590

sblock.fs_ffs1_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;

sbin/newfs/mkfs.c

591

sblock.fs_ffs1_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;

sbin/newfs/mkfs.c

597

wtfs((int)sblock.fs_sblockloc / DEV_BSIZE, SBSIZE, (char *)&sblock);

sbin/newfs/mkfs.c

599

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

sbin/newfs/mkfs.c

600

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

sbin/newfs/mkfs.c

601

sblock.fs_cssize - i < sblock.fs_bsize ?

sbin/newfs/mkfs.c

602

sblock.fs_cssize - i : sblock.fs_bsize,

sbin/newfs/mkfs.c

611

DISKLABELV1_FFS_FRAGBLOCK(sblock.fs_fsize, sblock.fs_frag);

sbin/newfs/mkfs.c

612

bpg = sblock.fs_fpg / sblock.fs_frag;

sbin/newfs/mkfs.c

634

cbase = cgbase(&sblock, cg);

sbin/newfs/mkfs.c

635

dmax = cbase + sblock.fs_fpg;

sbin/newfs/mkfs.c

636

if (dmax > sblock.fs_size)

sbin/newfs/mkfs.c

637

dmax = sblock.fs_size;

sbin/newfs/mkfs.c

638

if (fsbtodb(&sblock, cgsblock(&sblock, cg)) + iobufsize / DEV_BSIZE

sbin/newfs/mkfs.c

642

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

sbin/newfs/mkfs.c

643

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

sbin/newfs/mkfs.c

645

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

sbin/newfs/mkfs.c

647

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

sbin/newfs/mkfs.c

651

acg.cg_ffs2_niblk = sblock.fs_ipg;

sbin/newfs/mkfs.c

652

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

sbin/newfs/mkfs.c

658

if (cg == sblock.fs_ncg - 1)

sbin/newfs/mkfs.c

661

acg.cg_ncyl = sblock.fs_cpg;

sbin/newfs/mkfs.c

668

acg.cg_boff = acg.cg_btotoff + sblock.fs_cpg * sizeof(int32_t);

sbin/newfs/mkfs.c

670

sblock.fs_cpg * sizeof(u_int16_t);

sbin/newfs/mkfs.c

675

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

sbin/newfs/mkfs.c

676

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

sbin/newfs/mkfs.c

677

if (acg.cg_nextfreeoff > sblock.fs_cgsize)

sbin/newfs/mkfs.c

679

acg.cg_nextfreeoff, sblock.fs_cgsize);

sbin/newfs/mkfs.c

680

acg.cg_cs.cs_nifree += sblock.fs_ipg;

sbin/newfs/mkfs.c

691

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

sbin/newfs/mkfs.c

692

blkno = d / sblock.fs_frag;

sbin/newfs/mkfs.c

693

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

sbin/newfs/mkfs.c

696

cg_blktot(&acg)[cbtocylno(&sblock, d)]++;

sbin/newfs/mkfs.c

697

cg_blks(&sblock, &acg, cbtocylno(&sblock, d))

sbin/newfs/mkfs.c

698

[cbtorpos(&sblock, d)]++;

sbin/newfs/mkfs.c

702

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

sbin/newfs/mkfs.c

703

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

sbin/newfs/mkfs.c

704

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

sbin/newfs/mkfs.c

710

d + sblock.fs_frag <= acg.cg_ndblk;

sbin/newfs/mkfs.c

711

d += sblock.fs_frag) {

sbin/newfs/mkfs.c

712

blkno = d / sblock.fs_frag;

sbin/newfs/mkfs.c

713

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

sbin/newfs/mkfs.c

716

cg_blktot(&acg)[cbtocylno(&sblock, d)]++;

sbin/newfs/mkfs.c

717

cg_blks(&sblock, &acg, cbtocylno(&sblock, d))

sbin/newfs/mkfs.c

718

[cbtorpos(&sblock, d)]++;

sbin/newfs/mkfs.c

734

start = sblock.fs_bsize > SBLOCKSIZE ? sblock.fs_bsize : SBLOCKSIZE;

sbin/newfs/mkfs.c

739

bcopy((char *)&acg, &iobuf[start], sblock.fs_cgsize);

sbin/newfs/mkfs.c

740

start += sblock.fs_bsize;

sbin/newfs/mkfs.c

743

for (i = MINIMUM(sblock.fs_ipg, 2 * INOPB(&sblock)); i != 0; i--) {

sbin/newfs/mkfs.c

744

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/newfs/mkfs.c

752

wtfs(fsbtodb(&sblock, cgsblock(&sblock, cg)), iobufsize, iobuf);

sbin/newfs/mkfs.c

756

for (i = 2 * sblock.fs_frag;

sbin/newfs/mkfs.c

757

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

sbin/newfs/mkfs.c

758

i += sblock.fs_frag) {

sbin/newfs/mkfs.c

760

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

sbin/newfs/mkfs.c

764

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

sbin/newfs/mkfs.c

765

sblock.fs_bsize, &iobuf[start]);

sbin/newfs/mkfs.c

804

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

sbin/newfs/mkfs.c

808

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

sbin/newfs/mkfs.c

810

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

sbin/newfs/mkfs.c

822

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

sbin/newfs/mkfs.c

826

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

sbin/newfs/mkfs.c

828

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

sbin/newfs/mkfs.c

862

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

sbin/newfs/mkfs.c

866

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

sbin/newfs/mkfs.c

868

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

sbin/newfs/mkfs.c

880

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

sbin/newfs/mkfs.c

884

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

sbin/newfs/mkfs.c

886

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

sbin/newfs/mkfs.c

923

rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,

sbin/newfs/mkfs.c

933

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

sbin/newfs/mkfs.c

934

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

sbin/newfs/mkfs.c

939

blkno = fragstoblks(&sblock, d);

sbin/newfs/mkfs.c

940

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

sbin/newfs/mkfs.c

942

sblock.fs_cstotal.cs_nbfree--;

sbin/newfs/mkfs.c

946

sblock.fs_cstotal.cs_ndir++;

sbin/newfs/mkfs.c

950

cg_blktot(&acg)[cbtocylno(&sblock, d)]--;

sbin/newfs/mkfs.c

951

cg_blks(&sblock, &acg, cbtocylno(&sblock, d))

sbin/newfs/mkfs.c

952

[cbtorpos(&sblock, d)]--;

sbin/newfs/mkfs.c

954

if (size != sblock.fs_bsize) {

sbin/newfs/mkfs.c

955

frag = howmany(size, sblock.fs_fsize);

sbin/newfs/mkfs.c

956

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

sbin/newfs/mkfs.c

957

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

sbin/newfs/mkfs.c

958

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

sbin/newfs/mkfs.c

959

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

sbin/newfs/mkfs.c

960

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

sbin/newfs/mkfs.c

963

wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,

sbin/newfs/mkfs.c

981

rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,

sbin/newfs/mkfs.c

989

wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,

sbin/newfs/mkfs.c

992

sblock.fs_cstotal.cs_nifree--;

sbin/newfs/mkfs.c

994

if (ino >= sblock.fs_ipg * sblock.fs_ncg)

sbin/newfs/mkfs.c

997

d = fsbtodb(&sblock, ino_to_fsba(&sblock, ino));

sbin/newfs/mkfs.c

998

rdfs(d, sblock.fs_bsize, iobuf);

sbin/newfs_ext2fs/mke2fs.c

1102

isize = (uint64_t)sblock.e2fs_bsize * NDADDR +

sbin/newfs_ext2fs/mke2fs.c

1103

(uint64_t)sblock.e2fs_bsize * NINDIR(&sblock) +

sbin/newfs_ext2fs/mke2fs.c

1104

(uint64_t)sblock.e2fs_bsize * NINDIR(&sblock) * NINDIR(&sblock);

sbin/newfs_ext2fs/mke2fs.c

1106

(sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

1130

alloc(sblock.e2fs_bsize, node.e2di_mode);

sbin/newfs_ext2fs/mke2fs.c

1136

nblock = fsbtodb(&sblock, 1);

sbin/newfs_ext2fs/mke2fs.c

1139

dindir_block = malloc(sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

1146

reserved_gdb = malloc(sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

1155

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

sbin/newfs_ext2fs/mke2fs.c

1159

for (; i < sblock.e2fs_ngdb + sblock.e2fs.e2fs_reserved_ngdb; i++) {

sbin/newfs_ext2fs/mke2fs.c

1169

if (i >= NINDIR(&sblock))

sbin/newfs_ext2fs/mke2fs.c

1172

__func__, sblock.e2fs.e2fs_reserved_ngdb);

sbin/newfs_ext2fs/mke2fs.c

1174

htole32(cgbase(&sblock, 0) + NBLOCK_SUPERBLOCK + i);

sbin/newfs_ext2fs/mke2fs.c

1181

for (n = 0, cylno = 1; cylno < sblock.e2fs_ncg; cylno++) {

sbin/newfs_ext2fs/mke2fs.c

1183

if ((sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

1188

if (n >= NINDIR(&sblock))

sbin/newfs_ext2fs/mke2fs.c

1195

reserved_gdb[n++] = htole32(cgbase(&sblock, cylno) +

sbin/newfs_ext2fs/mke2fs.c

1197

nblock += fsbtodb(&sblock, 1);

sbin/newfs_ext2fs/mke2fs.c

1199

for (; n < NINDIR(&sblock); n++)

sbin/newfs_ext2fs/mke2fs.c

1203

wtfs(fsbtodb(&sblock, letoh32(dindir_block[i])),

sbin/newfs_ext2fs/mke2fs.c

1204

sblock.e2fs_bsize, reserved_gdb);

sbin/newfs_ext2fs/mke2fs.c

1205

nblock += fsbtodb(&sblock, 1);

sbin/newfs_ext2fs/mke2fs.c

1207

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

sbin/newfs_ext2fs/mke2fs.c

1214

wtfs(fsbtodb(&sblock, node.e2di_blocks[NDADDR + DOUBLE]),

sbin/newfs_ext2fs/mke2fs.c

1215

sblock.e2fs_bsize, dindir_block);

sbin/newfs_ext2fs/mke2fs.c

1238

if (size > sblock.e2fs_bsize)

sbin/newfs_ext2fs/mke2fs.c

1241

bbp = malloc(sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

1244

rdfs(fsbtodb(&sblock, gd[0].ext2bgd_b_bitmap), sblock.e2fs_bsize, bbp);

sbin/newfs_ext2fs/mke2fs.c

1247

len = sblock.e2fs.e2fs_bpg / NBBY;

sbin/newfs_ext2fs/mke2fs.c

1278

wtfs(fsbtodb(&sblock, gd[0].ext2bgd_b_bitmap), sblock.e2fs_bsize, bbp);

sbin/newfs_ext2fs/mke2fs.c

1284

sblock.e2fs.e2fs_fbcount--;

sbin/newfs_ext2fs/mke2fs.c

1286

return sblock.e2fs.e2fs_first_dblock + bno;

sbin/newfs_ext2fs/mke2fs.c

1302

bp = malloc(sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

1312

c = ino_to_cg(&sblock, ino);

sbin/newfs_ext2fs/mke2fs.c

1321

rdfs(fsbtodb(&sblock, gd[0].ext2bgd_i_bitmap),

sbin/newfs_ext2fs/mke2fs.c

1322

sblock.e2fs_bsize, bp);

sbin/newfs_ext2fs/mke2fs.c

1329

wtfs(fsbtodb(&sblock, gd[0].ext2bgd_i_bitmap),

sbin/newfs_ext2fs/mke2fs.c

1330

sblock.e2fs_bsize, bp);

sbin/newfs_ext2fs/mke2fs.c

1332

sblock.e2fs.e2fs_ficount--;

sbin/newfs_ext2fs/mke2fs.c

1335

if (ino >= sblock.e2fs.e2fs_ipg * sblock.e2fs_ncg)

sbin/newfs_ext2fs/mke2fs.c

1340

d = fsbtodb(&sblock, ino_to_fsba(&sblock, ino));

sbin/newfs_ext2fs/mke2fs.c

1341

rdfs(d, sblock.e2fs_bsize, bp);

sbin/newfs_ext2fs/mke2fs.c

1344

inodesize * ino_to_fsbo(&sblock, ino));

sbin/newfs_ext2fs/mke2fs.c

1345

e2fs_isave(&sblock, ip, dp);

sbin/newfs_ext2fs/mke2fs.c

1354

wtfs(d, sblock.e2fs_bsize, bp);

sbin/newfs_ext2fs/mke2fs.c

241

sblock.e2fs.e2fs_log_bsize = ilog2(bsize) - LOG_MINBSIZE;

sbin/newfs_ext2fs/mke2fs.c

242

sblock.e2fs.e2fs_log_fsize = ilog2(fsize) - LOG_MINFSIZE;

sbin/newfs_ext2fs/mke2fs.c

244

sblock.e2fs_bsize = bsize;

sbin/newfs_ext2fs/mke2fs.c

245

sblock.e2fs_fsize = fsize;

sbin/newfs_ext2fs/mke2fs.c

246

sblock.e2fs_bshift = sblock.e2fs.e2fs_log_bsize + LOG_MINBSIZE;

sbin/newfs_ext2fs/mke2fs.c

247

sblock.e2fs_qbmask = sblock.e2fs_bsize - 1;

sbin/newfs_ext2fs/mke2fs.c

248

sblock.e2fs_bmask = ~sblock.e2fs_qbmask;

sbin/newfs_ext2fs/mke2fs.c

249

sblock.e2fs_fsbtodb = ilog2(sblock.e2fs_bsize) - ilog2(sectorsize);

sbin/newfs_ext2fs/mke2fs.c

250

sblock.e2fs_ipb = sblock.e2fs_bsize / inodesize;

sbin/newfs_ext2fs/mke2fs.c

260

sblock.e2fs.e2fs_first_dblock = (sblock.e2fs_bsize > BBSIZE) ? 0 : 1;

sbin/newfs_ext2fs/mke2fs.c

261

minfssize = fsbtodb(&sblock,

sbin/newfs_ext2fs/mke2fs.c

262

sblock.e2fs.e2fs_first_dblock +

sbin/newfs_ext2fs/mke2fs.c

276

bcount = dbtofsb(&sblock, fssize);

sbin/newfs_ext2fs/mke2fs.c

287

blocks_per_cg = sblock.e2fs_bsize * NBBY;

sbin/newfs_ext2fs/mke2fs.c

289

ncg = howmany(bcount - sblock.e2fs.e2fs_first_dblock, blocks_per_cg);

sbin/newfs_ext2fs/mke2fs.c

310

blocks_lastcg = bcount - sblock.e2fs.e2fs_first_dblock -

sbin/newfs_ext2fs/mke2fs.c

328

inodes_per_cg = roundup(inodes_per_cg, sblock.e2fs_ipb);

sbin/newfs_ext2fs/mke2fs.c

330

iblocks_per_cg = inodes_per_cg / sblock.e2fs_ipb;

sbin/newfs_ext2fs/mke2fs.c

334

sblock.e2fs.e2fs_bcount = bcount;

sbin/newfs_ext2fs/mke2fs.c

335

sblock.e2fs.e2fs_icount = num_inodes;

sbin/newfs_ext2fs/mke2fs.c

337

sblock.e2fs_ncg = ncg;

sbin/newfs_ext2fs/mke2fs.c

338

sblock.e2fs_ngdb = blocks_gd;

sbin/newfs_ext2fs/mke2fs.c

339

sblock.e2fs_itpg = iblocks_per_cg;

sbin/newfs_ext2fs/mke2fs.c

341

sblock.e2fs.e2fs_rbcount = sblock.e2fs.e2fs_bcount * minfree / 100;

sbin/newfs_ext2fs/mke2fs.c

345

sblock.e2fs.e2fs_bpg = blocks_per_cg;

sbin/newfs_ext2fs/mke2fs.c

346

sblock.e2fs.e2fs_fpg = blocks_per_cg;

sbin/newfs_ext2fs/mke2fs.c

348

sblock.e2fs.e2fs_ipg = inodes_per_cg;

sbin/newfs_ext2fs/mke2fs.c

350

sblock.e2fs.e2fs_mtime = 0;

sbin/newfs_ext2fs/mke2fs.c

351

sblock.e2fs.e2fs_wtime = (u_int32_t)tv.tv_sec;

sbin/newfs_ext2fs/mke2fs.c

352

sblock.e2fs.e2fs_mnt_count = 0;

sbin/newfs_ext2fs/mke2fs.c

354

sblock.e2fs.e2fs_max_mnt_count = EXT2_DEF_MAX_MNT_COUNT;

sbin/newfs_ext2fs/mke2fs.c

356

sblock.e2fs.e2fs_magic = E2FS_MAGIC;

sbin/newfs_ext2fs/mke2fs.c

357

sblock.e2fs.e2fs_state = E2FS_ISCLEAN;

sbin/newfs_ext2fs/mke2fs.c

358

sblock.e2fs.e2fs_beh = E2FS_BEH_DEFAULT;

sbin/newfs_ext2fs/mke2fs.c

359

sblock.e2fs.e2fs_minrev = 0;

sbin/newfs_ext2fs/mke2fs.c

360

sblock.e2fs.e2fs_lastfsck = (u_int32_t)tv.tv_sec;

sbin/newfs_ext2fs/mke2fs.c

361

sblock.e2fs.e2fs_fsckintv = EXT2_DEF_FSCKINTV;

sbin/newfs_ext2fs/mke2fs.c

374

sblock.e2fs.e2fs_creator = E2FS_OS_LINUX;

sbin/newfs_ext2fs/mke2fs.c

377

sblock.e2fs.e2fs_rev = E2FS_REV0;

sbin/newfs_ext2fs/mke2fs.c

378

sblock.e2fs.e2fs_features_compat = 0;

sbin/newfs_ext2fs/mke2fs.c

379

sblock.e2fs.e2fs_features_incompat = 0;

sbin/newfs_ext2fs/mke2fs.c

380

sblock.e2fs.e2fs_features_rocompat = 0;

sbin/newfs_ext2fs/mke2fs.c

382

sblock.e2fs.e2fs_rev = E2FS_REV1;

sbin/newfs_ext2fs/mke2fs.c

392

sblock.e2fs.e2fs_features_compat = EXT2F_COMPAT_RESIZE;

sbin/newfs_ext2fs/mke2fs.c

393

sblock.e2fs.e2fs_features_incompat = EXT2F_INCOMPAT_FTYPE;

sbin/newfs_ext2fs/mke2fs.c

394

sblock.e2fs.e2fs_features_rocompat =

sbin/newfs_ext2fs/mke2fs.c

398

sblock.e2fs.e2fs_ruid = geteuid();

sbin/newfs_ext2fs/mke2fs.c

399

sblock.e2fs.e2fs_rgid = getegid();

sbin/newfs_ext2fs/mke2fs.c

401

sblock.e2fs.e2fs_first_ino = EXT2_FIRSTINO;

sbin/newfs_ext2fs/mke2fs.c

402

sblock.e2fs.e2fs_inode_size = inodesize;

sbin/newfs_ext2fs/mke2fs.c

406

uuid_get(&sblock);

sbin/newfs_ext2fs/mke2fs.c

408

if (strlen(volname) > sizeof(sblock.e2fs.e2fs_vname))

sbin/newfs_ext2fs/mke2fs.c

410

strlcpy(sblock.e2fs.e2fs_vname, volname,

sbin/newfs_ext2fs/mke2fs.c

411

sizeof(sblock.e2fs.e2fs_vname));

sbin/newfs_ext2fs/mke2fs.c

414

sblock.e2fs.e2fs_fsmnt[0] = '\0';

sbin/newfs_ext2fs/mke2fs.c

415

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

sbin/newfs_ext2fs/mke2fs.c

417

sblock.e2fs.e2fs_algo = 0; /* XXX unsupported? */

sbin/newfs_ext2fs/mke2fs.c

418

sblock.e2fs.e2fs_prealloc = 0; /* XXX unsupported? */

sbin/newfs_ext2fs/mke2fs.c

419

sblock.e2fs.e2fs_dir_prealloc = 0; /* XXX unsupported? */

sbin/newfs_ext2fs/mke2fs.c

422

sblock.e2fs.e2fs_reserved_ngdb = 0;

sbin/newfs_ext2fs/mke2fs.c

423

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

424

(sblock.e2fs.e2fs_features_compat & EXT2F_COMPAT_RESIZE) != 0) {

sbin/newfs_ext2fs/mke2fs.c

430

(sblock.e2fs.e2fs_bcount - sblock.e2fs.e2fs_first_dblock)

sbin/newfs_ext2fs/mke2fs.c

435

target_ncg = howmany(target_blocks, sblock.e2fs.e2fs_bpg);

sbin/newfs_ext2fs/mke2fs.c

437

sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

450

if (target_ngdb > NINDIR(&sblock))

sbin/newfs_ext2fs/mke2fs.c

451

target_ngdb = NINDIR(&sblock);

sbin/newfs_ext2fs/mke2fs.c

453

reserved_ngdb = target_ngdb - sblock.e2fs_ngdb;

sbin/newfs_ext2fs/mke2fs.c

460

sblock.e2fs.e2fs_features_compat &=

sbin/newfs_ext2fs/mke2fs.c

463

sblock.e2fs.e2fs_reserved_ngdb = reserved_ngdb;

sbin/newfs_ext2fs/mke2fs.c

469

gd = calloc(sblock.e2fs_ngdb, bsize);

sbin/newfs_ext2fs/mke2fs.c

478

boffset = cgbase(&sblock, cylno);

sbin/newfs_ext2fs/mke2fs.c

479

if (sblock.e2fs.e2fs_rev == E2FS_REV0 ||

sbin/newfs_ext2fs/mke2fs.c

480

(sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

483

boffset += NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb;

sbin/newfs_ext2fs/mke2fs.c

484

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

485

(sblock.e2fs.e2fs_features_compat &

sbin/newfs_ext2fs/mke2fs.c

487

boffset += sblock.e2fs.e2fs_reserved_ngdb;

sbin/newfs_ext2fs/mke2fs.c

499

sblock.e2fs.e2fs_bpg - cgoverhead(cylno);

sbin/newfs_ext2fs/mke2fs.c

501

gd[cylno].ext2bgd_nifree = sblock.e2fs.e2fs_ipg;

sbin/newfs_ext2fs/mke2fs.c

509

sblock.e2fs.e2fs_fbcount = fbcount;

sbin/newfs_ext2fs/mke2fs.c

510

sblock.e2fs.e2fs_ficount = ficount;

sbin/newfs_ext2fs/mke2fs.c

526

ncg, bsize * sblock.e2fs.e2fs_bpg / (1024 * 1024),

sbin/newfs_ext2fs/mke2fs.c

527

sblock.e2fs.e2fs_bpg, sblock.e2fs.e2fs_ipg);

sbin/newfs_ext2fs/mke2fs.c

533

iobufsize = (NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb) * sblock.e2fs_bsize;

sbin/newfs_ext2fs/mke2fs.c

578

(uint64_t)cgbase(&sblock, ncg - 1));

sbin/newfs_ext2fs/mke2fs.c

594

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

595

(sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

611

(uint64_t)cgbase(&sblock, cylno));

sbin/newfs_ext2fs/mke2fs.c

619

delta = sblock.e2fs_ncg - cylno - 1;

sbin/newfs_ext2fs/mke2fs.c

645

sblock.e2fs.e2fs_block_group_nr = 0;

sbin/newfs_ext2fs/mke2fs.c

647

if (cgbase(&sblock, 0) == 0) {

sbin/newfs_ext2fs/mke2fs.c

655

e2fs_sbsave(&sblock.e2fs, (struct ext2fs *)(iobuf + sboff));

sbin/newfs_ext2fs/mke2fs.c

656

e2fs_cgsave(gd, (struct ext2_gd *)(iobuf + sblock.e2fs_bsize),

sbin/newfs_ext2fs/mke2fs.c

657

sizeof(struct ext2_gd) * sblock.e2fs_ncg);

sbin/newfs_ext2fs/mke2fs.c

658

wtfs(fsbtodb(&sblock, cgbase(&sblock, 0)) + sboff / sectorsize,

sbin/newfs_ext2fs/mke2fs.c

676

if (sblock.e2fs.e2fs_rev == E2FS_REV0 ||

sbin/newfs_ext2fs/mke2fs.c

677

(sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

680

sblock.e2fs.e2fs_block_group_nr = cylno;

sbin/newfs_ext2fs/mke2fs.c

682

if (cgbase(&sblock, cylno) == 0) {

sbin/newfs_ext2fs/mke2fs.c

686

e2fs_sbsave(&sblock.e2fs, (struct ext2fs *)(iobuf + sboff));

sbin/newfs_ext2fs/mke2fs.c

688

sblock.e2fs_bsize * NBLOCK_SUPERBLOCK),

sbin/newfs_ext2fs/mke2fs.c

689

sizeof(struct ext2_gd) * sblock.e2fs_ncg);

sbin/newfs_ext2fs/mke2fs.c

691

wtfs(fsbtodb(&sblock, cgbase(&sblock, cylno)) +

sbin/newfs_ext2fs/mke2fs.c

698

memset(buf, 0, sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

699

if (cylno == (sblock.e2fs_ncg - 1)) {

sbin/newfs_ext2fs/mke2fs.c

701

nblcg = sblock.e2fs.e2fs_bcount -

sbin/newfs_ext2fs/mke2fs.c

702

cgbase(&sblock, sblock.e2fs_ncg - 1);

sbin/newfs_ext2fs/mke2fs.c

705

memset(&buf[i / NBBY], ~0U, sblock.e2fs.e2fs_bpg - i);

sbin/newfs_ext2fs/mke2fs.c

713

wtfs(fsbtodb(&sblock, gd[cylno].ext2bgd_b_bitmap), sblock.e2fs_bsize,

sbin/newfs_ext2fs/mke2fs.c

723

i = sblock.e2fs.e2fs_ipg / NBBY;

sbin/newfs_ext2fs/mke2fs.c

725

memset(buf + i, ~0U, sblock.e2fs_bsize - i);

sbin/newfs_ext2fs/mke2fs.c

731

wtfs(fsbtodb(&sblock, gd[cylno].ext2bgd_i_bitmap), sblock.e2fs_bsize,

sbin/newfs_ext2fs/mke2fs.c

741

memset(buf, 0, sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

742

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

sbin/newfs_ext2fs/mke2fs.c

743

for (j = 0; j < sblock.e2fs_ipb; j++) {

sbin/newfs_ext2fs/mke2fs.c

748

wtfs(fsbtodb(&sblock, gd[cylno].ext2bgd_i_tables + i),

sbin/newfs_ext2fs/mke2fs.c

749

sblock.e2fs_bsize, buf);

sbin/newfs_ext2fs/mke2fs.c

786

((daddr32_t)sblock.e2fs.e2fs_first_dblock + cgoverhead(0)) *

sbin/newfs_ext2fs/mke2fs.c

787

sblock.e2fs_bsize / sectorsize;

sbin/newfs_ext2fs/mke2fs.c

794

if (sec >= sblock.e2fs.e2fs_first_dblock * bsize / sectorsize) {

sbin/newfs_ext2fs/mke2fs.c

835

overh = NBLOCK_BLOCK_BITMAP + NBLOCK_INODE_BITMAP + sblock.e2fs_itpg;

sbin/newfs_ext2fs/mke2fs.c

837

if (sblock.e2fs.e2fs_rev == E2FS_REV0 ||

sbin/newfs_ext2fs/mke2fs.c

838

(sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

841

overh += NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb;

sbin/newfs_ext2fs/mke2fs.c

843

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

844

(sblock.e2fs.e2fs_features_compat &

sbin/newfs_ext2fs/mke2fs.c

846

overh += sblock.e2fs.e2fs_reserved_ngdb;

sbin/newfs_ext2fs/mke2fs.c

893

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

894

(sblock.e2fs.e2fs_features_compat & EXT2F_COMPAT_RESIZE) != 0)

sbin/newfs_ext2fs/mke2fs.c

905

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

906

sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE) {

sbin/newfs_ext2fs/mke2fs.c

913

nblks_lostfound = EXT2_LOSTFOUNDSIZE / sblock.e2fs_bsize;

sbin/newfs_ext2fs/mke2fs.c

921

node.e2di_size = sblock.e2fs_bsize * nblks_lostfound;

sbin/newfs_ext2fs/mke2fs.c

928

node.e2di_nblock = fsbtodb(&sblock, nblks_lostfound);

sbin/newfs_ext2fs/mke2fs.c

929

node.e2di_blocks[0] = alloc(sblock.e2fs_bsize, node.e2di_mode);

sbin/newfs_ext2fs/mke2fs.c

935

blk = alloc(sblock.e2fs_bsize, 0);

sbin/newfs_ext2fs/mke2fs.c

943

wtfs(fsbtodb(&sblock, node.e2di_blocks[0]), sblock.e2fs_bsize, buf);

sbin/newfs_ext2fs/mke2fs.c

944

pad_dir.e2d_reclen = sblock.e2fs_bsize;

sbin/newfs_ext2fs/mke2fs.c

946

memset(buf, 0, sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

948

wtfs(fsbtodb(&sblock, node.e2di_blocks[i]), sblock.e2fs_bsize,

sbin/newfs_ext2fs/mke2fs.c

957

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

958

sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE) {

sbin/newfs_ext2fs/mke2fs.c

974

node.e2di_nblock = fsbtodb(&sblock, 1);

sbin/newfs_ext2fs/mke2fs.c

980

wtfs(fsbtodb(&sblock, node.e2di_blocks[0]), sblock.e2fs_bsize, buf);

sbin/newfs_ext2fs/mke2fs.c

996

dirblksiz = sblock.e2fs_bsize;

sbin/quotacheck/quotacheck.c

282

bread(sblock_try[i] / DEV_BSIZE, (char *)&sblock,

sbin/quotacheck/quotacheck.c

284

if ((sblock.fs_magic == FS_UFS1_MAGIC ||

sbin/quotacheck/quotacheck.c

285

(sblock.fs_magic == FS_UFS2_MAGIC &&

sbin/quotacheck/quotacheck.c

286

sblock.fs_sblockloc == sblock_try[i])) &&

sbin/quotacheck/quotacheck.c

287

sblock.fs_bsize <= MAXBSIZE &&

sbin/quotacheck/quotacheck.c

288

sblock.fs_bsize >= sizeof(struct fs))

sbin/quotacheck/quotacheck.c

295

maxino = sblock.fs_ncg * sblock.fs_ipg;

sbin/quotacheck/quotacheck.c

296

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

sbin/quotacheck/quotacheck.c

297

ino = cg * sblock.fs_ipg;

sbin/quotacheck/quotacheck.c

299

bread(fsbtodb(&sblock, cgtod(&sblock, cg)),

sbin/quotacheck/quotacheck.c

300

(char *)(&cgblk), sblock.fs_cgsize);

sbin/quotacheck/quotacheck.c

301

if (sblock.fs_magic == FS_UFS2_MAGIC)

sbin/quotacheck/quotacheck.c

304

inosused = sblock.fs_ipg;

sbin/quotacheck/quotacheck.c

645

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

sbin/quotacheck/quotacheck.c

661

if (sblock.fs_magic == FS_UFS1_MAGIC)

sbin/quotacheck/quotacheck.c

675

if (inum % sblock.fs_ipg != 0)

sbin/quotacheck/quotacheck.c

678

lastvalidinum = inum + sblock.fs_ipg - 1;

sbin/quotacheck/quotacheck.c

684

inobufsize = blkroundup(&sblock, INOBUFSIZE);

sbin/quotacheck/quotacheck.c

685

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

sbin/quotacheck/quotacheck.c

687

readpercg = sblock.fs_ipg / fullcnt;

sbin/quotacheck/quotacheck.c

688

partialcnt = sblock.fs_ipg % fullcnt;

sbin/quotacheck/quotacheck.c

689

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

sbin/quotacheck/quotacheck.c

83

((sblock.fs_magic == FS_UFS1_MAGIC) ? \

sbin/tunefs/tunefs.c

162

getsb(&sblock, special);

sbin/tunefs/tunefs.c

177

CHANGEVAL(sblock.fs_maxbpg, maxbpg,

sbin/tunefs/tunefs.c

179

CHANGEVAL(sblock.fs_minfree, minfree,

sbin/tunefs/tunefs.c

183

sblock.fs_optim == FS_OPTSPACE)

sbin/tunefs/tunefs.c

186

sblock.fs_optim == FS_OPTTIME)

sbin/tunefs/tunefs.c

190

if (sblock.fs_optim == optim) {

sbin/tunefs/tunefs.c

197

chg[sblock.fs_optim], chg[optim]);

sbin/tunefs/tunefs.c

198

sblock.fs_optim = optim;

sbin/tunefs/tunefs.c

199

if (sblock.fs_minfree >= MINFREE &&

sbin/tunefs/tunefs.c

202

if (sblock.fs_minfree < MINFREE &&

sbin/tunefs/tunefs.c

207

CHANGEVAL(sblock.fs_avgfilesize, avgfilesize,

sbin/tunefs/tunefs.c

209

CHANGEVAL(sblock.fs_avgfpdir, avgfpdir,

sbin/tunefs/tunefs.c

215

sblock.fs_maxcontig);

sbin/tunefs/tunefs.c

218

sblock.fs_maxbpg);

sbin/tunefs/tunefs.c

220

sblock.fs_minfree);

sbin/tunefs/tunefs.c

222

chg[sblock.fs_optim]);

sbin/tunefs/tunefs.c

224

sblock.fs_avgfilesize);

sbin/tunefs/tunefs.c

227

sblock.fs_avgfpdir);

sbin/tunefs/tunefs.c

232

memcpy(buf, (char *)&sblock, SBLOCKSIZE);

sbin/tunefs/tunefs.c

235

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

sbin/tunefs/tunefs.c

236

bwrite(fsbtodb(&sblock, cgsblock(&sblock, i)),

sys/arch/alpha/stand/installboot.c

315

static char sblock[SBSIZE];

sys/arch/alpha/stand/installboot.c

379

sbread(devfd, partoffset, &fs, sblock);

sys/arch/alpha/stand/installboot.c

536

sbread(int fd, daddr_t poffset, struct fs **fs, char *sblock)

sys/arch/alpha/stand/installboot.c

543

devread(fd, sblock, poffset + sboff, SBSIZE, "superblock");

sys/arch/alpha/stand/installboot.c

544

*fs = (struct fs *)sblock;

sys/kern/uipc_socket.c

1286

error = sblock(sb, SBL_WAIT | SBL_NOINTR);

sys/kern/uipc_socket.c

1324

if ((error = sblock(&so->so_rcv, SBL_WAIT)) != 0)

sys/kern/uipc_socket.c

1345

if ((error = sblock(&so->so_rcv, SBL_WAIT)) != 0)

sys/kern/uipc_socket.c

1347

if ((error = sblock(&sosp->so_snd, SBL_WAIT)) != 0) {

sys/kern/uipc_socket.c

1475

sblock(&so->so_rcv, SBL_WAIT | SBL_NOINTR);

sys/kern/uipc_socket.c

1488

sblock(&so->so_rcv, SBL_WAIT | SBL_NOINTR);

sys/kern/uipc_socket.c

1513

sblock(&so->so_snd, SBL_WAIT | SBL_NOINTR);

sys/kern/uipc_socket.c

457

sblock(&soback->so_rcv, SBL_WAIT | SBL_NOINTR);

sys/kern/uipc_socket.c

468

sblock(&so->so_rcv, SBL_WAIT | SBL_NOINTR);

sys/kern/uipc_socket.c

639

if ((error = sblock(&so->so_snd, SBLOCKWAIT(flags))) != 0)

sys/kern/uipc_socket.c

890

if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0)

sys/sys/socketvar.h

311

int sblock(struct sockbuf *, int);

usr.sbin/installboot/i386_installboot.c

1073

sbread(int fd, daddr_t poffset, struct fs **fs, char *sblock)

usr.sbin/installboot/i386_installboot.c

1080

devread(fd, sblock, poffset + sboff, SBSIZE, "superblock");

usr.sbin/installboot/i386_installboot.c

1081

*fs = (struct fs *)sblock;

usr.sbin/installboot/i386_installboot.c

793

char *sblock, *buf;

usr.sbin/installboot/i386_installboot.c

856

if ((sblock = malloc(SBSIZE)) == NULL)

usr.sbin/installboot/i386_installboot.c

859

sbread(devfd, DL_SECTOBLK(dl, pp->p_offset), &fs, sblock);

usr.sbin/installboot/i386_installboot.c

931

free (sblock);

usr.sbin/makefs/ffs/mkfs.c

136

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

usr.sbin/makefs/ffs/mkfs.c

137

sizeof(sblock.fs_volname));

usr.sbin/makefs/ffs/mkfs.c

139

sblock.fs_inodefmt = FS_44INODEFMT;

usr.sbin/makefs/ffs/mkfs.c

140

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

usr.sbin/makefs/ffs/mkfs.c

142

sblock.fs_ffs1_flags = FS_FLAGS_UPDATED;

usr.sbin/makefs/ffs/mkfs.c

143

sblock.fs_flags = 0;

usr.sbin/makefs/ffs/mkfs.c

154

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

usr.sbin/makefs/ffs/mkfs.c

159

sblock.fs_avgfilesize = avgfilesize;

usr.sbin/makefs/ffs/mkfs.c

160

sblock.fs_avgfpdir = avgfpdir;

usr.sbin/makefs/ffs/mkfs.c

161

if (sblock.fs_avgfilesize <= 0)

usr.sbin/makefs/ffs/mkfs.c

163

sblock.fs_avgfilesize), exit(14);

usr.sbin/makefs/ffs/mkfs.c

164

if (sblock.fs_avgfpdir <= 0)

usr.sbin/makefs/ffs/mkfs.c

166

sblock.fs_avgfpdir), exit(15);

usr.sbin/makefs/ffs/mkfs.c

170

sblock.fs_bsize = bsize;

usr.sbin/makefs/ffs/mkfs.c

171

sblock.fs_fsize = fsize;

usr.sbin/makefs/ffs/mkfs.c

172

if (!POWEROF2(sblock.fs_bsize)) {

usr.sbin/makefs/ffs/mkfs.c

174

sblock.fs_bsize);

usr.sbin/makefs/ffs/mkfs.c

177

if (!POWEROF2(sblock.fs_fsize)) {

usr.sbin/makefs/ffs/mkfs.c

179

sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

182

if (sblock.fs_fsize < sectorsize) {

usr.sbin/makefs/ffs/mkfs.c

184

sblock.fs_fsize, sectorsize);

usr.sbin/makefs/ffs/mkfs.c

187

if (sblock.fs_bsize < MINBSIZE) {

usr.sbin/makefs/ffs/mkfs.c

189

sblock.fs_bsize, MINBSIZE);

usr.sbin/makefs/ffs/mkfs.c

192

if (sblock.fs_bsize > FFS_MAXBSIZE) {

usr.sbin/makefs/ffs/mkfs.c

194

sblock.fs_bsize, FFS_MAXBSIZE);

usr.sbin/makefs/ffs/mkfs.c

197

if (sblock.fs_bsize < sblock.fs_fsize) {

usr.sbin/makefs/ffs/mkfs.c

199

sblock.fs_bsize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

204

sblock.fs_maxbsize = sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

205

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

usr.sbin/makefs/ffs/mkfs.c

206

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

usr.sbin/makefs/ffs/mkfs.c

207

sblock.fs_maxbsize = FS_MAXCONTIG * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

208

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

usr.sbin/makefs/ffs/mkfs.c

210

sblock.fs_maxbsize = maxbsize;

usr.sbin/makefs/ffs/mkfs.c

212

sblock.fs_maxcontig = maxcontig;

usr.sbin/makefs/ffs/mkfs.c

213

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

usr.sbin/makefs/ffs/mkfs.c

214

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

usr.sbin/makefs/ffs/mkfs.c

215

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

usr.sbin/makefs/ffs/mkfs.c

218

if (sblock.fs_maxcontig > 1)

usr.sbin/makefs/ffs/mkfs.c

219

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

usr.sbin/makefs/ffs/mkfs.c

221

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

usr.sbin/makefs/ffs/mkfs.c

222

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

usr.sbin/makefs/ffs/mkfs.c

223

sblock.fs_qbmask = ~sblock.fs_bmask;

usr.sbin/makefs/ffs/mkfs.c

224

sblock.fs_qfmask = ~sblock.fs_fmask;

usr.sbin/makefs/ffs/mkfs.c

225

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

usr.sbin/makefs/ffs/mkfs.c

226

sblock.fs_bshift++;

usr.sbin/makefs/ffs/mkfs.c

227

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

usr.sbin/makefs/ffs/mkfs.c

228

sblock.fs_fshift++;

usr.sbin/makefs/ffs/mkfs.c

229

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

usr.sbin/makefs/ffs/mkfs.c

230

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

usr.sbin/makefs/ffs/mkfs.c

231

sblock.fs_fragshift++;

usr.sbin/makefs/ffs/mkfs.c

232

if (sblock.fs_frag > MAXFRAG) {

usr.sbin/makefs/ffs/mkfs.c

235

sblock.fs_fsize, sblock.fs_bsize,

usr.sbin/makefs/ffs/mkfs.c

236

sblock.fs_bsize / MAXFRAG);

usr.sbin/makefs/ffs/mkfs.c

239

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

usr.sbin/makefs/ffs/mkfs.c

240

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

usr.sbin/makefs/ffs/mkfs.c

243

sblock.fs_magic = FS_UFS1_MAGIC;

usr.sbin/makefs/ffs/mkfs.c

244

sblock.fs_sblockloc = SBLOCK_UFS1;

usr.sbin/makefs/ffs/mkfs.c

245

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

usr.sbin/makefs/ffs/mkfs.c

246

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

usr.sbin/makefs/ffs/mkfs.c

247

sblock.fs_maxsymlinklen = (NDADDR + NIADDR) * sizeof (int32_t);

usr.sbin/makefs/ffs/mkfs.c

248

sblock.fs_inodefmt = FS_44INODEFMT;

usr.sbin/makefs/ffs/mkfs.c

249

sblock.fs_cgoffset = 0;

usr.sbin/makefs/ffs/mkfs.c

250

sblock.fs_cgmask = 0xffffffff;

usr.sbin/makefs/ffs/mkfs.c

251

sblock.fs_ffs1_size = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

252

sblock.fs_rotdelay = 0;

usr.sbin/makefs/ffs/mkfs.c

253

sblock.fs_rps = 60;

usr.sbin/makefs/ffs/mkfs.c

254

sblock.fs_nspf = sblock.fs_fsize / sectorsize;

usr.sbin/makefs/ffs/mkfs.c

255

sblock.fs_cpg = 1;

usr.sbin/makefs/ffs/mkfs.c

256

sblock.fs_interleave = 1;

usr.sbin/makefs/ffs/mkfs.c

257

sblock.fs_trackskew = 0;

usr.sbin/makefs/ffs/mkfs.c

258

sblock.fs_cpc = 0;

usr.sbin/makefs/ffs/mkfs.c

259

sblock.fs_postblformat = 1;

usr.sbin/makefs/ffs/mkfs.c

260

sblock.fs_nrpos = 1;

usr.sbin/makefs/ffs/mkfs.c

262

sblock.fs_magic = FS_UFS2_MAGIC;

usr.sbin/makefs/ffs/mkfs.c

264

sblock.fs_sblockloc = SBLOCK_UFS2;

usr.sbin/makefs/ffs/mkfs.c

266

sblock.fs_sblockloc = SBLOCK_UFS1;

usr.sbin/makefs/ffs/mkfs.c

268

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

usr.sbin/makefs/ffs/mkfs.c

269

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

usr.sbin/makefs/ffs/mkfs.c

270

sblock.fs_maxsymlinklen = (NDADDR + NIADDR) * sizeof (int64_t);

usr.sbin/makefs/ffs/mkfs.c

273

sblock.fs_sblkno =

usr.sbin/makefs/ffs/mkfs.c

274

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

usr.sbin/makefs/ffs/mkfs.c

275

sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

276

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

usr.sbin/makefs/ffs/mkfs.c

277

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

usr.sbin/makefs/ffs/mkfs.c

278

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

usr.sbin/makefs/ffs/mkfs.c

279

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

usr.sbin/makefs/ffs/mkfs.c

280

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

usr.sbin/makefs/ffs/mkfs.c

281

sizepb *= NINDIR(&sblock);

usr.sbin/makefs/ffs/mkfs.c

282

sblock.fs_maxfilesize += sizepb;

usr.sbin/makefs/ffs/mkfs.c

301

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

usr.sbin/makefs/ffs/mkfs.c

302

minfpg = fragsperinode * INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

303

if (minfpg > sblock.fs_size)

usr.sbin/makefs/ffs/mkfs.c

304

minfpg = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

305

sblock.fs_ipg = INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

306

sblock.fs_fpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

307

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

usr.sbin/makefs/ffs/mkfs.c

308

if (sblock.fs_fpg < minfpg)

usr.sbin/makefs/ffs/mkfs.c

309

sblock.fs_fpg = minfpg;

usr.sbin/makefs/ffs/mkfs.c

310

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

usr.sbin/makefs/ffs/mkfs.c

311

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

312

sblock.fs_fpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

313

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

usr.sbin/makefs/ffs/mkfs.c

314

if (sblock.fs_fpg < minfpg)

usr.sbin/makefs/ffs/mkfs.c

315

sblock.fs_fpg = minfpg;

usr.sbin/makefs/ffs/mkfs.c

316

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

usr.sbin/makefs/ffs/mkfs.c

317

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

318

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

usr.sbin/makefs/ffs/mkfs.c

320

density -= sblock.fs_fsize;

usr.sbin/makefs/ffs/mkfs.c

332

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

usr.sbin/makefs/ffs/mkfs.c

333

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

usr.sbin/makefs/ffs/mkfs.c

334

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

335

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

usr.sbin/makefs/ffs/mkfs.c

337

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

usr.sbin/makefs/ffs/mkfs.c

339

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

usr.sbin/makefs/ffs/mkfs.c

341

sblock.fs_fpg -= sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

342

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

usr.sbin/makefs/ffs/mkfs.c

343

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

352

optimalfpg = sblock.fs_fpg;

usr.sbin/makefs/ffs/mkfs.c

354

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

usr.sbin/makefs/ffs/mkfs.c

355

lastminfpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

356

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

usr.sbin/makefs/ffs/mkfs.c

357

if (sblock.fs_size < lastminfpg) {

usr.sbin/makefs/ffs/mkfs.c

359

(long long)sblock.fs_size, lastminfpg);

usr.sbin/makefs/ffs/mkfs.c

362

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

usr.sbin/makefs/ffs/mkfs.c

363

sblock.fs_size % sblock.fs_fpg == 0)

usr.sbin/makefs/ffs/mkfs.c

365

sblock.fs_fpg -= sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

366

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

usr.sbin/makefs/ffs/mkfs.c

367

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

369

if (optimalfpg != sblock.fs_fpg)

usr.sbin/makefs/ffs/mkfs.c

371

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

usr.sbin/makefs/ffs/mkfs.c

372

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

usr.sbin/makefs/ffs/mkfs.c

373

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

usr.sbin/makefs/ffs/mkfs.c

375

sblock.fs_spc = sblock.fs_fpg * sblock.fs_nspf;

usr.sbin/makefs/ffs/mkfs.c

376

sblock.fs_nsect = sblock.fs_spc;

usr.sbin/makefs/ffs/mkfs.c

377

sblock.fs_npsect = sblock.fs_spc;

usr.sbin/makefs/ffs/mkfs.c

378

sblock.fs_ncyl = sblock.fs_ncg;

usr.sbin/makefs/ffs/mkfs.c

384

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

usr.sbin/makefs/ffs/mkfs.c

385

sblock.fs_cssize =

usr.sbin/makefs/ffs/mkfs.c

386

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

usr.sbin/makefs/ffs/mkfs.c

392

size = sblock.fs_cssize;

usr.sbin/makefs/ffs/mkfs.c

393

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

394

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

usr.sbin/makefs/ffs/mkfs.c

396

sblock.fs_csp = space;

usr.sbin/makefs/ffs/mkfs.c

397

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

usr.sbin/makefs/ffs/mkfs.c

398

if (sblock.fs_contigsumsize > 0) {

usr.sbin/makefs/ffs/mkfs.c

401

sblock.fs_maxcluster = lp = space;

usr.sbin/makefs/ffs/mkfs.c

402

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

usr.sbin/makefs/ffs/mkfs.c

403

*lp++ = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

406

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

usr.sbin/makefs/ffs/mkfs.c

407

if (sblock.fs_sbsize > SBLOCKSIZE)

usr.sbin/makefs/ffs/mkfs.c

408

sblock.fs_sbsize = SBLOCKSIZE;

usr.sbin/makefs/ffs/mkfs.c

409

sblock.fs_minfree = minfree;

usr.sbin/makefs/ffs/mkfs.c

410

sblock.fs_maxcontig = maxcontig;

usr.sbin/makefs/ffs/mkfs.c

411

sblock.fs_maxbpg = maxbpg;

usr.sbin/makefs/ffs/mkfs.c

412

sblock.fs_optim = opt;

usr.sbin/makefs/ffs/mkfs.c

413

sblock.fs_cgrotor = 0;

usr.sbin/makefs/ffs/mkfs.c

414

sblock.fs_pendingblocks = 0;

usr.sbin/makefs/ffs/mkfs.c

415

sblock.fs_pendinginodes = 0;

usr.sbin/makefs/ffs/mkfs.c

416

sblock.fs_cstotal.cs_ndir = 0;

usr.sbin/makefs/ffs/mkfs.c

417

sblock.fs_cstotal.cs_nbfree = 0;

usr.sbin/makefs/ffs/mkfs.c

418

sblock.fs_cstotal.cs_nifree = 0;

usr.sbin/makefs/ffs/mkfs.c

419

sblock.fs_cstotal.cs_nffree = 0;

usr.sbin/makefs/ffs/mkfs.c

420

sblock.fs_fmod = 0;

usr.sbin/makefs/ffs/mkfs.c

421

sblock.fs_ronly = 0;

usr.sbin/makefs/ffs/mkfs.c

422

sblock.fs_state = 0;

usr.sbin/makefs/ffs/mkfs.c

423

sblock.fs_clean = FS_ISCLEAN;

usr.sbin/makefs/ffs/mkfs.c

424

sblock.fs_ronly = 0;

usr.sbin/makefs/ffs/mkfs.c

425

sblock.fs_id[0] = tstamp;

usr.sbin/makefs/ffs/mkfs.c

426

sblock.fs_id[1] = random();

usr.sbin/makefs/ffs/mkfs.c

427

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

usr.sbin/makefs/ffs/mkfs.c

428

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

usr.sbin/makefs/ffs/mkfs.c

429

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

usr.sbin/makefs/ffs/mkfs.c

430

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

usr.sbin/makefs/ffs/mkfs.c

431

sblock.fs_cstotal.cs_nbfree =

usr.sbin/makefs/ffs/mkfs.c

432

fragstoblks(&sblock, sblock.fs_dsize) -

usr.sbin/makefs/ffs/mkfs.c

433

howmany(csfrags, sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

434

sblock.fs_cstotal.cs_nffree =

usr.sbin/makefs/ffs/mkfs.c

435

fragnum(&sblock, sblock.fs_size) +

usr.sbin/makefs/ffs/mkfs.c

436

(fragnum(&sblock, csfrags) > 0 ?

usr.sbin/makefs/ffs/mkfs.c

437

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

usr.sbin/makefs/ffs/mkfs.c

438

sblock.fs_cstotal.cs_nifree = sblock.fs_ncg * sblock.fs_ipg - ROOTINO;

usr.sbin/makefs/ffs/mkfs.c

439

sblock.fs_cstotal.cs_ndir = 0;

usr.sbin/makefs/ffs/mkfs.c

440

sblock.fs_dsize -= csfrags;

usr.sbin/makefs/ffs/mkfs.c

441

sblock.fs_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

443

sblock.fs_ffs1_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

444

sblock.fs_ffs1_dsize = sblock.fs_dsize;

usr.sbin/makefs/ffs/mkfs.c

445

sblock.fs_ffs1_csaddr = sblock.fs_csaddr;

usr.sbin/makefs/ffs/mkfs.c

446

sblock.fs_ffs1_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;

usr.sbin/makefs/ffs/mkfs.c

447

sblock.fs_ffs1_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;

usr.sbin/makefs/ffs/mkfs.c

448

sblock.fs_ffs1_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;

usr.sbin/makefs/ffs/mkfs.c

449

sblock.fs_ffs1_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;

usr.sbin/makefs/ffs/mkfs.c

457

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

usr.sbin/makefs/ffs/mkfs.c

458

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

usr.sbin/makefs/ffs/mkfs.c

459

sblock.fs_bsize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

462

sblock.fs_ncg,

usr.sbin/makefs/ffs/mkfs.c

463

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

usr.sbin/makefs/ffs/mkfs.c

464

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

usr.sbin/makefs/ffs/mkfs.c

472

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

usr.sbin/makefs/ffs/mkfs.c

479

if (sblock.fs_bsize < SBLOCKSIZE)

usr.sbin/makefs/ffs/mkfs.c

480

iobufsize = SBLOCKSIZE + 3 * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

482

iobufsize = 4 * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

488

memcpy(writebuf, &sblock, SBLOCKSIZE);

usr.sbin/makefs/ffs/mkfs.c

492

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

usr.sbin/makefs/ffs/mkfs.c

497

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

usr.sbin/makefs/ffs/mkfs.c

506

sblock.fs_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

508

sblock.fs_ffs1_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;

usr.sbin/makefs/ffs/mkfs.c

509

sblock.fs_ffs1_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;

usr.sbin/makefs/ffs/mkfs.c

510

sblock.fs_ffs1_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;

usr.sbin/makefs/ffs/mkfs.c

511

sblock.fs_ffs1_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;

usr.sbin/makefs/ffs/mkfs.c

513

ffs_write_superblock(&sblock, fsopts);

usr.sbin/makefs/ffs/mkfs.c

514

return (&sblock);

usr.sbin/makefs/ffs/mkfs.c

575

cbase = cgbase(&sblock, cylno);

usr.sbin/makefs/ffs/mkfs.c

576

dmax = cbase + sblock.fs_fpg;

usr.sbin/makefs/ffs/mkfs.c

577

if (dmax > sblock.fs_size)

usr.sbin/makefs/ffs/mkfs.c

578

dmax = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

579

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

usr.sbin/makefs/ffs/mkfs.c

580

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

usr.sbin/makefs/ffs/mkfs.c

582

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

usr.sbin/makefs/ffs/mkfs.c

583

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

usr.sbin/makefs/ffs/mkfs.c

587

acg.cg_ffs2_niblk = sblock.fs_ipg;

usr.sbin/makefs/ffs/mkfs.c

588

acg.cg_initediblk = sblock.fs_ipg < 2 * INOPB(&sblock) ?

usr.sbin/makefs/ffs/mkfs.c

589

sblock.fs_ipg : 2 * INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

591

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

592

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

usr.sbin/makefs/ffs/mkfs.c

597

if (cylno == sblock.fs_ncg - 1)

usr.sbin/makefs/ffs/mkfs.c

599

sblock.fs_fpg / sblock.fs_cpg);

usr.sbin/makefs/ffs/mkfs.c

601

acg.cg_ncyl = sblock.fs_cpg;

usr.sbin/makefs/ffs/mkfs.c

608

acg.cg_boff = acg.cg_btotoff + sblock.fs_cpg * sizeof(int32_t);

usr.sbin/makefs/ffs/mkfs.c

610

sblock.fs_cpg * sizeof(u_int16_t);

usr.sbin/makefs/ffs/mkfs.c

612

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

usr.sbin/makefs/ffs/mkfs.c

613

if (sblock.fs_contigsumsize <= 0) {

usr.sbin/makefs/ffs/mkfs.c

615

howmany(sblock.fs_fpg, CHAR_BIT);

usr.sbin/makefs/ffs/mkfs.c

618

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

usr.sbin/makefs/ffs/mkfs.c

622

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

usr.sbin/makefs/ffs/mkfs.c

624

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

usr.sbin/makefs/ffs/mkfs.c

626

if (acg.cg_nextfreeoff > sblock.fs_cgsize) {

usr.sbin/makefs/ffs/mkfs.c

630

acg.cg_cs.cs_nifree += sblock.fs_ipg;

usr.sbin/makefs/ffs/mkfs.c

645

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

usr.sbin/makefs/ffs/mkfs.c

646

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

649

d += sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

653

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

usr.sbin/makefs/ffs/mkfs.c

654

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

usr.sbin/makefs/ffs/mkfs.c

655

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

usr.sbin/makefs/ffs/mkfs.c

660

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

usr.sbin/makefs/ffs/mkfs.c

661

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

usr.sbin/makefs/ffs/mkfs.c

662

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

usr.sbin/makefs/ffs/mkfs.c

663

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

666

d += sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

676

if (sblock.fs_contigsumsize > 0) {

usr.sbin/makefs/ffs/mkfs.c

687

if (run > sblock.fs_contigsumsize)

usr.sbin/makefs/ffs/mkfs.c

688

run = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

700

if (run > sblock.fs_contigsumsize)

usr.sbin/makefs/ffs/mkfs.c

701

run = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

705

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

usr.sbin/makefs/ffs/mkfs.c

710

start = sblock.fs_bsize > SBLOCKSIZE ? sblock.fs_bsize : SBLOCKSIZE;

usr.sbin/makefs/ffs/mkfs.c

711

memcpy(&iobuf[start], &acg, sblock.fs_cgsize);

usr.sbin/makefs/ffs/mkfs.c

712

start += sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

716

if (sblock.fs_magic == FS_UFS1_MAGIC) {

usr.sbin/makefs/ffs/mkfs.c

725

ffs_wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf,

usr.sbin/makefs/ffs/mkfs.c

731

for (i = 2 * sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

732

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

usr.sbin/makefs/ffs/mkfs.c

733

i += sblock.fs_frag) {

usr.sbin/makefs/ffs/mkfs.c

735

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

usr.sbin/makefs/ffs/mkfs.c

739

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

usr.sbin/makefs/ffs/mkfs.c

740

sblock.fs_bsize, &iobuf[start], fsopts);