crypto/libressl/crypto/gost/gost89_params.c

167

const gost_subst_block *sblock;

crypto/libressl/crypto/gost/gost89_params.c

193

b = gost_cipher_list[i].sblock;

sbin/badsect/badsect.c

121

fs = &sblock;

sbin/badsect/badsect.c

178

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

sbin/badsect/badsect.c

61

struct fs sblock, *fs;

sbin/clri/clri.c

67

char *fs, sblock[SBSIZE];

sbin/clri/clri.c

79

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

sbin/clri/clri.c

82

sbp = (struct fs *)sblock;

sbin/dump/cache.c

117

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

sbin/dump/cache.c

81

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

sbin/dump/dump.h

90

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

sbin/dump/main.c

344

sblock = (struct fs *)sblock_buf;

sbin/dump/main.c

345

bread(SBOFF, (char *) sblock, SBSIZE);

sbin/dump/main.c

346

if (sblock->fs_magic != FS_MAGIC)

sbin/dump/main.c

348

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

sbin/dump/main.c

356

if (sblock->fs_inodefmt >= FS_44INODEFMT)

sbin/dump/main.c

359

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

sbin/dump/main.c

89

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

sbin/dump/tape.c

176

dblkno = fsbtodb(sblock, blkno);

sbin/dump/traverse.c

210

(long)dblksize(sblock, &di, i),

sbin/dump/traverse.c

216

filesize -= sblock->fs_bsize;

sbin/dump/traverse.c

256

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

sbin/dump/traverse.c

258

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

sbin/dump/traverse.c

261

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

sbin/dump/traverse.c

267

*filesize -= sblock->fs_bsize;

sbin/dump/traverse.c

272

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

sbin/dump/traverse.c

296

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

sbin/dump/traverse.c

379

dp->di_size < (unsigned)sblock->fs_maxsymlinklen) {

sbin/dump/traverse.c

408

if (dp->di_size > UFS_NDADDR * (unsigned)sblock->fs_bsize)

sbin/dump/traverse.c

409

cnt = UFS_NDADDR * sblock->fs_frag;

sbin/dump/traverse.c

411

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

sbin/dump/traverse.c

413

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

sbin/dump/traverse.c

432

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

sbin/dump/traverse.c

434

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

sbin/dump/traverse.c

436

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

sbin/dump/traverse.c

437

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

sbin/dump/traverse.c

439

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

sbin/dump/traverse.c

440

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

sbin/dump/traverse.c

445

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

sbin/dump/traverse.c

461

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

sbin/dump/traverse.c

462

tbperdb = sblock->fs_bsize >> tp_bshift;

sbin/dump/traverse.c

479

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

sbin/dump/traverse.c

536

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

sbin/dump/traverse.c

537

(int)sblock->fs_bsize);

sbin/dump/traverse.c

538

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

sbin/dump/traverse.c

539

maxino = minino + INOPB(sblock);

sbin/dump/traverse.c

561

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

sbin/dump/traverse.c

92

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

sbin/dump/traverse.c

95

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

sbin/ffsinfo/ffsinfo.c

270

rdfs((daddr_t)(SBOFF/DEV_BSIZE), (size_t)SBSIZE, &sblock, fsi);

sbin/ffsinfo/ffsinfo.c

271

if (sblock.fs_magic != FS_MAGIC) {

sbin/ffsinfo/ffsinfo.c

278

DBG_DUMP_FS(&sblock,

sbin/ffsinfo/ffsinfo.c

287

cg_stop=sblock.fs_ncg;

sbin/ffsinfo/ffsinfo.c

289

cg_start=sblock.fs_ncg-1;

sbin/ffsinfo/ffsinfo.c

290

cg_stop=sblock.fs_ncg;

sbin/ffsinfo/ffsinfo.c

291

} else if (cfg_cg<sblock.fs_ncg) {

sbin/ffsinfo/ffsinfo.c

295

cg_start=sblock.fs_ncg;

sbin/ffsinfo/ffsinfo.c

296

cg_stop=sblock.fs_ncg;

sbin/ffsinfo/ffsinfo.c

301

(size_t)sblock.fs_cssize);

sbin/ffsinfo/ffsinfo.c

309

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

sbin/ffsinfo/ffsinfo.c

310

rdfs(fsbtodb(&sblock, sblock.fs_csaddr +

sbin/ffsinfo/ffsinfo.c

311

numfrags(&sblock, i)), (size_t)(sblock.fs_cssize-i<

sbin/ffsinfo/ffsinfo.c

312

sblock.fs_bsize ? sblock.fs_cssize - i :

sbin/ffsinfo/ffsinfo.c

313

sblock.fs_bsize), (void *)(((char *)fscs)+i), fsi);

sbin/ffsinfo/ffsinfo.c

320

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

sbin/ffsinfo/ffsinfo.c

323

DBG_DUMP_CSUM(&sblock,

sbin/ffsinfo/ffsinfo.c

338

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

sbin/ffsinfo/ffsinfo.c

346

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

sbin/ffsinfo/ffsinfo.c

347

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

sbin/ffsinfo/ffsinfo.c

349

DBG_DUMP_CG(&sblock,

sbin/ffsinfo/ffsinfo.c

354

DBG_DUMP_INMAP(&sblock,

sbin/ffsinfo/ffsinfo.c

359

DBG_DUMP_FRMAP(&sblock,

sbin/ffsinfo/ffsinfo.c

364

DBG_DUMP_CLMAP(&sblock,

sbin/ffsinfo/ffsinfo.c

367

DBG_DUMP_CLSUM(&sblock,

sbin/ffsinfo/ffsinfo.c

372

DBG_DUMP_SPTBL(&sblock,

sbin/ffsinfo/ffsinfo.c

383

for(in=cg_start*sblock.fs_ipg; in<(ino_t)cg_stop*sblock.fs_ipg;

sbin/ffsinfo/ffsinfo.c

428

DBG_DUMP_INO(&sblock,

sbin/ffsinfo/ffsinfo.c

441

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

sbin/ffsinfo/ffsinfo.c

446

rdfs(fsbtodb(&sblock, ino->di_ib[0]), (size_t)sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

450

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

454

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

sbin/ffsinfo/ffsinfo.c

460

rdfs(fsbtodb(&sblock, ino->di_ib[1]), (size_t)sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

464

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

467

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

sbin/ffsinfo/ffsinfo.c

468

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

sbin/ffsinfo/ffsinfo.c

472

rdfs(fsbtodb(&sblock, *ind2ptr),

sbin/ffsinfo/ffsinfo.c

473

(size_t)sblock.fs_bsize, &i1blk, fsi);

sbin/ffsinfo/ffsinfo.c

477

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

481

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

sbin/ffsinfo/ffsinfo.c

488

rdfs(fsbtodb(&sblock, ino->di_ib[2]), (size_t)sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

493

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

497

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

sbin/ffsinfo/ffsinfo.c

499

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

sbin/ffsinfo/ffsinfo.c

503

rdfs(fsbtodb(&sblock, *ind3ptr),

sbin/ffsinfo/ffsinfo.c

504

(size_t)sblock.fs_bsize, &i2blk, fsi);

sbin/ffsinfo/ffsinfo.c

508

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

512

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

sbin/ffsinfo/ffsinfo.c

513

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

sbin/ffsinfo/ffsinfo.c

517

rdfs(fsbtodb(&sblock, *ind2ptr),

sbin/ffsinfo/ffsinfo.c

518

(size_t)sblock.fs_bsize, &i1blk, fsi);

sbin/ffsinfo/ffsinfo.c

522

DBG_DUMP_IBLK(&sblock,

sbin/ffsinfo/ffsinfo.c

526

rb-=howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

573

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

sbin/ffsinfo/ffsinfo.c

578

iblk = ino_to_fsba(&sblock, inumber);

sbin/ffsinfo/ffsinfo.c

579

rdfs(fsbtodb(&sblock, iblk), (size_t)sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

581

startinum = rounddown(inumber, INOPB(&sblock));

sbin/ffsinfo/ffsinfo.c

585

return (&(pi[inumber % INOPB(&sblock)]));

sbin/fsck/dir.c

112

blksiz = idesc->id_numfrags * sblock.fs_fsize;

sbin/fsck/dir.c

168

blksiz = idesc->id_numfrags * sblock.fs_fsize;

sbin/fsck/dir.c

582

lastbn = lblkno(&sblock, dp->di_size);

sbin/fsck/dir.c

586

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

sbin/fsck/dir.c

590

dp->di_size += sblock.fs_bsize;

sbin/fsck/dir.c

591

dp->di_blocks += btodb(sblock.fs_bsize);

sbin/fsck/dir.c

593

(long)dblksize(&sblock, dp, lastbn + 1));

sbin/fsck/dir.c

597

bp = getdirblk(newblk, sblock.fs_bsize);

sbin/fsck/dir.c

602

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

sbin/fsck/dir.c

607

(long)dblksize(&sblock, dp, lastbn + 1));

sbin/fsck/dir.c

622

dp->di_size -= sblock.fs_bsize;

sbin/fsck/dir.c

623

dp->di_blocks -= btodb(sblock.fs_bsize);

sbin/fsck/dir.c

624

freeblk(newblk, sblock.fs_frag);

sbin/fsck/dir.c

648

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

sbin/fsck/dir.c

655

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

sbin/fsck/inode.c

111

idesc->id_numfrags = sblock.fs_frag;

sbin/fsck/inode.c

112

remsize = dino.di_size - sblock.fs_bsize * UFS_NDADDR;

sbin/fsck/inode.c

113

sizepb = sblock.fs_bsize;

sbin/fsck/inode.c

139

sizepb *= NINDIR(&sblock);

sbin/fsck/inode.c

165

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

sbin/fsck/inode.c

167

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

sbin/fsck/inode.c

168

sizepb *= NINDIR(&sblock);

sbin/fsck/inode.c

170

if (nif > NINDIR(&sblock))

sbin/fsck/inode.c

171

nif = NINDIR(&sblock);

sbin/fsck/inode.c

172

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

sbin/fsck/inode.c

173

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

sbin/fsck/inode.c

236

if (cnt > sblock.fs_frag ||

sbin/fsck/inode.c

237

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

sbin/fsck/inode.c

240

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

sbin/fsck/inode.c

243

c = dtog(&sblock, blk);

sbin/fsck/inode.c

244

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

sbin/fsck/inode.c

245

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

sbin/fsck/inode.c

248

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

sbin/fsck/inode.c

251

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

sbin/fsck/inode.c

256

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

sbin/fsck/inode.c

259

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

sbin/fsck/inode.c

261

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

sbin/fsck/inode.c

280

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

sbin/fsck/inode.c

281

iblk = ino_to_fsba(&sblock, inumber);

sbin/fsck/inode.c

284

pbp = getdatablk(iblk, sblock.fs_bsize);

sbin/fsck/inode.c

285

startinum = rounddown(inumber, INOPB(&sblock));

sbin/fsck/inode.c

287

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

sbin/fsck/inode.c

309

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

sbin/fsck/inode.c

331

if (inum % sblock.fs_ipg != 0)

sbin/fsck/inode.c

339

inobufsize = blkroundup(&sblock, INOBUFSIZE);

sbin/fsck/inode.c

341

readpercg = sblock.fs_ipg / fullcnt;

sbin/fsck/inode.c

342

partialcnt = sblock.fs_ipg % fullcnt;

sbin/fsck/inode.c

379

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

sbin/fsck/inode.c

578

cg = ino_to_cg(&sblock, ino);

sbin/fsck/inode.c

579

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

sbin/fsck/inode.c

582

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

sbin/fsck/inode.c

608

dp->di_size = sblock.fs_fsize;

sbin/fsck/inode.c

609

dp->di_blocks = btodb(sblock.fs_fsize);

sbin/fsck/inode.c

73

dp->di_size < (unsigned)sblock.fs_maxsymlinklen))

sbin/fsck/inode.c

76

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

sbin/fsck/inode.c

78

if (--ndb == 0 && (offset = blkoff(&sblock, dino.di_size)) != 0)

sbin/fsck/inode.c

80

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

sbin/fsck/inode.c

82

idesc->id_numfrags = sblock.fs_frag;

sbin/fsck/inode.c

93

sblock.fs_bsize;

sbin/fsck/main.c

207

pwarn("clean, %d free ", sblock.fs_cstotal.cs_nffree +

sbin/fsck/main.c

208

sblock.fs_frag * sblock.fs_cstotal.cs_nbfree);

sbin/fsck/main.c

210

sblock.fs_cstotal.cs_nffree, sblock.fs_cstotal.cs_nbfree,

sbin/fsck/main.c

211

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

sbin/fsck/main.c

231

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

sbin/fsck/main.c

235

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

sbin/fsck/main.c

283

n_ffree = sblock.fs_cstotal.cs_nffree;

sbin/fsck/main.c

284

n_bfree = sblock.fs_cstotal.cs_nbfree;

sbin/fsck/main.c

286

n_files, n_blks, n_ffree + sblock.fs_frag * n_bfree);

sbin/fsck/main.c

288

n_ffree, n_bfree, n_ffree * 100.0 / sblock.fs_dsize);

sbin/fsck/main.c

290

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

sbin/fsck/main.c

293

n_blks += sblock.fs_ncg *

sbin/fsck/main.c

294

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

sbin/fsck/main.c

295

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

sbin/fsck/main.c

296

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

sbin/fsck/main.c

297

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

sbin/fsck/main.c

317

sblock.fs_time = time(NULL);

sbin/fsck/main.c

324

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

sbin/fsck/main.c

325

bwrite(fswritefd, (char *)&sblock,

sbin/fsck/main.c

326

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

sbin/fsck/main.c

338

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

sbin/fsck/pass1.c

106

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

sbin/fsck/pass1.c

109

cp = &cg_inosused(&cgrp)[(sblock.fs_ipg - 1) / NBBY];

sbin/fsck/pass1.c

147

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

sbin/fsck/pass1.c

155

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

sbin/fsck/pass1.c

205

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

sbin/fsck/pass1.c

209

dp->di_size > sblock.fs_maxfilesize ||

sbin/fsck/pass1.c

217

dp->di_size = sblock.fs_fsize;

sbin/fsck/pass1.c

227

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

sbin/fsck/pass1.c

242

fsbtodb(&sblock, dp->di_db[0]),

sbin/fsck/pass1.c

259

if (dp->di_size < sblock.fs_maxsymlinklen) {

sbin/fsck/pass1.c

264

ndb *= NINDIR(&sblock);

sbin/fsck/pass1.c

277

ndb /= NINDIR(&sblock);

sbin/fsck/pass1.c

325

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

sbin/fsck/pass1.c

68

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

sbin/fsck/pass1.c

69

cgd = cgdmin(&sblock, c);

sbin/fsck/pass1.c

71

i = cgbase(&sblock, c);

sbin/fsck/pass1.c

73

i = cgsblock(&sblock, c);

sbin/fsck/pass1.c

77

i = sblock.fs_csaddr;

sbin/fsck/pass1.c

78

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

sbin/fsck/pass1.c

88

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

sbin/fsck/pass1.c

89

inumber = c * sblock.fs_ipg;

sbin/fsck/pass1.c

91

inosused = sblock.fs_ipg;

sbin/fsck/pass1.c

94

cdevname, c, sblock.fs_ncg,

sbin/fsck/pass1.c

95

c * 100 / sblock.fs_ncg);

sbin/fsck/pass1b.c

58

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

sbin/fsck/pass1b.c

61

cdevname, c, sblock.fs_ncg,

sbin/fsck/pass1b.c

62

c * 100 / sblock.fs_ncg);

sbin/fsck/pass1b.c

65

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

sbin/fsck/pass4.c

58

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

sbin/fsck/pass4.c

61

cdevname, cg, sblock.fs_ncg,

sbin/fsck/pass4.c

62

cg * 100 / sblock.fs_ncg);

sbin/fsck/pass4.c

65

inumber = cg * sblock.fs_ipg;

sbin/fsck/pass5.c

165

cdevname, c, sblock.fs_ncg,

sbin/fsck/pass5.c

166

c * 100 / sblock.fs_ncg);

sbin/fsck/pass5.c

48

struct fs *fs = &sblock;

sbin/fsck/setup.c

158

if (skipclean && sblock.fs_clean) {

sbin/fsck/setup.c

162

maxfsblock = sblock.fs_size;

sbin/fsck/setup.c

163

maxino = sblock.fs_ncg * sblock.fs_ipg;

sbin/fsck/setup.c

167

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

sbin/fsck/setup.c

170

sblock.fs_optim = FS_OPTTIME;

sbin/fsck/setup.c

174

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

sbin/fsck/setup.c

176

sblock.fs_minfree);

sbin/fsck/setup.c

178

sblock.fs_minfree = 10;

sbin/fsck/setup.c

182

if (sblock.fs_interleave < 1 ||

sbin/fsck/setup.c

183

sblock.fs_interleave > sblock.fs_nsect) {

sbin/fsck/setup.c

185

sblock.fs_interleave);

sbin/fsck/setup.c

186

sblock.fs_interleave = 1;

sbin/fsck/setup.c

194

if (sblock.fs_npsect < sblock.fs_nsect ||

sbin/fsck/setup.c

195

sblock.fs_npsect > sblock.fs_nsect*2) {

sbin/fsck/setup.c

197

sblock.fs_npsect);

sbin/fsck/setup.c

198

sblock.fs_npsect = sblock.fs_nsect;

sbin/fsck/setup.c

206

if (sblock.fs_inodefmt >= FS_44INODEFMT) {

sbin/fsck/setup.c

209

sblock.fs_qbmask = ~sblock.fs_bmask;

sbin/fsck/setup.c

210

sblock.fs_qfmask = ~sblock.fs_fmask;

sbin/fsck/setup.c

212

sblock.fs_maxfilesize = (u_int64_t)1 << 39;

sbin/fsck/setup.c

218

if (cvtlevel >= 2 && sblock.fs_inodefmt < FS_44INODEFMT) {

sbin/fsck/setup.c

224

sblock.fs_inodefmt = FS_44INODEFMT;

sbin/fsck/setup.c

225

sizepb = sblock.fs_bsize;

sbin/fsck/setup.c

226

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

sbin/fsck/setup.c

228

sizepb *= NINDIR(&sblock);

sbin/fsck/setup.c

229

sblock.fs_maxfilesize += sizepb;

sbin/fsck/setup.c

231

sblock.fs_maxsymlinklen = UFS1_MAXSYMLINKLEN;

sbin/fsck/setup.c

232

sblock.fs_qbmask = ~sblock.fs_bmask;

sbin/fsck/setup.c

233

sblock.fs_qfmask = ~sblock.fs_fmask;

sbin/fsck/setup.c

240

if (cvtlevel >= 1 && sblock.fs_postblformat == FS_42POSTBLFMT) {

sbin/fsck/setup.c

246

sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;

sbin/fsck/setup.c

247

sblock.fs_nrpos = 8;

sbin/fsck/setup.c

248

sblock.fs_postbloff =

sbin/fsck/setup.c

249

(char *)(&sblock.fs_opostbl[0][0]) -

sbin/fsck/setup.c

250

(char *)(&sblock.fs_firstfield);

sbin/fsck/setup.c

251

sblock.fs_rotbloff = &sblock.fs_space[0] -

sbin/fsck/setup.c

252

(u_char *)(&sblock.fs_firstfield);

sbin/fsck/setup.c

253

sblock.fs_cgsize =

sbin/fsck/setup.c

254

fragroundup(&sblock, CGSIZE(&sblock));

sbin/fsck/setup.c

259

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

sbin/fsck/setup.c

266

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

sbin/fsck/setup.c

267

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

sbin/fsck/setup.c

268

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

sbin/fsck/setup.c

269

sblock.fs_cssize - i : sblock.fs_bsize;

sbin/fsck/setup.c

270

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

sbin/fsck/setup.c

271

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

sbin/fsck/setup.c

291

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

sbin/fsck/setup.c

295

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

sbin/fsck/setup.c

298

numdirs = sblock.fs_cstotal.cs_ndir;

sbin/fsck/setup.c

324

if (sblock.fs_flags & FS_DOSOFTDEP)

sbin/fsck/setup.c

343

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

sbin/fsck/setup.c

350

if (sblock.fs_magic != FS_MAGIC)

sbin/fsck/setup.c

352

if (sblock.fs_ncg < 1)

sbin/fsck/setup.c

354

if (sblock.fs_cpg < 1)

sbin/fsck/setup.c

356

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

sbin/fsck/setup.c

357

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

sbin/fsck/setup.c

359

if (sblock.fs_sbsize > SBSIZE)

sbin/fsck/setup.c

367

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

sbin/fsck/setup.c

377

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

sbin/fsck/setup.c

380

if (altsblock.fs_sblkno != sblock.fs_sblkno ||

sbin/fsck/setup.c

381

altsblock.fs_cblkno != sblock.fs_cblkno ||

sbin/fsck/setup.c

382

altsblock.fs_iblkno != sblock.fs_iblkno ||

sbin/fsck/setup.c

383

altsblock.fs_dblkno != sblock.fs_dblkno ||

sbin/fsck/setup.c

384

altsblock.fs_cgoffset != sblock.fs_cgoffset ||

sbin/fsck/setup.c

385

altsblock.fs_cgmask != sblock.fs_cgmask ||

sbin/fsck/setup.c

386

altsblock.fs_ncg != sblock.fs_ncg ||

sbin/fsck/setup.c

387

altsblock.fs_bsize != sblock.fs_bsize ||

sbin/fsck/setup.c

388

altsblock.fs_fsize != sblock.fs_fsize ||

sbin/fsck/setup.c

389

altsblock.fs_frag != sblock.fs_frag ||

sbin/fsck/setup.c

390

altsblock.fs_bmask != sblock.fs_bmask ||

sbin/fsck/setup.c

391

altsblock.fs_fmask != sblock.fs_fmask ||

sbin/fsck/setup.c

392

altsblock.fs_bshift != sblock.fs_bshift ||

sbin/fsck/setup.c

393

altsblock.fs_fshift != sblock.fs_fshift ||

sbin/fsck/setup.c

394

altsblock.fs_fragshift != sblock.fs_fragshift ||

sbin/fsck/setup.c

395

altsblock.fs_fsbtodb != sblock.fs_fsbtodb ||

sbin/fsck/setup.c

396

altsblock.fs_sbsize != sblock.fs_sbsize ||

sbin/fsck/setup.c

397

altsblock.fs_nindir != sblock.fs_nindir ||

sbin/fsck/setup.c

398

altsblock.fs_inopb != sblock.fs_inopb ||

sbin/fsck/setup.c

399

altsblock.fs_cssize != sblock.fs_cssize ||

sbin/fsck/setup.c

400

altsblock.fs_cpg != sblock.fs_cpg ||

sbin/fsck/setup.c

401

altsblock.fs_ipg != sblock.fs_ipg ||

sbin/fsck/setup.c

402

altsblock.fs_fpg != sblock.fs_fpg ||

sbin/fsck/setup.c

403

altsblock.fs_magic != sblock.fs_magic) {

sbin/fsck/utilities.c

126

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

sbin/fsck/utilities.c

127

iloff = inum % sblock.fs_ipg;

sbin/fsck/utilities.c

144

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

sbin/fsck/utilities.c

150

bufcnt = MAXBUFSPACE / sblock.fs_bsize;

sbin/fsck/utilities.c

155

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

sbin/fsck/utilities.c

180

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

sbin/fsck/utilities.c

206

dblk = fsbtodb(&sblock, blk);

sbin/fsck/utilities.c

232

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

sbin/fsck/utilities.c

233

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

sbin/fsck/utilities.c

234

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

sbin/fsck/utilities.c

235

sblock.fs_cssize - i < sblock.fs_bsize ?

sbin/fsck/utilities.c

236

sblock.fs_cssize - i : sblock.fs_bsize);

sbin/fsck/utilities.c

280

if (sblock.fs_clean != markclean) {

sbin/fsck/utilities.c

281

sblock.fs_clean = markclean;

sbin/fsck/utilities.c

380

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

sbin/fsck/utilities.c

382

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

sbin/fsck/utilities.c

383

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

sbin/fsck/utilities.c

393

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

sbin/fsck/utilities.c

394

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

sbin/fsck/utilities.c

397

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

sbin/fsck/utilities.c

403

if (frags == sblock.fs_frag)

sbin/fsdb/fsdb.c

100

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

sbin/fsdb/fsdb.c

103

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

sbin/fsdb/fsdbutil.c

193

getblk(bp, blk, sblock.fs_bsize);

sbin/fsdb/fsdbutil.c

195

bp = getdatablk(blk, sblock.fs_bsize);

sbin/fsdb/fsdbutil.c

198

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

sbin/fsdb/fsdbutil.c

241

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

sbin/fsdb/fsdbutil.c

250

if (--ndb == 0 && (offset = blkoff(&sblock, dp->di_size)) != 0) {

sbin/fsdb/fsdbutil.c

251

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

sbin/fsdb/fsdbutil.c

259

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

sbin/fsirand/fsirand.c

107

struct fs *sblock;

sbin/fsirand/fsirand.c

134

sblock = (struct fs *)&sbuf;

sbin/fsirand/fsirand.c

140

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

sbin/fsirand/fsirand.c

147

if (sblock->fs_magic != FS_MAGIC) {

sbin/fsirand/fsirand.c

151

if (sblock->fs_sbsize > SBSIZE) {

sbin/fsirand/fsirand.c

155

if (sblock->fs_postblformat == FS_42POSTBLFMT) {

sbin/fsirand/fsirand.c

159

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

sbin/fsirand/fsirand.c

165

sblock = (struct fs *)&sbuftmp;

sbin/fsirand/fsirand.c

166

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

sbin/fsirand/fsirand.c

167

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

sbin/fsirand/fsirand.c

171

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

sbin/fsirand/fsirand.c

177

if (sblock->fs_magic != FS_MAGIC) {

sbin/fsirand/fsirand.c

182

if (sblock->fs_sbsize > SBSIZE) {

sbin/fsirand/fsirand.c

188

sblock = (struct fs *)&sbuf;

sbin/fsirand/fsirand.c

191

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

sbin/fsirand/fsirand.c

198

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

sbin/fsirand/fsirand.c

199

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

sbin/fsirand/fsirand.c

201

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

sbin/fsirand/fsirand.c

202

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

sbin/fsirand/fsirand.c

203

sblock->fs_id[1]);

sbin/fsirand/fsirand.c

207

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

sbin/fsirand/fsirand.c

209

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

sbin/fsirand/fsirand.c

210

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

sbin/fsirand/fsirand.c

217

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

sbin/fsirand/fsirand.c

225

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

sbin/fsirand/fsirand.c

227

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

sbin/fsirand/fsirand.c

228

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

sbin/fsirand/fsirand.c

233

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

sbin/fsirand/fsirand.c

242

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

sbin/fsirand/fsirand.c

252

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

sbin/growfs/growfs.c

1013

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

sbin/growfs/growfs.c

1019

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

sbin/growfs/growfs.c

1020

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

sbin/growfs/growfs.c

1023

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

sbin/growfs/growfs.c

1025

sblock.fs_cstotal.cs_nffree++;

sbin/growfs/growfs.c

1032

frag_adjust(d%sblock.fs_fpg, 1);

sbin/growfs/growfs.c

1034

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

sbin/growfs/growfs.c

1035

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

sbin/growfs/growfs.c

1038

acg.cg_cs.cs_nffree-=sblock.fs_frag;

sbin/growfs/growfs.c

1040

sblock.fs_cstotal.cs_nffree-=sblock.fs_frag;

sbin/growfs/growfs.c

1041

sblock.fs_cstotal.cs_nbfree++;

sbin/growfs/growfs.c

1042

cg_blktot(&acg)[cbtocylno(&sblock,

sbin/growfs/growfs.c

1043

d%sblock.fs_fpg)]++;

sbin/growfs/growfs.c

1044

cg_blks(&sblock, &acg, cbtocylno(&sblock,

sbin/growfs/growfs.c

1045

d%sblock.fs_fpg))[cbtorpos(&sblock,

sbin/growfs/growfs.c

1046

d%sblock.fs_fpg)]++;

sbin/growfs/growfs.c

1047

if(sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1049

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

sbin/growfs/growfs.c

1050

if(lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

1069

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

sbin/growfs/growfs.c

1070

d-=sblock.fs_frag) {

sbin/growfs/growfs.c

1074

setblock(&sblock, cg_blksfree(&acg),

sbin/growfs/growfs.c

1075

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

sbin/growfs/growfs.c

1077

sblock.fs_cstotal.cs_nbfree++;

sbin/growfs/growfs.c

1078

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

sbin/growfs/growfs.c

1079

cg_blks(&sblock, &acg, cbtocylno(&sblock,

sbin/growfs/growfs.c

1080

d%sblock.fs_fpg))[cbtorpos(&sblock,

sbin/growfs/growfs.c

1081

d%sblock.fs_fpg)]++;

sbin/growfs/growfs.c

1082

if(sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1084

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

sbin/growfs/growfs.c

1088

if(lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

1103

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

sbin/growfs/growfs.c

1104

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

sbin/growfs/growfs.c

1106

DBG_DUMP_CG(&sblock,

sbin/growfs/growfs.c

1114

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

sbin/growfs/growfs.c

1115

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

sbin/growfs/growfs.c

1134

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

sbin/growfs/growfs.c

1135

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

sbin/growfs/growfs.c

1137

DBG_DUMP_CG(&sblock,

sbin/growfs/growfs.c

1147

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

sbin/growfs/growfs.c

1148

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

sbin/growfs/growfs.c

1149

d+=sblock.fs_frag) {

sbin/growfs/growfs.c

1150

clrblock(&sblock, cg_blksfree(&acg),

sbin/growfs/growfs.c

1151

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

sbin/growfs/growfs.c

1153

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1154

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

sbin/growfs/growfs.c

1155

cg_blks(&sblock, &acg, cbtocylno(&sblock,

sbin/growfs/growfs.c

1156

d%sblock.fs_fpg))[cbtorpos(&sblock,

sbin/growfs/growfs.c

1157

d%sblock.fs_fpg)]--;

sbin/growfs/growfs.c

1158

if(sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1160

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

sbin/growfs/growfs.c

1168

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

sbin/growfs/growfs.c

1169

for(; d-sblock.fs_csaddr<

sbin/growfs/growfs.c

1170

sblock.fs_cssize/sblock.fs_fsize;

sbin/growfs/growfs.c

1172

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

sbin/growfs/growfs.c

1174

sblock.fs_cstotal.cs_nffree--;

sbin/growfs/growfs.c

1177

acg.cg_cs.cs_nffree+=sblock.fs_frag;

sbin/growfs/growfs.c

1178

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1179

sblock.fs_cstotal.cs_nffree+=sblock.fs_frag;

sbin/growfs/growfs.c

1180

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

sbin/growfs/growfs.c

1181

cg_blks(&sblock, &acg, cbtocylno(&sblock,

sbin/growfs/growfs.c

1182

d%sblock.fs_fpg))[cbtorpos(&sblock,

sbin/growfs/growfs.c

1183

d%sblock.fs_fpg)]--;

sbin/growfs/growfs.c

1184

if(sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1186

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

sbin/growfs/growfs.c

1189

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

sbin/growfs/growfs.c

1210

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

sbin/growfs/growfs.c

1211

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

sbin/growfs/growfs.c

1213

DBG_DUMP_CG(&sblock,

sbin/growfs/growfs.c

1228

dupper = sblock.fs_csaddr - cbase +

sbin/growfs/growfs.c

1229

howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/growfs/growfs.c

1233

sblock.fs_dsize -= dupper-odupper;

sbin/growfs/growfs.c

1238

bp=(struct gfs_bpp *)malloc(((dupper-odupper)/sblock.fs_frag+2)*

sbin/growfs/growfs.c

1243

memset((char *)bp, 0, ((dupper-odupper)/sblock.fs_frag+2)*

sbin/growfs/growfs.c

1256

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

sbin/growfs/growfs.c

1261

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

sbin/growfs/growfs.c

1263

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

sbin/growfs/growfs.c

1271

sblock.fs_cstotal.cs_nffree--;

sbin/growfs/growfs.c

1286

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

sbin/growfs/growfs.c

1289

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

sbin/growfs/growfs.c

1290

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

sbin/growfs/growfs.c

1293

sblock.fs_cstotal.cs_nffree--;

sbin/growfs/growfs.c

1296

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

sbin/growfs/growfs.c

1297

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

sbin/growfs/growfs.c

1300

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

sbin/growfs/growfs.c

1302

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1303

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

sbin/growfs/growfs.c

1304

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

sbin/growfs/growfs.c

1305

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

sbin/growfs/growfs.c

1306

if(sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1307

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

sbin/growfs/growfs.c

1308

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

sbin/growfs/growfs.c

1309

lcs<sblock.fs_contigsumsize;

sbin/growfs/growfs.c

1315

if(lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

1335

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

sbin/growfs/growfs.c

1337

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1338

acg.cg_cs.cs_nffree+=sblock.fs_frag;

sbin/growfs/growfs.c

1339

sblock.fs_cstotal.cs_nffree+=sblock.fs_frag;

sbin/growfs/growfs.c

1340

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

sbin/growfs/growfs.c

1341

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

sbin/growfs/growfs.c

1342

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

sbin/growfs/growfs.c

1343

if(sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1344

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

sbin/growfs/growfs.c

1345

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

sbin/growfs/growfs.c

1346

lcs<sblock.fs_contigsumsize;

sbin/growfs/growfs.c

1352

if(lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

1365

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

sbin/growfs/growfs.c

1370

sblock.fs_cstotal.cs_nffree--;

sbin/growfs/growfs.c

1396

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

sbin/growfs/growfs.c

1402

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

sbin/growfs/growfs.c

1403

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

sbin/growfs/growfs.c

1404

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

sbin/growfs/growfs.c

1409

sblock.fs_cstotal.cs_nffree++;

sbin/growfs/growfs.c

1422

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

sbin/growfs/growfs.c

1423

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

sbin/growfs/growfs.c

1428

sblock.fs_cstotal.cs_nffree++;

sbin/growfs/growfs.c

1431

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

sbin/growfs/growfs.c

1441

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

sbin/growfs/growfs.c

1442

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

sbin/growfs/growfs.c

1444

f<roundup(dupper, sblock.fs_frag);

sbin/growfs/growfs.c

1449

sblock.fs_cstotal.cs_nffree++;

sbin/growfs/growfs.c

1452

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

sbin/growfs/growfs.c

1458

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

sbin/growfs/growfs.c

1459

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

sbin/growfs/growfs.c

1468

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

sbin/growfs/growfs.c

1469

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

sbin/growfs/growfs.c

1470

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

sbin/growfs/growfs.c

1471

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

sbin/growfs/growfs.c

1472

DBG_DUMP_HEX(&sblock,

sbin/growfs/growfs.c

1500

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

sbin/growfs/growfs.c

1523

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

sbin/growfs/growfs.c

1526

DBG_DUMP_CG(&sblock,

sbin/growfs/growfs.c

1618

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

sbin/growfs/growfs.c

1619

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

sbin/growfs/growfs.c

1620

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

sbin/growfs/growfs.c

1621

if (dmax > sblock.fs_size) {

sbin/growfs/growfs.c

1622

dmax = sblock.fs_size;

sbin/growfs/growfs.c

1624

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

sbin/growfs/growfs.c

1625

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

sbin/growfs/growfs.c

1626

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

sbin/growfs/growfs.c

1635

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

sbin/growfs/growfs.c

1639

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

sbin/growfs/growfs.c

1641

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

sbin/growfs/growfs.c

1645

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

sbin/growfs/growfs.c

1649

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

sbin/growfs/growfs.c

1651

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

sbin/growfs/growfs.c

1664

d=blkstofrags(&sblock, blkno);

sbin/growfs/growfs.c

1666

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

sbin/growfs/growfs.c

1667

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

1679

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

sbin/growfs/growfs.c

1689

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

sbin/growfs/growfs.c

1699

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

sbin/growfs/growfs.c

1711

sblock.fs_cstotal.cs_nbfree--;

sbin/growfs/growfs.c

1712

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

sbin/growfs/growfs.c

1713

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

sbin/growfs/growfs.c

175

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

sbin/growfs/growfs.c

1839

inumber+=(cg * sblock.fs_ipg);

sbin/growfs/growfs.c

1841

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

sbin/growfs/growfs.c

1846

iblk = ino_to_fsba(&sblock, inumber);

sbin/growfs/growfs.c

1847

in_src=fsbtodb(&sblock, iblk);

sbin/growfs/growfs.c

1848

rdfs(in_src, (size_t)sblock.fs_bsize, &ablk, fsi);

sbin/growfs/growfs.c

1849

startinum = rounddown(inumber, INOPB(&sblock));

sbin/growfs/growfs.c

1853

return (&(pi[inumber % INOPB(&sblock)]));

sbin/growfs/growfs.c

2042

DBG_DUMP_FS(&sblock,

sbin/growfs/growfs.c

2049

sblock.fs_size = dbtofsb(&osblock, pinfo.media_blocks);

sbin/growfs/growfs.c

2055

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

sbin/growfs/growfs.c

2061

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

sbin/growfs/growfs.c

2063

sblock.fs_size);

sbin/growfs/growfs.c

2073

if(sblock.fs_snapinum[j]) {

sbin/growfs/growfs.c

2078

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

sbin/growfs/growfs.c

2096

printf("new filesystemsize is: %d frags\n", sblock.fs_size);

sbin/growfs/growfs.c

2103

wtfs((daddr_t)pinfo.media_blocks-1, (size_t)DEV_BSIZE, &sblock, fso,

sbin/growfs/growfs.c

2119

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

sbin/growfs/growfs.c

212

sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl,

sbin/growfs/growfs.c

2120

if (sblock.fs_size * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) {

sbin/growfs/growfs.c

2121

sblock.fs_ncyl++;

sbin/growfs/growfs.c

2127

sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;

sbin/growfs/growfs.c

2128

if (sblock.fs_ncyl % sblock.fs_cpg) {

sbin/growfs/growfs.c

2129

sblock.fs_ncg++;

sbin/growfs/growfs.c

213

"cylinders", sblock.fs_ntrak, sblock.fs_nsect);

sbin/growfs/growfs.c

2132

if ((sblock.fs_size - (sblock.fs_ncg-1) * sblock.fs_fpg) <

sbin/growfs/growfs.c

2133

sblock.fs_fpg && cgdmin(&sblock, (sblock.fs_ncg-1))-

sbin/growfs/growfs.c

2134

cgbase(&sblock, (sblock.fs_ncg-1)) > (sblock.fs_size -

sbin/growfs/growfs.c

2135

(sblock.fs_ncg-1) * sblock.fs_fpg )) {

sbin/growfs/growfs.c

2140

sblock.fs_ncg--;

sbin/growfs/growfs.c

2142

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

sbin/growfs/growfs.c

2144

sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;

sbin/growfs/growfs.c

2146

sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;

sbin/growfs/growfs.c

2148

(sblock.fs_size-(sblock.fs_ncg)*sblock.fs_fpg) *

sbin/growfs/growfs.c

2149

NSPF(&sblock));

sbin/growfs/growfs.c

2150

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

sbin/growfs/growfs.c

2157

sblock.fs_cssize =

sbin/growfs/growfs.c

2158

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

sbin/growfs/growfs.c

216

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

sbin/growfs/growfs.c

2160

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

sbin/growfs/growfs.c

217

sblock.fs_ncg, sblock.fs_cpg,

sbin/growfs/growfs.c

218

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

sbin/growfs/growfs.c

219

sblock.fs_ipg);

sbin/growfs/growfs.c

2207

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

sbin/growfs/growfs.c

2222

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

sbin/growfs/growfs.c

2228

if(lcs < sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

2286

remaining_blocks=howmany(ino->di_size, sblock.fs_bsize);

sbin/growfs/growfs.c

2306

i1_src=fsbtodb(&sblock, ino->di_ib[0]);

sbin/growfs/growfs.c

2307

rdfs(i1_src, (size_t)sblock.fs_bsize, &i1blk, fsi);

sbin/growfs/growfs.c

2308

for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize,

sbin/growfs/growfs.c

2320

remaining_blocks-= howmany(sblock.fs_bsize, sizeof(ufs_daddr_t));

sbin/growfs/growfs.c

233

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

sbin/growfs/growfs.c

2330

i2_src=fsbtodb(&sblock, ino->di_ib[1]);

sbin/growfs/growfs.c

2331

rdfs(i2_src, (size_t)sblock.fs_bsize, &i2blk, fsi);

sbin/growfs/growfs.c

2332

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

sbin/growfs/growfs.c

2340

i1_src=fsbtodb(&sblock, *ind2ptr);

sbin/growfs/growfs.c

2341

rdfs(i1_src, (size_t)sblock.fs_bsize, &i1blk,

sbin/growfs/growfs.c

2344

sblock.fs_bsize, sizeof(ufs_daddr_t)),

sbin/growfs/growfs.c

2357

remaining_blocks-=SQUARE(howmany(sblock.fs_bsize, sizeof(ufs_daddr_t)));

sbin/growfs/growfs.c

236

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

sbin/growfs/growfs.c

2369

i3_src=fsbtodb(&sblock, ino->di_ib[2]);

sbin/growfs/growfs.c

237

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

sbin/growfs/growfs.c

2370

rdfs(i3_src, (size_t)sblock.fs_bsize, &i3blk, fsi);

sbin/growfs/growfs.c

2371

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

sbin/growfs/growfs.c

2379

i2_src=fsbtodb(&sblock, *ind3ptr);

sbin/growfs/growfs.c

2380

rdfs(i2_src, (size_t)sblock.fs_bsize, &i2blk,

sbin/growfs/growfs.c

2382

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

sbin/growfs/growfs.c

2391

i1_src=fsbtodb(&sblock, *ind2ptr);

sbin/growfs/growfs.c

2392

rdfs(i1_src, (size_t)sblock.fs_bsize,

sbin/growfs/growfs.c

2394

for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize,

sbin/growfs/growfs.c

257

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

sbin/growfs/growfs.c

258

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

sbin/growfs/growfs.c

259

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

sbin/growfs/growfs.c

271

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

sbin/growfs/growfs.c

274

DBG_DUMP_CSUM(&sblock,

sbin/growfs/growfs.c

284

sblock.fs_time = utime;

sbin/growfs/growfs.c

285

wtfs((daddr_t)(SBOFF / DEV_BSIZE), (size_t)SBSIZE, &sblock,

sbin/growfs/growfs.c

288

DBG_DUMP_FS(&sblock,

sbin/growfs/growfs.c

294

sblock.fs_fmod = 0;

sbin/growfs/growfs.c

295

sblock.fs_clean = 1;

sbin/growfs/growfs.c

296

sblock.fs_ronly = 0;

sbin/growfs/growfs.c

297

sblock.fs_cgrotor = 0;

sbin/growfs/growfs.c

298

sblock.fs_state = 0;

sbin/growfs/growfs.c

299

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

sbin/growfs/growfs.c

300

sblock.fs_flags &= FS_DOSOFTDEP;

sbin/growfs/growfs.c

326

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

sbin/growfs/growfs.c

327

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

sbin/growfs/growfs.c

328

(size_t)SBSIZE, &sblock, fso, Nflag);

sbin/growfs/growfs.c

331

DBG_DUMP_FS(&sblock,

sbin/growfs/growfs.c

360

cbase = cgbase(&sblock, cylno);

sbin/growfs/growfs.c

361

dmax = cbase + sblock.fs_fpg;

sbin/growfs/growfs.c

362

if (dmax > sblock.fs_size) {

sbin/growfs/growfs.c

363

dmax = sblock.fs_size;

sbin/growfs/growfs.c

365

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

sbin/growfs/growfs.c

366

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

sbin/growfs/growfs.c

368

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

sbin/growfs/growfs.c

371

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

sbin/growfs/growfs.c

375

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

sbin/growfs/growfs.c

376

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

sbin/growfs/growfs.c

378

acg.cg_ncyl = sblock.fs_cpg;

sbin/growfs/growfs.c

380

acg.cg_niblk = sblock.fs_ipg;

sbin/growfs/growfs.c

382

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

383

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

sbin/growfs/growfs.c

386

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

sbin/growfs/growfs.c

388

sblock.fs_cpg * sblock.fs_nrpos * sizeof(u_int16_t);

sbin/growfs/growfs.c

389

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

sbin/growfs/growfs.c

390

if (sblock.fs_contigsumsize <= 0) {

sbin/growfs/growfs.c

392

howmany(sblock.fs_cpg* sblock.fs_spc/ NSPF(&sblock), NBBY);

sbin/growfs/growfs.c

395

(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY) -

sbin/growfs/growfs.c

400

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

sbin/growfs/growfs.c

402

(sblock.fs_cpg * sblock.fs_spc / NSPB(&sblock), NBBY);

sbin/growfs/growfs.c

404

if (acg.cg_nextfreeoff-(intptr_t)(&acg.cg_firstfield) > sblock.fs_cgsize) {

sbin/growfs/growfs.c

411

acg.cg_cs.cs_nifree += sblock.fs_ipg;

sbin/growfs/growfs.c

417

for (i = 0; i < sblock.fs_ipg / INOPF(&sblock); i += sblock.fs_frag) {

sbin/growfs/growfs.c

419

for (j = 0; j < sblock.fs_bsize / sizeof(struct ufs1_dinode); j++) {

sbin/growfs/growfs.c

423

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

sbin/growfs/growfs.c

424

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

sbin/growfs/growfs.c

426

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

sbin/growfs/growfs.c

427

blkno = d / sblock.fs_frag;

sbin/growfs/growfs.c

428

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

sbin/growfs/growfs.c

429

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

433

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

sbin/growfs/growfs.c

434

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

sbin/growfs/growfs.c

435

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

sbin/growfs/growfs.c

437

sblock.fs_dsize += dlower;

sbin/growfs/growfs.c

438

sblock.fs_dsize += acg.cg_ndblk - dupper;

sbin/growfs/growfs.c

439

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

sbin/growfs/growfs.c

440

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

sbin/growfs/growfs.c

441

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

sbin/growfs/growfs.c

446

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

sbin/growfs/growfs.c

447

blkno = d / sblock.fs_frag;

sbin/growfs/growfs.c

448

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

sbin/growfs/growfs.c

449

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

453

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

sbin/growfs/growfs.c

454

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

sbin/growfs/growfs.c

455

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

sbin/growfs/growfs.c

456

d += sblock.fs_frag;

sbin/growfs/growfs.c

465

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

476

if (run > sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

477

run = sblock.fs_contigsumsize;

sbin/growfs/growfs.c

490

if (run > sblock.fs_contigsumsize) {

sbin/growfs/growfs.c

491

run = sblock.fs_contigsumsize;

sbin/growfs/growfs.c

496

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

sbin/growfs/growfs.c

497

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

sbin/growfs/growfs.c

498

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

sbin/growfs/growfs.c

499

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

sbin/growfs/growfs.c

501

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

sbin/growfs/growfs.c

502

(size_t)sblock.fs_bsize, &acg, fso, Nflag);

sbin/growfs/growfs.c

503

DBG_DUMP_CG(&sblock,

sbin/growfs/growfs.c

531

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

sbin/growfs/growfs.c

532

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

sbin/growfs/growfs.c

540

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

sbin/growfs/growfs.c

552

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

sbin/growfs/growfs.c

590

if(*block/sblock.fs_frag == f->old) {

sbin/growfs/growfs.c

594

*block=(f->new*sblock.fs_frag+(*block%sblock.fs_frag));

sbin/growfs/growfs.c

599

*block%sblock.fs_frag);

sbin/growfs/growfs.c

629

wtfs(dst, (size_t)sblock.fs_bsize, src,

sbin/growfs/growfs.c

674

DBG_DUMP_CG(&sblock,

sbin/growfs/growfs.c

689

acg.cg_ncyl=sblock.fs_cpg;

sbin/growfs/growfs.c

691

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

sbin/growfs/growfs.c

692

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

sbin/growfs/growfs.c

694

DBG_DUMP_CG(&sblock,

sbin/growfs/growfs.c

705

cbase = cgbase(&sblock, cylno);

sbin/growfs/growfs.c

706

dmax = cbase + sblock.fs_fpg;

sbin/growfs/growfs.c

707

if (dmax > sblock.fs_size)

sbin/growfs/growfs.c

708

dmax = sblock.fs_size;

sbin/growfs/growfs.c

719

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

sbin/growfs/growfs.c

723

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

sbin/growfs/growfs.c

725

acg.cg_ncyl = sblock.fs_cpg;

sbin/growfs/growfs.c

729

sblock.fs_ncg,

sbin/growfs/growfs.c

731

sblock.fs_cpg);

sbin/growfs/growfs.c

733

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

sbin/growfs/growfs.c

734

if (sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

735

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

sbin/growfs/growfs.c

750

if(osblock.fs_size % sblock.fs_frag) {

sbin/growfs/growfs.c

751

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

sbin/growfs/growfs.c

757

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

sbin/growfs/growfs.c

770

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

sbin/growfs/growfs.c

771

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

sbin/growfs/growfs.c

772

sblock.fs_frag))) {

sbin/growfs/growfs.c

777

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

sbin/growfs/growfs.c

779

acg.cg_cs.cs_nffree-=sblock.fs_frag;

sbin/growfs/growfs.c

781

sblock.fs_frag);

sbin/growfs/growfs.c

782

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

sbin/growfs/growfs.c

783

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

sbin/growfs/growfs.c

784

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

sbin/growfs/growfs.c

785

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

sbin/growfs/growfs.c

794

sblock.fs_frag))) {

sbin/growfs/growfs.c

808

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

sbin/growfs/growfs.c

821

sblock.fs_frag))) {

sbin/growfs/growfs.c

835

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

sbin/growfs/growfs.c

836

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

sbin/growfs/growfs.c

837

i+=sblock.fs_frag) {

sbin/growfs/growfs.c

838

j = i / sblock.fs_frag;

sbin/growfs/growfs.c

839

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

sbin/growfs/growfs.c

842

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

sbin/growfs/growfs.c

843

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

sbin/growfs/growfs.c

844

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

sbin/growfs/growfs.c

860

sblock.fs_cstotal.cs_nffree +=

sbin/growfs/growfs.c

862

sblock.fs_cstotal.cs_nbfree +=

sbin/growfs/growfs.c

876

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

sbin/growfs/growfs.c

879

DBG_DUMP_CG(&sblock,

sbin/growfs/growfs.c

920

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

sbin/growfs/growfs.c

930

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

sbin/growfs/growfs.c

942

DBG_DUMP_CG(&sblock,

sbin/growfs/growfs.c

981

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

sbin/growfs/growfs.c

996

if(sblock.fs_contigsumsize > 0) {

sbin/growfs/growfs.c

997

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

sbin/growfs/growfs.c

998

lcs=0; lcs<sblock.fs_contigsumsize;

sbin/newfs/mkfs.c

1000

wtfs(fsbtodb(&sblock, node.di_db[0]), node.di_size, buf);

sbin/newfs/mkfs.c

1015

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

sbin/newfs/mkfs.c

1016

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

sbin/newfs/mkfs.c

1017

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

sbin/newfs/mkfs.c

1052

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

sbin/newfs/mkfs.c

1062

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

sbin/newfs/mkfs.c

1063

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

sbin/newfs/mkfs.c

1068

blkno = fragstoblks(&sblock, d);

sbin/newfs/mkfs.c

1069

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

sbin/newfs/mkfs.c

1070

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

1073

sblock.fs_cstotal.cs_nbfree--;

sbin/newfs/mkfs.c

1077

sblock.fs_cstotal.cs_ndir++;

sbin/newfs/mkfs.c

1080

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

sbin/newfs/mkfs.c

1081

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

sbin/newfs/mkfs.c

1082

if (size != sblock.fs_bsize) {

sbin/newfs/mkfs.c

1083

frag = howmany(size, sblock.fs_fsize);

sbin/newfs/mkfs.c

1084

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

sbin/newfs/mkfs.c

1085

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

sbin/newfs/mkfs.c

1086

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

sbin/newfs/mkfs.c

1087

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

sbin/newfs/mkfs.c

1088

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

sbin/newfs/mkfs.c

1091

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

sbin/newfs/mkfs.c

1117

usedb = (sblock.fs_iblkno + ipg / INOPF(&sblock))

sbin/newfs/mkfs.c

1118

* NSPF(&sblock) * (off_t)sectorsize;

sbin/newfs/mkfs.c

1121

new_ipg = roundup(new_ipg, INOPB(&sblock));

sbin/newfs/mkfs.c

1142

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

sbin/newfs/mkfs.c

1150

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

sbin/newfs/mkfs.c

1152

sblock.fs_cstotal.cs_nifree--;

sbin/newfs/mkfs.c

1154

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

sbin/newfs/mkfs.c

1159

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

sbin/newfs/mkfs.c

1160

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

sbin/newfs/mkfs.c

1161

inobuf[ino_to_fsbo(&sblock, ino)] = *ip;

sbin/newfs/mkfs.c

1162

wtfs(d, sblock.fs_bsize, (char *)inobuf);

sbin/newfs/mkfs.c

229

sblock.fs_inodefmt = FS_42INODEFMT;

sbin/newfs/mkfs.c

230

sblock.fs_maxsymlinklen = 0;

sbin/newfs/mkfs.c

232

sblock.fs_inodefmt = FS_44INODEFMT;

sbin/newfs/mkfs.c

233

sblock.fs_maxsymlinklen = UFS1_MAXSYMLINKLEN;

sbin/newfs/mkfs.c

236

sblock.fs_flags |= FS_DOSOFTDEP;

sbin/newfs/mkfs.c

238

strlcpy(sblock.fs_volname, volumelabel, MAXVOLLEN);

sbin/newfs/mkfs.c

247

(char *)&sblock);

sbin/newfs/mkfs.c

251

sblock.fs_nsect = nsectors;

sbin/newfs/mkfs.c

252

sblock.fs_ntrak = ntracks;

sbin/newfs/mkfs.c

253

if (sblock.fs_ntrak <= 0)

sbin/newfs/mkfs.c

254

printf("preposterous ntrak %d\n", sblock.fs_ntrak), exit(14);

sbin/newfs/mkfs.c

255

if (sblock.fs_nsect <= 0)

sbin/newfs/mkfs.c

256

printf("preposterous nsect %d\n", sblock.fs_nsect), exit(15);

sbin/newfs/mkfs.c

260

sblock.fs_avgfilesize = avgfilesize;

sbin/newfs/mkfs.c

261

sblock.fs_avgfpdir = avgfilesperdir;

sbin/newfs/mkfs.c

262

if (sblock.fs_avgfilesize <= 0)

sbin/newfs/mkfs.c

264

sblock.fs_avgfilesize), exit(14);

sbin/newfs/mkfs.c

265

if (sblock.fs_avgfpdir <= 0)

sbin/newfs/mkfs.c

267

sblock.fs_avgfpdir), exit(15);

sbin/newfs/mkfs.c

271

sblock.fs_bsize = bsize;

sbin/newfs/mkfs.c

272

sblock.fs_fsize = fsize;

sbin/newfs/mkfs.c

273

if (!powerof2(sblock.fs_bsize)) {

sbin/newfs/mkfs.c

275

sblock.fs_bsize);

sbin/newfs/mkfs.c

278

if (!powerof2(sblock.fs_fsize)) {

sbin/newfs/mkfs.c

280

sblock.fs_fsize);

sbin/newfs/mkfs.c

283

if (sblock.fs_fsize < sectorsize) {

sbin/newfs/mkfs.c

285

sblock.fs_fsize, sectorsize);

sbin/newfs/mkfs.c

288

if (sblock.fs_bsize < MINBSIZE) {

sbin/newfs/mkfs.c

290

sblock.fs_bsize, MINBSIZE);

sbin/newfs/mkfs.c

293

if (sblock.fs_bsize < sblock.fs_fsize) {

sbin/newfs/mkfs.c

295

sblock.fs_bsize, sblock.fs_fsize);

sbin/newfs/mkfs.c

298

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

sbin/newfs/mkfs.c

299

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

sbin/newfs/mkfs.c

300

sblock.fs_qbmask = ~sblock.fs_bmask;

sbin/newfs/mkfs.c

301

sblock.fs_qfmask = ~sblock.fs_fmask;

sbin/newfs/mkfs.c

302

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

sbin/newfs/mkfs.c

303

sblock.fs_bshift++;

sbin/newfs/mkfs.c

304

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

sbin/newfs/mkfs.c

305

sblock.fs_fshift++;

sbin/newfs/mkfs.c

306

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

sbin/newfs/mkfs.c

307

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

sbin/newfs/mkfs.c

308

sblock.fs_fragshift++;

sbin/newfs/mkfs.c

309

if (sblock.fs_frag > MAXFRAG) {

sbin/newfs/mkfs.c

311

sblock.fs_fsize, sblock.fs_bsize,

sbin/newfs/mkfs.c

312

sblock.fs_bsize / MAXFRAG);

sbin/newfs/mkfs.c

315

sblock.fs_nrpos = nrpos;

sbin/newfs/mkfs.c

316

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

sbin/newfs/mkfs.c

317

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

sbin/newfs/mkfs.c

318

sblock.fs_nspf = sblock.fs_fsize / sectorsize;

sbin/newfs/mkfs.c

319

for (sblock.fs_fsbtodb = 0, i = NSPF(&sblock); i > 1; i >>= 1)

sbin/newfs/mkfs.c

320

sblock.fs_fsbtodb++;

sbin/newfs/mkfs.c

321

sblock.fs_sblkno =

sbin/newfs/mkfs.c

322

roundup(howmany(bbsize + sbsize, sblock.fs_fsize), sblock.fs_frag);

sbin/newfs/mkfs.c

323

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

sbin/newfs/mkfs.c

324

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

sbin/newfs/mkfs.c

325

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

sbin/newfs/mkfs.c

326

sblock.fs_cgoffset = roundup(

sbin/newfs/mkfs.c

327

howmany(sblock.fs_nsect, NSPF(&sblock)), sblock.fs_frag);

sbin/newfs/mkfs.c

328

for (sblock.fs_cgmask = 0xffffffff, i = sblock.fs_ntrak; i > 1; i >>= 1)

sbin/newfs/mkfs.c

329

sblock.fs_cgmask <<= 1;

sbin/newfs/mkfs.c

330

if (!powerof2(sblock.fs_ntrak))

sbin/newfs/mkfs.c

331

sblock.fs_cgmask <<= 1;

sbin/newfs/mkfs.c

332

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

sbin/newfs/mkfs.c

333

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

sbin/newfs/mkfs.c

334

sizepb *= NINDIR(&sblock);

sbin/newfs/mkfs.c

335

sblock.fs_maxfilesize += sizepb;

sbin/newfs/mkfs.c

341

sblock.fs_spc = secpercyl;

sbin/newfs/mkfs.c

342

for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc;

sbin/newfs/mkfs.c

343

sblock.fs_cpc > 1 && (i & 1) == 0;

sbin/newfs/mkfs.c

344

sblock.fs_cpc >>= 1, i >>= 1)

sbin/newfs/mkfs.c

346

mincpc = sblock.fs_cpc;

sbin/newfs/mkfs.c

347

bpcg = sblock.fs_spc * sectorsize;

sbin/newfs/mkfs.c

348

inospercg = roundup(bpcg / sizeof(struct ufs1_dinode), INOPB(&sblock));

sbin/newfs/mkfs.c

349

if (inospercg > MAXIPG(&sblock))

sbin/newfs/mkfs.c

350

inospercg = MAXIPG(&sblock);

sbin/newfs/mkfs.c

351

used = (sblock.fs_iblkno + inospercg / INOPF(&sblock)) * NSPF(&sblock);

sbin/newfs/mkfs.c

352

mincpgcnt = howmany(sblock.fs_cgoffset * (~sblock.fs_cgmask) + used,

sbin/newfs/mkfs.c

353

sblock.fs_spc);

sbin/newfs/mkfs.c

359

sblock.fs_cpg = mincpg;

sbin/newfs/mkfs.c

360

sblock.fs_ipg = inospercg;

sbin/newfs/mkfs.c

362

sblock.fs_contigsumsize = MIN(maxcontig, FS_MAXCONTIG);

sbin/newfs/mkfs.c

364

while (CGSIZE(&sblock) > (uint32_t)sblock.fs_bsize) {

sbin/newfs/mkfs.c

366

if (sblock.fs_bsize < MAXBSIZE) {

sbin/newfs/mkfs.c

367

sblock.fs_bsize <<= 1;

sbin/newfs/mkfs.c

371

sblock.fs_cpc <<= 1;

sbin/newfs/mkfs.c

374

sblock.fs_cpg = mincpg;

sbin/newfs/mkfs.c

376

sblock.fs_frag <<= 1;

sbin/newfs/mkfs.c

377

sblock.fs_fragshift += 1;

sbin/newfs/mkfs.c

378

if (sblock.fs_frag <= MAXFRAG)

sbin/newfs/mkfs.c

381

if (sblock.fs_fsize == sblock.fs_bsize) {

sbin/newfs/mkfs.c

386

sblock.fs_frag >>= 1;

sbin/newfs/mkfs.c

387

sblock.fs_fragshift -= 1;

sbin/newfs/mkfs.c

388

sblock.fs_fsize <<= 1;

sbin/newfs/mkfs.c

389

sblock.fs_nspf <<= 1;

sbin/newfs/mkfs.c

396

sblock.fs_ipg = inospercg;

sbin/newfs/mkfs.c

397

while (inospercg > MAXIPG(&sblock)) {

sbin/newfs/mkfs.c

399

if (mincpc == 1 || sblock.fs_frag == 1 ||

sbin/newfs/mkfs.c

400

sblock.fs_bsize == MINBSIZE)

sbin/newfs/mkfs.c

402

printf("With a block size of %d %s %d\n", sblock.fs_bsize,

sbin/newfs/mkfs.c

405

/ MAXIPG(&sblock) + 1));

sbin/newfs/mkfs.c

406

sblock.fs_bsize >>= 1;

sbin/newfs/mkfs.c

407

sblock.fs_frag >>= 1;

sbin/newfs/mkfs.c

408

sblock.fs_fragshift -= 1;

sbin/newfs/mkfs.c

410

sblock.fs_cpg = roundup(mincpgcnt, mincpc);

sbin/newfs/mkfs.c

411

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

sbin/newfs/mkfs.c

412

sblock.fs_bsize <<= 1;

sbin/newfs/mkfs.c

415

mincpg = sblock.fs_cpg;

sbin/newfs/mkfs.c

417

sblock.fs_ipg = inospercg;

sbin/newfs/mkfs.c

420

if (inospercg > MAXIPG(&sblock)) {

sbin/newfs/mkfs.c

423

/ MAXIPG(&sblock) + 1));

sbin/newfs/mkfs.c

430

printf("With %d sectors per cylinder, ", sblock.fs_spc);

sbin/newfs/mkfs.c

434

if (sblock.fs_bsize != bsize)

sbin/newfs/mkfs.c

437

bsize, sblock.fs_bsize);

sbin/newfs/mkfs.c

438

if (sblock.fs_fsize != fsize)

sbin/newfs/mkfs.c

441

fsize, sblock.fs_fsize);

sbin/newfs/mkfs.c

447

sblock.fs_cpg = cpg;

sbin/newfs/mkfs.c

448

if (sblock.fs_cpg % mincpc != 0) {

sbin/newfs/mkfs.c

451

sblock.fs_cpg = roundup(sblock.fs_cpg, mincpc);

sbin/newfs/mkfs.c

453

cpg = sblock.fs_cpg;

sbin/newfs/mkfs.c

458

sblock.fs_ipg = calcipg(sblock.fs_cpg, bpcg, &usedb);

sbin/newfs/mkfs.c

459

while (sblock.fs_ipg > MAXIPG(&sblock)) {

sbin/newfs/mkfs.c

461

sblock.fs_cpg -= mincpc;

sbin/newfs/mkfs.c

462

sblock.fs_ipg = calcipg(sblock.fs_cpg, bpcg, &usedb);

sbin/newfs/mkfs.c

467

while (CGSIZE(&sblock) > (uint32_t)sblock.fs_bsize) {

sbin/newfs/mkfs.c

469

sblock.fs_cpg -= mincpc;

sbin/newfs/mkfs.c

470

sblock.fs_ipg = calcipg(sblock.fs_cpg, bpcg, &usedb);

sbin/newfs/mkfs.c

472

sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);

sbin/newfs/mkfs.c

473

if ((sblock.fs_cpg * sblock.fs_spc) % NSPB(&sblock) != 0) {

sbin/newfs/mkfs.c

477

if (sblock.fs_cpg < mincpg) {

sbin/newfs/mkfs.c

481

} else if (sblock.fs_cpg != cpg) {

sbin/newfs/mkfs.c

493

printf(" cylinders per group to %d.\n", sblock.fs_cpg);

sbin/newfs/mkfs.c

498

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

sbin/newfs/mkfs.c

503

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

sbin/newfs/mkfs.c

504

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

sbin/newfs/mkfs.c

505

if ((long)fssize * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) {

sbin/newfs/mkfs.c

506

sblock.fs_ncyl++;

sbin/newfs/mkfs.c

509

if (sblock.fs_ncyl < 1) {

sbin/newfs/mkfs.c

524

sblock.fs_interleave = interleave;

sbin/newfs/mkfs.c

525

sblock.fs_trackskew = trackskew;

sbin/newfs/mkfs.c

526

sblock.fs_npsect = nphyssectors;

sbin/newfs/mkfs.c

527

sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;

sbin/newfs/mkfs.c

528

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

sbin/newfs/mkfs.c

529

if (sblock.fs_sbsize > SBSIZE)

sbin/newfs/mkfs.c

530

sblock.fs_sbsize = SBSIZE;

sbin/newfs/mkfs.c

531

if (sblock.fs_ntrak == 1) {

sbin/newfs/mkfs.c

532

sblock.fs_cpc = 0;

sbin/newfs/mkfs.c

535

postblsize = sblock.fs_nrpos * sblock.fs_cpc * sizeof(int16_t);

sbin/newfs/mkfs.c

536

rotblsize = sblock.fs_cpc * sblock.fs_spc / NSPB(&sblock);

sbin/newfs/mkfs.c

538

if (sblock.fs_nrpos == 8 && sblock.fs_cpc <= 16) {

sbin/newfs/mkfs.c

540

sblock.fs_postbloff = (char *)(&sblock.fs_opostbl[0][0]) -

sbin/newfs/mkfs.c

541

(char *)(&sblock.fs_firstfield);

sbin/newfs/mkfs.c

542

sblock.fs_rotbloff = &sblock.fs_space[0] -

sbin/newfs/mkfs.c

543

(u_char *)(&sblock.fs_firstfield);

sbin/newfs/mkfs.c

546

sblock.fs_postbloff = &sblock.fs_space[0] -

sbin/newfs/mkfs.c

547

(u_char *)(&sblock.fs_firstfield);

sbin/newfs/mkfs.c

548

sblock.fs_rotbloff = sblock.fs_postbloff + postblsize;

sbin/newfs/mkfs.c

552

sblock.fs_nsect > (1 << NBBY) * NSPB(&sblock)) {

sbin/newfs/mkfs.c

555

"rotational layout tables with nsect", sblock.fs_nsect,

sbin/newfs/mkfs.c

556

"and ntrak", sblock.fs_ntrak,

sbin/newfs/mkfs.c

558

sblock.fs_cpc = 0;

sbin/newfs/mkfs.c

561

sblock.fs_sbsize = fragroundup(&sblock, totalsbsize);

sbin/newfs/mkfs.c

562

if (sblock.fs_sbsize > SBSIZE)

sbin/newfs/mkfs.c

563

sblock.fs_sbsize = SBSIZE;

sbin/newfs/mkfs.c

567

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

sbin/newfs/mkfs.c

568

for (rpos = 0; rpos < sblock.fs_nrpos; rpos++)

sbin/newfs/mkfs.c

569

fs_postbl(&sblock, cylno)[rpos] = -1;

sbin/newfs/mkfs.c

570

for (i = (rotblsize - 1) * sblock.fs_frag;

sbin/newfs/mkfs.c

571

i >= 0; i -= sblock.fs_frag) {

sbin/newfs/mkfs.c

572

cylno = cbtocylno(&sblock, i);

sbin/newfs/mkfs.c

573

rpos = cbtorpos(&sblock, i);

sbin/newfs/mkfs.c

574

blk = fragstoblks(&sblock, i);

sbin/newfs/mkfs.c

575

if (fs_postbl(&sblock, cylno)[rpos] == -1)

sbin/newfs/mkfs.c

576

fs_rotbl(&sblock)[blk] = 0;

sbin/newfs/mkfs.c

578

fs_rotbl(&sblock)[blk] =

sbin/newfs/mkfs.c

579

fs_postbl(&sblock, cylno)[rpos] - blk;

sbin/newfs/mkfs.c

580

fs_postbl(&sblock, cylno)[rpos] = blk;

sbin/newfs/mkfs.c

586

sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;

sbin/newfs/mkfs.c

587

if (sblock.fs_ncyl % sblock.fs_cpg)

sbin/newfs/mkfs.c

588

sblock.fs_ncg++;

sbin/newfs/mkfs.c

589

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

sbin/newfs/mkfs.c

590

i = MIN(~sblock.fs_cgmask, sblock.fs_ncg - 1);

sbin/newfs/mkfs.c

591

if (cgdmin(&sblock, i) - cgbase(&sblock, i) >= sblock.fs_fpg) {

sbin/newfs/mkfs.c

593

cgdmin(&sblock, i) - cgbase(&sblock, i) / sblock.fs_frag,

sbin/newfs/mkfs.c

594

(long)(sblock.fs_fpg / sblock.fs_frag));

sbin/newfs/mkfs.c

596

sblock.fs_cpg, "must be increased");

sbin/newfs/mkfs.c

599

j = sblock.fs_ncg - 1;

sbin/newfs/mkfs.c

600

if ((i = fssize - j * sblock.fs_fpg) < sblock.fs_fpg &&

sbin/newfs/mkfs.c

601

cgdmin(&sblock, j) - cgbase(&sblock, j) > i) {

sbin/newfs/mkfs.c

604

NSPF(&sblock) *

sbin/newfs/mkfs.c

605

(cgdmin(&sblock, 0) + 3 * sblock.fs_frag));

sbin/newfs/mkfs.c

610

(cgdmin(&sblock, j) - cgbase(&sblock, j)) / sblock.fs_frag,

sbin/newfs/mkfs.c

611

i / sblock.fs_frag);

sbin/newfs/mkfs.c

614

i * NSPF(&sblock));

sbin/newfs/mkfs.c

615

sblock.fs_ncg--;

sbin/newfs/mkfs.c

616

sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;

sbin/newfs/mkfs.c

617

sblock.fs_size = fssize = sblock.fs_ncyl * sblock.fs_spc /

sbin/newfs/mkfs.c

618

NSPF(&sblock);

sbin/newfs/mkfs.c

623

sblock.fs_spc -

sbin/newfs/mkfs.c

624

(fssize * NSPF(&sblock) - (sblock.fs_ncyl - 1)

sbin/newfs/mkfs.c

625

* sblock.fs_spc));

sbin/newfs/mkfs.c

630

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

sbin/newfs/mkfs.c

631

sblock.fs_cssize =

sbin/newfs/mkfs.c

632

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

sbin/newfs/mkfs.c

638

i = sblock.fs_bsize / sizeof(struct csum);

sbin/newfs/mkfs.c

639

sblock.fs_csmask = ~(i - 1);

sbin/newfs/mkfs.c

640

for (sblock.fs_csshift = 0; i > 1; i >>= 1)

sbin/newfs/mkfs.c

641

sblock.fs_csshift++;

sbin/newfs/mkfs.c

642

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

sbin/newfs/mkfs.c

645

sblock.fs_magic = FS_MAGIC;

sbin/newfs/mkfs.c

646

sblock.fs_rotdelay = rotdelay;

sbin/newfs/mkfs.c

647

sblock.fs_minfree = minfree;

sbin/newfs/mkfs.c

648

sblock.fs_maxcontig = maxcontig;

sbin/newfs/mkfs.c

649

sblock.fs_maxbpg = maxbpg;

sbin/newfs/mkfs.c

650

sblock.fs_rps = rpm / 60;

sbin/newfs/mkfs.c

651

sblock.fs_optim = opt;

sbin/newfs/mkfs.c

652

sblock.fs_cgrotor = 0;

sbin/newfs/mkfs.c

653

sblock.fs_cstotal.cs_ndir = 0;

sbin/newfs/mkfs.c

654

sblock.fs_cstotal.cs_nbfree = 0;

sbin/newfs/mkfs.c

655

sblock.fs_cstotal.cs_nifree = 0;

sbin/newfs/mkfs.c

656

sblock.fs_cstotal.cs_nffree = 0;

sbin/newfs/mkfs.c

657

sblock.fs_fmod = 0;

sbin/newfs/mkfs.c

658

sblock.fs_ronly = 0;

sbin/newfs/mkfs.c

659

sblock.fs_clean = 1;

sbin/newfs/mkfs.c

661

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

sbin/newfs/mkfs.c

662

sblock.fs_id[1] = random();

sbin/newfs/mkfs.c

670

fsys, sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl,

sbin/newfs/mkfs.c

671

"cylinders", sblock.fs_ntrak, sblock.fs_nsect);

sbin/newfs/mkfs.c

674

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

sbin/newfs/mkfs.c

675

sblock.fs_ncg, sblock.fs_cpg,

sbin/newfs/mkfs.c

676

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

sbin/newfs/mkfs.c

677

sblock.fs_ipg,

sbin/newfs/mkfs.c

678

sblock.fs_flags & FS_DOSOFTDEP ? " SOFTUPDATES" : "");

sbin/newfs/mkfs.c

685

fsbtodb(&sblock,sblock.fs_size) -

sbin/newfs/mkfs.c

687

erfs(SBOFF + slice_offset, (fsbtodb(&sblock,sblock.fs_size) -

sbin/newfs/mkfs.c

699

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

sbin/newfs/mkfs.c

704

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

sbin/newfs/mkfs.c

705

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

sbin/newfs/mkfs.c

723

sblock.fs_time = utime;

sbin/newfs/mkfs.c

724

wtfs((int)SBOFF / sectorsize, sbsize, (char *)&sblock);

sbin/newfs/mkfs.c

725

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

sbin/newfs/mkfs.c

726

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

sbin/newfs/mkfs.c

727

sblock.fs_cssize - i < sblock.fs_bsize ?

sbin/newfs/mkfs.c

728

sblock.fs_cssize - i : sblock.fs_bsize,

sbin/newfs/mkfs.c

733

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

sbin/newfs/mkfs.c

734

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

sbin/newfs/mkfs.c

735

sbsize, (char *)&sblock);

sbin/newfs/mkfs.c

780

cbase = cgbase(&sblock, cylno);

sbin/newfs/mkfs.c

781

dmax = cbase + sblock.fs_fpg;

sbin/newfs/mkfs.c

782

if (dmax > sblock.fs_size)

sbin/newfs/mkfs.c

783

dmax = sblock.fs_size;

sbin/newfs/mkfs.c

784

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

sbin/newfs/mkfs.c

785

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

sbin/newfs/mkfs.c

787

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

sbin/newfs/mkfs.c

789

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

sbin/newfs/mkfs.c

793

if (cylno == sblock.fs_ncg - 1)

sbin/newfs/mkfs.c

794

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

sbin/newfs/mkfs.c

796

acg.cg_ncyl = sblock.fs_cpg;

sbin/newfs/mkfs.c

797

acg.cg_niblk = sblock.fs_ipg;

sbin/newfs/mkfs.c

799

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

800

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

sbin/newfs/mkfs.c

802

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

sbin/newfs/mkfs.c

804

sblock.fs_cpg * sblock.fs_nrpos * sizeof(u_int16_t);

sbin/newfs/mkfs.c

805

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

sbin/newfs/mkfs.c

806

if (sblock.fs_contigsumsize <= 0) {

sbin/newfs/mkfs.c

808

howmany(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY);

sbin/newfs/mkfs.c

811

(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY) -

sbin/newfs/mkfs.c

816

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

sbin/newfs/mkfs.c

818

(sblock.fs_cpg * sblock.fs_spc / NSPB(&sblock), NBBY);

sbin/newfs/mkfs.c

820

if (acg.cg_nextfreeoff - (long)(&acg.cg_firstfield) > sblock.fs_cgsize) {

sbin/newfs/mkfs.c

824

acg.cg_cs.cs_nifree += sblock.fs_ipg;

sbin/newfs/mkfs.c

831

for (i = 0; i < sblock.fs_ipg / INOPF(&sblock); i += sblock.fs_frag) {

sbin/newfs/mkfs.c

834

j < sblock.fs_bsize / sizeof(struct ufs1_dinode);

sbin/newfs/mkfs.c

839

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

sbin/newfs/mkfs.c

840

sblock.fs_bsize, (char *)zino);

sbin/newfs/mkfs.c

847

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

sbin/newfs/mkfs.c

848

blkno = d / sblock.fs_frag;

sbin/newfs/mkfs.c

849

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

sbin/newfs/mkfs.c

850

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

853

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

sbin/newfs/mkfs.c

854

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

sbin/newfs/mkfs.c

855

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

sbin/newfs/mkfs.c

857

sblock.fs_dsize += dlower;

sbin/newfs/mkfs.c

859

sblock.fs_dsize += acg.cg_ndblk - dupper;

sbin/newfs/mkfs.c

860

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

sbin/newfs/mkfs.c

861

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

sbin/newfs/mkfs.c

862

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

sbin/newfs/mkfs.c

867

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

sbin/newfs/mkfs.c

868

blkno = d / sblock.fs_frag;

sbin/newfs/mkfs.c

869

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

sbin/newfs/mkfs.c

870

if (sblock.fs_contigsumsize > 0)

sbin/newfs/mkfs.c

873

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

sbin/newfs/mkfs.c

874

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

sbin/newfs/mkfs.c

875

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

sbin/newfs/mkfs.c

876

d += sblock.fs_frag;

sbin/newfs/mkfs.c

885

if (sblock.fs_contigsumsize > 0) {

sbin/newfs/mkfs.c

896

if (run > sblock.fs_contigsumsize)

sbin/newfs/mkfs.c

897

run = sblock.fs_contigsumsize;

sbin/newfs/mkfs.c

909

if (run > sblock.fs_contigsumsize)

sbin/newfs/mkfs.c

910

run = sblock.fs_contigsumsize;

sbin/newfs/mkfs.c

914

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

sbin/newfs/mkfs.c

915

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

sbin/newfs/mkfs.c

916

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

sbin/newfs/mkfs.c

917

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

sbin/newfs/mkfs.c

919

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

sbin/newfs/mkfs.c

920

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

sbin/newfs/mkfs.c

986

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

sbin/newfs/mkfs.c

991

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

sbin/newfs/mkfs.c

997

node.di_size = sblock.fs_bsize;

sbin/newfs/mkfs.c

999

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

sbin/quotacheck/quotacheck.c

251

bread(SBOFF, (char *)&sblock, (long)SBSIZE);

sbin/quotacheck/quotacheck.c

252

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

sbin/quotacheck/quotacheck.c

253

quotamaxino = sblock.fs_ncg * sblock.fs_ipg;

sbin/quotacheck/quotacheck.c

255

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

sbin/quotacheck/quotacheck.c

256

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

sbin/quotacheck/quotacheck.c

525

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

sbin/quotacheck/quotacheck.c

549

inobufsize = blkroundup(&sblock, INOBUFSIZE);

sbin/quotacheck/quotacheck.c

551

readpercg = sblock.fs_ipg / fullcnt;

sbin/quotacheck/quotacheck.c

552

partialcnt = sblock.fs_ipg % fullcnt;

sbin/tunefs/tunefs.c

113

getsb(&sblock, special);

sbin/tunefs/tunefs.c

136

name, sblock.fs_maxcontig, i);

sbin/tunefs/tunefs.c

137

sblock.fs_maxcontig = i;

sbin/tunefs/tunefs.c

148

name, sblock.fs_rotdelay, i);

sbin/tunefs/tunefs.c

149

sblock.fs_rotdelay = i;

sbin/tunefs/tunefs.c

163

name, sblock.fs_maxbpg, i);

sbin/tunefs/tunefs.c

164

sblock.fs_maxbpg = i;

sbin/tunefs/tunefs.c

175

if (sblock.fs_avgfilesize == i) {

sbin/tunefs/tunefs.c

180

name, sblock.fs_avgfilesize, i);

sbin/tunefs/tunefs.c

181

sblock.fs_avgfilesize = i;

sbin/tunefs/tunefs.c

194

name, sblock.fs_minfree, i);

sbin/tunefs/tunefs.c

195

sblock.fs_minfree = i;

sbin/tunefs/tunefs.c

197

sblock.fs_optim == FS_OPTSPACE)

sbin/tunefs/tunefs.c

200

sblock.fs_optim == FS_OPTTIME)

sbin/tunefs/tunefs.c

210

sblock.fs_flags |= FS_DOSOFTDEP;

sbin/tunefs/tunefs.c

213

sblock.fs_flags &= ~FS_DOSOFTDEP;

sbin/tunefs/tunefs.c

236

if (sblock.fs_optim == i) {

sbin/tunefs/tunefs.c

242

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

sbin/tunefs/tunefs.c

243

sblock.fs_optim = i;

sbin/tunefs/tunefs.c

244

if (sblock.fs_minfree >= MINFREE &&

sbin/tunefs/tunefs.c

247

if (sblock.fs_minfree < MINFREE &&

sbin/tunefs/tunefs.c

260

if (sblock.fs_avgfpdir == i) {

sbin/tunefs/tunefs.c

265

name, sblock.fs_avgfpdir, i);

sbin/tunefs/tunefs.c

266

sblock.fs_avgfpdir = i;

sbin/tunefs/tunefs.c

276

putsb(&sblock, special, Aflag);

sbin/tunefs/tunefs.c

338

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

sbin/tunefs/tunefs.c

340

sblock.fs_maxcontig);

sbin/tunefs/tunefs.c

342

sblock.fs_rotdelay);

sbin/tunefs/tunefs.c

344

sblock.fs_maxbpg);

sbin/tunefs/tunefs.c

346

sblock.fs_avgfilesize);

sbin/tunefs/tunefs.c

348

sblock.fs_avgfpdir);

sbin/tunefs/tunefs.c

350

sblock.fs_minfree);

sbin/tunefs/tunefs.c

352

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

sbin/tunefs/tunefs.c

353

if (sblock.fs_minfree >= MINFREE &&

sbin/tunefs/tunefs.c

354

sblock.fs_optim == FS_OPTSPACE)

sbin/tunefs/tunefs.c

356

if (sblock.fs_minfree < MINFREE &&

sbin/tunefs/tunefs.c

357

sblock.fs_optim == FS_OPTTIME)

sbin/tunefs/tunefs.c

379

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

usr.sbin/makefs/ffs/mkfs.c

151

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

usr.sbin/makefs/ffs/mkfs.c

152

sizeof(sblock.fs_volname));

usr.sbin/makefs/ffs/mkfs.c

156

sblock.fs_old_inodefmt = FS_42INODEFMT;

usr.sbin/makefs/ffs/mkfs.c

157

sblock.fs_maxsymlinklen = 0;

usr.sbin/makefs/ffs/mkfs.c

158

sblock.fs_old_flags = 0;

usr.sbin/makefs/ffs/mkfs.c

162

sblock.fs_old_inodefmt = FS_44INODEFMT;

usr.sbin/makefs/ffs/mkfs.c

164

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

usr.sbin/makefs/ffs/mkfs.c

167

sblock.fs_maxsymlinklen = UFS1_MAXSYMLINKLEN;

usr.sbin/makefs/ffs/mkfs.c

170

sblock.fs_old_flags = FS_FLAGS_UPDATED;

usr.sbin/makefs/ffs/mkfs.c

172

sblock.fs_flags = 0;

usr.sbin/makefs/ffs/mkfs.c

183

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

usr.sbin/makefs/ffs/mkfs.c

188

sblock.fs_avgfilesize = avgfilesize;

usr.sbin/makefs/ffs/mkfs.c

189

sblock.fs_avgfpdir = avgfpdir;

usr.sbin/makefs/ffs/mkfs.c

190

if (sblock.fs_avgfilesize <= 0)

usr.sbin/makefs/ffs/mkfs.c

192

sblock.fs_avgfilesize), exit(14);

usr.sbin/makefs/ffs/mkfs.c

193

if (sblock.fs_avgfpdir <= 0)

usr.sbin/makefs/ffs/mkfs.c

195

sblock.fs_avgfpdir), exit(15);

usr.sbin/makefs/ffs/mkfs.c

199

sblock.fs_bsize = bsize;

usr.sbin/makefs/ffs/mkfs.c

200

sblock.fs_fsize = fsize;

usr.sbin/makefs/ffs/mkfs.c

201

if (!powerof2(sblock.fs_bsize)) {

usr.sbin/makefs/ffs/mkfs.c

203

sblock.fs_bsize);

usr.sbin/makefs/ffs/mkfs.c

206

if (!powerof2(sblock.fs_fsize)) {

usr.sbin/makefs/ffs/mkfs.c

208

sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

211

if (sblock.fs_fsize < sectorsize) {

usr.sbin/makefs/ffs/mkfs.c

213

sblock.fs_fsize, sectorsize);

usr.sbin/makefs/ffs/mkfs.c

216

if (sblock.fs_bsize < MINBSIZE) {

usr.sbin/makefs/ffs/mkfs.c

218

sblock.fs_bsize, MINBSIZE);

usr.sbin/makefs/ffs/mkfs.c

221

if (sblock.fs_bsize > FFS_MAXBSIZE) {

usr.sbin/makefs/ffs/mkfs.c

223

sblock.fs_bsize, FFS_MAXBSIZE);

usr.sbin/makefs/ffs/mkfs.c

226

if (sblock.fs_bsize < sblock.fs_fsize) {

usr.sbin/makefs/ffs/mkfs.c

228

sblock.fs_bsize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

234

sblock.fs_maxbsize = sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

235

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

usr.sbin/makefs/ffs/mkfs.c

236

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

usr.sbin/makefs/ffs/mkfs.c

237

sblock.fs_maxbsize = FS_MAXCONTIG * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

238

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

usr.sbin/makefs/ffs/mkfs.c

240

sblock.fs_maxbsize = maxbsize;

usr.sbin/makefs/ffs/mkfs.c

243

sblock.fs_maxcontig = maxcontig;

usr.sbin/makefs/ffs/mkfs.c

245

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

usr.sbin/makefs/ffs/mkfs.c

246

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

usr.sbin/makefs/ffs/mkfs.c

247

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

usr.sbin/makefs/ffs/mkfs.c

251

if (sblock.fs_maxcontig > 1)

usr.sbin/makefs/ffs/mkfs.c

252

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

usr.sbin/makefs/ffs/mkfs.c

254

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

usr.sbin/makefs/ffs/mkfs.c

255

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

usr.sbin/makefs/ffs/mkfs.c

256

sblock.fs_qbmask = ~sblock.fs_bmask;

usr.sbin/makefs/ffs/mkfs.c

257

sblock.fs_qfmask = ~sblock.fs_fmask;

usr.sbin/makefs/ffs/mkfs.c

258

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

usr.sbin/makefs/ffs/mkfs.c

259

sblock.fs_bshift++;

usr.sbin/makefs/ffs/mkfs.c

260

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

usr.sbin/makefs/ffs/mkfs.c

261

sblock.fs_fshift++;

usr.sbin/makefs/ffs/mkfs.c

262

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

usr.sbin/makefs/ffs/mkfs.c

263

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

usr.sbin/makefs/ffs/mkfs.c

264

sblock.fs_fragshift++;

usr.sbin/makefs/ffs/mkfs.c

265

if (sblock.fs_frag > MAXFRAG) {

usr.sbin/makefs/ffs/mkfs.c

268

sblock.fs_fsize, sblock.fs_bsize,

usr.sbin/makefs/ffs/mkfs.c

269

sblock.fs_bsize / MAXFRAG);

usr.sbin/makefs/ffs/mkfs.c

272

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

usr.sbin/makefs/ffs/mkfs.c

274

sblock.fs_size = sblock.fs_providersize = fssize =

usr.sbin/makefs/ffs/mkfs.c

275

dbtofsb(&sblock, fssize);

usr.sbin/makefs/ffs/mkfs.c

277

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

usr.sbin/makefs/ffs/mkfs.c

281

sblock.fs_magic = FS_UFS1_MAGIC;

usr.sbin/makefs/ffs/mkfs.c

283

sblock.fs_sblockloc = SBLOCK_UFS1;

usr.sbin/makefs/ffs/mkfs.c

285

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

usr.sbin/makefs/ffs/mkfs.c

286

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

usr.sbin/makefs/ffs/mkfs.c

287

sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *

usr.sbin/makefs/ffs/mkfs.c

289

sblock.fs_old_inodefmt = FS_44INODEFMT;

usr.sbin/makefs/ffs/mkfs.c

290

sblock.fs_old_cgoffset = 0;

usr.sbin/makefs/ffs/mkfs.c

291

sblock.fs_old_cgmask = 0xffffffff;

usr.sbin/makefs/ffs/mkfs.c

293

sblock.fs_old_size = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

295

sblock.fs_old_rotdelay = 0;

usr.sbin/makefs/ffs/mkfs.c

296

sblock.fs_old_rps = 60;

usr.sbin/makefs/ffs/mkfs.c

297

sblock.fs_old_nspf = sblock.fs_fsize / sectorsize;

usr.sbin/makefs/ffs/mkfs.c

298

sblock.fs_old_cpg = 1;

usr.sbin/makefs/ffs/mkfs.c

299

sblock.fs_old_interleave = 1;

usr.sbin/makefs/ffs/mkfs.c

300

sblock.fs_old_trackskew = 0;

usr.sbin/makefs/ffs/mkfs.c

301

sblock.fs_old_cpc = 0;

usr.sbin/makefs/ffs/mkfs.c

302

sblock.fs_old_postblformat = 1;

usr.sbin/makefs/ffs/mkfs.c

303

sblock.fs_old_nrpos = 1;

usr.sbin/makefs/ffs/mkfs.c

306

sblock.fs_flags |= FS_DOSOFTDEP;

usr.sbin/makefs/ffs/mkfs.c

309

sblock.fs_magic = FS_UFS2_MAGIC;

usr.sbin/makefs/ffs/mkfs.c

310

sblock.fs_sblockloc = SBLOCK_UFS2;

usr.sbin/makefs/ffs/mkfs.c

311

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

usr.sbin/makefs/ffs/mkfs.c

312

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

usr.sbin/makefs/ffs/mkfs.c

313

sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *

usr.sbin/makefs/ffs/mkfs.c

316

sblock.fs_flags |= FS_DOSOFTDEP;

usr.sbin/makefs/ffs/mkfs.c

320

sblock.fs_sblkno =

usr.sbin/makefs/ffs/mkfs.c

322

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

usr.sbin/makefs/ffs/mkfs.c

324

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

usr.sbin/makefs/ffs/mkfs.c

326

sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

327

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

usr.sbin/makefs/ffs/mkfs.c

328

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

usr.sbin/makefs/ffs/mkfs.c

329

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

usr.sbin/makefs/ffs/mkfs.c

330

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

usr.sbin/makefs/ffs/mkfs.c

331

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

usr.sbin/makefs/ffs/mkfs.c

332

sizepb *= NINDIR(&sblock);

usr.sbin/makefs/ffs/mkfs.c

333

sblock.fs_maxfilesize += sizepb;

usr.sbin/makefs/ffs/mkfs.c

350

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

usr.sbin/makefs/ffs/mkfs.c

365

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

usr.sbin/makefs/ffs/mkfs.c

366

minfpg = fragsperinode * INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

367

if (minfpg > sblock.fs_size)

usr.sbin/makefs/ffs/mkfs.c

368

minfpg = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

369

sblock.fs_ipg = INOPB(&sblock);

usr.sbin/makefs/ffs/mkfs.c

370

sblock.fs_fpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

371

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

usr.sbin/makefs/ffs/mkfs.c

372

if (sblock.fs_fpg < minfpg)

usr.sbin/makefs/ffs/mkfs.c

373

sblock.fs_fpg = minfpg;

usr.sbin/makefs/ffs/mkfs.c

374

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

usr.sbin/makefs/ffs/mkfs.c

375

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

376

sblock.fs_fpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

377

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

usr.sbin/makefs/ffs/mkfs.c

378

if (sblock.fs_fpg < minfpg)

usr.sbin/makefs/ffs/mkfs.c

379

sblock.fs_fpg = minfpg;

usr.sbin/makefs/ffs/mkfs.c

380

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

usr.sbin/makefs/ffs/mkfs.c

381

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

383

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

usr.sbin/makefs/ffs/mkfs.c

386

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

usr.sbin/makefs/ffs/mkfs.c

389

density -= sblock.fs_fsize;

usr.sbin/makefs/ffs/mkfs.c

401

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

usr.sbin/makefs/ffs/mkfs.c

402

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

usr.sbin/makefs/ffs/mkfs.c

403

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

404

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

usr.sbin/makefs/ffs/mkfs.c

407

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

usr.sbin/makefs/ffs/mkfs.c

409

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

usr.sbin/makefs/ffs/mkfs.c

412

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

usr.sbin/makefs/ffs/mkfs.c

414

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

usr.sbin/makefs/ffs/mkfs.c

417

sblock.fs_fpg -= sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

418

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

usr.sbin/makefs/ffs/mkfs.c

419

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

428

optimalfpg = sblock.fs_fpg;

usr.sbin/makefs/ffs/mkfs.c

430

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

usr.sbin/makefs/ffs/mkfs.c

431

lastminfpg = roundup(sblock.fs_iblkno +

usr.sbin/makefs/ffs/mkfs.c

432

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

usr.sbin/makefs/ffs/mkfs.c

433

if (sblock.fs_size < lastminfpg) {

usr.sbin/makefs/ffs/mkfs.c

435

(long long)sblock.fs_size, lastminfpg);

usr.sbin/makefs/ffs/mkfs.c

438

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

usr.sbin/makefs/ffs/mkfs.c

439

sblock.fs_size % sblock.fs_fpg == 0)

usr.sbin/makefs/ffs/mkfs.c

441

sblock.fs_fpg -= sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

442

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

usr.sbin/makefs/ffs/mkfs.c

443

INOPB(&sblock));

usr.sbin/makefs/ffs/mkfs.c

445

if (optimalfpg != sblock.fs_fpg)

usr.sbin/makefs/ffs/mkfs.c

447

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

usr.sbin/makefs/ffs/mkfs.c

449

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

usr.sbin/makefs/ffs/mkfs.c

451

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

usr.sbin/makefs/ffs/mkfs.c

453

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

usr.sbin/makefs/ffs/mkfs.c

455

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

usr.sbin/makefs/ffs/mkfs.c

456

sblock.fs_old_nsect = sblock.fs_old_spc;

usr.sbin/makefs/ffs/mkfs.c

457

sblock.fs_old_npsect = sblock.fs_old_spc;

usr.sbin/makefs/ffs/mkfs.c

458

sblock.fs_old_ncyl = sblock.fs_ncg;

usr.sbin/makefs/ffs/mkfs.c

464

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

usr.sbin/makefs/ffs/mkfs.c

465

sblock.fs_cssize =

usr.sbin/makefs/ffs/mkfs.c

466

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

usr.sbin/makefs/ffs/mkfs.c

472

size = sblock.fs_cssize;

usr.sbin/makefs/ffs/mkfs.c

473

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

474

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

usr.sbin/makefs/ffs/mkfs.c

476

sblock.fs_csp = space;

usr.sbin/makefs/ffs/mkfs.c

477

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

usr.sbin/makefs/ffs/mkfs.c

478

if (sblock.fs_contigsumsize > 0) {

usr.sbin/makefs/ffs/mkfs.c

481

sblock.fs_maxcluster = lp = space;

usr.sbin/makefs/ffs/mkfs.c

482

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

usr.sbin/makefs/ffs/mkfs.c

483

*lp++ = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

486

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

usr.sbin/makefs/ffs/mkfs.c

487

if (sblock.fs_sbsize > SBLOCKSIZE)

usr.sbin/makefs/ffs/mkfs.c

488

sblock.fs_sbsize = SBLOCKSIZE;

usr.sbin/makefs/ffs/mkfs.c

489

sblock.fs_minfree = minfree;

usr.sbin/makefs/ffs/mkfs.c

490

sblock.fs_maxcontig = maxcontig;

usr.sbin/makefs/ffs/mkfs.c

491

sblock.fs_maxbpg = maxbpg;

usr.sbin/makefs/ffs/mkfs.c

492

sblock.fs_optim = opt;

usr.sbin/makefs/ffs/mkfs.c

493

sblock.fs_cgrotor = 0;

usr.sbin/makefs/ffs/mkfs.c

494

sblock.fs_pendingblocks = 0;

usr.sbin/makefs/ffs/mkfs.c

495

sblock.fs_pendinginodes = 0;

usr.sbin/makefs/ffs/mkfs.c

496

sblock.fs_cstotal.cs_ndir = 0;

usr.sbin/makefs/ffs/mkfs.c

497

sblock.fs_cstotal.cs_nbfree = 0;

usr.sbin/makefs/ffs/mkfs.c

498

sblock.fs_cstotal.cs_nifree = 0;

usr.sbin/makefs/ffs/mkfs.c

499

sblock.fs_cstotal.cs_nffree = 0;

usr.sbin/makefs/ffs/mkfs.c

500

sblock.fs_fmod = 0;

usr.sbin/makefs/ffs/mkfs.c

501

sblock.fs_ronly = 0;

usr.sbin/makefs/ffs/mkfs.c

502

sblock.fs_state = 0;

usr.sbin/makefs/ffs/mkfs.c

503

sblock.fs_clean = FS_ISCLEAN;

usr.sbin/makefs/ffs/mkfs.c

504

sblock.fs_ronly = 0;

usr.sbin/makefs/ffs/mkfs.c

505

sblock.fs_id[0] = tstamp;

usr.sbin/makefs/ffs/mkfs.c

506

sblock.fs_id[1] = random();

usr.sbin/makefs/ffs/mkfs.c

507

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

usr.sbin/makefs/ffs/mkfs.c

508

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

usr.sbin/makefs/ffs/mkfs.c

509

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

usr.sbin/makefs/ffs/mkfs.c

510

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

usr.sbin/makefs/ffs/mkfs.c

511

sblock.fs_cstotal.cs_nbfree =

usr.sbin/makefs/ffs/mkfs.c

512

fragstoblks(&sblock, sblock.fs_dsize) -

usr.sbin/makefs/ffs/mkfs.c

513

howmany(csfrags, sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

514

sblock.fs_cstotal.cs_nffree =

usr.sbin/makefs/ffs/mkfs.c

515

fragnum(&sblock, sblock.fs_size) +

usr.sbin/makefs/ffs/mkfs.c

516

(fragnum(&sblock, csfrags) > 0 ?

usr.sbin/makefs/ffs/mkfs.c

517

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

usr.sbin/makefs/ffs/mkfs.c

518

sblock.fs_cstotal.cs_nifree =

usr.sbin/makefs/ffs/mkfs.c

519

sblock.fs_ncg * sblock.fs_ipg - UFS_ROOTINO;

usr.sbin/makefs/ffs/mkfs.c

520

sblock.fs_cstotal.cs_ndir = 0;

usr.sbin/makefs/ffs/mkfs.c

521

sblock.fs_dsize -= csfrags;

usr.sbin/makefs/ffs/mkfs.c

522

sblock.fs_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

525

sblock.fs_old_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

526

sblock.fs_old_dsize = sblock.fs_dsize;

usr.sbin/makefs/ffs/mkfs.c

527

sblock.fs_old_csaddr = sblock.fs_csaddr;

usr.sbin/makefs/ffs/mkfs.c

528

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

usr.sbin/makefs/ffs/mkfs.c

529

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

usr.sbin/makefs/ffs/mkfs.c

530

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

usr.sbin/makefs/ffs/mkfs.c

531

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

usr.sbin/makefs/ffs/mkfs.c

540

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

usr.sbin/makefs/ffs/mkfs.c

541

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

usr.sbin/makefs/ffs/mkfs.c

542

sblock.fs_bsize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

545

sblock.fs_ncg,

usr.sbin/makefs/ffs/mkfs.c

546

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

usr.sbin/makefs/ffs/mkfs.c

547

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

usr.sbin/makefs/ffs/mkfs.c

555

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

usr.sbin/makefs/ffs/mkfs.c

562

if (sblock.fs_bsize < SBLOCKSIZE)

usr.sbin/makefs/ffs/mkfs.c

563

iobufsize = SBLOCKSIZE + 3 * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

565

iobufsize = 4 * sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

571

memcpy(writebuf, &sblock, sbsize);

usr.sbin/makefs/ffs/mkfs.c

573

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

usr.sbin/makefs/ffs/mkfs.c

577

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

usr.sbin/makefs/ffs/mkfs.c

582

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

usr.sbin/makefs/ffs/mkfs.c

591

sblock.fs_time = tstamp;

usr.sbin/makefs/ffs/mkfs.c

594

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

usr.sbin/makefs/ffs/mkfs.c

595

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

usr.sbin/makefs/ffs/mkfs.c

596

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

usr.sbin/makefs/ffs/mkfs.c

597

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

usr.sbin/makefs/ffs/mkfs.c

601

sblock.fs_flags |= FS_SWAPPED;

usr.sbin/makefs/ffs/mkfs.c

602

ffs_write_superblock(&sblock, fsopts);

usr.sbin/makefs/ffs/mkfs.c

603

return (&sblock);

usr.sbin/makefs/ffs/mkfs.c

621

memcpy(writebuf, &sblock, sbsize);

usr.sbin/makefs/ffs/mkfs.c

676

cbase = cgbase(&sblock, cylno);

usr.sbin/makefs/ffs/mkfs.c

677

dmax = cbase + sblock.fs_fpg;

usr.sbin/makefs/ffs/mkfs.c

678

if (dmax > sblock.fs_size)

usr.sbin/makefs/ffs/mkfs.c

679

dmax = sblock.fs_size;

usr.sbin/makefs/ffs/mkfs.c

680

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

usr.sbin/makefs/ffs/mkfs.c

681

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

usr.sbin/makefs/ffs/mkfs.c

683

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

usr.sbin/makefs/ffs/mkfs.c

684

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

usr.sbin/makefs/ffs/mkfs.c

688

acg.cg_niblk = sblock.fs_ipg;

usr.sbin/makefs/ffs/mkfs.c

690

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

usr.sbin/makefs/ffs/mkfs.c

693

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

694

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

usr.sbin/makefs/ffs/mkfs.c

702

if (cylno == sblock.fs_ncg - 1)

usr.sbin/makefs/ffs/mkfs.c

705

sblock.fs_fpg / sblock.fs_old_cpg);

usr.sbin/makefs/ffs/mkfs.c

707

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

usr.sbin/makefs/ffs/mkfs.c

710

acg.cg_old_ncyl = sblock.fs_old_cpg;

usr.sbin/makefs/ffs/mkfs.c

720

sblock.fs_old_cpg * sizeof(int32_t);

usr.sbin/makefs/ffs/mkfs.c

722

sblock.fs_old_cpg * sizeof(u_int16_t);

usr.sbin/makefs/ffs/mkfs.c

724

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

usr.sbin/makefs/ffs/mkfs.c

725

if (sblock.fs_contigsumsize <= 0) {

usr.sbin/makefs/ffs/mkfs.c

727

howmany(sblock.fs_fpg, CHAR_BIT);

usr.sbin/makefs/ffs/mkfs.c

730

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

usr.sbin/makefs/ffs/mkfs.c

734

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

usr.sbin/makefs/ffs/mkfs.c

736

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

usr.sbin/makefs/ffs/mkfs.c

738

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

usr.sbin/makefs/ffs/mkfs.c

742

acg.cg_cs.cs_nifree += sblock.fs_ipg;

usr.sbin/makefs/ffs/mkfs.c

754

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

usr.sbin/makefs/ffs/mkfs.c

755

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

759

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

usr.sbin/makefs/ffs/mkfs.c

760

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

usr.sbin/makefs/ffs/mkfs.c

761

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

usr.sbin/makefs/ffs/mkfs.c

763

d += sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

767

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

usr.sbin/makefs/ffs/mkfs.c

768

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

usr.sbin/makefs/ffs/mkfs.c

769

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

usr.sbin/makefs/ffs/mkfs.c

774

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

usr.sbin/makefs/ffs/mkfs.c

775

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

usr.sbin/makefs/ffs/mkfs.c

776

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

usr.sbin/makefs/ffs/mkfs.c

777

if (sblock.fs_contigsumsize > 0)

usr.sbin/makefs/ffs/mkfs.c

781

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

usr.sbin/makefs/ffs/mkfs.c

782

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

usr.sbin/makefs/ffs/mkfs.c

783

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

usr.sbin/makefs/ffs/mkfs.c

785

d += sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

795

if (sblock.fs_contigsumsize > 0) {

usr.sbin/makefs/ffs/mkfs.c

806

if (run > sblock.fs_contigsumsize)

usr.sbin/makefs/ffs/mkfs.c

807

run = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

819

if (run > sblock.fs_contigsumsize)

usr.sbin/makefs/ffs/mkfs.c

820

run = sblock.fs_contigsumsize;

usr.sbin/makefs/ffs/mkfs.c

824

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

usr.sbin/makefs/ffs/mkfs.c

829

start = MAX(sblock.fs_bsize, SBLOCKSIZE);

usr.sbin/makefs/ffs/mkfs.c

830

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

usr.sbin/makefs/ffs/mkfs.c

832

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

usr.sbin/makefs/ffs/mkfs.c

833

start += sblock.fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

838

if (sblock.fs_magic == FS_UFS1_MAGIC) {

usr.sbin/makefs/ffs/mkfs.c

848

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

usr.sbin/makefs/ffs/mkfs.c

854

for (i = 2 * sblock.fs_frag;

usr.sbin/makefs/ffs/mkfs.c

855

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

usr.sbin/makefs/ffs/mkfs.c

856

i += sblock.fs_frag) {

usr.sbin/makefs/ffs/mkfs.c

858

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

usr.sbin/makefs/ffs/mkfs.c

862

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

usr.sbin/makefs/ffs/mkfs.c

863

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