sbin/badsect/badsect.c

146

fs = &sblock;

sbin/badsect/badsect.c

232

rdfs(FFS_FSBTODB(fs, cgtod(fs, cg)), (int)sblock.fs_cgsize, &acg);

sbin/clri/clri.c

104

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

sbin/clri/clri.c

107

sbp = (struct fs *)sblock;

sbin/clri/clri.c

150

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

sbin/clri/clri.c

84

char *fs, sblock[SBLOCKSIZE];

sbin/dump/ffs_inode.c

102

ffs_sb_swap(sblock, sblock);

sbin/dump/ffs_inode.c

109

if ((is_ufs2 || sblock->fs_old_flags & FS_FLAGS_UPDATED)

sbin/dump/ffs_inode.c

110

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

sbin/dump/ffs_inode.c

127

if (is_ufs2 || sblock->fs_old_inodefmt >= FS_44INODEFMT) {

sbin/dump/ffs_inode.c

137

sblock->fs_qbmask = ~sblock->fs_bmask;

sbin/dump/ffs_inode.c

138

sblock->fs_qfmask = ~sblock->fs_fmask;

sbin/dump/ffs_inode.c

143

ufsi.ufs_dsize = FFS_FSBTODB(sblock,sblock->fs_size);

sbin/dump/ffs_inode.c

144

ufsi.ufs_bsize = sblock->fs_bsize;

sbin/dump/ffs_inode.c

145

ufsi.ufs_bshift = sblock->fs_bshift;

sbin/dump/ffs_inode.c

146

ufsi.ufs_fsize = sblock->fs_fsize;

sbin/dump/ffs_inode.c

147

ufsi.ufs_frag = sblock->fs_frag;

sbin/dump/ffs_inode.c

148

ufsi.ufs_fsatoda = sblock->fs_fsbtodb;

sbin/dump/ffs_inode.c

149

ufsi.ufs_nindir = sblock->fs_nindir;

sbin/dump/ffs_inode.c

150

ufsi.ufs_inopb = sblock->fs_inopb;

sbin/dump/ffs_inode.c

151

ufsi.ufs_maxsymlinklen = sblock->fs_maxsymlinklen;

sbin/dump/ffs_inode.c

152

ufsi.ufs_bmask = sblock->fs_bmask;

sbin/dump/ffs_inode.c

153

ufsi.ufs_fmask = sblock->fs_fmask;

sbin/dump/ffs_inode.c

154

ufsi.ufs_qbmask = sblock->fs_qbmask;

sbin/dump/ffs_inode.c

155

ufsi.ufs_qfmask = sblock->fs_qfmask;

sbin/dump/ffs_inode.c

157

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

sbin/dump/ffs_inode.c

166

return sblock->fs_ipg * sblock->fs_ncg;

sbin/dump/ffs_inode.c

177

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

sbin/dump/ffs_inode.c

180

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

sbin/dump/ffs_inode.c

181

ino = cg * sblock->fs_ipg;

sbin/dump/ffs_inode.c

182

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

sbin/dump/ffs_inode.c

183

sblock->fs_cgsize);

sbin/dump/ffs_inode.c

185

ffs_cg_swap(cgp, cgp, sblock);

sbin/dump/ffs_inode.c

186

if (sblock->fs_magic == FS_UFS2_MAGIC)

sbin/dump/ffs_inode.c

189

inosused = sblock->fs_ipg;

sbin/dump/ffs_inode.c

197

if (sblock->fs_flags & FS_DOSOFTDEP) {

sbin/dump/ffs_inode.c

239

bread(fsatoda(ufsib, ino_to_fsba(sblock, inum)), (char *)inoblock,

sbin/dump/ffs_inode.c

241

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

sbin/dump/ffs_inode.c

242

maxino = minino + FFS_INOPB(sblock);

sbin/dump/ffs_inode.c

63

static struct fs *sblock;

sbin/dump/ffs_inode.c

79

sblock = (struct fs *)superblock;

sbin/dump/ffs_inode.c

85

switch(sblock->fs_magic) {

sbin/dump/ffs_inode.c

87

sblock->fs_magic = FS_UFS2_MAGIC;

sbin/dump/ffs_inode.c

95

sblock->fs_magic = FS_UFS2_MAGIC_SWAPPED;

sbin/dump_lfs/lfs_inode.c

101

sblock->lfs_is64 = true;

sbin/dump_lfs/lfs_inode.c

102

sblock->lfs_dobyteswap = false;

sbin/dump_lfs/lfs_inode.c

105

sblock->lfs_is64 = true;

sbin/dump_lfs/lfs_inode.c

106

sblock->lfs_dobyteswap = true;

sbin/dump_lfs/lfs_inode.c

112

if (lfs_fsbtob(sblock, (off_t)lfs_sb_getsboff(sblock, 0)) != sboff) {

sbin/dump_lfs/lfs_inode.c

113

sboff = lfs_fsbtob(sblock, (off_t)lfs_sb_getsboff(sblock, 0));

sbin/dump_lfs/lfs_inode.c

122

rawread(lfs_fsbtob(sblock, (off_t)lfs_sb_getsboff(sblock, 1)), u.tbuf,

sbin/dump_lfs/lfs_inode.c

126

sblock->lfs_dlfs_u.u_32.dlfs_magic) {

sbin/dump_lfs/lfs_inode.c

128

LFS_FSBTODB(sblock, (off_t)lfs_sb_getsboff(sblock, 1)));

sbin/dump_lfs/lfs_inode.c

130

u.lfss.lfs_is64 = sblock->lfs_is64;

sbin/dump_lfs/lfs_inode.c

131

u.lfss.lfs_dobyteswap = sblock->lfs_dobyteswap;

sbin/dump_lfs/lfs_inode.c

133

if (lfs_sb_getversion(sblock) > 1) {

sbin/dump_lfs/lfs_inode.c

134

if (lfs_sb_getserial(&u.lfss) < lfs_sb_getserial(sblock)) {

sbin/dump_lfs/lfs_inode.c

135

memcpy(sblock, u.tbuf, sizeof(u.tbuf));

sbin/dump_lfs/lfs_inode.c

136

sboff = lfs_fsbtob(sblock, (off_t)lfs_sb_getsboff(sblock, 1));

sbin/dump_lfs/lfs_inode.c

139

if (lfs_sb_getotstamp(&u.lfss) < lfs_sb_getotstamp(sblock)) {

sbin/dump_lfs/lfs_inode.c

140

memcpy(sblock, u.tbuf, sizeof(u.tbuf));

sbin/dump_lfs/lfs_inode.c

141

sboff = lfs_fsbtob(sblock, (off_t)lfs_sb_getsboff(sblock, 1));

sbin/dump_lfs/lfs_inode.c

151

is_ufs2 = sblock->lfs_is64;

sbin/dump_lfs/lfs_inode.c

157

if (sblock->lfs_is64) {

sbin/dump_lfs/lfs_inode.c

161

return sblock->lfs_dobyteswap;

sbin/dump_lfs/lfs_inode.c

175

ufsi.ufs_dsize = LFS_FSBTODB(sblock, lfs_sb_getsize(sblock));

sbin/dump_lfs/lfs_inode.c

176

if (lfs_sb_getversion(sblock) == 1)

sbin/dump_lfs/lfs_inode.c

177

ufsi.ufs_dsize = lfs_sb_getsize(sblock) >> lfs_sb_getblktodb(sblock);

sbin/dump_lfs/lfs_inode.c

178

ufsi.ufs_bsize = lfs_sb_getbsize(sblock);

sbin/dump_lfs/lfs_inode.c

179

ufsi.ufs_bshift = lfs_sb_getbshift(sblock);

sbin/dump_lfs/lfs_inode.c

180

ufsi.ufs_fsize = lfs_sb_getfsize(sblock);

sbin/dump_lfs/lfs_inode.c

181

ufsi.ufs_frag = lfs_sb_getfrag(sblock);

sbin/dump_lfs/lfs_inode.c

182

ufsi.ufs_fsatoda = lfs_sb_getfsbtodb(sblock);

sbin/dump_lfs/lfs_inode.c

183

if (lfs_sb_getversion(sblock) == 1)

sbin/dump_lfs/lfs_inode.c

185

ufsi.ufs_nindir = lfs_sb_getnindir(sblock);

sbin/dump_lfs/lfs_inode.c

186

ufsi.ufs_inopb = lfs_sb_getinopb(sblock);

sbin/dump_lfs/lfs_inode.c

187

ufsi.ufs_maxsymlinklen = lfs_sb_getmaxsymlinklen(sblock);

sbin/dump_lfs/lfs_inode.c

188

ufsi.ufs_bmask = ~(lfs_sb_getbmask(sblock));

sbin/dump_lfs/lfs_inode.c

189

ufsi.ufs_qbmask = lfs_sb_getbmask(sblock);

sbin/dump_lfs/lfs_inode.c

190

ufsi.ufs_fmask = ~(lfs_sb_getffmask(sblock));

sbin/dump_lfs/lfs_inode.c

191

ufsi.ufs_qfmask = lfs_sb_getffmask(sblock);

sbin/dump_lfs/lfs_inode.c

193

dev_bsize = lfs_sb_getbsize(sblock) >> lfs_sb_getblktodb(sblock);

sbin/dump_lfs/lfs_inode.c

202

- (lfs_sb_getcleansz(sblock) + lfs_sb_getsegtabsz(sblock))

sbin/dump_lfs/lfs_inode.c

203

* lfs_sb_getbsize(sblock))

sbin/dump_lfs/lfs_inode.c

204

/ lfs_sb_getbsize(sblock)) * lfs_sb_getifpb(sblock) - 1;

sbin/dump_lfs/lfs_inode.c

269

bread(LFS_FSBTODB(sblock, up), bp, lfs_sb_getbsize(sblock));

sbin/dump_lfs/lfs_inode.c

301

bread(LFS_FSBTODB(sblock, up), bp, lfs_sb_getbsize(sblock));

sbin/dump_lfs/lfs_inode.c

316

lbn = ino/lfs_sb_getifpb(sblock) + lfs_sb_getcleansz(sblock) + lfs_sb_getsegtabsz(sblock);

sbin/dump_lfs/lfs_inode.c

319

if (sblock->lfs_is64) {

sbin/dump_lfs/lfs_inode.c

324

blkno = lfs_bmap(sblock, ldp, lbn);

sbin/dump_lfs/lfs_inode.c

326

bread(LFS_FSBTODB(sblock, blkno), ifileblock,

sbin/dump_lfs/lfs_inode.c

327

lfs_sb_getbsize(sblock));

sbin/dump_lfs/lfs_inode.c

328

index = ino % lfs_sb_getifpb(sblock);

sbin/dump_lfs/lfs_inode.c

329

if (sblock->lfs_is64) {

sbin/dump_lfs/lfs_inode.c

331

} else if (lfs_sb_getversion(sblock) > 1) {

sbin/dump_lfs/lfs_inode.c

371

inum2 = sblock->lfs_is64 ?

sbin/dump_lfs/lfs_inode.c

375

blkno = lfs_sb_getidaddr(sblock);

sbin/dump_lfs/lfs_inode.c

376

bread(LFS_FSBTODB(sblock, blkno), inoblock.space,

sbin/dump_lfs/lfs_inode.c

377

(int)lfs_sb_getbsize(sblock));

sbin/dump_lfs/lfs_inode.c

378

dp = lfs_ifind(sblock, inum, inoblock.space);

sbin/dump_lfs/lfs_inode.c

380

if (sblock->lfs_is64) {

sbin/dump_lfs/lfs_inode.c

390

blkno = lfs_if_getdaddr(sblock, lfs_ientry(inum));

sbin/dump_lfs/lfs_inode.c

395

bread(LFS_FSBTODB(sblock, blkno), inoblock.space,

sbin/dump_lfs/lfs_inode.c

396

(int)lfs_sb_getbsize(sblock));

sbin/dump_lfs/lfs_inode.c

398

return (void *)lfs_ifind(sblock, inum, inoblock.space);

sbin/dump_lfs/lfs_inode.c

65

struct lfs *sblock;

sbin/dump_lfs/lfs_inode.c

88

sblock = (struct lfs *)superblock;

sbin/dump_lfs/lfs_inode.c

90

rawread(sboff, (char *) sblock, LFS_SBPAD);

sbin/dump_lfs/lfs_inode.c

91

switch (sblock->lfs_dlfs_u.u_32.dlfs_magic) {

sbin/dump_lfs/lfs_inode.c

93

sblock->lfs_is64 = false;

sbin/dump_lfs/lfs_inode.c

94

sblock->lfs_dobyteswap = false;

sbin/dump_lfs/lfs_inode.c

97

sblock->lfs_is64 = false;

sbin/dump_lfs/lfs_inode.c

98

sblock->lfs_dobyteswap = true;

sbin/fsck_ext2fs/dir.c

159

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

sbin/fsck_ext2fs/dir.c

165

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

sbin/fsck_ext2fs/dir.c

166

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

sbin/fsck_ext2fs/dir.c

167

blksiz = idesc->id_numfrags * sblock.e2fs_bsize;

sbin/fsck_ext2fs/dir.c

204

blksiz = idesc->id_numfrags * sblock.e2fs_bsize;

sbin/fsck_ext2fs/dir.c

206

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

sbin/fsck_ext2fs/dir.c

216

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

sbin/fsck_ext2fs/dir.c

223

idesc->id_loc += sblock.e2fs_bsize;

sbin/fsck_ext2fs/dir.c

224

idesc->id_filesize -= sblock.e2fs_bsize;

sbin/fsck_ext2fs/dir.c

234

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

sbin/fsck_ext2fs/dir.c

239

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

sbin/fsck_ext2fs/dir.c

266

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

sbin/fsck_ext2fs/dir.c

274

if (sblock.e2fs.e2fs_rev < E2FS_REV1 ||

sbin/fsck_ext2fs/dir.c

275

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

sbin/fsck_ext2fs/dir.c

356

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/dir.c

357

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/dir.c

387

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/dir.c

388

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/dir.c

538

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

sbin/fsck_ext2fs/dir.c

539

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

sbin/fsck_ext2fs/dir.c

561

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

sbin/fsck_ext2fs/dir.c

571

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

sbin/fsck_ext2fs/dir.c

572

inosnblock(dp, inonblock(dp) + btodb(sblock.e2fs_bsize));

sbin/fsck_ext2fs/dir.c

574

sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

577

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

sbin/fsck_ext2fs/dir.c

579

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

sbin/fsck_ext2fs/dir.c

580

bp = getdirblk(newblk, sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

585

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

sbin/fsck_ext2fs/dir.c

589

sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

592

emptydir.dot_reclen = h2fs16(sblock.e2fs_bsize);

sbin/fsck_ext2fs/dir.c

605

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

sbin/fsck_ext2fs/dir.c

606

inosnblock(dp, inonblock(dp) - btodb(sblock.e2fs_bsize));

sbin/fsck_ext2fs/dir.c

624

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

sbin/fsck_ext2fs/dir.c

626

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/dir.c

627

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/dir.c

632

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/dir.c

633

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/dir.c

641

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

sbin/fsck_ext2fs/fsck.h

106

extern struct m_ext2fs sblock;

sbin/fsck_ext2fs/inode.c

105

if (sblock.e2fs.e2fs_rev < E2FS_REV1) {

sbin/fsck_ext2fs/inode.c

109

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

sbin/fsck_ext2fs/inode.c

114

sblock.e2fs.e2fs_features_rocompat |= EXT2F_ROCOMPAT_LARGEFILE;

sbin/fsck_ext2fs/inode.c

123

if (sblock.e2fs.e2fs_rev < E2FS_REV1) {

sbin/fsck_ext2fs/inode.c

127

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

sbin/fsck_ext2fs/inode.c

132

sblock.e2fs.e2fs_features_rocompat |= EXT2F_ROCOMPAT_HUGE_FILE;

sbin/fsck_ext2fs/inode.c

185

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

sbin/fsck_ext2fs/inode.c

200

sblock.e2fs_bsize);

sbin/fsck_ext2fs/inode.c

218

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

sbin/fsck_ext2fs/inode.c

219

sizepb = sblock.e2fs_bsize;

sbin/fsck_ext2fs/inode.c

245

sizepb *= EXT2_NINDIR(&sblock);

sbin/fsck_ext2fs/inode.c

273

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

sbin/fsck_ext2fs/inode.c

275

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

sbin/fsck_ext2fs/inode.c

276

sizepb *= EXT2_NINDIR(&sblock);

sbin/fsck_ext2fs/inode.c

277

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

sbin/fsck_ext2fs/inode.c

278

nif = EXT2_NINDIR(&sblock);

sbin/fsck_ext2fs/inode.c

282

nif < EXT2_NINDIR(&sblock)) {

sbin/fsck_ext2fs/inode.c

283

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

sbin/fsck_ext2fs/inode.c

346

c = dtog(&sblock, blk);

sbin/fsck_ext2fs/inode.c

348

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

sbin/fsck_ext2fs/inode.c

349

sblock.e2fs.e2fs_first_dblock) {

sbin/fsck_ext2fs/inode.c

350

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

sbin/fsck_ext2fs/inode.c

351

sblock.e2fs.e2fs_first_dblock) {

sbin/fsck_ext2fs/inode.c

355

sblock.e2fs.e2fs_bpg * c + overh +

sbin/fsck_ext2fs/inode.c

356

sblock.e2fs.e2fs_first_dblock);

sbin/fsck_ext2fs/inode.c

359

sblock.e2fs.e2fs_bpg * c +

sbin/fsck_ext2fs/inode.c

360

overh + sblock.e2fs.e2fs_first_dblock);

sbin/fsck_ext2fs/inode.c

365

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

sbin/fsck_ext2fs/inode.c

366

sblock.e2fs.e2fs_first_dblock) {

sbin/fsck_ext2fs/inode.c

370

sblock.e2fs.e2fs_bpg * c + overh +

sbin/fsck_ext2fs/inode.c

371

sblock.e2fs.e2fs_first_dblock);

sbin/fsck_ext2fs/inode.c

374

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

sbin/fsck_ext2fs/inode.c

375

overh + sblock.e2fs.e2fs_first_dblock);

sbin/fsck_ext2fs/inode.c

395

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

sbin/fsck_ext2fs/inode.c

400

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

sbin/fsck_ext2fs/inode.c

401

iblk = fsck_ino_to_fsba(&sblock, inumber);

sbin/fsck_ext2fs/inode.c

404

pbp = getdatablk(iblk, sblock.e2fs_bsize);

sbin/fsck_ext2fs/inode.c

406

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

sbin/fsck_ext2fs/inode.c

409

EXT2_DINODE_SIZE(&sblock) * ino_to_fsbo(&sblock, inumber));

sbin/fsck_ext2fs/inode.c

435

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

sbin/fsck_ext2fs/inode.c

447

bp += EXT2_DINODE_SIZE(&sblock);

sbin/fsck_ext2fs/inode.c

460

inobufsize = ext2_blkroundup(&sblock, INOBUFSIZE);

sbin/fsck_ext2fs/inode.c

461

fullcnt = inobufsize / EXT2_DINODE_SIZE(&sblock);

sbin/fsck_ext2fs/inode.c

462

readpercg = sblock.e2fs.e2fs_ipg / fullcnt;

sbin/fsck_ext2fs/inode.c

463

partialcnt = sblock.e2fs.e2fs_ipg % fullcnt;

sbin/fsck_ext2fs/inode.c

464

partialsize = partialcnt * EXT2_DINODE_SIZE(&sblock);

sbin/fsck_ext2fs/inode.c

501

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

sbin/fsck_ext2fs/inode.c

643

if (sblock.e2fs.e2fs_rev > E2FS_REV0)

sbin/fsck_ext2fs/inode.c

729

inossize(dp, sblock.e2fs_bsize);

sbin/fsck_ext2fs/inode.c

730

inosnblock(dp, btodb(sblock.e2fs_bsize));

sbin/fsck_ext2fs/inode.c

767

if ((sblock.e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_HUGE_FILE)) {

sbin/fsck_ext2fs/inode.c

770

nblock = EXT2_FSBTODB(&sblock, nblock);

sbin/fsck_ext2fs/inode.c

801

if (EXT2_DBTOFSB(&sblock, nblock) <= 0xffffffffffffULL) {

sbin/fsck_ext2fs/inode.c

804

dp->e2di_nblock = h2fs32(EXT2_DBTOFSB(&sblock, nblock));

sbin/fsck_ext2fs/inode.c

805

dp->e2di_nblock_high = h2fs16((EXT2_DBTOFSB(&sblock, nblock) >> 32));

sbin/fsck_ext2fs/main.c

257

if (sblock.e2fs.e2fs_rev > E2FS_REV0) {

sbin/fsck_ext2fs/main.c

259

sblock.e2fs.e2fs_fsmnt);

sbin/fsck_ext2fs/main.c

308

n_bfree = sblock.e2fs.e2fs_fbcount;

sbin/fsck_ext2fs/main.c

314

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

sbin/fsck_ext2fs/main.c

317

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

sbin/fsck_ext2fs/main.c

319

n_blks += sblock.e2fs.e2fs_first_dblock;

sbin/fsck_ext2fs/main.c

343

sblock.e2fs.e2fs_wtime = t;

sbin/fsck_ext2fs/main.c

344

sblock.e2fs.e2fs_lastfsck = t;

sbin/fsck_ext2fs/main.c

96

struct m_ext2fs sblock;

sbin/fsck_ext2fs/pass1.c

100

dbase = c * sblock.e2fs.e2fs_bpg +

sbin/fsck_ext2fs/pass1.c

101

sblock.e2fs.e2fs_first_dblock;

sbin/fsck_ext2fs/pass1.c

103

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

sbin/fsck_ext2fs/pass1.c

104

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

sbin/fsck_ext2fs/pass1.c

106

fs2h32(sblock.e2fs_gd[c].ext2bgd_i_tables)

sbin/fsck_ext2fs/pass1.c

110

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

sbin/fsck_ext2fs/pass1.c

111

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

sbin/fsck_ext2fs/pass1.c

113

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

sbin/fsck_ext2fs/pass1.c

114

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

sbin/fsck_ext2fs/pass1.c

116

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

sbin/fsck_ext2fs/pass1.c

117

(sblock.e2fs.e2fs_features_rocompat &

sbin/fsck_ext2fs/pass1.c

122

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

sbin/fsck_ext2fs/pass1.c

142

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

sbin/fsck_ext2fs/pass1.c

144

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

sbin/fsck_ext2fs/pass1.c

166

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

sbin/fsck_ext2fs/pass1.c

216

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

sbin/fsck_ext2fs/pass1.c

224

inossize(dp, sblock.e2fs_bsize);

sbin/fsck_ext2fs/pass1.c

227

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

sbin/fsck_ext2fs/pass1.c

247

ndb *= EXT2_NINDIR(&sblock);

sbin/fsck_ext2fs/pass1.c

262

ndb /= EXT2_NINDIR(&sblock);

sbin/fsck_ext2fs/pass1.c

304

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

sbin/fsck_ext2fs/pass1.c

99

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

sbin/fsck_ext2fs/pass1b.c

91

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

sbin/fsck_ext2fs/pass1b.c

92

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

sbin/fsck_ext2fs/pass2.c

159

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

sbin/fsck_ext2fs/pass2.c

165

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

sbin/fsck_ext2fs/pass2.c

169

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

sbin/fsck_ext2fs/pass2.c

172

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

sbin/fsck_ext2fs/pass2.c

247

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/pass2.c

248

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)

sbin/fsck_ext2fs/pass2.c

260

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/pass2.c

261

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/pass2.c

295

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/pass2.c

296

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE))

sbin/fsck_ext2fs/pass2.c

318

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/pass2.c

319

(sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)

sbin/fsck_ext2fs/pass2.c

435

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/pass2.c

436

(sblock.e2fs.e2fs_features_incompat &

sbin/fsck_ext2fs/pass5.c

175

dbase = c * sblock.e2fs.e2fs_bpg +

sbin/fsck_ext2fs/pass5.c

176

sblock.e2fs.e2fs_first_dblock;

sbin/fsck_ext2fs/pass5.c

177

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

sbin/fsck_ext2fs/pass5.c

178

sblock.e2fs.e2fs_first_dblock;

sbin/fsck_ext2fs/pass5.c

183

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

sbin/fsck_ext2fs/pass5.c

86

struct m_ext2fs *fs = &sblock;

sbin/fsck_ext2fs/setup.c

185

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

sbin/fsck_ext2fs/setup.c

186

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

sbin/fsck_ext2fs/setup.c

195

maxfsblock = sblock.e2fs.e2fs_bcount;

sbin/fsck_ext2fs/setup.c

196

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

sbin/fsck_ext2fs/setup.c

197

sizepb = sblock.e2fs_bsize;

sbin/fsck_ext2fs/setup.c

198

maxfilesize = sblock.e2fs_bsize * EXT2FS_NDADDR - 1;

sbin/fsck_ext2fs/setup.c

200

sizepb *= EXT2_NINDIR(&sblock);

sbin/fsck_ext2fs/setup.c

207

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

sbin/fsck_ext2fs/setup.c

209

sblock.e2fs.e2fs_rbcount);

sbin/fsck_ext2fs/setup.c

211

sblock.e2fs.e2fs_rbcount =

sbin/fsck_ext2fs/setup.c

212

sblock.e2fs.e2fs_bcount * MINFREE / 100;

sbin/fsck_ext2fs/setup.c

217

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

sbin/fsck_ext2fs/setup.c

219

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

sbin/fsck_ext2fs/setup.c

230

sblock.e2fs_gd = malloc(sblock.e2fs_ngdb * sblock.e2fs_bsize);

sbin/fsck_ext2fs/setup.c

231

if (sblock.e2fs_gd == NULL)

sbin/fsck_ext2fs/setup.c

234

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

sbin/fsck_ext2fs/setup.c

236

(char *)&sblock.e2fs_gd[i * sblock.e2fs_bsize /

sbin/fsck_ext2fs/setup.c

238

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

sbin/fsck_ext2fs/setup.c

240

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

sbin/fsck_ext2fs/setup.c

275

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

sbin/fsck_ext2fs/setup.c

276

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

sbin/fsck_ext2fs/setup.c

309

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

sbin/fsck_ext2fs/setup.c

314

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

sbin/fsck_ext2fs/setup.c

318

if (sblock.e2fs.e2fs_log_bsize > 2) {

sbin/fsck_ext2fs/setup.c

322

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/setup.c

323

(!powerof2(sblock.e2fs.e2fs_inode_size) ||

sbin/fsck_ext2fs/setup.c

324

sblock.e2fs.e2fs_inode_size < EXT2_REV0_DINODE_SIZE ||

sbin/fsck_ext2fs/setup.c

325

sblock.e2fs.e2fs_inode_size >

sbin/fsck_ext2fs/setup.c

326

(1024 << sblock.e2fs.e2fs_log_bsize))) {

sbin/fsck_ext2fs/setup.c

333

sblock.e2fs_ncg =

sbin/fsck_ext2fs/setup.c

334

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

sbin/fsck_ext2fs/setup.c

335

sblock.e2fs.e2fs_bpg);

sbin/fsck_ext2fs/setup.c

336

sblock.e2fs_fsbtodb = sblock.e2fs.e2fs_log_bsize + ilog2(1024 / dev_bsize);

sbin/fsck_ext2fs/setup.c

337

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

sbin/fsck_ext2fs/setup.c

338

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

sbin/fsck_ext2fs/setup.c

339

sblock.e2fs_qbmask = sblock.e2fs_bsize - 1;

sbin/fsck_ext2fs/setup.c

340

sblock.e2fs_bmask = ~sblock.e2fs_qbmask;

sbin/fsck_ext2fs/setup.c

341

sblock.e2fs_ngdb = howmany(sblock.e2fs_ncg,

sbin/fsck_ext2fs/setup.c

342

sblock.e2fs_bsize / sizeof(struct ext2_gd));

sbin/fsck_ext2fs/setup.c

343

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

sbin/fsck_ext2fs/setup.c

344

sblock.e2fs_itpg = howmany(sblock.e2fs.e2fs_ipg, sblock.e2fs_ipb);

sbin/fsck_ext2fs/setup.c

352

dev_bsize = sblock.e2fs_bsize / EXT2_FSBTODB(&sblock, 1);

sbin/fsck_ext2fs/setup.c

355

if (sblock.e2fs_ncg == 1) {

sbin/fsck_ext2fs/setup.c

360

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

sbin/fsck_ext2fs/setup.c

397

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/setup.c

398

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

sbin/fsck_ext2fs/setup.c

399

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

sbin/fsck_ext2fs/setup.c

403

sblock.e2fs.e2fs_features_compat,

sbin/fsck_ext2fs/setup.c

404

sblock.e2fs.e2fs_features_incompat,

sbin/fsck_ext2fs/setup.c

405

sblock.e2fs.e2fs_features_rocompat);

sbin/fsck_ext2fs/setup.c

407

if ((sblock.e2fs.e2fs_features_rocompat & ~EXT2F_ROCOMPAT_SUPP_FSCK)) {

sbin/fsck_ext2fs/setup.c

411

sblock.e2fs.e2fs_features_rocompat & ~EXT2F_ROCOMPAT_SUPP_FSCK);

sbin/fsck_ext2fs/setup.c

414

if ((sblock.e2fs.e2fs_features_incompat & ~EXT2F_INCOMPAT_SUPP_FSCK)) {

sbin/fsck_ext2fs/setup.c

418

sblock.e2fs.e2fs_features_incompat & ~EXT2F_INCOMPAT_SUPP_FSCK);

sbin/fsck_ext2fs/setup.c

456

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

sbin/fsck_ext2fs/setup.c

457

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

sbin/fsck_ext2fs/setup.c

458

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

sbin/fsck_ext2fs/setup.c

459

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

sbin/fsck_ext2fs/setup.c

460

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

sbin/fsck_ext2fs/setup.c

462

h2fs32(sblock.e2fs.e2fs_first_dblock);

sbin/fsck_ext2fs/setup.c

463

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

sbin/fsck_ext2fs/setup.c

464

bp->b_un.b_fs->e2fs_fsize = h2fs32(sblock.e2fs.e2fs_fsize);

sbin/fsck_ext2fs/setup.c

465

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

sbin/fsck_ext2fs/setup.c

466

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

sbin/fsck_ext2fs/setup.c

467

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

sbin/fsck_ext2fs/setup.c

468

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

sbin/fsck_ext2fs/setup.c

469

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

sbin/fsck_ext2fs/setup.c

470

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

sbin/fsck_ext2fs/setup.c

471

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

sbin/fsck_ext2fs/setup.c

472

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

sbin/fsck_ext2fs/setup.c

473

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

sbin/fsck_ext2fs/setup.c

474

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

sbin/fsck_ext2fs/setup.c

476

h2fs16(sblock.e2fs.e2fs_max_mnt_count);

sbin/fsck_ext2fs/setup.c

477

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

sbin/fsck_ext2fs/setup.c

478

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

sbin/fsck_ext2fs/setup.c

479

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

sbin/fsck_ext2fs/setup.c

480

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

sbin/fsck_ext2fs/setup.c

481

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

sbin/fsck_ext2fs/setup.c

548

sblock.e2fs_itpg;

sbin/fsck_ext2fs/setup.c

549

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/fsck_ext2fs/setup.c

550

sblock.e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSESUPER) {

sbin/fsck_ext2fs/setup.c

554

overh += 1 /* superblock */ + sblock.e2fs_ngdb;

sbin/fsck_ext2fs/utilities.c

154

bufcnt = MAXBUFSPACE / sblock.e2fs_bsize;

sbin/fsck_ext2fs/utilities.c

159

bufp = malloc((size_t)sblock.e2fs_bsize);

sbin/fsck_ext2fs/utilities.c

186

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

sbin/fsck_ext2fs/utilities.c

213

dblk = EXT2_FSBTODB(&sblock, blk);

sbin/fsck_ext2fs/utilities.c

238

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

sbin/fsck_ext2fs/utilities.c

240

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

sbin/fsck_ext2fs/utilities.c

241

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

sbin/fsck_ext2fs/utilities.c

242

sblock.e2fs_bsize);

sbin/fsck_ext2fs/utilities.c

287

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

sbin/fsck_ext2fs/utilities.c

296

sblock.e2fs.e2fs_state = E2FS_ISCLEAN;

sbin/fsck_ffs/dir.c

185

blksiz = idesc->id_numfrags * sblock->fs_fsize;

sbin/fsck_ffs/dir.c

249

blksiz = idesc->id_numfrags * sblock->fs_fsize;

sbin/fsck_ffs/dir.c

744

btodb(sblock->fs_bsize), 0);

sbin/fsck_ffs/dir.c

770

lastbn = ffs_lblkno(sblock, iswap64(DIP(dp, size)));

sbin/fsck_ffs/dir.c

774

if ((newblk = allocblk(sblock->fs_frag)) == 0)

sbin/fsck_ffs/dir.c

779

dp2->di_size = iswap64(iswap64(dp2->di_size)+sblock->fs_bsize);

sbin/fsck_ffs/dir.c

781

btodb(sblock->fs_bsize));

sbin/fsck_ffs/dir.c

786

dp1->di_size = iswap64(iswap64(dp1->di_size)+sblock->fs_bsize);

sbin/fsck_ffs/dir.c

788

btodb(sblock->fs_bsize));

sbin/fsck_ffs/dir.c

791

bp = getdirblk(dirblk, ffs_sblksize(sblock, (daddr_t)DIP(dp, size), lastbn + 1));

sbin/fsck_ffs/dir.c

795

bp = getdirblk(newblk, sblock->fs_bsize);

sbin/fsck_ffs/dir.c

801

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

sbin/fsck_ffs/dir.c

805

bp = getdirblk(dirblk, ffs_sblksize(sblock, (daddr_t)DIP(dp, size), lastbn + 1));

sbin/fsck_ffs/dir.c

821

dp2->di_size = iswap64(iswap64(dp2->di_size)-sblock->fs_bsize);

sbin/fsck_ffs/dir.c

823

btodb(sblock->fs_bsize));

sbin/fsck_ffs/dir.c

827

dp1->di_size = iswap64(iswap64(dp1->di_size)-sblock->fs_bsize);

sbin/fsck_ffs/dir.c

829

btodb(sblock->fs_bsize));

sbin/fsck_ffs/dir.c

831

freeblk(newblk, sblock->fs_frag);

sbin/fsck_ffs/dir.c

853

update_uquot(ino, 0, 0, btodb(sblock->fs_fsize), 1);

sbin/fsck_ffs/dir.c

869

bp = getdirblk(dirblk, sblock->fs_fsize);

sbin/fsck_ffs/dir.c

877

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

sbin/fsck_ffs/fsck.h

158

extern struct fs *sblock;

sbin/fsck_ffs/fsck.h

164

memmove(sblk.b_un.b_fs, sblock, SBLOCKSIZE); \

sbin/fsck_ffs/inode.c

100

(offset = ffs_blkoff(sblock, iswap64(DIP(&dino, size)))) != 0)

sbin/fsck_ffs/inode.c

1006

iswap32(dp->dp1.di_ib[ilevel - 1]), sblock->fs_bsize);

sbin/fsck_ffs/inode.c

1018

di_blocks += btodb(sblock->fs_bsize);

sbin/fsck_ffs/inode.c

102

ffs_numfrags(sblock, ffs_fragroundup(sblock, offset));

sbin/fsck_ffs/inode.c

1030

ibp = getdatablk(iblkno, sblock->fs_bsize);

sbin/fsck_ffs/inode.c

104

idesc->id_numfrags = sblock->fs_frag;

sbin/fsck_ffs/inode.c

1041

filesize += sblock->fs_bsize;

sbin/fsck_ffs/inode.c

116

sblock->fs_bsize));

sbin/fsck_ffs/inode.c

136

idesc->id_numfrags = sblock->fs_frag;

sbin/fsck_ffs/inode.c

137

remsize = iswap64(DIP(&dino, size)) - sblock->fs_bsize * UFS_NDADDR;

sbin/fsck_ffs/inode.c

138

sizepb = sblock->fs_bsize;

sbin/fsck_ffs/inode.c

170

sizepb *= FFS_NINDIR(sblock);

sbin/fsck_ffs/inode.c

194

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

sbin/fsck_ffs/inode.c

196

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

sbin/fsck_ffs/inode.c

197

sizepb *= FFS_NINDIR(sblock);

sbin/fsck_ffs/inode.c

198

if (howmany(isize, sizepb) > (size_t)FFS_NINDIR(sblock))

sbin/fsck_ffs/inode.c

199

nif = FFS_NINDIR(sblock);

sbin/fsck_ffs/inode.c

215

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

sbin/fsck_ffs/inode.c

216

for (i = nif; i < FFS_NINDIR(sblock); i++) {

sbin/fsck_ffs/inode.c

285

if (cnt > sblock->fs_frag ||

sbin/fsck_ffs/inode.c

286

ffs_fragnum(sblock, blk) + cnt > sblock->fs_frag) {

sbin/fsck_ffs/inode.c

289

(long long)blk, (int)ffs_fragnum(sblock, blk), cnt);

sbin/fsck_ffs/inode.c

291

c = dtog(sblock, blk);

sbin/fsck_ffs/inode.c

292

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

sbin/fsck_ffs/inode.c

293

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

sbin/fsck_ffs/inode.c

297

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

sbin/fsck_ffs/inode.c

300

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

sbin/fsck_ffs/inode.c

305

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

sbin/fsck_ffs/inode.c

309

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

sbin/fsck_ffs/inode.c

311

(long long)(blk+cnt), sblock->fs_fpg);

sbin/fsck_ffs/inode.c

332

inumber < startinum || inumber >= startinum + FFS_INOPB(sblock)) {

sbin/fsck_ffs/inode.c

333

iblk = ino_to_fsba(sblock, inumber);

sbin/fsck_ffs/inode.c

336

pbp = getdatablk(iblk, sblock->fs_bsize);

sbin/fsck_ffs/inode.c

337

startinum = (inumber / FFS_INOPB(sblock)) * FFS_INOPB(sblock);

sbin/fsck_ffs/inode.c

340

blkoff = (inumber % FFS_INOPB(sblock)) * DINODE2_SIZE;

sbin/fsck_ffs/inode.c

343

blkoff = (inumber % FFS_INOPB(sblock)) * DINODE1_SIZE;

sbin/fsck_ffs/inode.c

353

int32_t maxsymlinklen = sblock->fs_maxsymlinklen;

sbin/fsck_ffs/inode.c

415

dblk = FFS_FSBTODB(sblock, ino_to_fsba(sblock, lastinum));

sbin/fsck_ffs/inode.c

443

if (inum % sblock->fs_ipg != 0)

sbin/fsck_ffs/inode.c

447

lastvalidinum = inum + sblock->fs_ipg - 1;

sbin/fsck_ffs/inode.c

454

inobufsize = ffs_blkroundup(sblock, INOBUFSIZE);

sbin/fsck_ffs/inode.c

456

readpercg = sblock->fs_ipg / fullcnt;

sbin/fsck_ffs/inode.c

457

partialcnt = sblock->fs_ipg % fullcnt;

sbin/fsck_ffs/inode.c

495

blks = howmany(size, sblock->fs_bsize);

sbin/fsck_ffs/inode.c

732

cg = ino_to_cg(sblock, ino);

sbin/fsck_ffs/inode.c

734

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

sbin/fsck_ffs/inode.c

736

newalloced = MIN(sblock->fs_ipg,

sbin/fsck_ffs/inode.c

755

getblk(&cgblk, cgtod(sblock, cg), sblock->fs_cgsize);

sbin/fsck_ffs/inode.c

756

memcpy(cgp, cgblk.b_un.b_cg, sblock->fs_cgsize);

sbin/fsck_ffs/inode.c

758

ffs_cg_swap(cgblk.b_un.b_cg, cgp, sblock);

sbin/fsck_ffs/inode.c

763

setbit(cg_inosused(cgp, 0), ino % sblock->fs_ipg);

sbin/fsck_ffs/inode.c

765

sblock->fs_cstotal.cs_nifree--;

sbin/fsck_ffs/inode.c

766

sblock->fs_cs(fs, cg).cs_nifree--;

sbin/fsck_ffs/inode.c

776

nfrags = sblock->fs_frag;

sbin/fsck_ffs/inode.c

799

dp2->di_size = iswap64(ffs_lfragtosize(sblock, nfrags));

sbin/fsck_ffs/inode.c

800

dp2->di_blocks = iswap64(btodb(ffs_lfragtosize(sblock, nfrags)));

sbin/fsck_ffs/inode.c

813

dp1->di_size = iswap64(ffs_lfragtosize(sblock, nfrags));

sbin/fsck_ffs/inode.c

814

dp1->di_blocks = iswap32(btodb(ffs_lfragtosize(sblock, nfrags)));

sbin/fsck_ffs/inode.c

834

cg = ino_to_cg(sblock, ino);

sbin/fsck_ffs/inode.c

835

getblk(&cgblk, cgtod(sblock, cg), sblock->fs_cgsize);

sbin/fsck_ffs/inode.c

836

memcpy(cgp, cgblk.b_un.b_cg, sblock->fs_cgsize);

sbin/fsck_ffs/inode.c

838

ffs_cg_swap(cgblk.b_un.b_cg, cgp, sblock);

sbin/fsck_ffs/inode.c

863

clrbit(cg_inosused(cgp, 0), ino % sblock->fs_ipg);

sbin/fsck_ffs/inode.c

865

sblock->fs_cstotal.cs_nifree++;

sbin/fsck_ffs/inode.c

866

sblock->fs_cs(fs, cg).cs_nifree++;

sbin/fsck_ffs/inode.c

876

daddr_t blkno = ffs_lblkno(sblock, offset);

sbin/fsck_ffs/inode.c

882

const daddr_t naddrperblk = sblock->fs_bsize /

sbin/fsck_ffs/inode.c

887

offset &= ~(sblock->fs_bsize - 1);

sbin/fsck_ffs/inode.c

89

(idesc->id_filesize < sblock->fs_maxsymlinklen ||

sbin/fsck_ffs/inode.c

898

*bp = getdatablk(blkno, sblock->fs_bsize);

sbin/fsck_ffs/inode.c

899

return (bp != NULL) ? sblock->fs_bsize : 0;

sbin/fsck_ffs/inode.c

91

(sblock->fs_maxsymlinklen == 0 && DIP(dp, blocks) == 0))))

sbin/fsck_ffs/inode.c

919

ibp = getdatablk(iblkno, sblock->fs_bsize);

sbin/fsck_ffs/inode.c

931

ibp = getdatablk(iblkno, sblock->fs_bsize);

sbin/fsck_ffs/inode.c

934

return sblock->fs_bsize;

sbin/fsck_ffs/inode.c

942

*blkno = allocblk(sblock->fs_frag);

sbin/fsck_ffs/inode.c

945

bp = getdatablk(*blkno, sblock->fs_bsize);

sbin/fsck_ffs/inode.c

946

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

sbin/fsck_ffs/inode.c

958

const daddr_t naddrperblk = sblock->fs_bsize /

sbin/fsck_ffs/inode.c

965

blkno = ffs_lblkno(sblock, filesize);

sbin/fsck_ffs/inode.c

97

ndb = howmany(iswap64(DIP(&dino, size)), sblock->fs_bsize);

sbin/fsck_ffs/inode.c

972

di_blocks += btodb(sblock->fs_bsize);

sbin/fsck_ffs/inode.c

999

di_blocks += btodb(sblock->fs_bsize);

sbin/fsck_ffs/main.c

420

pwarn("** Last Mounted on %s\n", sblock->fs_fsmnt);

sbin/fsck_ffs/main.c

495

n_ffree = sblock->fs_cstotal.cs_nffree;

sbin/fsck_ffs/main.c

496

n_bfree = sblock->fs_cstotal.cs_nbfree;

sbin/fsck_ffs/main.c

499

(long long)(n_ffree + sblock->fs_frag * n_bfree));

sbin/fsck_ffs/main.c

502

(long long)(n_ffree * 100 / (daddr_t)sblock->fs_dsize),

sbin/fsck_ffs/main.c

503

(long long)(((n_ffree * 1000 + (daddr_t)sblock->fs_dsize / 2)

sbin/fsck_ffs/main.c

504

/ (daddr_t)sblock->fs_dsize) % 10));

sbin/fsck_ffs/main.c

506

(n_files -= maxino - UFS_ROOTINO - sblock->fs_cstotal.cs_nifree))

sbin/fsck_ffs/main.c

509

n_blks += sblock->fs_ncg *

sbin/fsck_ffs/main.c

510

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

sbin/fsck_ffs/main.c

511

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

sbin/fsck_ffs/main.c

512

n_blks += howmany(sblock->fs_cssize, sblock->fs_fsize);

sbin/fsck_ffs/main.c

513

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

sbin/fsck_ffs/main.c

534

sblock->fs_time = time(NULL);

sbin/fsck_ffs/main.c

558

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

sbin/fsck_ffs/main.c

81

struct fs *sblock;

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

103

getblk(&cgblk, cgtod(sblock, c), sblock->fs_cgsize);

sbin/fsck_ffs/pass1.c

104

memcpy(cgp, cgblk.b_un.b_cg, sblock->fs_cgsize);

sbin/fsck_ffs/pass1.c

106

ffs_cg_swap(cgblk.b_un.b_cg, cgp, sblock);

sbin/fsck_ffs/pass1.c

110

inosused = sblock->fs_ipg;

sbin/fsck_ffs/pass1.c

114

cdevname(), c, sblock->fs_ncg,

sbin/fsck_ffs/pass1.c

115

c * 100 / sblock->fs_ncg);

sbin/fsck_ffs/pass1.c

120

c, sblock->fs_ncg);

sbin/fsck_ffs/pass1.c

181

if (inosused < (ino_t)sblock->fs_ipg || inumber == lastino)

sbin/fsck_ffs/pass1.c

189

if (lastino < (c * (ino_t)sblock->fs_ipg))

sbin/fsck_ffs/pass1.c

192

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

sbin/fsck_ffs/pass1.c

274

kernmaxfilesize = sblock->fs_maxfilesize;

sbin/fsck_ffs/pass1.c

276

kernmaxfilesize = (u_int64_t)0x80000000 * sblock->fs_bsize - 1;

sbin/fsck_ffs/pass1.c

277

if (size > kernmaxfilesize || size + sblock->fs_bsize - 1 < size ||

sbin/fsck_ffs/pass1.c

285

DIP_SET(dp, size, iswap64(sblock->fs_fsize));

sbin/fsck_ffs/pass1.c

286

size = sblock->fs_fsize;

sbin/fsck_ffs/pass1.c

290

ndb = howmany(size, sblock->fs_bsize);

sbin/fsck_ffs/pass1.c

311

FFS_FSBTODB(sblock, iswap32(DIP(dp, db[0]))),

sbin/fsck_ffs/pass1.c

330

if ((sblock->fs_maxsymlinklen < 0) ||

sbin/fsck_ffs/pass1.c

331

(size < (uint64_t)sblock->fs_maxsymlinklen) ||

sbin/fsck_ffs/pass1.c

333

(sblock->fs_maxsymlinklen == 0 && DIP(dp, blocks) == 0)) {

sbin/fsck_ffs/pass1.c

341

ndb *= FFS_NINDIR(sblock);

sbin/fsck_ffs/pass1.c

364

ndb /= FFS_NINDIR(sblock);

sbin/fsck_ffs/pass1.c

446

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

sbin/fsck_ffs/pass1.c

449

(offset = ffs_blkoff(sblock, iswap32(dp->dp2.di_extsize))) != 0)

sbin/fsck_ffs/pass1.c

450

idesc->id_numfrags = ffs_numfrags(sblock,

sbin/fsck_ffs/pass1.c

451

ffs_fragroundup(sblock, offset));

sbin/fsck_ffs/pass1.c

453

idesc->id_numfrags = sblock->fs_frag;

sbin/fsck_ffs/pass1.c

462

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

sbin/fsck_ffs/pass1.c

81

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

sbin/fsck_ffs/pass1.c

82

cgd = cgdmin(sblock, c);

sbin/fsck_ffs/pass1.c

84

i = cgbase(sblock, c);

sbin/fsck_ffs/pass1.c

86

i = cgsblock(sblock, c);

sbin/fsck_ffs/pass1.c

90

i = sblock->fs_csaddr;

sbin/fsck_ffs/pass1.c

91

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

sbin/fsck_ffs/pass1b.c

69

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

sbin/fsck_ffs/pass1b.c

73

cdevname(), c, sblock->fs_ncg,

sbin/fsck_ffs/pass1b.c

74

c * 100 / sblock->fs_ncg);

sbin/fsck_ffs/pass1b.c

78

progress_bar(cdevname(), "phase 1b", c, sblock->fs_ncg);

sbin/fsck_ffs/pass1b.c

80

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

sbin/fsck_ffs/pass4.c

167

cg = dtog(sblock, blkno);

sbin/fsck_ffs/pass4.c

168

getblk(&cgblk, cgtod(sblock, cg), sblock->fs_cgsize);

sbin/fsck_ffs/pass4.c

169

memcpy(cgp, cgblk.b_un.b_cg, sblock->fs_cgsize);

sbin/fsck_ffs/pass4.c

171

ffs_cg_swap(cgblk.b_un.b_cg, cgp, sblock);

sbin/fsck_ffs/pass4.c

194

dtogd(sblock, blkno));

sbin/fsck_ffs/pass4.c

200

-btodb(sblock->fs_fsize), 0);

sbin/fsck_ffs/pass4.c

202

if (idesc->id_numfrags != sblock->fs_frag &&

sbin/fsck_ffs/pass4.c

205

sblock->fs_cstotal.cs_nffree ++;

sbin/fsck_ffs/pass4.c

206

sblock->fs_cs(fs, cg).cs_nffree ++;

sbin/fsck_ffs/pass4.c

211

if (cgp && res != SKIP && idesc->id_numfrags == sblock->fs_frag) {

sbin/fsck_ffs/pass4.c

213

sblock->fs_cstotal.cs_nbfree++;

sbin/fsck_ffs/pass4.c

214

sblock->fs_cs(fs, cg).cs_nbfree++;

sbin/fsck_ffs/pass4.c

215

ffs_clusteracct(sblock, cgp,

sbin/fsck_ffs/pass4.c

216

ffs_fragstoblks(sblock, dtogd(sblock, idesc->id_blkno)), 1);

sbin/fsck_ffs/pass4.c

73

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

sbin/fsck_ffs/pass4.c

77

cdevname(), cg, sblock->fs_ncg,

sbin/fsck_ffs/pass4.c

78

cg * 100 / sblock->fs_ncg);

sbin/fsck_ffs/pass4.c

83

cg, sblock->fs_ncg);

sbin/fsck_ffs/pass4.c

85

inumber = cg * sblock->fs_ipg;

sbin/fsck_ffs/pass5.c

220

ffs_cg_swap(cgblk.b_un.b_cg, cg, sblock);

sbin/fsck_ffs/pass5.c

232

FFS_FSBTODB(sblock, cgsblock(sblock, c)),

sbin/fsck_ffs/pass5.c

233

sblock->fs_sbsize);

sbin/fsck_ffs/pass5.c

242

getblk(&asblk, cgsblock(sblock, c), sblock->fs_sbsize);

sbin/fsck_ffs/pass5.c

248

sblock->fs_sbsize);

sbin/fsck_ffs/pass5.c

256

sb_oldfscompat_write(sblock, sblocksave);

sbin/fsck_ffs/pass5.c

257

if ((asblk.b_errs || cmpsblks(sblock, altsblock) ||

sbin/fsck_ffs/pass5.c

262

FFS_FSBTODB(sblock, cgsblock(sblock, c)),

sbin/fsck_ffs/pass5.c

263

sblock->fs_sbsize);

sbin/fsck_ffs/pass5.c

265

sb_oldfscompat_read(sblock, 0);

sbin/fsck_ffs/pass5.c

65

struct fs *fs = sblock;

sbin/fsck_ffs/pass6.c

53

if ((sblock->fs_flags & FS_DOQUOTA2) == 0)

sbin/fsck_ffs/pass6.c

57

if ((sblock->fs_quota_flags & FS_Q2_DO_TYPE(i)) == 0 &&

sbin/fsck_ffs/pass6.c

58

sblock->fs_quotafile[i] != 0) {

sbin/fsck_ffs/pass6.c

65

freeino(sblock->fs_quotafile[i]);

sbin/fsck_ffs/pass6.c

66

sblock->fs_quotafile[i] = 0;

sbin/fsck_ffs/pass6.c

72

if ((sblock->fs_quota_flags &

sbin/fsck_ffs/pass6.c

77

sblock->fs_flags &= ~FS_DOQUOTA2;

sbin/fsck_ffs/quota2.c

102

if (off < (uint64_t)sblock->fs_bsize) {

sbin/fsck_ffs/quota2.c

106

if (readblk(dp, off, &bp) != sblock->fs_bsize ||

sbin/fsck_ffs/quota2.c

113

(off % sblock->fs_bsize));

sbin/fsck_ffs/quota2.c

149

if (off < sblock->fs_bsize) {

sbin/fsck_ffs/quota2.c

153

if (readblk(dp, off, &bp) != sblock->fs_bsize ||

sbin/fsck_ffs/quota2.c

160

(off % sblock->fs_bsize));

sbin/fsck_ffs/quota2.c

196

uint64_t blk = off / sblock->fs_bsize;

sbin/fsck_ffs/quota2.c

197

uint64_t boff = off % sblock->fs_bsize;

sbin/fsck_ffs/quota2.c

252

if ((sblock->fs_quota_flags & FS_Q2_DO_TYPE(type)) == 0)

sbin/fsck_ffs/quota2.c

254

if (sblock->fs_quotafile[type] != 0) {

sbin/fsck_ffs/quota2.c

257

info = inoinfo(sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

266

capstrtype, sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

272

capstrtype, sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

276

" type %d\n", sblock->fs_quotafile[type],

sbin/fsck_ffs/quota2.c

280

dp = ginode(sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

287

mode, capstrtype, sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

298

capstrtype, sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

303

if (readblk(dp, 0, &hbp) != sblock->fs_bsize ||

sbin/fsck_ffs/quota2.c

305

freeino(sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

306

sblock->fs_quotafile[type] = 0;

sbin/fsck_ffs/quota2.c

315

sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

328

freeino(sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

329

sblock->fs_quotafile[type] = 0;

sbin/fsck_ffs/quota2.c

333

if (sblock->fs_quotafile[type] == 0) {

sbin/fsck_ffs/quota2.c

343

quota2_create_inode(sblock, type);

sbin/fsck_ffs/quota2.c

346

dp = ginode(sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

347

if (readblk(dp, 0, &hbp) != sblock->fs_bsize ||

sbin/fsck_ffs/quota2.c

354

nq2map = filesize / sblock->fs_bsize;

sbin/fsck_ffs/quota2.c

358

nq2e = (sblock->fs_bsize -

sbin/fsck_ffs/quota2.c

378

nq2e = (sblock->fs_bsize -

sbin/fsck_ffs/quota2.c

395

if (readblk(dp, i * sblock->fs_bsize, &bp)

sbin/fsck_ffs/quota2.c

396

!= sblock->fs_bsize || bp->b_errs != 0) {

sbin/fsck_ffs/quota2.c

404

q2h->q2h_free = iswap64(off + i * sblock->fs_bsize);

sbin/fsck_ffs/quota2.c

473

if ((sblock->fs_quota_flags & FS_Q2_DO_TYPE(type)) == 0)

sbin/fsck_ffs/quota2.c

479

dp = ginode(sblock->fs_quotafile[type]);

sbin/fsck_ffs/quota2.c

480

if (readblk(dp, 0, &hbp) != sblock->fs_bsize ||

sbin/fsck_ffs/quota2.c

523

if ((sblock->fs_flags & FS_DOQUOTA2) == 0)

sbin/fsck_ffs/quota2.c

525

if (sblock->fs_quota_magic != Q2_HEAD_MAGIC) {

sbin/fsck_ffs/quota2.c

534

if ((sblock->fs_quota_flags & FS_Q2_DO_TYPE(USRQUOTA)) &&

sbin/fsck_ffs/quota2.c

535

sblock->fs_quotafile[USRQUOTA] == 0) {

sbin/fsck_ffs/quota2.c

539

if ((sblock->fs_quota_flags & FS_Q2_DO_TYPE(GRPQUOTA)) &&

sbin/fsck_ffs/quota2.c

540

sblock->fs_quotafile[GRPQUOTA] == 0) {

sbin/fsck_ffs/quota2.c

61

if (readblk(dp, 0, &bp) != sblock->fs_bsize ||

sbin/fsck_ffs/quota2.c

66

quota2_create_blk0(sblock->fs_bsize, bp->b_un.b_buf,

sbin/fsck_ffs/quota2.c

70

sblock->fs_quotafile[type] = ino;

sbin/fsck_ffs/quota2.c

94

sblock->fs_bsize, needswap);

sbin/fsck_ffs/setup.c

1153

uint32_t *snapinum = &sblock->fs_snapinum[0];

sbin/fsck_ffs/setup.c

132

sblock = aligned_alloc(DEV_BSIZE, SBLOCKSIZE);

sbin/fsck_ffs/setup.c

136

sblock == NULL || altsblock == NULL)

sbin/fsck_ffs/setup.c

187

if (sblock->fs_magic != FS_UFS1_MAGIC ||

sbin/fsck_ffs/setup.c

188

(sblock->fs_old_flags & FS_FLAGS_UPDATED) != 0) {

sbin/fsck_ffs/setup.c

193

if (sblock->fs_flags & FS_DOWAPBL) {

sbin/fsck_ffs/setup.c

205

sblock->fs_flags &= ~FS_DOWAPBL;

sbin/fsck_ffs/setup.c

217

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

sbin/fsck_ffs/setup.c

222

if (sblock->fs_clean & FS_ISCLEAN) {

sbin/fsck_ffs/setup.c

232

maxfsblock = sblock->fs_size;

sbin/fsck_ffs/setup.c

233

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

sbin/fsck_ffs/setup.c

234

sizepb = sblock->fs_bsize;

sbin/fsck_ffs/setup.c

235

maxfilesize = sblock->fs_bsize * UFS_NDADDR - 1;

sbin/fsck_ffs/setup.c

237

sizepb *= FFS_NINDIR(sblock);

sbin/fsck_ffs/setup.c

241

(sblock->fs_old_flags & FS_FLAGS_UPDATED) == 0) {

sbin/fsck_ffs/setup.c

246

sblock->fs_old_flags |= FS_FLAGS_UPDATED;

sbin/fsck_ffs/setup.c

248

sblock->fs_old_cpc = 0;

sbin/fsck_ffs/setup.c

249

sblock->fs_old_nrpos = 1;

sbin/fsck_ffs/setup.c

250

sblock->fs_old_trackskew = 0;

sbin/fsck_ffs/setup.c

257

(sblock->fs_old_flags & FS_FLAGS_UPDATED)) {

sbin/fsck_ffs/setup.c

262

sblock->fs_old_flags &= ~FS_FLAGS_UPDATED;

sbin/fsck_ffs/setup.c

263

sb_oldfscompat_write(sblock, sblock);

sbin/fsck_ffs/setup.c

264

sblock->fs_old_flags &= ~FS_FLAGS_UPDATED; /* just in case */

sbin/fsck_ffs/setup.c

266

sblock->fs_old_postblformat = FS_DYNAMICPOSTBLFMT;

sbin/fsck_ffs/setup.c

267

sblock->fs_old_cpc = 0;

sbin/fsck_ffs/setup.c

268

sblock->fs_old_nrpos = 1;

sbin/fsck_ffs/setup.c

269

sblock->fs_old_trackskew = 0;

sbin/fsck_ffs/setup.c

270

memset(&sblock->fs_old_postbl_start, 0xff, 256);

sbin/fsck_ffs/setup.c

271

sb_oldfscompat_read(sblock, &sblocksave);

sbin/fsck_ffs/setup.c

277

if (sblock->fs_flags & ~(FS_KNOWN_FLAGS)) {

sbin/fsck_ffs/setup.c

278

pfatal("UNKNOWN FLAGS=0x%08x IN SUPERBLOCK", sblock->fs_flags);

sbin/fsck_ffs/setup.c

280

sblock->fs_flags &= FS_KNOWN_FLAGS;

sbin/fsck_ffs/setup.c

284

if (sblock->fs_optim != FS_OPTTIME && sblock->fs_optim != FS_OPTSPACE) {

sbin/fsck_ffs/setup.c

287

sblock->fs_optim = FS_OPTTIME;

sbin/fsck_ffs/setup.c

291

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

sbin/fsck_ffs/setup.c

293

sblock->fs_minfree);

sbin/fsck_ffs/setup.c

295

sblock->fs_minfree = 10;

sbin/fsck_ffs/setup.c

299

if (!is_ufs2 && sblock->fs_old_postblformat != FS_42POSTBLFMT &&

sbin/fsck_ffs/setup.c

300

(sblock->fs_old_interleave < 1 ||

sbin/fsck_ffs/setup.c

301

sblock->fs_old_interleave > sblock->fs_old_nsect)) {

sbin/fsck_ffs/setup.c

303

sblock->fs_old_interleave);

sbin/fsck_ffs/setup.c

304

sblock->fs_old_interleave = 1;

sbin/fsck_ffs/setup.c

312

if (!is_ufs2 && sblock->fs_old_postblformat != FS_42POSTBLFMT &&

sbin/fsck_ffs/setup.c

313

(sblock->fs_old_npsect < sblock->fs_old_nsect ||

sbin/fsck_ffs/setup.c

314

sblock->fs_old_npsect > sblock->fs_old_nsect*2)) {

sbin/fsck_ffs/setup.c

316

sblock->fs_old_npsect);

sbin/fsck_ffs/setup.c

317

sblock->fs_old_npsect = sblock->fs_old_nsect;

sbin/fsck_ffs/setup.c

325

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

sbin/fsck_ffs/setup.c

327

sblock->fs_bmask);

sbin/fsck_ffs/setup.c

328

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

sbin/fsck_ffs/setup.c

336

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

sbin/fsck_ffs/setup.c

338

sblock->fs_fmask);

sbin/fsck_ffs/setup.c

339

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

sbin/fsck_ffs/setup.c

355

if (is_ufs2 || sblock->fs_old_inodefmt >= FS_44INODEFMT) {

sbin/fsck_ffs/setup.c

356

if (sblock->fs_maxfilesize != maxfilesize) {

sbin/fsck_ffs/setup.c

358

(unsigned long long)sblock->fs_maxfilesize);

sbin/fsck_ffs/setup.c

359

sblock->fs_maxfilesize = maxfilesize;

sbin/fsck_ffs/setup.c

367

if ((is_ufs2 && sblock->fs_maxsymlinklen != UFS2_MAXSYMLINKLEN)

sbin/fsck_ffs/setup.c

369

(!is_ufs2 && sblock->fs_maxsymlinklen != UFS1_MAXSYMLINKLEN))

sbin/fsck_ffs/setup.c

372

sblock->fs_maxsymlinklen);

sbin/fsck_ffs/setup.c

373

sblock->fs_maxsymlinklen = is_ufs2 ?

sbin/fsck_ffs/setup.c

382

if (sblock->fs_qbmask != ~sblock->fs_bmask) {

sbin/fsck_ffs/setup.c

384

(unsigned long long)sblock->fs_qbmask);

sbin/fsck_ffs/setup.c

385

sblock->fs_qbmask = ~sblock->fs_bmask;

sbin/fsck_ffs/setup.c

393

if (sblock->fs_qfmask != ~sblock->fs_fmask) {

sbin/fsck_ffs/setup.c

395

(unsigned long long)sblock->fs_qfmask);

sbin/fsck_ffs/setup.c

396

sblock->fs_qfmask = ~sblock->fs_fmask;

sbin/fsck_ffs/setup.c

406

sblock->fs_qbmask = ~sblock->fs_bmask;

sbin/fsck_ffs/setup.c

407

sblock->fs_qfmask = ~sblock->fs_fmask;

sbin/fsck_ffs/setup.c

414

sblock->fs_old_inodefmt < FS_44INODEFMT) {

sbin/fsck_ffs/setup.c

420

sblock->fs_old_inodefmt = FS_44INODEFMT;

sbin/fsck_ffs/setup.c

421

sblock->fs_maxfilesize = maxfilesize;

sbin/fsck_ffs/setup.c

422

sblock->fs_maxsymlinklen = UFS1_MAXSYMLINKLEN;

sbin/fsck_ffs/setup.c

423

sblock->fs_qbmask = ~sblock->fs_bmask;

sbin/fsck_ffs/setup.c

424

sblock->fs_qfmask = ~sblock->fs_fmask;

sbin/fsck_ffs/setup.c

432

sblock->fs_old_postblformat == FS_42POSTBLFMT) {

sbin/fsck_ffs/setup.c

438

sblock->fs_old_postblformat = FS_DYNAMICPOSTBLFMT;

sbin/fsck_ffs/setup.c

439

sblock->fs_old_nrpos = 8;

sbin/fsck_ffs/setup.c

440

sblock->fs_old_postbloff =

sbin/fsck_ffs/setup.c

441

(char *)(&sblock->fs_old_postbl_start) -

sbin/fsck_ffs/setup.c

442

(char *)(&sblock->fs_firstfield);

sbin/fsck_ffs/setup.c

443

sblock->fs_old_rotbloff =

sbin/fsck_ffs/setup.c

444

(char *)(&sblock->fs_magic+1) -

sbin/fsck_ffs/setup.c

445

(char *)(&sblock->fs_firstfield);

sbin/fsck_ffs/setup.c

446

sblock->fs_cgsize =

sbin/fsck_ffs/setup.c

447

ffs_fragroundup(sblock, CGSIZE(sblock));

sbin/fsck_ffs/setup.c

452

memmove(sblk.b_un.b_fs, sblock, SBLOCKSIZE);

sbin/fsck_ffs/setup.c

456

memmove(asblk.b_un.b_fs, sblk.b_un.b_fs, (size_t)sblock->fs_sbsize);

sbin/fsck_ffs/setup.c

463

sblock->fs_csp = (struct csum *)aligned_alloc(DEV_BSIZE,

sbin/fsck_ffs/setup.c

464

sblock->fs_cssize);

sbin/fsck_ffs/setup.c

465

if (sblock->fs_csp == NULL) {

sbin/fsck_ffs/setup.c

467

sblock->fs_cssize);

sbin/fsck_ffs/setup.c

470

memset(sblock->fs_csp, 0, sblock->fs_cssize);

sbin/fsck_ffs/setup.c

471

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

sbin/fsck_ffs/setup.c

472

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

sbin/fsck_ffs/setup.c

473

sblock->fs_cssize - i : sblock->fs_bsize;

sbin/fsck_ffs/setup.c

474

ccsp = (struct csum *)((char *)sblock->fs_csp + i);

sbin/fsck_ffs/setup.c

476

FFS_FSBTODB(sblock, sblock->fs_csaddr + j * sblock->fs_frag),

sbin/fsck_ffs/setup.c

488

FFS_FSBTODB(sblock,

sbin/fsck_ffs/setup.c

489

sblock->fs_csaddr + j * sblock->fs_frag),

sbin/fsck_ffs/setup.c

505

inostathead = calloc((unsigned)(sblock->fs_ncg),

sbin/fsck_ffs/setup.c

509

(unsigned)(sizeof(struct inostatlist) * (sblock->fs_ncg)));

sbin/fsck_ffs/setup.c

518

numdirs = sblock->fs_cstotal.cs_ndir;

sbin/fsck_ffs/setup.c

533

cgrp = aligned_alloc(DEV_BSIZE, sblock->fs_cgsize);

sbin/fsck_ffs/setup.c

536

sblock->fs_cgsize);

sbin/fsck_ffs/setup.c

540

if (sblock->fs_flags & FS_DOSOFTDEP)

sbin/fsck_ffs/setup.c

566

if (sblock->fs_flags & FS_DOQUOTA2) {

sbin/fsck_ffs/setup.c

579

(size_t)sblock->fs_bsize)

sbin/fsck_ffs/setup.c

837

memmove(sblock, sblk.b_un.b_fs, SBLOCKSIZE);

sbin/fsck_ffs/setup.c

839

ffs_sb_swap(sblk.b_un.b_fs, sblock);

sbin/fsck_ffs/setup.c

840

if (sblock->fs_magic == FS_UFS2EA_MAGIC) {

sbin/fsck_ffs/setup.c

842

sblock->fs_magic = FS_UFS2_MAGIC;

sbin/fsck_ffs/setup.c

844

is_ufs2 = sblock->fs_magic == FS_UFS2_MAGIC;

sbin/fsck_ffs/setup.c

852

if (sblock->fs_sbsize > SBLOCKSIZE)

sbin/fsck_ffs/setup.c

860

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

sbin/fsck_ffs/setup.c

870

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

sbin/fsck_ffs/setup.c

877

memmove(altsblock, asblk.b_un.b_fs, sblock->fs_sbsize);

sbin/fsck_ffs/setup.c

885

if (cmpsblks(sblock, altsblock)) {

sbin/fsck_ffs/setup.c

891

olp = (uint32_t *)sblock;

sbin/fsck_ffs/setup.c

892

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

sbin/fsck_ffs/setup.c

898

(int)((uint8_t *)olp-(uint8_t *)sblock),

sbin/fsck_ffs/setup.c

910

sb_oldfscompat_read(sblock, &sblocksave);

sbin/fsck_ffs/utilities.c

138

bufp = aligned_alloc(DEV_BSIZE, (unsigned int)sblock->fs_bsize);

sbin/fsck_ffs/utilities.c

151

bufcnt = MAXBUFSPACE / sblock->fs_bsize;

sbin/fsck_ffs/utilities.c

156

bufp = aligned_alloc(DEV_BSIZE, (unsigned int)sblock->fs_bsize);

sbin/fsck_ffs/utilities.c

186

if (bp->b_bno == FFS_FSBTODB(sblock, blkno))

sbin/fsck_ffs/utilities.c

211

dblk = FFS_FSBTODB(sblock, blk);

sbin/fsck_ffs/utilities.c

239

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

sbin/fsck_ffs/utilities.c

240

int size = sblock->fs_cssize - i < sblock->fs_bsize ?

sbin/fsck_ffs/utilities.c

241

sblock->fs_cssize - i : sblock->fs_bsize;

sbin/fsck_ffs/utilities.c

242

ccsp = (struct csum *)((char *)sblock->fs_csp + i);

sbin/fsck_ffs/utilities.c

246

FFS_FSBTODB(sblock, sblock->fs_csaddr + j * sblock->fs_frag),

sbin/fsck_ffs/utilities.c

285

if (!is_ufs2 && (sblock->fs_old_flags & FS_FLAGS_UPDATED) == 0)

sbin/fsck_ffs/utilities.c

288

sblk.b_bno = sblock->fs_sblockloc / dev_bsize;

sbin/fsck_ffs/utilities.c

308

if (markclean && (sblock->fs_clean & FS_ISCLEAN) == 0) {

sbin/fsck_ffs/utilities.c

317

sblock->fs_clean = FS_ISCLEAN;

sbin/fsck_ffs/utilities.c

318

sblock->fs_pendingblocks = 0;

sbin/fsck_ffs/utilities.c

319

sblock->fs_pendinginodes = 0;

sbin/fsck_ffs/utilities.c

412

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

sbin/fsck_ffs/utilities.c

414

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

sbin/fsck_ffs/utilities.c

415

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

sbin/fsck_ffs/utilities.c

425

cg = dtog(sblock, i + j);

sbin/fsck_ffs/utilities.c

426

getblk(&cgblk, cgtod(sblock, cg), sblock->fs_cgsize);

sbin/fsck_ffs/utilities.c

427

memcpy(cgp, cgblk.b_un.b_cg, sblock->fs_cgsize);

sbin/fsck_ffs/utilities.c

429

ffs_cg_swap(cgblk.b_un.b_cg, cgp, sblock);

sbin/fsck_ffs/utilities.c

433

baseblk = dtogd(sblock, i + j);

sbin/fsck_ffs/utilities.c

439

if (frags == sblock->fs_frag) {

sbin/fsck_ffs/utilities.c

441

sblock->fs_cstotal.cs_nbfree--;

sbin/fsck_ffs/utilities.c

442

sblock->fs_cs(fs, cg).cs_nbfree--;

sbin/fsck_ffs/utilities.c

443

ffs_clusteracct(sblock, cgp,

sbin/fsck_ffs/utilities.c

444

ffs_fragstoblks(sblock, baseblk), -1);

sbin/fsck_ffs/utilities.c

447

sblock->fs_cstotal.cs_nffree -= frags;

sbin/fsck_ffs/utilities.c

448

sblock->fs_cs(fs, cg).cs_nffree -= frags;

sbin/fsck_ffs/utilities.c

574

memcpy(blk->b_un.b_cg, cgrp, sblock->fs_cgsize);

sbin/fsck_ffs/utilities.c

576

ffs_cg_swap(cgrp, blk->b_un.b_cg, sblock);

sbin/fsck_ffs/utilities.c

598

ilp = &inostathead[inum / sblock->fs_ipg];

sbin/fsck_ffs/utilities.c

599

iloff = inum % sblock->fs_ipg;

sbin/fsck_ffs/utilities.c

772

if ((sblock->fs_flags & FS_DOQUOTA2) == 0)

sbin/fsck_ffs/utilities.c

775

if (sblock->fs_quota_magic != Q2_HEAD_MAGIC)

sbin/fsck_ffs/utilities.c

778

if (sblock->fs_quotafile[USRQUOTA] == inum)

sbin/fsck_ffs/utilities.c

781

if (sblock->fs_quotafile[GRPQUOTA] == inum)

sbin/fsck_ffs/wapbl.c

154

sblock->fs_journal_version == UFS_WAPBL_VERSION &&

sbin/fsck_ffs/wapbl.c

155

sblock->fs_journal_location == UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM &&

sbin/fsck_ffs/wapbl.c

156

sblock->fs_journallocs[UFS_WAPBL_INFS_INO] == ino)

sbin/fsck_ffs/wapbl.c

173

if (sblock->fs_flags & FS_DOWAPBL) {

sbin/fsck_ffs/wapbl.c

174

if (sblock->fs_journal_version != UFS_WAPBL_VERSION) {

sbin/fsck_ffs/wapbl.c

176

sblock->fs_journal_version);

sbin/fsck_ffs/wapbl.c

181

sblock->fs_flags &= ~FS_DOWAPBL;

sbin/fsck_ffs/wapbl.c

182

sblock->fs_journal_flags = UFS_WAPBL_FLAGS_CLEAR_LOG;

sbin/fsck_ffs/wapbl.c

186

switch(sblock->fs_journal_location) {

sbin/fsck_ffs/wapbl.c

189

sblock->fs_journallocs[UFS_WAPBL_EPART_ADDR];

sbin/fsck_ffs/wapbl.c

191

sblock->fs_journallocs[UFS_WAPBL_EPART_COUNT];

sbin/fsck_ffs/wapbl.c

193

sblock->fs_journallocs[UFS_WAPBL_EPART_BLKSZ];

sbin/fsck_ffs/wapbl.c

197

sblock->fs_journallocs[UFS_WAPBL_INFS_ADDR];

sbin/fsck_ffs/wapbl.c

199

sblock->fs_journallocs[UFS_WAPBL_INFS_COUNT];

sbin/fsck_ffs/wapbl.c

201

sblock->fs_journallocs[UFS_WAPBL_INFS_BLKSZ];

sbin/fsck_ffs/wapbl.c

205

sblock->fs_journal_location);

sbin/fsck_ffs/wapbl.c

210

sblock->fs_flags &= ~FS_DOWAPBL;

sbin/fsck_ffs/wapbl.c

211

sblock->fs_journal_flags = UFS_WAPBL_FLAGS_CLEAR_LOG;

sbin/fsck_ffs/wapbl.c

212

sblock->fs_journal_location =

sbin/fsck_ffs/wapbl.c

218

if (sblock->fs_flags & FS_DOWAPBL) {

sbin/fsck_ffs/wapbl.c

228

sblock->fs_flags &= ~FS_DOWAPBL;

sbin/fsck_ffs/wapbl.c

229

sblock->fs_journal_flags = UFS_WAPBL_FLAGS_CLEAR_LOG;

sbin/fsck_ffs/wapbl.c

241

switch (sblock->fs_journal_flags) {

sbin/fsck_ffs/wapbl.c

246

switch(sblock->fs_journal_location) {

sbin/fsck_ffs/wapbl.c

251

if (sblock->fs_journal_flags ==

sbin/fsck_ffs/wapbl.c

257

sblock->fs_journal_location);

sbin/fsck_ffs/wapbl.c

262

sblock->fs_journal_flags = 0;

sbin/fsck_ffs/wapbl.c

263

sblock->fs_journal_location =

sbin/fsck_ffs/wapbl.c

272

sblock->fs_journal_flags);

sbin/fsck_ffs/wapbl.c

277

sblock->fs_journal_flags = 0;

sbin/fsck_ffs/wapbl.c

278

sblock->fs_journal_location =

sbin/fsdb/fsdb.c

1572

if (!is_ufs2 && sblock->fs_old_inodefmt < FS_44INODEFMT)

sbin/fsdb/fsdb.c

1599

if (!is_ufs2 && sblock->fs_old_inodefmt < FS_44INODEFMT)

sbin/fsdb/fsdb.c

218

sblock->fs_fsmnt);

sbin/fsdb/fsdb.c

226

sblock->fs_clean = 0; /* mark it dirty */

sbin/fsdb/fsdb.c

637

FFS_DBTOFSB(sblock, strtoull(argv[i], NULL, 0));

sbin/fsdb/fsdb.c

647

FFS_DBTOFSB(sblock, strtoull(argv[i], NULL, 0));

sbin/fsdb/fsdb.c

650

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

sbin/fsdb/fsdb.c

651

inum = c * sblock->fs_ipg;

sbin/fsdb/fsdb.c

652

getblk(&cgblk, cgtod(sblock, c), sblock->fs_cgsize);

sbin/fsdb/fsdb.c

653

memcpy(cgp, cgblk.b_un.b_cg, sblock->fs_cgsize);

sbin/fsdb/fsdb.c

655

ffs_cg_swap(cgblk.b_un.b_cg, cgp, sblock);

sbin/fsdb/fsdb.c

659

inosused = sblock->fs_ipg;

sbin/fsdb/fsdb.c

664

ino_to_fsba(sblock, inum)) :

sbin/fsdb/fsdb.c

666

ino_to_fsba(sblock, inum))) {

sbin/fsdb/fsdb.c

668

(unsigned long long)FFS_FSBTODB(sblock,

sbin/fsdb/fsdb.c

669

ino_to_fsba(sblock, inum)),

sbin/fsdb/fsdb.c

671

(inum / FFS_INOPB(sblock)) * FFS_INOPB(sblock),

sbin/fsdb/fsdb.c

673

(inum / FFS_INOPB(sblock) + 1) * FFS_INOPB(sblock));

sbin/fsdb/fsdb.c

690

size < (uint64_t)sblock->fs_maxsymlinklen &&

sbin/fsdb/fsdb.c

72

struct fs *sblock;

sbin/fsdb/fsdb.c

768

(unsigned long long)FFS_FSBTODB(sblock, blk),

sbin/fsdb/fsdb.c

798

bread(fsreadfd, (char *)idblk, FFS_FSBTODB(sblock, blk),

sbin/fsdb/fsdb.c

799

(int)sblock->fs_bsize);

sbin/fsdb/fsdb.c

802

sblock->fs_bsize / sizeof(uint32_t), wantedblk))

sbin/fsdb/fsdb.c

806

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

sbin/fsdb/fsdb.c

844

bread(fsreadfd, (char *)idblk, FFS_FSBTODB(sblock, blk),

sbin/fsdb/fsdb.c

845

(int)sblock->fs_bsize);

sbin/fsdb/fsdb.c

848

sblock->fs_bsize / sizeof(uint64_t), wantedblk))

sbin/fsdb/fsdb.c

852

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

sbin/fsdb/fsdb.c

874

if (size > sblock->fs_bsize)

sbin/fsdb/fsdb.c

875

size = sblock->fs_bsize;

sbin/fsdb/fsdb.c

882

if (bread(fsreadfd, buf, FFS_FSBTODB(sblock, blk), rsize) != 0)

sbin/fsdb/fsdb.c

957

const int ptrperblk_shift = sblock->fs_bshift - 2;

sbin/fsdb/fsdb.c

969

bread(fsreadfd, (char *)idblk, FFS_FSBTODB(sblock, blk),

sbin/fsdb/fsdb.c

970

(int)sblock->fs_bsize);

sbin/fsdb/fsdb.c

986

const int ptrperblk_shift = sblock->fs_bshift - 3;

sbin/fsdb/fsdb.c

998

bread(fsreadfd, (char *)idblk, FFS_FSBTODB(sblock, blk),

sbin/fsdb/fsdb.c

999

(int)sblock->fs_bsize);

sbin/fsdb/fsdbutil.c

129

if (size > 0 && size < (uint64_t)sblock->fs_maxsymlinklen &&

sbin/fsdb/fsdbutil.c

167

if (!is_ufs2 && sblock->fs_old_inodefmt < FS_44INODEFMT)

sbin/fsdb/fsdbutil.c

175

if (!is_ufs2 && sblock->fs_old_inodefmt < FS_44INODEFMT)

sbin/newfs/mkfs.c

1068

for (i = dirblksiz; i < sblock.fs_bsize; i += dirblksiz)

sbin/newfs/mkfs.c

1073

for (i = dirblksiz; i < sblock.fs_bsize; i += dirblksiz)

sbin/newfs/mkfs.c

1076

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/newfs/mkfs.c

1085

node.dp1.di_size = sblock.fs_bsize;

sbin/newfs/mkfs.c

1089

node.dp1.di_blocks = btodb(ffs_fragroundup(&sblock,

sbin/newfs/mkfs.c

1094

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

sbin/newfs/mkfs.c

1107

node.dp2.di_size = sblock.fs_bsize;

sbin/newfs/mkfs.c

1111

node.dp2.di_blocks = btodb(ffs_fragroundup(&sblock,

sbin/newfs/mkfs.c

1116

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

sbin/newfs/mkfs.c

1142

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

sbin/newfs/mkfs.c

1145

node.dp1.di_blocks = btodb(ffs_fragroundup(&sblock,

sbin/newfs/mkfs.c

1148

wtfs(FFS_FSBTODB(&sblock, node.dp1.di_db[0]), sblock.fs_fsize, &buf);

sbin/newfs/mkfs.c

1169

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

sbin/newfs/mkfs.c

1172

node.dp2.di_blocks = btodb(ffs_fragroundup(&sblock,

sbin/newfs/mkfs.c

1175

wtfs(FFS_FSBTODB(&sblock, node.dp2.di_db[0]), sblock.fs_fsize, &buf);

sbin/newfs/mkfs.c

1189

sizeof(struct quota2_header) > (u_int)sblock.fs_bsize)

sbin/newfs/mkfs.c

1201

quota2_create_blk0(sblock.fs_bsize, &buf, q2h_hash_shift,

sbin/newfs/mkfs.c

1218

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/newfs/mkfs.c

1227

node.dp1.di_size = sblock.fs_bsize;

sbin/newfs/mkfs.c

1232

node.dp1.di_blocks = btodb(ffs_fragroundup(&sblock,

sbin/newfs/mkfs.c

1236

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

sbin/newfs/mkfs.c

1249

node.dp2.di_size = sblock.fs_bsize;

sbin/newfs/mkfs.c

1254

node.dp2.di_blocks = btodb(ffs_fragroundup(&sblock,

sbin/newfs/mkfs.c

1258

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

sbin/newfs/mkfs.c

1262

sblock.fs_quotafile[i] = nextino;

sbin/newfs/mkfs.c

1303

rdfs(FFS_FSBTODB(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize, &acg);

sbin/newfs/mkfs.c

1306

ffs_cg_swap(&acg, &acg, &sblock);

sbin/newfs/mkfs.c

1315

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

sbin/newfs/mkfs.c

1316

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

sbin/newfs/mkfs.c

1317

d >> sblock.fs_fragshift))

sbin/newfs/mkfs.c

1322

blkno = ffs_fragstoblks(&sblock, d);

sbin/newfs/mkfs.c

1323

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

sbin/newfs/mkfs.c

1324

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

1327

sblock.fs_cstotal.cs_nbfree--;

sbin/newfs/mkfs.c

1331

sblock.fs_cstotal.cs_ndir++;

sbin/newfs/mkfs.c

1335

int cn = old_cbtocylno(&sblock, d);

sbin/newfs/mkfs.c

1337

old_cg_blks(&sblock, &acg,

sbin/newfs/mkfs.c

1338

cn, 0)[old_cbtorpos(&sblock, d)]--;

sbin/newfs/mkfs.c

1340

if (size != sblock.fs_bsize) {

sbin/newfs/mkfs.c

1341

frag = howmany(size, sblock.fs_fsize);

sbin/newfs/mkfs.c

1342

fscs_0->cs_nffree += sblock.fs_frag - frag;

sbin/newfs/mkfs.c

1343

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

sbin/newfs/mkfs.c

1344

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

sbin/newfs/mkfs.c

1345

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

sbin/newfs/mkfs.c

1346

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

sbin/newfs/mkfs.c

1351

ffs_cg_swap(&acg, &acg, &sblock);

sbin/newfs/mkfs.c

1352

wtfs(FFS_FSBTODB(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize, &acg);

sbin/newfs/mkfs.c

1367

rdfs(FFS_FSBTODB(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize, &acg);

sbin/newfs/mkfs.c

1370

ffs_cg_swap(&acg, &acg, &sblock);

sbin/newfs/mkfs.c

1379

ffs_cg_swap(&acg, &acg, &sblock);

sbin/newfs/mkfs.c

1380

wtfs(FFS_FSBTODB(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize, &acg);

sbin/newfs/mkfs.c

1381

sblock.fs_cstotal.cs_nifree--;

sbin/newfs/mkfs.c

1383

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

sbin/newfs/mkfs.c

1388

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

sbin/newfs/mkfs.c

1389

rdfs(d, sblock.fs_bsize, (char *)iobuf);

sbin/newfs/mkfs.c

1390

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/newfs/mkfs.c

1392

dp1 += ino_to_fsbo(&sblock, ino);

sbin/newfs/mkfs.c

1405

dp2 += ino_to_fsbo(&sblock, ino);

sbin/newfs/mkfs.c

1416

wtfs(d, sblock.fs_bsize, iobuf);

sbin/newfs/mkfs.c

157

((sblock.fs_magic == FS_UFS1_MAGIC) ? \

sbin/newfs/mkfs.c

1615

cg0_data = cgsblock(&sblock, 0) * sblock.fs_fsize + iobufsize;

sbin/newfs/mkfs.c

1621

if (sblkoff >= sblock.fs_sblockloc) {

sbin/newfs/mkfs.c

1625

roundup(sizeof sblock, sectorsize), iobuf);

sbin/newfs/mkfs.c

214

sblock.fs_old_inodefmt = FS_42INODEFMT;

sbin/newfs/mkfs.c

215

sblock.fs_maxsymlinklen = 0;

sbin/newfs/mkfs.c

216

sblock.fs_old_flags = 0;

sbin/newfs/mkfs.c

218

sblock.fs_old_inodefmt = FS_44INODEFMT;

sbin/newfs/mkfs.c

219

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

sbin/newfs/mkfs.c

221

sblock.fs_old_flags = FS_FLAGS_UPDATED;

sbin/newfs/mkfs.c

223

sblock.fs_old_flags = 0;

sbin/newfs/mkfs.c

224

sblock.fs_flags = 0;

sbin/newfs/mkfs.c

230

sblock.fs_avgfilesize = avgfilesize;

sbin/newfs/mkfs.c

231

sblock.fs_avgfpdir = avgfpdir;

sbin/newfs/mkfs.c

232

if (sblock.fs_avgfilesize <= 0) {

sbin/newfs/mkfs.c

234

sblock.fs_avgfilesize);

sbin/newfs/mkfs.c

237

if (sblock.fs_avgfpdir <= 0) {

sbin/newfs/mkfs.c

239

sblock.fs_avgfpdir);

sbin/newfs/mkfs.c

245

sblock.fs_bsize = bsize;

sbin/newfs/mkfs.c

246

sblock.fs_fsize = fsize;

sbin/newfs/mkfs.c

247

if (!powerof2(sblock.fs_bsize)) {

sbin/newfs/mkfs.c

249

sblock.fs_bsize);

sbin/newfs/mkfs.c

252

if (!powerof2(sblock.fs_fsize)) {

sbin/newfs/mkfs.c

254

sblock.fs_fsize);

sbin/newfs/mkfs.c

257

if (sblock.fs_fsize < sectorsize) {

sbin/newfs/mkfs.c

259

sblock.fs_fsize, sectorsize);

sbin/newfs/mkfs.c

262

if (sblock.fs_bsize < MINBSIZE) {

sbin/newfs/mkfs.c

264

sblock.fs_bsize, MINBSIZE);

sbin/newfs/mkfs.c

267

if (sblock.fs_bsize > MAXBSIZE) {

sbin/newfs/mkfs.c

269

sblock.fs_bsize, MAXBSIZE);

sbin/newfs/mkfs.c

272

if (sblock.fs_bsize < sblock.fs_fsize) {

sbin/newfs/mkfs.c

274

sblock.fs_bsize, sblock.fs_fsize);

sbin/newfs/mkfs.c

279

sblock.fs_maxbsize = sblock.fs_bsize;

sbin/newfs/mkfs.c

280

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

sbin/newfs/mkfs.c

281

sblock.fs_maxbsize = FS_MAXCONTIG * sblock.fs_bsize;

sbin/newfs/mkfs.c

283

sblock.fs_maxbsize = maxbsize;

sbin/newfs/mkfs.c

285

sblock.fs_maxcontig = maxcontig;

sbin/newfs/mkfs.c

286

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

sbin/newfs/mkfs.c

287

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

sbin/newfs/mkfs.c

289

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

sbin/newfs/mkfs.c

291

if (sblock.fs_maxcontig > 1)

sbin/newfs/mkfs.c

292

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

sbin/newfs/mkfs.c

294

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

sbin/newfs/mkfs.c

295

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

sbin/newfs/mkfs.c

296

sblock.fs_qbmask = ~sblock.fs_bmask;

sbin/newfs/mkfs.c

297

sblock.fs_qfmask = ~sblock.fs_fmask;

sbin/newfs/mkfs.c

298

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

sbin/newfs/mkfs.c

299

sblock.fs_bshift++;

sbin/newfs/mkfs.c

300

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

sbin/newfs/mkfs.c

301

sblock.fs_fshift++;

sbin/newfs/mkfs.c

302

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

sbin/newfs/mkfs.c

303

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

sbin/newfs/mkfs.c

304

sblock.fs_fragshift++;

sbin/newfs/mkfs.c

305

if (sblock.fs_frag > MAXFRAG) {

sbin/newfs/mkfs.c

308

sblock.fs_fsize, sblock.fs_bsize,

sbin/newfs/mkfs.c

309

sblock.fs_bsize / MAXFRAG);

sbin/newfs/mkfs.c

312

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

sbin/newfs/mkfs.c

313

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

sbin/newfs/mkfs.c

315

if ((uint64_t)sblock.fs_size >= 1ull << 31) {

sbin/newfs/mkfs.c

317

") for a FFSv1 filesystem\n", sblock.fs_size);

sbin/newfs/mkfs.c

320

sblock.fs_magic = FS_UFS1_MAGIC;

sbin/newfs/mkfs.c

321

sblock.fs_sblockloc = SBLOCK_UFS1;

sbin/newfs/mkfs.c

322

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

sbin/newfs/mkfs.c

323

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

sbin/newfs/mkfs.c

324

sblock.fs_old_cgoffset = 0;

sbin/newfs/mkfs.c

325

sblock.fs_old_cgmask = 0xffffffff;

sbin/newfs/mkfs.c

326

sblock.fs_old_size = sblock.fs_size;

sbin/newfs/mkfs.c

327

sblock.fs_old_rotdelay = 0;

sbin/newfs/mkfs.c

328

sblock.fs_old_rps = 60;

sbin/newfs/mkfs.c

329

sblock.fs_old_nspf = sblock.fs_fsize / sectorsize;

sbin/newfs/mkfs.c

330

sblock.fs_old_cpg = 1;

sbin/newfs/mkfs.c

331

sblock.fs_old_interleave = 1;

sbin/newfs/mkfs.c

332

sblock.fs_old_trackskew = 0;

sbin/newfs/mkfs.c

333

sblock.fs_old_cpc = 0;

sbin/newfs/mkfs.c

334

sblock.fs_old_postblformat = FS_DYNAMICPOSTBLFMT;

sbin/newfs/mkfs.c

335

sblock.fs_old_nrpos = 1;

sbin/newfs/mkfs.c

337

sblock.fs_magic = FS_UFS2_MAGIC;

sbin/newfs/mkfs.c

338

sblock.fs_sblockloc = SBLOCK_UFS2;

sbin/newfs/mkfs.c

339

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

sbin/newfs/mkfs.c

340

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

sbin/newfs/mkfs.c

343

sblock.fs_sblkno =

sbin/newfs/mkfs.c

344

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

sbin/newfs/mkfs.c

345

sblock.fs_frag);

sbin/newfs/mkfs.c

346

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

sbin/newfs/mkfs.c

347

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

sbin/newfs/mkfs.c

348

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

sbin/newfs/mkfs.c

349

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

sbin/newfs/mkfs.c

350

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

sbin/newfs/mkfs.c

351

sizepb *= FFS_NINDIR(&sblock);

sbin/newfs/mkfs.c

352

sblock.fs_maxfilesize += sizepb;

sbin/newfs/mkfs.c

378

if (sblock.fs_size < sblock.fs_iblkno + 3 * sblock.fs_frag) {

sbin/newfs/mkfs.c

380

(long long)sblock.fs_size, sblock.fs_iblkno + 3 * sblock.fs_frag);

sbin/newfs/mkfs.c

384

inodeblks = howmany(num_inodes, FFS_INOPB(&sblock));

sbin/newfs/mkfs.c

390

fragsperinodeblk = MAX(ffs_numfrags(&sblock,

sbin/newfs/mkfs.c

391

(uint64_t)density * FFS_INOPB(&sblock)), 1);

sbin/newfs/mkfs.c

392

inodeblks = (sblock.fs_size - sblock.fs_iblkno) /

sbin/newfs/mkfs.c

393

(sblock.fs_frag + fragsperinodeblk);

sbin/newfs/mkfs.c

398

if (inodeblks > (uint64_t)(sblock.fs_size - sblock.fs_iblkno)/sblock.fs_frag - 2)

sbin/newfs/mkfs.c

399

inodeblks = (sblock.fs_size-sblock.fs_iblkno)/sblock.fs_frag-2;

sbin/newfs/mkfs.c

401

if (inodeblks * FFS_INOPB(&sblock) >= 1ull << 31)

sbin/newfs/mkfs.c

402

inodeblks = ((1ull << 31) - NBBY) / FFS_INOPB(&sblock);

sbin/newfs/mkfs.c

407

cgzero = CGSIZE_IF(&sblock, 0, 0);

sbin/newfs/mkfs.c

408

cgall = CGSIZE_IF(&sblock, inodeblks * FFS_INOPB(&sblock), sblock.fs_size);

sbin/newfs/mkfs.c

409

ncg = howmany(cgall - cgzero, sblock.fs_bsize - cgzero);

sbin/newfs/mkfs.c

416

u = sblock.fs_size / 2 / (sblock.fs_iblkno +

sbin/newfs/mkfs.c

417

inodeblks * sblock.fs_frag);

sbin/newfs/mkfs.c

431

sblock.fs_fpg = roundup(howmany(sblock.fs_size, ncg), sblock.fs_frag);

sbin/newfs/mkfs.c

433

sblock.fs_fpg = roundup(sblock.fs_fpg, NBBY);

sbin/newfs/mkfs.c

434

inodes_per_cg = ((inodeblks - 1) / ncg + 1) * FFS_INOPB(&sblock);

sbin/newfs/mkfs.c

436

i = CGSIZE_IF(&sblock, inodes_per_cg, sblock.fs_fpg);

sbin/newfs/mkfs.c

437

if (i > sblock.fs_bsize) {

sbin/newfs/mkfs.c

438

sblock.fs_fpg -= (i - sblock.fs_bsize) * NBBY;

sbin/newfs/mkfs.c

440

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

sbin/newfs/mkfs.c

441

inodes_per_cg = ((inodeblks - 1) / ncg + 1) * FFS_INOPB(&sblock);

sbin/newfs/mkfs.c

443

sblock.fs_ipg = inodes_per_cg;

sbin/newfs/mkfs.c

445

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

sbin/newfs/mkfs.c

447

(int)CGSIZE(&sblock), sblock.fs_bsize);

sbin/newfs/mkfs.c

451

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

sbin/newfs/mkfs.c

453

i = sblock.fs_size - sblock.fs_fpg * (ncg - 1ull);

sbin/newfs/mkfs.c

454

if (i < sblock.fs_dblkno) {

sbin/newfs/mkfs.c

463

sblock.fs_size -= i;

sbin/newfs/mkfs.c

465

sblock.fs_ncg = ncg;

sbin/newfs/mkfs.c

467

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

sbin/newfs/mkfs.c

469

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

sbin/newfs/mkfs.c

470

sblock.fs_old_nsect = sblock.fs_old_spc;

sbin/newfs/mkfs.c

471

sblock.fs_old_npsect = sblock.fs_old_spc;

sbin/newfs/mkfs.c

472

sblock.fs_old_ncyl = sblock.fs_ncg;

sbin/newfs/mkfs.c

482

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

sbin/newfs/mkfs.c

483

sblock.fs_cssize =

sbin/newfs/mkfs.c

484

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

sbin/newfs/mkfs.c

487

fscs_0 = mmap(0, 2 * sblock.fs_fsize, PROT_READ|PROT_WRITE,

sbin/newfs/mkfs.c

491

memset(fscs_0, 0, 2 * sblock.fs_fsize);

sbin/newfs/mkfs.c

492

fs_csaddr = sblock.fs_csaddr;

sbin/newfs/mkfs.c

494

fscs_end = (void *)((char *)fscs_0 + 2 * sblock.fs_fsize);

sbin/newfs/mkfs.c

495

fscs_reset = (void *)((char *)fscs_0 + sblock.fs_fsize);

sbin/newfs/mkfs.c

499

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

sbin/newfs/mkfs.c

500

if (sblock.fs_sbsize > SBLOCKSIZE)

sbin/newfs/mkfs.c

501

sblock.fs_sbsize = SBLOCKSIZE;

sbin/newfs/mkfs.c

502

sblock.fs_minfree = minfree;

sbin/newfs/mkfs.c

503

sblock.fs_maxcontig = maxcontig;

sbin/newfs/mkfs.c

504

sblock.fs_maxbpg = maxbpg;

sbin/newfs/mkfs.c

505

sblock.fs_optim = opt;

sbin/newfs/mkfs.c

506

sblock.fs_cgrotor = 0;

sbin/newfs/mkfs.c

507

sblock.fs_pendingblocks = 0;

sbin/newfs/mkfs.c

508

sblock.fs_pendinginodes = 0;

sbin/newfs/mkfs.c

509

sblock.fs_cstotal.cs_ndir = 0;

sbin/newfs/mkfs.c

510

sblock.fs_cstotal.cs_nbfree = 0;

sbin/newfs/mkfs.c

511

sblock.fs_cstotal.cs_nifree = 0;

sbin/newfs/mkfs.c

512

sblock.fs_cstotal.cs_nffree = 0;

sbin/newfs/mkfs.c

513

sblock.fs_fmod = 0;

sbin/newfs/mkfs.c

514

sblock.fs_ronly = 0;

sbin/newfs/mkfs.c

515

sblock.fs_state = 0;

sbin/newfs/mkfs.c

516

sblock.fs_clean = FS_ISCLEAN;

sbin/newfs/mkfs.c

517

sblock.fs_ronly = 0;

sbin/newfs/mkfs.c

518

sblock.fs_id[0] = (long)tv.tv_sec; /* XXXfvdl huh? */

sbin/newfs/mkfs.c

519

sblock.fs_id[1] = arc4random() & INT32_MAX;

sbin/newfs/mkfs.c

520

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

sbin/newfs/mkfs.c

521

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

sbin/newfs/mkfs.c

522

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

sbin/newfs/mkfs.c

523

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

sbin/newfs/mkfs.c

524

sblock.fs_cstotal.cs_nbfree =

sbin/newfs/mkfs.c

525

ffs_fragstoblks(&sblock, sblock.fs_dsize) -

sbin/newfs/mkfs.c

526

howmany(csfrags, sblock.fs_frag);

sbin/newfs/mkfs.c

527

sblock.fs_cstotal.cs_nffree =

sbin/newfs/mkfs.c

528

ffs_fragnum(&sblock, sblock.fs_size) +

sbin/newfs/mkfs.c

529

(ffs_fragnum(&sblock, csfrags) > 0 ?

sbin/newfs/mkfs.c

530

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

sbin/newfs/mkfs.c

531

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

sbin/newfs/mkfs.c

532

sblock.fs_cstotal.cs_ndir = 0;

sbin/newfs/mkfs.c

533

sblock.fs_dsize -= csfrags;

sbin/newfs/mkfs.c

534

sblock.fs_time = tv.tv_sec;

sbin/newfs/mkfs.c

536

sblock.fs_old_time = tv.tv_sec;

sbin/newfs/mkfs.c

537

sblock.fs_old_dsize = sblock.fs_dsize;

sbin/newfs/mkfs.c

538

sblock.fs_old_csaddr = sblock.fs_csaddr;

sbin/newfs/mkfs.c

539

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

sbin/newfs/mkfs.c

540

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

sbin/newfs/mkfs.c

541

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

sbin/newfs/mkfs.c

542

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

sbin/newfs/mkfs.c

546

sblock.fs_flags |= FS_DOQUOTA2;

sbin/newfs/mkfs.c

547

sblock.fs_quota_magic = Q2_HEAD_MAGIC;

sbin/newfs/mkfs.c

548

sblock.fs_quota_flags = quotas;

sbin/newfs/mkfs.c

557

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

sbin/newfs/mkfs.c

558

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

sbin/newfs/mkfs.c

559

sblock.fs_bsize, sblock.fs_fsize);

sbin/newfs/mkfs.c

562

sblock.fs_ncg,

sbin/newfs/mkfs.c

563

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

sbin/newfs/mkfs.c

564

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

sbin/newfs/mkfs.c

572

if (sblock.fs_bsize < SBLOCKSIZE)

sbin/newfs/mkfs.c

573

iobufsize = SBLOCKSIZE + 3 * sblock.fs_bsize;

sbin/newfs/mkfs.c

575

iobufsize = 4 * sblock.fs_bsize;

sbin/newfs/mkfs.c

577

if (!mfs && sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/newfs/mkfs.c

579

iobuf_memsize += 14 * sblock.fs_bsize;

sbin/newfs/mkfs.c

662

memcpy(iobuf, &sblock, sizeof sblock);

sbin/newfs/mkfs.c

664

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

sbin/newfs/mkfs.c

665

if ((sblock.fs_old_flags & FS_FLAGS_UPDATED) == 0)

sbin/newfs/mkfs.c

673

(uint64_t)FFS_FSBTODB(&sblock, cgsblock(&sblock, sblock.fs_ncg-1)));

sbin/newfs/mkfs.c

685

delta = verbosity > 2 ? 0 : max_cols * BASE / sblock.fs_ncg;

sbin/newfs/mkfs.c

686

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

sbin/newfs/mkfs.c

702

(uint64_t)FFS_FSBTODB(&sblock, cgsblock(&sblock, cylno)));

sbin/newfs/mkfs.c

710

delta = sblock.fs_ncg - cylno - 1;

sbin/newfs/mkfs.c

733

sblock.fs_time = tv.tv_sec;

sbin/newfs/mkfs.c

735

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

sbin/newfs/mkfs.c

736

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

sbin/newfs/mkfs.c

737

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

sbin/newfs/mkfs.c

738

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

sbin/newfs/mkfs.c

743

i = cgsblock(&sblock, 0) * sblock.fs_fsize - sblock.fs_sblockloc;

sbin/newfs/mkfs.c

744

if ((size_t)i < sizeof(sblock))

sbin/newfs/mkfs.c

746

memcpy(iobuf, &sblock, sizeof(sblock));

sbin/newfs/mkfs.c

747

memset(iobuf + sizeof(sblock), 0, i - sizeof(sblock));

sbin/newfs/mkfs.c

749

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

sbin/newfs/mkfs.c

752

if ((sblock.fs_old_flags & FS_FLAGS_UPDATED) == 0)

sbin/newfs/mkfs.c

755

wtfs(sblock.fs_sblockloc / sectorsize, i, iobuf);

sbin/newfs/mkfs.c

759

ffs_csum_swap(fscs_0, fscs_0, sblock.fs_fsize);

sbin/newfs/mkfs.c

760

wtfs(FFS_FSBTODB(&sblock, sblock.fs_csaddr), sblock.fs_fsize, fscs_0);

sbin/newfs/mkfs.c

764

ffs_csum_swap(fscs_reset, fscs_reset, sblock.fs_fsize);

sbin/newfs/mkfs.c

766

wtfs(FFS_FSBTODB(&sblock, fs_csaddr), sblock.fs_fsize, fscs_reset);

sbin/newfs/mkfs.c

771

munmap(fscs_0, 2 * sblock.fs_fsize);

sbin/newfs/mkfs.c

791

cbase = cgbase(&sblock, cylno);

sbin/newfs/mkfs.c

792

dmax = cbase + sblock.fs_fpg;

sbin/newfs/mkfs.c

793

if (dmax > sblock.fs_size)

sbin/newfs/mkfs.c

794

dmax = sblock.fs_size;

sbin/newfs/mkfs.c

795

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

sbin/newfs/mkfs.c

796

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

sbin/newfs/mkfs.c

798

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

sbin/newfs/mkfs.c

799

if (dupper >= cgstart(&sblock, cylno + 1)) {

sbin/newfs/mkfs.c

805

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

sbin/newfs/mkfs.c

809

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

810

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

sbin/newfs/mkfs.c

814

acg.cg_niblk = sblock.fs_ipg;

sbin/newfs/mkfs.c

815

acg.cg_initediblk = sblock.fs_ipg < 2 * FFS_INOPB(&sblock) ?

sbin/newfs/mkfs.c

816

sblock.fs_ipg : 2 * FFS_INOPB(&sblock);

sbin/newfs/mkfs.c

819

acg.cg_old_ncyl = sblock.fs_old_cpg;

sbin/newfs/mkfs.c

820

if ((sblock.fs_old_flags & FS_FLAGS_UPDATED) == 0 &&

sbin/newfs/mkfs.c

821

(cylno == sblock.fs_ncg - 1))

sbin/newfs/mkfs.c

823

sblock.fs_old_ncyl % sblock.fs_old_cpg;

sbin/newfs/mkfs.c

825

acg.cg_old_niblk = sblock.fs_ipg;

sbin/newfs/mkfs.c

828

sblock.fs_old_cpg * sizeof(int32_t);

sbin/newfs/mkfs.c

830

sblock.fs_old_cpg * sizeof(u_int16_t);

sbin/newfs/mkfs.c

832

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

sbin/newfs/mkfs.c

833

if (sblock.fs_contigsumsize <= 0) {

sbin/newfs/mkfs.c

835

howmany(sblock.fs_fpg, CHAR_BIT);

sbin/newfs/mkfs.c

838

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

sbin/newfs/mkfs.c

849

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

sbin/newfs/mkfs.c

851

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

sbin/newfs/mkfs.c

853

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

sbin/newfs/mkfs.c

857

acg.cg_cs.cs_nifree += sblock.fs_ipg;

sbin/newfs/mkfs.c

869

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

sbin/newfs/mkfs.c

870

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

874

int cn = old_cbtocylno(&sblock, d);

sbin/newfs/mkfs.c

876

old_cg_blks(&sblock, &acg,

sbin/newfs/mkfs.c

877

cn, 0)[old_cbtorpos(&sblock, d)]++;

sbin/newfs/mkfs.c

879

d += sblock.fs_frag;

sbin/newfs/mkfs.c

883

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

sbin/newfs/mkfs.c

884

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

sbin/newfs/mkfs.c

885

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

sbin/newfs/mkfs.c

890

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

sbin/newfs/mkfs.c

891

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

sbin/newfs/mkfs.c

892

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

sbin/newfs/mkfs.c

893

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

897

int cn = old_cbtocylno(&sblock, d);

sbin/newfs/mkfs.c

899

old_cg_blks(&sblock, &acg,

sbin/newfs/mkfs.c

900

cn, 0)[old_cbtorpos(&sblock, d)]++;

sbin/newfs/mkfs.c

902

d += sblock.fs_frag;

sbin/newfs/mkfs.c

912

if (sblock.fs_contigsumsize > 0) {

sbin/newfs/mkfs.c

923

if (run > sblock.fs_contigsumsize)

sbin/newfs/mkfs.c

924

run = sblock.fs_contigsumsize;

sbin/newfs/mkfs.c

936

if (run > sblock.fs_contigsumsize)

sbin/newfs/mkfs.c

937

run = sblock.fs_contigsumsize;

sbin/newfs/mkfs.c

945

ffs_csum_swap(fscs_reset, fscs_reset, sblock.fs_fsize);

sbin/newfs/mkfs.c

947

wtfs(FFS_FSBTODB(&sblock, fs_csaddr), sblock.fs_fsize, fscs_reset);

sbin/newfs/mkfs.c

949

memset(fscs_next, 0, sblock.fs_fsize);

sbin/newfs/mkfs.c

955

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

sbin/newfs/mkfs.c

956

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

sbin/newfs/mkfs.c

958

ffs_cg_swap(&acg, (struct cg*)&iobuf[start], &sblock);

sbin/newfs/mkfs.c

959

start += sblock.fs_bsize;

sbin/newfs/mkfs.c

962

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

sbin/newfs/mkfs.c

963

if (sblock.fs_magic == FS_UFS1_MAGIC) {

sbin/newfs/mkfs.c

972

wtfs(FFS_FSBTODB(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf);

sbin/newfs/mkfs.c

976

if (sblock.fs_magic != FS_UFS1_MAGIC)

sbin/newfs/mkfs.c

980

d = (iobuf_memsize - start) / sblock.fs_bsize * sblock.fs_frag;

sbin/newfs/mkfs.c

981

dupper = sblock.fs_ipg / FFS_INOPF(&sblock);

sbin/newfs/mkfs.c

982

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

sbin/newfs/mkfs.c

989

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

sbin/newfs/mkfs.c

990

d * sblock.fs_bsize / sblock.fs_frag, &iobuf[start]);

sbin/newfs_ext2fs/mke2fs.c

1005

wtfs(EXT2_FSBTODB(&sblock, node.e2di_blocks[0]),

sbin/newfs_ext2fs/mke2fs.c

1006

sblock.e2fs_bsize, buf);

sbin/newfs_ext2fs/mke2fs.c

1022

dirblksiz = sblock.e2fs_bsize;

sbin/newfs_ext2fs/mke2fs.c

1128

isize = (uint64_t)sblock.e2fs_bsize * EXT2FS_NDADDR +

sbin/newfs_ext2fs/mke2fs.c

1129

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

sbin/newfs_ext2fs/mke2fs.c

1130

(uint64_t)sblock.e2fs_bsize * EXT2_NINDIR(&sblock) *

sbin/newfs_ext2fs/mke2fs.c

1131

EXT2_NINDIR(&sblock);

sbin/newfs_ext2fs/mke2fs.c

1133

(sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

1157

alloc(sblock.e2fs_bsize, node.e2di_mode);

sbin/newfs_ext2fs/mke2fs.c

1163

nblock = EXT2_FSBTODB(&sblock, 1);

sbin/newfs_ext2fs/mke2fs.c

1166

dindir_block = malloc(sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

1173

reserved_gdb = malloc(sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

1182

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

sbin/newfs_ext2fs/mke2fs.c

1186

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

sbin/newfs_ext2fs/mke2fs.c

1196

if (i >= EXT2_NINDIR(&sblock))

sbin/newfs_ext2fs/mke2fs.c

1199

__func__, sblock.e2fs.e2fs_reserved_ngdb);

sbin/newfs_ext2fs/mke2fs.c

1201

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

sbin/newfs_ext2fs/mke2fs.c

1208

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

sbin/newfs_ext2fs/mke2fs.c

1210

if ((sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

1215

if (n >= EXT2_NINDIR(&sblock))

sbin/newfs_ext2fs/mke2fs.c

1222

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

sbin/newfs_ext2fs/mke2fs.c

1224

nblock += EXT2_FSBTODB(&sblock, 1);

sbin/newfs_ext2fs/mke2fs.c

1226

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

sbin/newfs_ext2fs/mke2fs.c

1230

wtfs(EXT2_FSBTODB(&sblock, fs2h32(dindir_block[i])),

sbin/newfs_ext2fs/mke2fs.c

1231

sblock.e2fs_bsize, reserved_gdb);

sbin/newfs_ext2fs/mke2fs.c

1232

nblock += EXT2_FSBTODB(&sblock, 1);

sbin/newfs_ext2fs/mke2fs.c

1234

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

sbin/newfs_ext2fs/mke2fs.c

1241

wtfs(EXT2_FSBTODB(&sblock, node.e2di_blocks[EXT2FS_NDADDR + DOUBLE]),

sbin/newfs_ext2fs/mke2fs.c

1242

sblock.e2fs_bsize, dindir_block);

sbin/newfs_ext2fs/mke2fs.c

1265

if (size > sblock.e2fs_bsize)

sbin/newfs_ext2fs/mke2fs.c

1268

bbp = malloc(sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

1271

rdfs(EXT2_FSBTODB(&sblock, fs2h32(gd[0].ext2bgd_b_bitmap)),

sbin/newfs_ext2fs/mke2fs.c

1272

sblock.e2fs_bsize, bbp);

sbin/newfs_ext2fs/mke2fs.c

1275

len = sblock.e2fs.e2fs_bpg / NBBY;

sbin/newfs_ext2fs/mke2fs.c

1306

wtfs(EXT2_FSBTODB(&sblock, fs2h32(gd[0].ext2bgd_b_bitmap)),

sbin/newfs_ext2fs/mke2fs.c

1307

sblock.e2fs_bsize, bbp);

sbin/newfs_ext2fs/mke2fs.c

1313

sblock.e2fs.e2fs_fbcount--;

sbin/newfs_ext2fs/mke2fs.c

1315

return sblock.e2fs.e2fs_first_dblock + bno;

sbin/newfs_ext2fs/mke2fs.c

1331

bp = malloc(sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

1341

c = ino_to_cg(&sblock, ino);

sbin/newfs_ext2fs/mke2fs.c

1350

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

sbin/newfs_ext2fs/mke2fs.c

1351

sblock.e2fs_bsize, bp);

sbin/newfs_ext2fs/mke2fs.c

1358

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

sbin/newfs_ext2fs/mke2fs.c

1359

sblock.e2fs_bsize, bp);

sbin/newfs_ext2fs/mke2fs.c

1361

sblock.e2fs.e2fs_ficount--;

sbin/newfs_ext2fs/mke2fs.c

1364

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

sbin/newfs_ext2fs/mke2fs.c

1369

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

sbin/newfs_ext2fs/mke2fs.c

1370

rdfs(d, sblock.e2fs_bsize, bp);

sbin/newfs_ext2fs/mke2fs.c

1373

inodesize * ino_to_fsbo(&sblock, ino));

sbin/newfs_ext2fs/mke2fs.c

1374

e2fs_isave(ip, dp, EXT2_DINODE_SIZE(&sblock));

sbin/newfs_ext2fs/mke2fs.c

1383

wtfs(d, sblock.e2fs_bsize, bp);

sbin/newfs_ext2fs/mke2fs.c

246

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

sbin/newfs_ext2fs/mke2fs.c

248

sblock.e2fs.e2fs_fsize = ilog2(fsize) - LOG_MINBSIZE;

sbin/newfs_ext2fs/mke2fs.c

250

sblock.e2fs_bsize = bsize;

sbin/newfs_ext2fs/mke2fs.c

251

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

sbin/newfs_ext2fs/mke2fs.c

252

sblock.e2fs_qbmask = sblock.e2fs_bsize - 1;

sbin/newfs_ext2fs/mke2fs.c

253

sblock.e2fs_bmask = ~sblock.e2fs_qbmask;

sbin/newfs_ext2fs/mke2fs.c

254

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

sbin/newfs_ext2fs/mke2fs.c

255

sblock.e2fs_ipb = sblock.e2fs_bsize / inodesize;

sbin/newfs_ext2fs/mke2fs.c

265

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

sbin/newfs_ext2fs/mke2fs.c

266

minfssize = EXT2_FSBTODB(&sblock,

sbin/newfs_ext2fs/mke2fs.c

267

sblock.e2fs.e2fs_first_dblock +

sbin/newfs_ext2fs/mke2fs.c

281

bcount = EXT2_DBTOFSB(&sblock, fssize);

sbin/newfs_ext2fs/mke2fs.c

292

blocks_per_cg = sblock.e2fs_bsize * NBBY;

sbin/newfs_ext2fs/mke2fs.c

294

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

sbin/newfs_ext2fs/mke2fs.c

315

blocks_lastcg = bcount - sblock.e2fs.e2fs_first_dblock -

sbin/newfs_ext2fs/mke2fs.c

333

inodes_per_cg = roundup(inodes_per_cg, sblock.e2fs_ipb);

sbin/newfs_ext2fs/mke2fs.c

335

iblocks_per_cg = inodes_per_cg / sblock.e2fs_ipb;

sbin/newfs_ext2fs/mke2fs.c

339

sblock.e2fs.e2fs_bcount = bcount;

sbin/newfs_ext2fs/mke2fs.c

340

sblock.e2fs.e2fs_icount = num_inodes;

sbin/newfs_ext2fs/mke2fs.c

342

sblock.e2fs_ncg = ncg;

sbin/newfs_ext2fs/mke2fs.c

343

sblock.e2fs_ngdb = blocks_gd;

sbin/newfs_ext2fs/mke2fs.c

344

sblock.e2fs_itpg = iblocks_per_cg;

sbin/newfs_ext2fs/mke2fs.c

346

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

sbin/newfs_ext2fs/mke2fs.c

350

sblock.e2fs.e2fs_bpg = blocks_per_cg;

sbin/newfs_ext2fs/mke2fs.c

351

sblock.e2fs.e2fs_fpg = blocks_per_cg;

sbin/newfs_ext2fs/mke2fs.c

353

sblock.e2fs.e2fs_ipg = inodes_per_cg;

sbin/newfs_ext2fs/mke2fs.c

355

sblock.e2fs.e2fs_mtime = 0;

sbin/newfs_ext2fs/mke2fs.c

356

sblock.e2fs.e2fs_wtime = tv.tv_sec;

sbin/newfs_ext2fs/mke2fs.c

357

sblock.e2fs.e2fs_mnt_count = 0;

sbin/newfs_ext2fs/mke2fs.c

359

sblock.e2fs.e2fs_max_mnt_count = EXT2_DEF_MAX_MNT_COUNT;

sbin/newfs_ext2fs/mke2fs.c

361

sblock.e2fs.e2fs_magic = E2FS_MAGIC;

sbin/newfs_ext2fs/mke2fs.c

362

sblock.e2fs.e2fs_state = E2FS_ISCLEAN;

sbin/newfs_ext2fs/mke2fs.c

363

sblock.e2fs.e2fs_beh = E2FS_BEH_DEFAULT;

sbin/newfs_ext2fs/mke2fs.c

364

sblock.e2fs.e2fs_minrev = 0;

sbin/newfs_ext2fs/mke2fs.c

365

sblock.e2fs.e2fs_lastfsck = tv.tv_sec;

sbin/newfs_ext2fs/mke2fs.c

366

sblock.e2fs.e2fs_fsckintv = EXT2_DEF_FSCKINTV;

sbin/newfs_ext2fs/mke2fs.c

379

sblock.e2fs.e2fs_creator = E2FS_OS_LINUX;

sbin/newfs_ext2fs/mke2fs.c

382

sblock.e2fs.e2fs_rev = E2FS_REV0;

sbin/newfs_ext2fs/mke2fs.c

383

sblock.e2fs.e2fs_features_compat = 0;

sbin/newfs_ext2fs/mke2fs.c

384

sblock.e2fs.e2fs_features_incompat = 0;

sbin/newfs_ext2fs/mke2fs.c

385

sblock.e2fs.e2fs_features_rocompat = 0;

sbin/newfs_ext2fs/mke2fs.c

387

sblock.e2fs.e2fs_rev = E2FS_REV1;

sbin/newfs_ext2fs/mke2fs.c

397

sblock.e2fs.e2fs_features_compat = EXT2F_COMPAT_RESIZE;

sbin/newfs_ext2fs/mke2fs.c

398

sblock.e2fs.e2fs_features_incompat = EXT2F_INCOMPAT_FTYPE;

sbin/newfs_ext2fs/mke2fs.c

399

sblock.e2fs.e2fs_features_rocompat =

sbin/newfs_ext2fs/mke2fs.c

403

sblock.e2fs.e2fs_ruid = geteuid();

sbin/newfs_ext2fs/mke2fs.c

404

sblock.e2fs.e2fs_rgid = getegid();

sbin/newfs_ext2fs/mke2fs.c

406

sblock.e2fs.e2fs_first_ino = EXT2_FIRSTINO;

sbin/newfs_ext2fs/mke2fs.c

407

sblock.e2fs.e2fs_inode_size = inodesize;

sbin/newfs_ext2fs/mke2fs.c

414

uuid_enc_le(sblock.e2fs.e2fs_uuid, &uuid);

sbin/newfs_ext2fs/mke2fs.c

416

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

sbin/newfs_ext2fs/mke2fs.c

418

strlcpy(sblock.e2fs.e2fs_vname, volname,

sbin/newfs_ext2fs/mke2fs.c

419

sizeof(sblock.e2fs.e2fs_vname));

sbin/newfs_ext2fs/mke2fs.c

422

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

sbin/newfs_ext2fs/mke2fs.c

423

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

sbin/newfs_ext2fs/mke2fs.c

425

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

sbin/newfs_ext2fs/mke2fs.c

426

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

sbin/newfs_ext2fs/mke2fs.c

427

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

sbin/newfs_ext2fs/mke2fs.c

430

sblock.e2fs.e2fs_reserved_ngdb = 0;

sbin/newfs_ext2fs/mke2fs.c

431

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

432

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

sbin/newfs_ext2fs/mke2fs.c

438

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

sbin/newfs_ext2fs/mke2fs.c

443

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

sbin/newfs_ext2fs/mke2fs.c

445

sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

458

if (target_ngdb > EXT2_NINDIR(&sblock))

sbin/newfs_ext2fs/mke2fs.c

459

target_ngdb = EXT2_NINDIR(&sblock);

sbin/newfs_ext2fs/mke2fs.c

461

reserved_ngdb = target_ngdb - sblock.e2fs_ngdb;

sbin/newfs_ext2fs/mke2fs.c

468

sblock.e2fs.e2fs_features_compat &=

sbin/newfs_ext2fs/mke2fs.c

471

sblock.e2fs.e2fs_reserved_ngdb = reserved_ngdb;

sbin/newfs_ext2fs/mke2fs.c

477

gd = malloc(sblock.e2fs_ngdb * bsize);

sbin/newfs_ext2fs/mke2fs.c

480

memset(gd, 0, sblock.e2fs_ngdb * bsize);

sbin/newfs_ext2fs/mke2fs.c

487

boffset = cgbase(&sblock, cylno);

sbin/newfs_ext2fs/mke2fs.c

488

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

sbin/newfs_ext2fs/mke2fs.c

489

(sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

492

boffset += NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb;

sbin/newfs_ext2fs/mke2fs.c

493

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

494

(sblock.e2fs.e2fs_features_compat &

sbin/newfs_ext2fs/mke2fs.c

496

boffset += sblock.e2fs.e2fs_reserved_ngdb;

sbin/newfs_ext2fs/mke2fs.c

508

sblock.e2fs.e2fs_bpg - cgoverhead(cylno));

sbin/newfs_ext2fs/mke2fs.c

513

sblock.e2fs.e2fs_ipg-EXT2_RESERVED_INODES);

sbin/newfs_ext2fs/mke2fs.c

516

h2fs16(sblock.e2fs.e2fs_ipg);

sbin/newfs_ext2fs/mke2fs.c

521

sblock.e2fs.e2fs_fbcount = fbcount;

sbin/newfs_ext2fs/mke2fs.c

522

sblock.e2fs.e2fs_ficount = ficount;

sbin/newfs_ext2fs/mke2fs.c

538

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

sbin/newfs_ext2fs/mke2fs.c

539

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

sbin/newfs_ext2fs/mke2fs.c

545

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

sbin/newfs_ext2fs/mke2fs.c

595

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

sbin/newfs_ext2fs/mke2fs.c

617

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

618

(sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

634

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

sbin/newfs_ext2fs/mke2fs.c

642

delta = sblock.e2fs_ncg - cylno - 1;

sbin/newfs_ext2fs/mke2fs.c

668

sblock.e2fs.e2fs_block_group_nr = 0;

sbin/newfs_ext2fs/mke2fs.c

670

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

sbin/newfs_ext2fs/mke2fs.c

678

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

sbin/newfs_ext2fs/mke2fs.c

679

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

sbin/newfs_ext2fs/mke2fs.c

680

sizeof(struct ext2_gd) * sblock.e2fs_ncg);

sbin/newfs_ext2fs/mke2fs.c

681

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

sbin/newfs_ext2fs/mke2fs.c

699

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

sbin/newfs_ext2fs/mke2fs.c

700

(sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

703

sblock.e2fs.e2fs_block_group_nr = cylno;

sbin/newfs_ext2fs/mke2fs.c

705

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

sbin/newfs_ext2fs/mke2fs.c

709

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

sbin/newfs_ext2fs/mke2fs.c

711

sblock.e2fs_bsize * NBLOCK_SUPERBLOCK),

sbin/newfs_ext2fs/mke2fs.c

712

sizeof(struct ext2_gd) * sblock.e2fs_ncg);

sbin/newfs_ext2fs/mke2fs.c

714

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

sbin/newfs_ext2fs/mke2fs.c

721

memset(buf, 0, sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

722

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

sbin/newfs_ext2fs/mke2fs.c

724

nblcg = sblock.e2fs.e2fs_bcount -

sbin/newfs_ext2fs/mke2fs.c

725

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

sbin/newfs_ext2fs/mke2fs.c

728

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

sbin/newfs_ext2fs/mke2fs.c

736

wtfs(EXT2_FSBTODB(&sblock, fs2h32(gd[cylno].ext2bgd_b_bitmap)),

sbin/newfs_ext2fs/mke2fs.c

737

sblock.e2fs_bsize, buf);

sbin/newfs_ext2fs/mke2fs.c

746

i = sblock.e2fs.e2fs_ipg / NBBY;

sbin/newfs_ext2fs/mke2fs.c

748

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

sbin/newfs_ext2fs/mke2fs.c

754

wtfs(EXT2_FSBTODB(&sblock, fs2h32(gd[cylno].ext2bgd_i_bitmap)),

sbin/newfs_ext2fs/mke2fs.c

755

sblock.e2fs_bsize, buf);

sbin/newfs_ext2fs/mke2fs.c

764

memset(buf, 0, sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

765

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

sbin/newfs_ext2fs/mke2fs.c

766

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

sbin/newfs_ext2fs/mke2fs.c

771

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

sbin/newfs_ext2fs/mke2fs.c

772

sblock.e2fs_bsize, buf);

sbin/newfs_ext2fs/mke2fs.c

809

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

sbin/newfs_ext2fs/mke2fs.c

810

sblock.e2fs_bsize;

sbin/newfs_ext2fs/mke2fs.c

817

if (sblkoff >= sblock.e2fs.e2fs_first_dblock * bsize) {

sbin/newfs_ext2fs/mke2fs.c

859

overh = NBLOCK_BLOCK_BITMAP + NBLOCK_INODE_BITMAP + sblock.e2fs_itpg;

sbin/newfs_ext2fs/mke2fs.c

861

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

sbin/newfs_ext2fs/mke2fs.c

862

(sblock.e2fs.e2fs_features_rocompat &

sbin/newfs_ext2fs/mke2fs.c

865

overh += NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb;

sbin/newfs_ext2fs/mke2fs.c

867

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

868

(sblock.e2fs.e2fs_features_compat &

sbin/newfs_ext2fs/mke2fs.c

870

overh += sblock.e2fs.e2fs_reserved_ngdb;

sbin/newfs_ext2fs/mke2fs.c

917

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

918

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

sbin/newfs_ext2fs/mke2fs.c

929

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

930

sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE) {

sbin/newfs_ext2fs/mke2fs.c

937

nblks_lostfound = EXT2_LOSTFOUNDSIZE / sblock.e2fs_bsize;

sbin/newfs_ext2fs/mke2fs.c

945

node.e2di_size = sblock.e2fs_bsize * nblks_lostfound;

sbin/newfs_ext2fs/mke2fs.c

952

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

sbin/newfs_ext2fs/mke2fs.c

953

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

sbin/newfs_ext2fs/mke2fs.c

959

blk = alloc(sblock.e2fs_bsize, 0);

sbin/newfs_ext2fs/mke2fs.c

967

wtfs(EXT2_FSBTODB(&sblock, node.e2di_blocks[0]),

sbin/newfs_ext2fs/mke2fs.c

968

sblock.e2fs_bsize, buf);

sbin/newfs_ext2fs/mke2fs.c

969

pad_dir.e2d_reclen = sblock.e2fs_bsize;

sbin/newfs_ext2fs/mke2fs.c

971

memset(buf, 0, sblock.e2fs_bsize);

sbin/newfs_ext2fs/mke2fs.c

973

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

sbin/newfs_ext2fs/mke2fs.c

974

sblock.e2fs_bsize, buf);

sbin/newfs_ext2fs/mke2fs.c

982

if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&

sbin/newfs_ext2fs/mke2fs.c

983

sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE) {

sbin/newfs_ext2fs/mke2fs.c

999

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

sbin/tunefs/tunefs.c

246

getsb(&sblock, special);

sbin/tunefs/tunefs.c

261

CHANGEVAL(sblock.fs_maxbpg, maxbpg,

sbin/tunefs/tunefs.c

263

CHANGEVAL(sblock.fs_minfree, minfree,

sbin/tunefs/tunefs.c

267

sblock.fs_optim == FS_OPTSPACE)

sbin/tunefs/tunefs.c

270

sblock.fs_optim == FS_OPTTIME)

sbin/tunefs/tunefs.c

274

if (sblock.fs_optim == optim) {

sbin/tunefs/tunefs.c

281

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

sbin/tunefs/tunefs.c

282

sblock.fs_optim = optim;

sbin/tunefs/tunefs.c

283

if (sblock.fs_minfree >= MINFREE &&

sbin/tunefs/tunefs.c

286

if (sblock.fs_minfree < MINFREE &&

sbin/tunefs/tunefs.c

293

secsize = sblock.fs_fsize / FFS_FSBTODB(&sblock, 1);

sbin/tunefs/tunefs.c

299

else if (secshift > sblock.fs_fshift)

sbin/tunefs/tunefs.c

301

secsize, sblock.fs_fsize);

sbin/tunefs/tunefs.c

303

fsbtodb = sblock.fs_fshift - secshift;

sbin/tunefs/tunefs.c

304

if (fsbtodb == sblock.fs_fsbtodb) {

sbin/tunefs/tunefs.c

306

sblock.fs_fsize / FFS_FSBTODB(&sblock, 1));

sbin/tunefs/tunefs.c

309

sblock.fs_fsize / FFS_FSBTODB(&sblock, 1),

sbin/tunefs/tunefs.c

311

sblock.fs_fsbtodb = fsbtodb;

sbin/tunefs/tunefs.c

315

CHANGEVAL(sblock.fs_avgfilesize, avgfilesize,

sbin/tunefs/tunefs.c

317

CHANGEVAL(sblock.fs_avgfpdir, avgfpdir,

sbin/tunefs/tunefs.c

323

sblock.fs_flags |= FS_DOQUOTA2;

sbin/tunefs/tunefs.c

324

if (sblock.fs_flags & FS_DOQUOTA2) {

sbin/tunefs/tunefs.c

325

sblock.fs_quota_magic = Q2_HEAD_MAGIC;

sbin/tunefs/tunefs.c

328

if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(USRQUOTA))

sbin/tunefs/tunefs.c

331

sblock.fs_quota_flags |=

sbin/tunefs/tunefs.c

333

sblock.fs_quotafile[USRQUOTA] = 0;

sbin/tunefs/tunefs.c

337

if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(USRQUOTA))

sbin/tunefs/tunefs.c

340

sblock.fs_quota_flags &=

sbin/tunefs/tunefs.c

346

if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(GRPQUOTA))

sbin/tunefs/tunefs.c

349

sblock.fs_quota_flags |=

sbin/tunefs/tunefs.c

351

sblock.fs_quotafile[GRPQUOTA] = 0;

sbin/tunefs/tunefs.c

355

if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(GRPQUOTA))

sbin/tunefs/tunefs.c

358

sblock.fs_quota_flags &=

sbin/tunefs/tunefs.c

372

} else if (sblock.fs_flags & FS_NFS4ACLS) {

sbin/tunefs/tunefs.c

374

} else if (sblock.fs_flags & FS_POSIX1EACLS) {

sbin/tunefs/tunefs.c

378

sblock.fs_flags |= FS_NFS4ACLS;

sbin/tunefs/tunefs.c

382

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

sbin/tunefs/tunefs.c

386

sblock.fs_flags &= ~FS_NFS4ACLS;

sbin/tunefs/tunefs.c

397

} else if (sblock.fs_flags & FS_POSIX1EACLS) {

sbin/tunefs/tunefs.c

399

} else if (sblock.fs_flags & FS_NFS4ACLS) {

sbin/tunefs/tunefs.c

403

sblock.fs_flags |= FS_POSIX1EACLS;

sbin/tunefs/tunefs.c

407

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

sbin/tunefs/tunefs.c

412

sblock.fs_flags &= ~FS_POSIX1EACLS;

sbin/tunefs/tunefs.c

421

sblock.fs_maxcontig);

sbin/tunefs/tunefs.c

423

sblock.fs_maxbpg);

sbin/tunefs/tunefs.c

425

sblock.fs_minfree);

sbin/tunefs/tunefs.c

426

printf("\toptimization preference: %s\n", chg[sblock.fs_optim]);

sbin/tunefs/tunefs.c

427

printf("\taverage file size: %d\n", sblock.fs_avgfilesize);

sbin/tunefs/tunefs.c

429

sblock.fs_avgfpdir);

sbin/tunefs/tunefs.c

432

if (sblock.fs_flags & FS_DOQUOTA2) {

sbin/tunefs/tunefs.c

433

if (sblock.fs_quota_flags & FS_Q2_DO_TYPE(USRQUOTA)) {

sbin/tunefs/tunefs.c

435

if (sblock.fs_quota_flags &

sbin/tunefs/tunefs.c

439

if (sblock.fs_quota_flags & FS_Q2_DO_TYPE(GRPQUOTA))

sbin/tunefs/tunefs.c

446

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

sbin/tunefs/tunefs.c

448

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

sbin/tunefs/tunefs.c

453

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

sbin/tunefs/tunefs.c

473

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

sbin/tunefs/tunefs.c

476

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

sbin/tunefs/tunefs.c

477

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

sbin/tunefs/tunefs.c

519

switch (sblock.fs_journal_location) {

sbin/tunefs/tunefs.c

526

size = sblock.fs_journallocs[UFS_WAPBL_EPART_COUNT];

sbin/tunefs/tunefs.c

527

blksize = sblock.fs_journallocs[UFS_WAPBL_EPART_BLKSZ];

sbin/tunefs/tunefs.c

532

size = sblock.fs_journallocs[UFS_WAPBL_INFS_COUNT];

sbin/tunefs/tunefs.c

533

blksize = sblock.fs_journallocs[UFS_WAPBL_INFS_BLKSZ];

sbin/tunefs/tunefs.c

558

if (sblock.fs_journal_flags & UFS_WAPBL_FLAGS_CREATE_LOG)

sbin/tunefs/tunefs.c

560

if (sblock.fs_journal_flags & UFS_WAPBL_FLAGS_CLEAR_LOG)

sbin/tunefs/tunefs.c

583

switch (sblock.fs_journal_location) {

sbin/tunefs/tunefs.c

586

old_size = sblock.fs_journallocs[UFS_WAPBL_EPART_COUNT] *

sbin/tunefs/tunefs.c

587

sblock.fs_journallocs[UFS_WAPBL_EPART_BLKSZ];

sbin/tunefs/tunefs.c

592

old_size = sblock.fs_journallocs[UFS_WAPBL_INFS_COUNT] *

sbin/tunefs/tunefs.c

593

sblock.fs_journallocs[UFS_WAPBL_INFS_BLKSZ];

sbin/tunefs/tunefs.c

609

sblock.fs_journal_flags |= UFS_WAPBL_FLAGS_CLEAR_LOG;

sbin/tunefs/tunefs.c

610

sblock.fs_journal_flags &= ~UFS_WAPBL_FLAGS_CREATE_LOG;

sbin/tunefs/tunefs.c

626

sblock.fs_journal_location = UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM;

sbin/tunefs/tunefs.c

627

sblock.fs_journallocs[UFS_WAPBL_INFS_ADDR] = 0;

sbin/tunefs/tunefs.c

628

sblock.fs_journallocs[UFS_WAPBL_INFS_COUNT] = logfilesize;

sbin/tunefs/tunefs.c

629

sblock.fs_journallocs[UFS_WAPBL_INFS_BLKSZ] = 0;

sbin/tunefs/tunefs.c

630

sblock.fs_journallocs[UFS_WAPBL_INFS_INO] = 0;

sbin/tunefs/tunefs.c

631

sblock.fs_journal_flags |= UFS_WAPBL_FLAGS_CREATE_LOG;

sbin/tunefs/tunefs.c

632

sblock.fs_journal_flags &= ~UFS_WAPBL_FLAGS_CLEAR_LOG;

sys/arch/mvme68k/stand/installboot/installboot.c

235

static char sblock[SBLOCKSIZE];

sys/arch/mvme68k/stand/installboot/installboot.c

279

devread(devfd, sblock, (daddr_t)(BBSIZE / DEV_BSIZE),

sys/arch/mvme68k/stand/installboot/installboot.c

281

fs = (struct fs *)sblock;

sys/dev/kttcp.c

227

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

sys/dev/kttcp.c

389

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

sys/kern/uipc_socket.c

1218

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

sys/kern/uipc_socket.c

1722

(void )sblock(sb, M_WAITOK);

sys/kern/uipc_socket.c

944

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

sys/net/if_gre.c

512

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

sys/net/if_gre.c

572

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

sys/netinet/sctp_output.c

4228

error = sblock(&so->so_snd, SBLOCKWAIT(flags));

sys/netinet/sctp_output.c

4303

error = sblock(&so->so_snd, M_WAITOK);

sys/netinet/sctp_output.c

9307

error = sblock(&so->so_snd, SBLOCKWAIT(flags));

sys/netinet/sctp_output.c

9396

error = sblock(&so->so_snd, M_WAITOK);

sys/sys/socketvar.h

341

int sblock(struct sockbuf *, int);

tests/fs/lfs/t_rfw.c

112

" count=16 conv=sync", IMGNAME, sblock[i], sbaddr[i]);

tests/fs/lfs/t_rfw.c

153

" conv=sync,notrunc", IMGNAME, sblock[i], sbaddr[i]);

tests/fs/lfs/t_rfw.c

60

const char *sblock[2] = { SBLOCK0_COPY, SBLOCK1_COPY };

usr.sbin/dumpfs/dumpfs.c

295

const char *name, int fd, off_t sblock)

usr.sbin/dumpfs/dumpfs.c

312

if ((sblock != SBLOCK_UFS1) || ISOPT(opt_alt_super))

usr.sbin/dumpfs/dumpfs.c

314

(long long)sblock, (long long)(sblock/dev_bsize));

usr.sbin/makefs/ffs/mkfs.c

170

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

usr.sbin/makefs/ffs/mkfs.c

171

sizeof(sblock.fs_volname));

usr.sbin/makefs/ffs/mkfs.c

174

sblock.fs_old_inodefmt = FS_42INODEFMT;

usr.sbin/makefs/ffs/mkfs.c

175

sblock.fs_maxsymlinklen = 0;

usr.sbin/makefs/ffs/mkfs.c

176

sblock.fs_old_flags = 0;

usr.sbin/makefs/ffs/mkfs.c

178

sblock.fs_old_inodefmt = FS_44INODEFMT;

usr.sbin/makefs/ffs/mkfs.c

179

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

usr.sbin/makefs/ffs/mkfs.c

181

sblock.fs_old_flags = FS_FLAGS_UPDATED;

usr.sbin/makefs/ffs/mkfs.c

182

sblock.fs_flags = 0;

usr.sbin/makefs/ffs/mkfs.c

193

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

usr.sbin/makefs/ffs/mkfs.c

198

sblock.fs_avgfilesize = avgfilesize;

usr.sbin/makefs/ffs/mkfs.c

199

sblock.fs_avgfpdir = avgfpdir;

usr.sbin/makefs/ffs/mkfs.c

200

if (sblock.fs_avgfilesize <= 0)

usr.sbin/makefs/ffs/mkfs.c

202

sblock.fs_avgfilesize), exit(14);

usr.sbin/makefs/ffs/mkfs.c

203

if (sblock.fs_avgfpdir <= 0)

usr.sbin/makefs/ffs/mkfs.c

205

sblock.fs_avgfpdir), exit(15);

usr.sbin/makefs/ffs/mkfs.c

209

sblock.fs_bsize = bsize;

usr.sbin/makefs/ffs/mkfs.c

210

sblock.fs_fsize = fsize;

usr.sbin/makefs/ffs/mkfs.c

211

if (!POWEROF2(sblock.fs_bsize)) {

usr.sbin/makefs/ffs/mkfs.c

213

sblock.fs_bsize);

usr.sbin/makefs/ffs/mkfs.c

216

if (!POWEROF2(sblock.fs_fsize)) {

usr.sbin/makefs/ffs/mkfs.c

218

sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

221

if (sblock.fs_fsize < sectorsize) {

usr.sbin/makefs/ffs/mkfs.c

223

sblock.fs_fsize, sectorsize);

usr.sbin/makefs/ffs/mkfs.c

226

if (sblock.fs_bsize < MINBSIZE) {

usr.sbin/makefs/ffs/mkfs.c

228

sblock.fs_bsize, MINBSIZE);

usr.sbin/makefs/ffs/mkfs.c

231

if (sblock.fs_bsize > FFS_MAXBSIZE) {

usr.sbin/makefs/ffs/mkfs.c

233

sblock.fs_bsize, FFS_MAXBSIZE);

usr.sbin/makefs/ffs/mkfs.c

236

if (sblock.fs_bsize < sblock.fs_fsize) {

usr.sbin/makefs/ffs/mkfs.c

238

sblock.fs_bsize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

243

sblock.fs_maxbsize = sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

244

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

usr.sbin/makefs/ffs/mkfs.c

245

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

usr.sbin/makefs/ffs/mkfs.c

246

sblock.fs_maxbsize = FS_MAXCONTIG * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

247

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

usr.sbin/makefs/ffs/mkfs.c

249

sblock.fs_maxbsize = maxbsize;

usr.sbin/makefs/ffs/mkfs.c

251

sblock.fs_maxcontig = maxcontig;

usr.sbin/makefs/ffs/mkfs.c

252

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

usr.sbin/makefs/ffs/mkfs.c

253

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

usr.sbin/makefs/ffs/mkfs.c

254

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

usr.sbin/makefs/ffs/mkfs.c

257

if (sblock.fs_maxcontig > 1)

usr.sbin/makefs/ffs/mkfs.c

258

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

usr.sbin/makefs/ffs/mkfs.c

260

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

usr.sbin/makefs/ffs/mkfs.c

261

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

usr.sbin/makefs/ffs/mkfs.c

262

sblock.fs_qbmask = ~sblock.fs_bmask;

usr.sbin/makefs/ffs/mkfs.c

263

sblock.fs_qfmask = ~sblock.fs_fmask;

usr.sbin/makefs/ffs/mkfs.c

264

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

usr.sbin/makefs/ffs/mkfs.c

265

sblock.fs_bshift++;

usr.sbin/makefs/ffs/mkfs.c

266

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

usr.sbin/makefs/ffs/mkfs.c

267

sblock.fs_fshift++;

usr.sbin/makefs/ffs/mkfs.c

268

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

usr.sbin/makefs/ffs/mkfs.c

269

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

usr.sbin/makefs/ffs/mkfs.c

270

sblock.fs_fragshift++;

usr.sbin/makefs/ffs/mkfs.c

271

if (sblock.fs_frag > MAXFRAG) {

usr.sbin/makefs/ffs/mkfs.c

274

sblock.fs_fsize, sblock.fs_bsize,

usr.sbin/makefs/ffs/mkfs.c

275

sblock.fs_bsize / MAXFRAG);

usr.sbin/makefs/ffs/mkfs.c

278

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

usr.sbin/makefs/ffs/mkfs.c

279

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

usr.sbin/makefs/ffs/mkfs.c

282

sblock.fs_magic = FS_UFS1_MAGIC;

usr.sbin/makefs/ffs/mkfs.c

283

sblock.fs_sblockloc = SBLOCK_UFS1;

usr.sbin/makefs/ffs/mkfs.c

284

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

usr.sbin/makefs/ffs/mkfs.c

285

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

usr.sbin/makefs/ffs/mkfs.c

288

sblock.fs_old_cgoffset = 0;

usr.sbin/makefs/ffs/mkfs.c

289

sblock.fs_old_cgmask = 0xffffffff;

usr.sbin/makefs/ffs/mkfs.c

290

sblock.fs_old_size = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

291

sblock.fs_old_rotdelay = 0;

usr.sbin/makefs/ffs/mkfs.c

292

sblock.fs_old_rps = 60;

usr.sbin/makefs/ffs/mkfs.c

293

sblock.fs_old_nspf = sblock.fs_fsize / sectorsize;

usr.sbin/makefs/ffs/mkfs.c

294

sblock.fs_old_cpg = 1;

usr.sbin/makefs/ffs/mkfs.c

295

sblock.fs_old_interleave = 1;

usr.sbin/makefs/ffs/mkfs.c

296

sblock.fs_old_trackskew = 0;

usr.sbin/makefs/ffs/mkfs.c

297

sblock.fs_old_cpc = 0;

usr.sbin/makefs/ffs/mkfs.c

298

sblock.fs_old_postblformat = 1;

usr.sbin/makefs/ffs/mkfs.c

299

sblock.fs_old_nrpos = 1;

usr.sbin/makefs/ffs/mkfs.c

302

sblock.fs_magic = FS_UFS2EA_MAGIC;

usr.sbin/makefs/ffs/mkfs.c

304

sblock.fs_magic = FS_UFS2_MAGIC;

usr.sbin/makefs/ffs/mkfs.c

306

sblock.fs_sblockloc = SBLOCK_UFS2;

usr.sbin/makefs/ffs/mkfs.c

308

sblock.fs_sblockloc = SBLOCK_UFS1;

usr.sbin/makefs/ffs/mkfs.c

310

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

usr.sbin/makefs/ffs/mkfs.c

311

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

usr.sbin/makefs/ffs/mkfs.c

315

sblock.fs_sblkno =

usr.sbin/makefs/ffs/mkfs.c

316

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

usr.sbin/makefs/ffs/mkfs.c

317

sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

318

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

usr.sbin/makefs/ffs/mkfs.c

319

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

usr.sbin/makefs/ffs/mkfs.c

320

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

usr.sbin/makefs/ffs/mkfs.c

321

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

usr.sbin/makefs/ffs/mkfs.c

322

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

usr.sbin/makefs/ffs/mkfs.c

323

sizepb *= FFS_NINDIR(&sblock);

usr.sbin/makefs/ffs/mkfs.c

324

sblock.fs_maxfilesize += sizepb;

usr.sbin/makefs/ffs/mkfs.c

343

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

usr.sbin/makefs/ffs/mkfs.c

344

minfpg = fragsperinode * FFS_INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

345

if (minfpg > sblock.fs_size)

usr.sbin/makefs/ffs/mkfs.c

346

minfpg = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

347

sblock.fs_ipg = FFS_INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

348

sblock.fs_fpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

349

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

usr.sbin/makefs/ffs/mkfs.c

350

if (sblock.fs_fpg < minfpg)

usr.sbin/makefs/ffs/mkfs.c

351

sblock.fs_fpg = minfpg;

usr.sbin/makefs/ffs/mkfs.c

352

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

usr.sbin/makefs/ffs/mkfs.c

353

FFS_INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

354

sblock.fs_fpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

355

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

usr.sbin/makefs/ffs/mkfs.c

356

if (sblock.fs_fpg < minfpg)

usr.sbin/makefs/ffs/mkfs.c

357

sblock.fs_fpg = minfpg;

usr.sbin/makefs/ffs/mkfs.c

358

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

usr.sbin/makefs/ffs/mkfs.c

359

FFS_INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

360

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

usr.sbin/makefs/ffs/mkfs.c

362

density -= sblock.fs_fsize;

usr.sbin/makefs/ffs/mkfs.c

374

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

usr.sbin/makefs/ffs/mkfs.c

375

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

usr.sbin/makefs/ffs/mkfs.c

376

FFS_INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

377

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

usr.sbin/makefs/ffs/mkfs.c

379

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

usr.sbin/makefs/ffs/mkfs.c

381

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

usr.sbin/makefs/ffs/mkfs.c

383

sblock.fs_fpg -= sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

384

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

usr.sbin/makefs/ffs/mkfs.c

385

FFS_INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

394

optimalfpg = sblock.fs_fpg;

usr.sbin/makefs/ffs/mkfs.c

396

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

usr.sbin/makefs/ffs/mkfs.c

397

lastminfpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

398

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

usr.sbin/makefs/ffs/mkfs.c

399

if (sblock.fs_size < lastminfpg) {

usr.sbin/makefs/ffs/mkfs.c

401

(long long)sblock.fs_size, lastminfpg);

usr.sbin/makefs/ffs/mkfs.c

404

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

usr.sbin/makefs/ffs/mkfs.c

405

sblock.fs_size % sblock.fs_fpg == 0)

usr.sbin/makefs/ffs/mkfs.c

407

sblock.fs_fpg -= sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

408

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

usr.sbin/makefs/ffs/mkfs.c

409

FFS_INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

411

if (optimalfpg != sblock.fs_fpg)

usr.sbin/makefs/ffs/mkfs.c

413

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

usr.sbin/makefs/ffs/mkfs.c

414

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

usr.sbin/makefs/ffs/mkfs.c

415

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

usr.sbin/makefs/ffs/mkfs.c

417

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

usr.sbin/makefs/ffs/mkfs.c

418

sblock.fs_old_nsect = sblock.fs_old_spc;

usr.sbin/makefs/ffs/mkfs.c

419

sblock.fs_old_npsect = sblock.fs_old_spc;

usr.sbin/makefs/ffs/mkfs.c

420

sblock.fs_old_ncyl = sblock.fs_ncg;

usr.sbin/makefs/ffs/mkfs.c

426

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

usr.sbin/makefs/ffs/mkfs.c

427

sblock.fs_cssize =

usr.sbin/makefs/ffs/mkfs.c

428

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

usr.sbin/makefs/ffs/mkfs.c

434

size = sblock.fs_cssize;

usr.sbin/makefs/ffs/mkfs.c

435

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

436

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

usr.sbin/makefs/ffs/mkfs.c

438

sblock.fs_csp = space;

usr.sbin/makefs/ffs/mkfs.c

439

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

usr.sbin/makefs/ffs/mkfs.c

440

if (sblock.fs_contigsumsize > 0) {

usr.sbin/makefs/ffs/mkfs.c

443

sblock.fs_maxcluster = lp = space;

usr.sbin/makefs/ffs/mkfs.c

444

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

usr.sbin/makefs/ffs/mkfs.c

445

*lp++ = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

448

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

usr.sbin/makefs/ffs/mkfs.c

449

if (sblock.fs_sbsize > SBLOCKSIZE)

usr.sbin/makefs/ffs/mkfs.c

450

sblock.fs_sbsize = SBLOCKSIZE;

usr.sbin/makefs/ffs/mkfs.c

451

sblock.fs_minfree = minfree;

usr.sbin/makefs/ffs/mkfs.c

452

sblock.fs_maxcontig = maxcontig;

usr.sbin/makefs/ffs/mkfs.c

453

sblock.fs_maxbpg = maxbpg;

usr.sbin/makefs/ffs/mkfs.c

454

sblock.fs_optim = opt;

usr.sbin/makefs/ffs/mkfs.c

455

sblock.fs_cgrotor = 0;

usr.sbin/makefs/ffs/mkfs.c

456

sblock.fs_pendingblocks = 0;

usr.sbin/makefs/ffs/mkfs.c

457

sblock.fs_pendinginodes = 0;

usr.sbin/makefs/ffs/mkfs.c

458

sblock.fs_cstotal.cs_ndir = 0;

usr.sbin/makefs/ffs/mkfs.c

459

sblock.fs_cstotal.cs_nbfree = 0;

usr.sbin/makefs/ffs/mkfs.c

460

sblock.fs_cstotal.cs_nifree = 0;

usr.sbin/makefs/ffs/mkfs.c

461

sblock.fs_cstotal.cs_nffree = 0;

usr.sbin/makefs/ffs/mkfs.c

462

sblock.fs_fmod = 0;

usr.sbin/makefs/ffs/mkfs.c

463

sblock.fs_ronly = 0;

usr.sbin/makefs/ffs/mkfs.c

464

sblock.fs_state = 0;

usr.sbin/makefs/ffs/mkfs.c

465

sblock.fs_clean = FS_ISCLEAN;

usr.sbin/makefs/ffs/mkfs.c

466

sblock.fs_ronly = 0;

usr.sbin/makefs/ffs/mkfs.c

467

sblock.fs_id[0] = tstamp;

usr.sbin/makefs/ffs/mkfs.c

468

sblock.fs_id[1] = random();

usr.sbin/makefs/ffs/mkfs.c

469

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

usr.sbin/makefs/ffs/mkfs.c

470

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

usr.sbin/makefs/ffs/mkfs.c

471

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

usr.sbin/makefs/ffs/mkfs.c

472

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

usr.sbin/makefs/ffs/mkfs.c

473

sblock.fs_cstotal.cs_nbfree =

usr.sbin/makefs/ffs/mkfs.c

474

ffs_fragstoblks(&sblock, sblock.fs_dsize) -

usr.sbin/makefs/ffs/mkfs.c

475

howmany(csfrags, sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

476

sblock.fs_cstotal.cs_nffree =

usr.sbin/makefs/ffs/mkfs.c

477

ffs_fragnum(&sblock, sblock.fs_size) +

usr.sbin/makefs/ffs/mkfs.c

478

(ffs_fragnum(&sblock, csfrags) > 0 ?

usr.sbin/makefs/ffs/mkfs.c

479

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

usr.sbin/makefs/ffs/mkfs.c

480

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

usr.sbin/makefs/ffs/mkfs.c

481

sblock.fs_cstotal.cs_ndir = 0;

usr.sbin/makefs/ffs/mkfs.c

482

sblock.fs_dsize -= csfrags;

usr.sbin/makefs/ffs/mkfs.c

483

sblock.fs_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

485

sblock.fs_old_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

486

sblock.fs_old_dsize = sblock.fs_dsize;

usr.sbin/makefs/ffs/mkfs.c

487

sblock.fs_old_csaddr = sblock.fs_csaddr;

usr.sbin/makefs/ffs/mkfs.c

488

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

usr.sbin/makefs/ffs/mkfs.c

489

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

usr.sbin/makefs/ffs/mkfs.c

490

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

usr.sbin/makefs/ffs/mkfs.c

491

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

usr.sbin/makefs/ffs/mkfs.c

499

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

usr.sbin/makefs/ffs/mkfs.c

500

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

usr.sbin/makefs/ffs/mkfs.c

501

sblock.fs_bsize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

504

sblock.fs_ncg,

usr.sbin/makefs/ffs/mkfs.c

505

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

usr.sbin/makefs/ffs/mkfs.c

506

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

usr.sbin/makefs/ffs/mkfs.c

514

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

usr.sbin/makefs/ffs/mkfs.c

521

if (sblock.fs_bsize < SBLOCKSIZE)

usr.sbin/makefs/ffs/mkfs.c

522

iobufsize = SBLOCKSIZE + 3 * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

524

iobufsize = 4 * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

530

ffs_sb_copy(&wb.fs, &sblock, sbsize, fsopts);

usr.sbin/makefs/ffs/mkfs.c

534

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

usr.sbin/makefs/ffs/mkfs.c

539

(long long)FFS_FSBTODB(&sblock, cgsblock(&sblock, cylno)));

usr.sbin/makefs/ffs/mkfs.c

548

sblock.fs_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

550

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

usr.sbin/makefs/ffs/mkfs.c

551

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

usr.sbin/makefs/ffs/mkfs.c

552

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

usr.sbin/makefs/ffs/mkfs.c

553

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

usr.sbin/makefs/ffs/mkfs.c

556

sblock.fs_flags |= FS_SWAPPED;

usr.sbin/makefs/ffs/mkfs.c

557

ffs_write_superblock(&sblock, fsopts);

usr.sbin/makefs/ffs/mkfs.c

558

return (&sblock);

usr.sbin/makefs/ffs/mkfs.c

576

ffs_sb_copy(&wb.fs, &sblock, sbsize, fsopts);

usr.sbin/makefs/ffs/mkfs.c

622

cbase = cgbase(&sblock, cylno);

usr.sbin/makefs/ffs/mkfs.c

623

dmax = cbase + sblock.fs_fpg;

usr.sbin/makefs/ffs/mkfs.c

624

if (dmax > sblock.fs_size)

usr.sbin/makefs/ffs/mkfs.c

625

dmax = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

626

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

usr.sbin/makefs/ffs/mkfs.c

627

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

usr.sbin/makefs/ffs/mkfs.c

629

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

usr.sbin/makefs/ffs/mkfs.c

630

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

usr.sbin/makefs/ffs/mkfs.c

634

acg.cg_niblk = sblock.fs_ipg;

usr.sbin/makefs/ffs/mkfs.c

635

acg.cg_initediblk = sblock.fs_ipg < 2 * FFS_INOPB(&sblock) ?

usr.sbin/makefs/ffs/mkfs.c

636

sblock.fs_ipg : 2 * FFS_INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

638

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

639

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

usr.sbin/makefs/ffs/mkfs.c

644

acg.cg_old_ncyl = sblock.fs_old_cpg;

usr.sbin/makefs/ffs/mkfs.c

645

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

usr.sbin/makefs/ffs/mkfs.c

646

if ((sblock.fs_old_flags & FS_FLAGS_UPDATED) == 0) {

usr.sbin/makefs/ffs/mkfs.c

655

sblock.fs_old_ncyl % sblock.fs_old_cpg;

usr.sbin/makefs/ffs/mkfs.c

667

sblock.fs_fpg / sblock.fs_old_cpg);

usr.sbin/makefs/ffs/mkfs.c

677

sblock.fs_old_cpg * sizeof(int32_t);

usr.sbin/makefs/ffs/mkfs.c

679

sblock.fs_old_cpg * sizeof(u_int16_t);

usr.sbin/makefs/ffs/mkfs.c

681

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

usr.sbin/makefs/ffs/mkfs.c

682

if (sblock.fs_contigsumsize <= 0) {

usr.sbin/makefs/ffs/mkfs.c

684

howmany(sblock.fs_fpg, CHAR_BIT);

usr.sbin/makefs/ffs/mkfs.c

687

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

usr.sbin/makefs/ffs/mkfs.c

691

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

usr.sbin/makefs/ffs/mkfs.c

693

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

usr.sbin/makefs/ffs/mkfs.c

695

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

usr.sbin/makefs/ffs/mkfs.c

699

acg.cg_cs.cs_nifree += sblock.fs_ipg;

usr.sbin/makefs/ffs/mkfs.c

714

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

usr.sbin/makefs/ffs/mkfs.c

715

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

719

int cn = old_cbtocylno(&sblock, d);

usr.sbin/makefs/ffs/mkfs.c

721

old_cg_blks(&sblock, &acg,

usr.sbin/makefs/ffs/mkfs.c

722

cn, 0)[old_cbtorpos(&sblock, d)]++;

usr.sbin/makefs/ffs/mkfs.c

724

d += sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

728

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

usr.sbin/makefs/ffs/mkfs.c

729

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

usr.sbin/makefs/ffs/mkfs.c

730

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

usr.sbin/makefs/ffs/mkfs.c

735

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

usr.sbin/makefs/ffs/mkfs.c

736

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

usr.sbin/makefs/ffs/mkfs.c

737

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

usr.sbin/makefs/ffs/mkfs.c

738

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

742

int cn = old_cbtocylno(&sblock, d);

usr.sbin/makefs/ffs/mkfs.c

744

old_cg_blks(&sblock, &acg,

usr.sbin/makefs/ffs/mkfs.c

745

cn, 0)[old_cbtorpos(&sblock, d)]++;

usr.sbin/makefs/ffs/mkfs.c

747

d += sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

757

if (sblock.fs_contigsumsize > 0) {

usr.sbin/makefs/ffs/mkfs.c

768

if (run > sblock.fs_contigsumsize)

usr.sbin/makefs/ffs/mkfs.c

769

run = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

781

if (run > sblock.fs_contigsumsize)

usr.sbin/makefs/ffs/mkfs.c

782

run = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

786

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

usr.sbin/makefs/ffs/mkfs.c

791

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

usr.sbin/makefs/ffs/mkfs.c

792

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

usr.sbin/makefs/ffs/mkfs.c

794

ffs_cg_swap(&acg, (struct cg*)&iobuf[start], &sblock);

usr.sbin/makefs/ffs/mkfs.c

795

start += sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

799

if (sblock.fs_magic == FS_UFS1_MAGIC) {

usr.sbin/makefs/ffs/mkfs.c

808

ffs_wtfs(FFS_FSBTODB(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf,

usr.sbin/makefs/ffs/mkfs.c

814

for (i = 2 * sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

815

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

usr.sbin/makefs/ffs/mkfs.c

816

i += sblock.fs_frag) {

usr.sbin/makefs/ffs/mkfs.c

818

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

usr.sbin/makefs/ffs/mkfs.c

822

ffs_wtfs(FFS_FSBTODB(&sblock, cgimin(&sblock, cylno) + i),

usr.sbin/makefs/ffs/mkfs.c

823

sblock.fs_bsize, &iobuf[start], fsopts);

usr.sbin/quotacheck/quotacheck.c

368

bread(sblock_try[i], (char *)&sblock, SBLOCKSIZE);

usr.sbin/quotacheck/quotacheck.c

369

switch (sblock.fs_magic) {

usr.sbin/quotacheck/quotacheck.c

372

sblock.fs_magic = FS_UFS2_MAGIC;

usr.sbin/quotacheck/quotacheck.c

382

sblock.fs_magic = FS_UFS2_MAGIC_SWAPPED;

usr.sbin/quotacheck/quotacheck.c

390

ffs_sb_swap(&sblock, &sblock);

usr.sbin/quotacheck/quotacheck.c

397

if (is_ufs2 || sblock.fs_old_flags & FS_FLAGS_UPDATED) {

usr.sbin/quotacheck/quotacheck.c

398

if (sblock.fs_sblockloc != sblock_try[i])

usr.sbin/quotacheck/quotacheck.c

408

cgp = malloc(sblock.fs_cgsize);

usr.sbin/quotacheck/quotacheck.c

411

sblock.fs_cgsize);

usr.sbin/quotacheck/quotacheck.c

417

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

usr.sbin/quotacheck/quotacheck.c

418

maxino = sblock.fs_ncg * sblock.fs_ipg;

usr.sbin/quotacheck/quotacheck.c

419

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

usr.sbin/quotacheck/quotacheck.c

420

ino = cg * sblock.fs_ipg;

usr.sbin/quotacheck/quotacheck.c

423

if (sblock.fs_magic == FS_UFS2_MAGIC) {

usr.sbin/quotacheck/quotacheck.c

424

bread(FFS_FSBTODB(&sblock, cgtod(&sblock, cg)), (char *)cgp,

usr.sbin/quotacheck/quotacheck.c

425

sblock.fs_cgsize);

usr.sbin/quotacheck/quotacheck.c

427

ffs_cg_swap(cgp, cgp, &sblock);

usr.sbin/quotacheck/quotacheck.c

431

inosused = sblock.fs_ipg;

usr.sbin/quotacheck/quotacheck.c

436

fsname, cg, sblock.fs_ncg,

usr.sbin/quotacheck/quotacheck.c

437

cg * 100 / sblock.fs_ncg);

usr.sbin/quotacheck/quotacheck.c

750

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

usr.sbin/quotacheck/quotacheck.c

779

if (inum % sblock.fs_ipg != 0)

usr.sbin/quotacheck/quotacheck.c

783

lastvalidinum = inum + sblock.fs_ipg - 1;

usr.sbin/quotacheck/quotacheck.c

789

inobufsize = ffs_blkroundup(&sblock, INOBUFSIZE);

usr.sbin/quotacheck/quotacheck.c

791

readpercg = sblock.fs_ipg / fullcnt;

usr.sbin/quotacheck/quotacheck.c

792

partialcnt = sblock.fs_ipg % fullcnt;