bin/cp/utils.c

107

fs->st_mode & ~(S_ISUID | S_ISGID));

bin/cp/utils.c

116

fs->st_mode & ~(S_ISUID | S_ISGID));

bin/cp/utils.c

136

if (S_ISREG(fs->st_mode) && fs->st_size > 0 &&

bin/cp/utils.c

137

fs->st_size <= 8 * 1024 * 1024 &&

bin/cp/utils.c

138

(p = mmap(NULL, (size_t)fs->st_size, PROT_READ,

bin/cp/utils.c

141

for (bufp = p, wresid = fs->st_size; ;

bin/cp/utils.c

152

cp_pct(wtotal, fs->st_size));

bin/cp/utils.c

162

if (munmap(p, fs->st_size) < 0) {

bin/cp/utils.c

182

cp_pct(wtotal, fs->st_size));

bin/cp/utils.c

213

if (pflag && setfile(fs, to_fd))

bin/cp/utils.c

277

setfile(struct stat *fs, int fd)

bin/cp/utils.c

285

islink = !fdval && S_ISLNK(fs->st_mode);

bin/cp/utils.c

286

fs->st_mode &= S_ISUID | S_ISGID | S_ISVTX |

bin/cp/utils.c

289

TIMESPEC_TO_TIMEVAL(&tv[0], &fs->st_atimespec);

bin/cp/utils.c

290

TIMESPEC_TO_TIMEVAL(&tv[1], &fs->st_mtimespec);

bin/cp/utils.c

309

if (!gotstat || fs->st_uid != ts.st_uid || fs->st_gid != ts.st_gid)

bin/cp/utils.c

310

if (fdval ? fchown(fd, fs->st_uid, fs->st_gid) :

bin/cp/utils.c

311

(islink ? lchown(to.p_path, fs->st_uid, fs->st_gid) :

bin/cp/utils.c

312

chown(to.p_path, fs->st_uid, fs->st_gid))) {

bin/cp/utils.c

317

fs->st_mode &= ~(S_ISUID | S_ISGID);

bin/cp/utils.c

320

if (!gotstat || fs->st_mode != ts.st_mode)

bin/cp/utils.c

321

if (fdval ? fchmod(fd, fs->st_mode) :

bin/cp/utils.c

322

(islink ? lchmod(to.p_path, fs->st_mode) :

bin/cp/utils.c

323

chmod(to.p_path, fs->st_mode))) {

bin/cp/utils.c

329

if (!gotstat || fs->st_flags != ts.st_flags)

bin/cp/utils.c

331

fchflags(fd, fs->st_flags) :

bin/cp/utils.c

332

(islink ? lchflags(to.p_path, fs->st_flags) :

bin/cp/utils.c

333

chflags(to.p_path, fs->st_flags))) {

bin/cp/utils.c

56

struct stat *fs;

bin/cp/utils.c

71

fs = entp->fts_statp;

crypto/libressl/crypto/err/err.c

891

const char *ls, *fs, *rs;

crypto/libressl/crypto/err/err.c

899

fs = ERR_func_error_string(e);

crypto/libressl/crypto/err/err.c

906

if (fs == NULL) {

crypto/libressl/crypto/err/err.c

908

fs = fsbuf;

crypto/libressl/crypto/err/err.c

915

ret = snprintf(buf, len, "error:%08lX:%s:%s:%s", e, ls, fs, rs);

games/backgammon/common_source/save.c

54

char *fs;

games/backgammon/common_source/save.c

70

fs = fname;

games/backgammon/common_source/save.c

71

while ((*fs = readc()) != '\n') {

games/backgammon/common_source/save.c

72

if (*fs == old.c_cc[VERASE]) {

games/backgammon/common_source/save.c

73

if (fs > fname) {

games/backgammon/common_source/save.c

74

fs--;

games/backgammon/common_source/save.c

78

writec(*fs);

games/backgammon/common_source/save.c

83

writec(*fs++);

games/backgammon/common_source/save.c

85

*fs = '\0';

games/sail/extern.h

195

char fs;

games/sail/game.c

61

maxmove(struct ship *ship, int dir, int fs)

games/sail/game.c

74

if ((ship->file->FS || fs) && fs != -1) {

games/sail/game.c

76

Move = ship->specs->fs;

lib/libfsid/ext2.c

49

static struct ext2fs *fs;

lib/libfsid/ext2.c

54

fs = (struct ext2fs *)&buffer;

lib/libfsid/ext2.c

56

if (fs->e2fs_magic == E2FS_MAGIC)

lib/libfsid/ext2.c

65

static struct ext2fs *fs;

lib/libfsid/ext2.c

70

fs = (struct ext2fs *)&buffer;

lib/libfsid/ext2.c

72

if (fs->e2fs_magic != E2FS_MAGIC || fs->e2fs_vname[0] == '\0')

lib/libfsid/ext2.c

75

fs->e2fs_vname[sizeof(fs->e2fs_vname) - 1] = '\0';

lib/libfsid/ext2.c

77

return fs->e2fs_vname;

lib/libfsid/hammer.c

44

static struct hammer_volume_ondisk *fs;

lib/libfsid/hammer.c

49

fs = (struct hammer_volume_ondisk *)&buffer;

lib/libfsid/hammer.c

51

if (fs->vol_signature != HAMMER_FSBUF_VOLUME)

lib/libfsid/hammer.c

60

static struct hammer_volume_ondisk *fs;

lib/libfsid/hammer.c

65

fs = (struct hammer_volume_ondisk *)&buffer;

lib/libfsid/hammer.c

67

if (fs->vol_signature != HAMMER_FSBUF_VOLUME ||

lib/libfsid/hammer.c

68

fs->vol_label[0] == '\0')

lib/libfsid/hammer.c

71

fs->vol_label[sizeof(fs->vol_label) - 1] = '\0';

lib/libfsid/hammer.c

73

return fs->vol_label;

lib/libfsid/ufs.c

45

static struct fs *fs;

lib/libfsid/ufs.c

50

fs = (struct fs *)&buffer;

lib/libfsid/ufs.c

52

if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||

lib/libfsid/ufs.c

53

(unsigned)fs->fs_bsize < sizeof(struct fs)) {

lib/libfsid/ufs.c

63

static struct fs *fs;

lib/libfsid/ufs.c

68

fs = (struct fs *)&buffer;

lib/libfsid/ufs.c

70

if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||

lib/libfsid/ufs.c

71

(unsigned)fs->fs_bsize < sizeof(struct fs) ||

lib/libfsid/ufs.c

72

fs->fs_volname[0] == '\0') {

lib/libfsid/ufs.c

76

fs->fs_volname[MAXVOLLEN - 1] = '\0';

lib/libfsid/ufs.c

78

return fs->fs_volname;

lib/libpam/modules/pam_login_access/login_access.c

29

static char fs[] = ":"; /* field separator */

lib/libpam/modules/pam_login_access/login_access.c

81

if (!(perm = strtok(line, fs))

lib/libpam/modules/pam_login_access/login_access.c

82

|| !(users = strtok(NULL, fs))

lib/libpam/modules/pam_login_access/login_access.c

83

|| !(froms = strtok(NULL, fs))

lib/libpam/modules/pam_login_access/login_access.c

84

|| strtok(NULL, fs)) {

libexec/rpc.rquotad/rquotad.c

190

struct fstab *fs;

libexec/rpc.rquotad/rquotad.c

194

while ((fs = getfsent())) {

libexec/rpc.rquotad/rquotad.c

195

if (strcmp(fs->fs_vfstype, "ufs"))

libexec/rpc.rquotad/rquotad.c

197

if (!hasquota(fs, &qfpathname))

libexec/rpc.rquotad/rquotad.c

203

fs_current->fs_file = malloc(sizeof(char) * (strlen(fs->fs_file) + 1));

libexec/rpc.rquotad/rquotad.c

204

strcpy(fs_current->fs_file, fs->fs_file);

libexec/rpc.rquotad/rquotad.c

226

struct fs_stat *fs;

libexec/rpc.rquotad/rquotad.c

234

for (fs = fs_begin; fs != NULL; fs = fs->fs_next) {

libexec/rpc.rquotad/rquotad.c

236

if (fs->st_dev != st_path.st_dev)

libexec/rpc.rquotad/rquotad.c

240

if (quotactl(fs->fs_file, qcmd, id, dqblk) == 0)

libexec/rpc.rquotad/rquotad.c

243

if ((fd = open(fs->qfpathname, O_RDONLY)) < 0) {

libexec/rpc.rquotad/rquotad.c

244

syslog(LOG_ERR, "open error: %s: %m", fs->qfpathname);

libexec/rpc.rquotad/rquotad.c

264

syslog(LOG_ERR, "read error: %s: %m", fs->qfpathname);

libexec/rpc.rquotad/rquotad.c

278

hasquota(struct fstab *fs, char **qfnamep)

libexec/rpc.rquotad/rquotad.c

289

strcpy(buf, fs->fs_mntops);

libexec/rpc.rquotad/rquotad.c

302

sprintf(buf, "%s/%s.%s", fs->fs_file, QUOTAFILENAME, qfextension[USRQUOTA]);

libexec/rpc.rquotad/rquotad.c

40

static int hasquota(struct fstab *fs, char **qfnamep);

libexec/rtld-elf/rtld.c

2228

struct statfs fs;

libexec/rtld-elf/rtld.c

2235

if (fstatfs(fd, &fs) != 0) {

libexec/rtld-elf/rtld.c

2239

if (fs.f_flags & MNT_NOEXEC) {

libexec/rtld-elf/rtld.c

2240

_rtld_error("Cannot execute objects on %s\n", fs.f_mntonname);

sbin/badsect/badsect.c

121

fs = &sblock;

sbin/badsect/badsect.c

122

rdfs(SBOFF, SBSIZE, (char *)fs);

sbin/badsect/badsect.c

123

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

sbin/badsect/badsect.c

134

diskbn = dbtofsb(fs, number);

sbin/badsect/badsect.c

155

fsbn = dbtofsb(fs, blkno);

sbin/badsect/badsect.c

156

if (fs->fs_size < 0 || fsbn + cnt < 0) {

sbin/badsect/badsect.c

160

if (fsbn + cnt > fs->fs_size) {

sbin/badsect/badsect.c

164

cg = dtog(fs, fsbn);

sbin/badsect/badsect.c

165

if (fsbn < cgdmin(fs, cg)) {

sbin/badsect/badsect.c

166

if (cg == 0 || (fsbn+cnt) > cgsblock(fs, cg)) {

sbin/badsect/badsect.c

172

if ((fsbn+cnt) > cgbase(fs, cg+1)) {

sbin/badsect/badsect.c

178

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

sbin/badsect/badsect.c

185

bn = dtogd(fs, fsbn);

sbin/badsect/badsect.c

61

struct fs sblock, *fs;

sbin/clri/clri.c

102

err(1, "%s", fs);

sbin/clri/clri.c

104

err(1, "%s", fs);

sbin/clri/clri.c

116

err(1, "%s", fs);

sbin/clri/clri.c

118

err(1, "%s", fs);

sbin/clri/clri.c

60

struct fs *sbp;

sbin/clri/clri.c

67

char *fs, sblock[SBSIZE];

sbin/clri/clri.c

72

fs = *++argv;

sbin/clri/clri.c

75

if ((fd = open(fs, O_RDWR, 0)) < 0)

sbin/clri/clri.c

76

err(1, "%s", fs);

sbin/clri/clri.c

78

err(1, "%s", fs);

sbin/clri/clri.c

80

errx(1, "%s: can't read superblock", fs);

sbin/clri/clri.c

82

sbp = (struct fs *)sblock;

sbin/clri/clri.c

85

fs, sbp->fs_magic, FS_MAGIC);

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

89

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

sbin/dump/optr.c

265

allocfsent(struct fstab *fs)

sbin/dump/optr.c

269

new = (struct fstab *)malloc(sizeof (*fs));

sbin/dump/optr.c

271

(new->fs_file = strdup(fs->fs_file)) == NULL ||

sbin/dump/optr.c

272

(new->fs_type = strdup(fs->fs_type)) == NULL ||

sbin/dump/optr.c

273

(new->fs_spec = strdup(fs->fs_spec)) == NULL)

sbin/dump/optr.c

275

new->fs_passno = fs->fs_passno;

sbin/dump/optr.c

276

new->fs_freq = fs->fs_freq;

sbin/dump/optr.c

290

struct fstab *fs;

sbin/dump/optr.c

298

while ((fs = getfsent()) != NULL) {

sbin/dump/optr.c

299

if (strcmp(fs->fs_type, FSTAB_RW) &&

sbin/dump/optr.c

300

strcmp(fs->fs_type, FSTAB_RO) &&

sbin/dump/optr.c

301

strcmp(fs->fs_type, FSTAB_RQ))

sbin/dump/optr.c

303

fs = allocfsent(fs);

sbin/dump/optr.c

306

pf->pf_fstab = fs;

sbin/dump/optr.c

322

struct fstab *fs;

sbin/dump/optr.c

326

fs = pf->pf_fstab;

sbin/dump/optr.c

327

if (strcmp(fs->fs_file, key) == 0 ||

sbin/dump/optr.c

328

strcmp(fs->fs_spec, key) == 0)

sbin/dump/optr.c

329

return (fs);

sbin/dump/optr.c

330

rn = rawname(fs->fs_spec);

sbin/dump/optr.c

332

return (fs);

sbin/dump/optr.c

334

if (*fs->fs_spec == '/' &&

sbin/dump/optr.c

335

strcmp(fs->fs_spec + 1, key) == 0)

sbin/dump/optr.c

336

return (fs);

sbin/dump/optr.c

337

if (*fs->fs_file == '/' &&

sbin/dump/optr.c

338

strcmp(fs->fs_file + 1, key) == 0)

sbin/dump/optr.c

339

return (fs);

sbin/dumpfs/dumpfs.c

101

eval |= dumpfs(fs->fs_spec);

sbin/dumpfs/dumpfs.c

49

struct fs fs;

sbin/dumpfs/dumpfs.c

52

#define afs fsun.fs

sbin/dumpfs/dumpfs.c

71

struct fstab *fs;

sbin/dumpfs/dumpfs.c

92

if ((fs = getfsfile(*argv)) == NULL)

sbin/dumpfs/dumpfs.c

99

eval |= marshal(fs->fs_spec);

sbin/ffsinfo/ffsinfo.c

67

struct fs fs;

sbin/ffsinfo/ffsinfo.c

70

#define sblock fsun1.fs

sbin/ffsinfo/ffsinfo.c

71

#define osblock fsun2.fs

sbin/fsck/fsck.h

271

extern void ffs_clrblock(struct fs *, u_char *, ufs_daddr_t);

sbin/fsck/fsck.h

272

extern void ffs_fragacct(struct fs *, int, int32_t [], int);

sbin/fsck/fsck.h

273

extern int ffs_isblock(struct fs *, u_char *, ufs_daddr_t);

sbin/fsck/fsck.h

274

extern void ffs_setblock(struct fs *, u_char *, ufs_daddr_t);

sbin/fsck/fsck.h

85

struct fs *b_fs; /* super block */

sbin/fsck/pass5.c

102

switch ((int)fs->fs_postblformat) {

sbin/fsck/pass5.c

108

mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] -

sbin/fsck/pass5.c

110

blkmapsize = howmany(fs->fs_fpg, NBBY);

sbin/fsck/pass5.c

113

savednrpos = fs->fs_nrpos;

sbin/fsck/pass5.c

114

fs->fs_nrpos = 8;

sbin/fsck/pass5.c

121

newcg->cg_btotoff + fs->fs_cpg * sizeof(int32_t);

sbin/fsck/pass5.c

123

fs->fs_cpg * fs->fs_nrpos * sizeof(u_int16_t);

sbin/fsck/pass5.c

125

newcg->cg_iusedoff + howmany(fs->fs_ipg, NBBY);

sbin/fsck/pass5.c

128

howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs), NBBY);

sbin/fsck/pass5.c

130

if (fs->fs_contigsumsize > 0) {

sbin/fsck/pass5.c

136

(fs->fs_contigsumsize + 1) * sizeof(u_int32_t);

sbin/fsck/pass5.c

138

howmany(fs->fs_cpg * fs->fs_spc / NSPB(fs), NBBY);

sbin/fsck/pass5.c

150

fs->fs_postblformat);

sbin/fsck/pass5.c

159

j = blknum(fs, fs->fs_size + fs->fs_frag - 1);

sbin/fsck/pass5.c

160

for (i = fs->fs_size; i < j; i++)

sbin/fsck/pass5.c

162

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

sbin/fsck/pass5.c

169

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

sbin/fsck/pass5.c

172

dbase = cgbase(fs, c);

sbin/fsck/pass5.c

173

dmax = dbase + fs->fs_fpg;

sbin/fsck/pass5.c

174

if (dmax > fs->fs_size)

sbin/fsck/pass5.c

175

dmax = fs->fs_size;

sbin/fsck/pass5.c

178

if (c == fs->fs_ncg - 1)

sbin/fsck/pass5.c

179

newcg->cg_ncyl = fs->fs_ncyl % fs->fs_cpg;

sbin/fsck/pass5.c

181

newcg->cg_ncyl = fs->fs_cpg;

sbin/fsck/pass5.c

183

if (fs->fs_contigsumsize > 0)

sbin/fsck/pass5.c

184

newcg->cg_nclusterblks = newcg->cg_ndblk / fs->fs_frag;

sbin/fsck/pass5.c

188

newcg->cg_cs.cs_nifree = fs->fs_ipg;

sbin/fsck/pass5.c

204

if (fs->fs_postblformat == FS_42POSTBLFMT)

sbin/fsck/pass5.c

206

j = fs->fs_ipg * c;

sbin/fsck/pass5.c

239

d += fs->fs_frag, i += fs->fs_frag) {

sbin/fsck/pass5.c

241

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

sbin/fsck/pass5.c

247

if (frags == fs->fs_frag) {

sbin/fsck/pass5.c

249

j = cbtocylno(fs, i);

sbin/fsck/pass5.c

251

cg_blks(fs, newcg, j)[cbtorpos(fs, i)]++;

sbin/fsck/pass5.c

252

if (fs->fs_contigsumsize > 0)

sbin/fsck/pass5.c

254

i / fs->fs_frag);

sbin/fsck/pass5.c

257

blk = blkmap(fs, cg_blksfree(newcg), i);

sbin/fsck/pass5.c

258

ffs_fragacct(fs, blk, newcg->cg_frsum, 1);

sbin/fsck/pass5.c

261

if (fs->fs_contigsumsize > 0) {

sbin/fsck/pass5.c

272

if (run > fs->fs_contigsumsize)

sbin/fsck/pass5.c

273

run = fs->fs_contigsumsize;

sbin/fsck/pass5.c

285

if (run > fs->fs_contigsumsize)

sbin/fsck/pass5.c

286

run = fs->fs_contigsumsize;

sbin/fsck/pass5.c

294

cs = &fs->fs_cs(fs, c);

sbin/fsck/pass5.c

301

memmove(cg, newcg, (size_t)fs->fs_cgsize);

sbin/fsck/pass5.c

325

c * fs->fs_ipg + i * NBBY + k);

sbin/fsck/pass5.c

338

c * fs->fs_fpg + i * NBBY + k);

sbin/fsck/pass5.c

349

if (fs->fs_postblformat == FS_42POSTBLFMT)

sbin/fsck/pass5.c

350

fs->fs_nrpos = savednrpos;

sbin/fsck/pass5.c

351

if (memcmp(&cstotal, &fs->fs_cstotal, sizeof *cs) != 0

sbin/fsck/pass5.c

353

memmove(&fs->fs_cstotal, &cstotal, sizeof *cs);

sbin/fsck/pass5.c

354

fs->fs_ronly = 0;

sbin/fsck/pass5.c

355

fs->fs_fmod = 0;

sbin/fsck/pass5.c

48

struct fs *fs = &sblock;

sbin/fsck/pass5.c

61

memset(newcg, 0, (size_t)fs->fs_cgsize);

sbin/fsck/pass5.c

62

newcg->cg_niblk = fs->fs_ipg;

sbin/fsck/pass5.c

64

if (fs->fs_maxcontig < 2 && fs->fs_contigsumsize > 0) {

sbin/fsck/pass5.c

68

fs->fs_contigsumsize = 0;

sbin/fsck/pass5.c

73

if (fs->fs_maxcontig > 1) {

sbin/fsck/pass5.c

76

if (fs->fs_contigsumsize < 1) {

sbin/fsck/pass5.c

78

} else if (fs->fs_contigsumsize < fs->fs_maxcontig &&

sbin/fsck/pass5.c

79

fs->fs_contigsumsize < FS_MAXCONTIG) {

sbin/fsck/pass5.c

83

i = fs->fs_contigsumsize;

sbin/fsck/pass5.c

84

fs->fs_contigsumsize =

sbin/fsck/pass5.c

85

MIN(fs->fs_maxcontig, FS_MAXCONTIG);

sbin/fsck/pass5.c

86

if (CGSIZE(fs) > fs->fs_bsize) {

sbin/fsck/pass5.c

88

fs->fs_contigsumsize = i;

sbin/fsck/pass5.c

94

fs->fs_cgsize =

sbin/fsck/pass5.c

95

fragroundup(fs, CGSIZE(fs));

sbin/fsck_msdosfs/fat.c

720

readfat(int fs, struct bootblock *boot, struct fat_descriptor **fp)

sbin/fsck_msdosfs/fat.c

735

fat->fd = fs;

sbin/fsirand/fsirand.c

107

struct fs *sblock;

sbin/fsirand/fsirand.c

134

sblock = (struct fs *)&sbuf;

sbin/fsirand/fsirand.c

165

sblock = (struct fs *)&sbuftmp;

sbin/fsirand/fsirand.c

188

sblock = (struct fs *)&sbuf;

sbin/growfs/debug.c

100

dbg_dump_hex(struct fs *sb, const char *comment, unsigned char *mem)

sbin/growfs/debug.c

130

dbg_dump_fs(struct fs *sb, const char *comment)

sbin/growfs/debug.c

397

dbg_dump_inmap(struct fs *sb, const char *comment, struct cg *cgr)

sbin/growfs/debug.c

442

dbg_dump_frmap(struct fs *sb, const char *comment, struct cg *cgr)

sbin/growfs/debug.c

486

dbg_dump_clmap(struct fs *sb, const char *comment, struct cg *cgr)

sbin/growfs/debug.c

530

dbg_dump_clsum(struct fs *sb, const char *comment, struct cg *cgr)

sbin/growfs/debug.c

559

dbg_dump_sptbl(struct fs *sb, const char *comment, struct cg *cgr)

sbin/growfs/debug.c

596

dbg_dump_ino(struct fs *sb, const char *comment, struct ufs1_dinode *ino)

sbin/growfs/debug.c

666

dbg_dump_iblk(struct fs *sb, const char *comment, char *block, size_t length)

sbin/growfs/debug.h

52

void dbg_dump_hex(struct fs *, const char *, unsigned char *);

sbin/growfs/debug.h

53

void dbg_dump_fs(struct fs *, const char *);

sbin/growfs/debug.h

56

void dbg_dump_ino(struct fs *, const char *, struct ufs1_dinode *);

sbin/growfs/debug.h

57

void dbg_dump_iblk(struct fs *, const char *, char *, size_t);

sbin/growfs/debug.h

58

void dbg_dump_inmap(struct fs *, const char *, struct cg *);

sbin/growfs/debug.h

59

void dbg_dump_frmap(struct fs *, const char *, struct cg *);

sbin/growfs/debug.h

60

void dbg_dump_clmap(struct fs *, const char *, struct cg *);

sbin/growfs/debug.h

61

void dbg_dump_clsum(struct fs *, const char *, struct cg *);

sbin/growfs/debug.h

62

void dbg_dump_sptbl(struct fs *, const char *, struct cg *);

sbin/growfs/growfs.c

123

static int isblock(struct fs *, unsigned char *, int);

sbin/growfs/growfs.c

124

static void clrblock(struct fs *, unsigned char *, int);

sbin/growfs/growfs.c

125

static void setblock(struct fs *, unsigned char *, int);

sbin/growfs/growfs.c

1726

isblock(struct fs *fs, unsigned char *cp, int h)

sbin/growfs/growfs.c

1732

switch (fs->fs_frag) {

sbin/growfs/growfs.c

1749

fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);

sbin/growfs/growfs.c

1762

clrblock(struct fs *fs, unsigned char *cp, int h)

sbin/growfs/growfs.c

1766

switch ((fs)->fs_frag) {

sbin/growfs/growfs.c

1780

warnx("clrblock bad fs_frag %d", fs->fs_frag);

sbin/growfs/growfs.c

1795

setblock(struct fs *fs, unsigned char *cp, int h)

sbin/growfs/growfs.c

1799

switch (fs->fs_frag) {

sbin/growfs/growfs.c

1813

warnx("setblock bad fs_frag %d", fs->fs_frag);

sbin/growfs/growfs.c

69

struct fs fs;

sbin/growfs/growfs.c

72

#define sblock fsun1.fs /* the new superblock */

sbin/growfs/growfs.c

73

#define osblock fsun2.fs /* the old superblock */

sbin/hammer/cmd_cleanup.c

109

char *fstype, *fs, *path;

sbin/hammer/cmd_cleanup.c

125

fs = stfsbuf[i].f_mntfromname;

sbin/hammer/cmd_cleanup.c

128

(strstr(fs, "/@@0x") != NULL ||

sbin/hammer/cmd_cleanup.c

129

strstr(fs, "/@@-1") != NULL))) {

sbin/hammer/cmd_softprune.c

41

struct statfs fs;

sbin/hammer/cmd_softprune.c

414

struct statfs fs;

sbin/hammer/cmd_softprune.c

429

if (statfs(fspath, &fs) < 0) {

sbin/hammer/cmd_softprune.c

438

if (bcmp(&fs.f_fsid, &scan->fs.f_fsid, sizeof(fs.f_fsid)) != 0)

sbin/hammer/cmd_softprune.c

440

if (strcmp(fs.f_mntonname, scan->fs.f_mntonname) != 0)

sbin/hammer/cmd_softprune.c

452

scan->fs = fs;

sbin/hammer/hammer_util.h

173

int hammer_fs_to_vol(const char *fs, struct hammer_ioc_volume_list *iocp);

sbin/hammer/hammer_util.h

174

int hammer_fs_to_rootvol(const char *fs, char *buf, int len);

sbin/hammer/misc.c

109

hammer_fs_to_vol(const char *fs, struct hammer_ioc_volume_list *p)

sbin/hammer/misc.c

114

fd = open(fs, O_RDONLY);

sbin/hammer/misc.c

143

hammer_fs_to_rootvol(const char *fs, char *buf, int len)

sbin/hammer/misc.c

148

if (hammer_fs_to_vol(fs, &ioc) == -1)

sbin/hammer2/subs.c

418

struct statfs *fs;

sbin/hammer2/subs.c

430

fs = calloc(n, sizeof(struct statfs));

sbin/hammer2/subs.c

431

if (getfsstat(fs, sizeof(*fs) * n, MNT_NOWAIT) != n) {

sbin/hammer2/subs.c

433

free(fs);

sbin/hammer2/subs.c

441

if (strcmp(fs[i].f_fstypename, "hammer2") != 0)

sbin/hammer2/subs.c

443

av[w++] = strdup(fs[i].f_mntonname);

sbin/hammer2/subs.c

446

free(fs);

sbin/ipfw/ipfw2.c

1345

list_queues(struct dn_ioc_flowset *fs, struct dn_ioc_flowqueue *q)

sbin/ipfw/ipfw2.c

1350

fs->flow_mask.u.ip.proto,

sbin/ipfw/ipfw2.c

1351

fs->flow_mask.u.ip.src_ip, fs->flow_mask.u.ip.src_port,

sbin/ipfw/ipfw2.c

1352

fs->flow_mask.u.ip.dst_ip, fs->flow_mask.u.ip.dst_port);

sbin/ipfw/ipfw2.c

1353

if (fs->rq_elements == 0)

sbin/ipfw/ipfw2.c

1359

heapsort(q, fs->rq_elements, sizeof(*q), sort_q);

sbin/ipfw/ipfw2.c

1360

for (l = 0; l < fs->rq_elements; l++) {

sbin/ipfw/ipfw2.c

1386

print_flowset_parms(struct dn_ioc_flowset *fs, char *prefix)

sbin/ipfw/ipfw2.c

1393

l = fs->qsize;

sbin/ipfw/ipfw2.c

1394

if (fs->flags_fs & DN_QSIZE_IS_BYTES) {

sbin/ipfw/ipfw2.c

1401

if (fs->plr)

sbin/ipfw/ipfw2.c

1402

sprintf(plr, "plr %f", 1.0 * fs->plr / (double)(0x7fffffff));

sbin/ipfw/ipfw2.c

1405

if (fs->flags_fs & DN_IS_RED) /* RED parameters */

sbin/ipfw/ipfw2.c

1408

(fs->flags_fs & DN_IS_GENTLE_RED) ? 'G' : ' ',

sbin/ipfw/ipfw2.c

1409

1.0 * fs->w_q / (double)(1 << SCALE_RED),

sbin/ipfw/ipfw2.c

1410

SCALE_VAL(fs->min_th),

sbin/ipfw/ipfw2.c

1411

SCALE_VAL(fs->max_th),

sbin/ipfw/ipfw2.c

1412

1.0 * fs->max_p / (double)(1 << SCALE_RED));

sbin/ipfw/ipfw2.c

1417

prefix, qs, plr, fs->rq_elements, fs->rq_size, red);

sbin/ipfw/ipfw2.c

1426

struct dn_ioc_flowset *fs;

sbin/ipfw/ipfw2.c

1439

if (p->fs.fs_type != DN_IS_PIPE)

sbin/ipfw/ipfw2.c

1445

l = sizeof(*p) + p->fs.rq_elements * sizeof(*q);

sbin/ipfw/ipfw2.c

1466

print_flowset_parms(&p->fs, prefix);

sbin/ipfw/ipfw2.c

1471

list_queues(&p->fs, q);

sbin/ipfw/ipfw2.c

1473

for (fs = next; nbytes >= (int)sizeof(*fs); fs = next) {

sbin/ipfw/ipfw2.c

1476

if (fs->fs_type != DN_IS_QUEUE)

sbin/ipfw/ipfw2.c

1478

l = sizeof(*fs) + fs->rq_elements * sizeof(*q);

sbin/ipfw/ipfw2.c

1479

next = (uint8_t *)fs + l;

sbin/ipfw/ipfw2.c

1481

q = (struct dn_ioc_flowqueue *)(fs+1);

sbin/ipfw/ipfw2.c

1483

fs->fs_nr, fs->weight, fs->parent_nr);

sbin/ipfw/ipfw2.c

1484

print_flowset_parms(fs, prefix);

sbin/ipfw/ipfw2.c

1485

list_queues(fs, q);

sbin/ipfw/ipfw2.c

2059

pipe.fs.fs_nr = i;

sbin/ipfw/ipfw2.c

2066

pipe.fs.fs_nr);

sbin/ipfw/ipfw2.c

2171

pipe.fs.fs_nr = i;

sbin/ipfw/ipfw2.c

2180

pipe.fs.flags_fs |= DN_NOERROR;

sbin/ipfw/ipfw2.c

2190

pipe.fs.plr = (int)(d*0x7fffffff);

sbin/ipfw/ipfw2.c

2197

pipe.fs.qsize = getbw(av[0], &pipe.fs.flags_fs, 1024);

sbin/ipfw/ipfw2.c

2203

pipe.fs.rq_size = strtoul(av[0], NULL, 0);

sbin/ipfw/ipfw2.c

2214

pipe.fs.flow_mask.type = ETHERTYPE_IP;

sbin/ipfw/ipfw2.c

2215

pipe.fs.flow_mask.u.ip.dst_ip = 0;

sbin/ipfw/ipfw2.c

2216

pipe.fs.flow_mask.u.ip.src_ip = 0;

sbin/ipfw/ipfw2.c

2217

pipe.fs.flow_mask.u.ip.dst_port = 0;

sbin/ipfw/ipfw2.c

2218

pipe.fs.flow_mask.u.ip.src_port = 0;

sbin/ipfw/ipfw2.c

2219

pipe.fs.flow_mask.u.ip.proto = 0;

sbin/ipfw/ipfw2.c

2233

pipe.fs.flow_mask.u.ip.dst_ip = ~0;

sbin/ipfw/ipfw2.c

2234

pipe.fs.flow_mask.u.ip.src_ip = ~0;

sbin/ipfw/ipfw2.c

2235

pipe.fs.flow_mask.u.ip.dst_port = ~0;

sbin/ipfw/ipfw2.c

2236

pipe.fs.flow_mask.u.ip.src_port = ~0;

sbin/ipfw/ipfw2.c

2237

pipe.fs.flow_mask.u.ip.proto = ~0;

sbin/ipfw/ipfw2.c

2238

pipe.fs.flags_fs |= DN_HAVE_FLOW_MASK;

sbin/ipfw/ipfw2.c

2242

p32 = &pipe.fs.flow_mask.u.ip.dst_ip;

sbin/ipfw/ipfw2.c

2246

p32 = &pipe.fs.flow_mask.u.ip.src_ip;

sbin/ipfw/ipfw2.c

2250

p16 = &pipe.fs.flow_mask.u.ip.dst_port;

sbin/ipfw/ipfw2.c

2254

p16 = &pipe.fs.flow_mask.u.ip.src_port;

sbin/ipfw/ipfw2.c

2282

pipe.fs.flow_mask.u.ip.proto = (uint8_t)a;

sbin/ipfw/ipfw2.c

2285

pipe.fs.flags_fs |= DN_HAVE_FLOW_MASK;

sbin/ipfw/ipfw2.c

2294

pipe.fs.flags_fs |= DN_IS_RED;

sbin/ipfw/ipfw2.c

2296

pipe.fs.flags_fs |= DN_IS_GENTLE_RED;

sbin/ipfw/ipfw2.c

2304

pipe.fs.w_q = (int) (w_q * (1 << SCALE_RED));

sbin/ipfw/ipfw2.c

2307

pipe.fs.min_th = strtoul(end, &end, 0);

sbin/ipfw/ipfw2.c

2309

pipe.fs.min_th *= 1024;

sbin/ipfw/ipfw2.c

2312

pipe.fs.max_th = strtoul(end, &end, 0);

sbin/ipfw/ipfw2.c

2314

pipe.fs.max_th *= 1024;

sbin/ipfw/ipfw2.c

2320

pipe.fs.max_p = (int)(max_p * (1 << SCALE_RED));

sbin/ipfw/ipfw2.c

2326

pipe.fs.flags_fs &= ~(DN_IS_RED|DN_IS_GENTLE_RED);

sbin/ipfw/ipfw2.c

2354

pipe.fs.weight = strtoul(av[0], &end, 0);

sbin/ipfw/ipfw2.c

2362

pipe.fs.parent_nr = strtoul(av[0], &end, 0);

sbin/ipfw/ipfw2.c

2376

if (pipe.fs.parent_nr == 0)

sbin/ipfw/ipfw2.c

2378

if (pipe.fs.weight >100)

sbin/ipfw/ipfw2.c

2381

if (pipe.fs.flags_fs & DN_QSIZE_IS_BYTES) {

sbin/ipfw/ipfw2.c

2382

if (pipe.fs.qsize > 1024*1024)

sbin/ipfw/ipfw2.c

2385

if (pipe.fs.qsize > 100)

sbin/ipfw/ipfw2.c

2388

if (pipe.fs.flags_fs & DN_IS_RED) {

sbin/ipfw/ipfw2.c

2395

if (pipe.fs.min_th >= pipe.fs.max_th)

sbin/ipfw/ipfw2.c

2397

pipe.fs.min_th, pipe.fs.max_th);

sbin/ipfw/ipfw2.c

2398

if (pipe.fs.max_th == 0)

sbin/ipfw/ipfw2.c

2448

w_q = ((double)pipe.fs.w_q) / (1 << SCALE_RED);

sbin/ipfw/ipfw2.c

2450

pipe.fs.lookup_step = (int)idle / lookup_depth;

sbin/ipfw/ipfw2.c

2451

if (!pipe.fs.lookup_step)

sbin/ipfw/ipfw2.c

2452

pipe.fs.lookup_step = 1;

sbin/ipfw/ipfw2.c

2454

for (t = pipe.fs.lookup_step; t > 0; --t)

sbin/ipfw/ipfw2.c

2456

pipe.fs.lookup_weight = (int)(weight * (1 << SCALE_RED));

sbin/ipfw3/ipfw3dummynet.c

170

pipe.fs.fs_nr = i;

sbin/ipfw3/ipfw3dummynet.c

181

pipe.fs.flags_fs |= DN_NOERROR;

sbin/ipfw3/ipfw3dummynet.c

191

pipe.fs.plr = (int)(d*0x7fffffff);

sbin/ipfw3/ipfw3dummynet.c

198

pipe.fs.qsize = getbw(av[0], &pipe.fs.flags_fs, 1024);

sbin/ipfw3/ipfw3dummynet.c

204

pipe.fs.rq_size = strtoul(av[0], NULL, 0);

sbin/ipfw3/ipfw3dummynet.c

216

pipe.fs.flow_mask.type = ETHERTYPE_IP;

sbin/ipfw3/ipfw3dummynet.c

217

pipe.fs.flow_mask.u.ip.dst_ip = 0;

sbin/ipfw3/ipfw3dummynet.c

218

pipe.fs.flow_mask.u.ip.src_ip = 0;

sbin/ipfw3/ipfw3dummynet.c

219

pipe.fs.flow_mask.u.ip.dst_port = 0;

sbin/ipfw3/ipfw3dummynet.c

220

pipe.fs.flow_mask.u.ip.src_port = 0;

sbin/ipfw3/ipfw3dummynet.c

221

pipe.fs.flow_mask.u.ip.proto = 0;

sbin/ipfw3/ipfw3dummynet.c

235

pipe.fs.flow_mask.u.ip.dst_ip = ~0;

sbin/ipfw3/ipfw3dummynet.c

236

pipe.fs.flow_mask.u.ip.src_ip = ~0;

sbin/ipfw3/ipfw3dummynet.c

237

pipe.fs.flow_mask.u.ip.dst_port = ~0;

sbin/ipfw3/ipfw3dummynet.c

238

pipe.fs.flow_mask.u.ip.src_port = ~0;

sbin/ipfw3/ipfw3dummynet.c

239

pipe.fs.flow_mask.u.ip.proto = ~0;

sbin/ipfw3/ipfw3dummynet.c

240

pipe.fs.flags_fs |= DN_HAVE_FLOW_MASK;

sbin/ipfw3/ipfw3dummynet.c

244

p32 = &pipe.fs.flow_mask.u.ip.dst_ip;

sbin/ipfw3/ipfw3dummynet.c

248

p32 = &pipe.fs.flow_mask.u.ip.src_ip;

sbin/ipfw3/ipfw3dummynet.c

252

p16 = &pipe.fs.flow_mask.u.ip.dst_port;

sbin/ipfw3/ipfw3dummynet.c

256

p16 = &pipe.fs.flow_mask.u.ip.src_port;

sbin/ipfw3/ipfw3dummynet.c

284

pipe.fs.flow_mask.u.ip.proto =

sbin/ipfw3/ipfw3dummynet.c

288

pipe.fs.flags_fs |= DN_HAVE_FLOW_MASK;

sbin/ipfw3/ipfw3dummynet.c

298

pipe.fs.flags_fs |= DN_IS_RED;

sbin/ipfw3/ipfw3dummynet.c

300

pipe.fs.flags_fs |= DN_IS_GENTLE_RED;

sbin/ipfw3/ipfw3dummynet.c

308

pipe.fs.w_q = (int) (w_q * (1 << SCALE_RED));

sbin/ipfw3/ipfw3dummynet.c

311

pipe.fs.min_th = strtoul(end, &end, 0);

sbin/ipfw3/ipfw3dummynet.c

313

pipe.fs.min_th *= 1024;

sbin/ipfw3/ipfw3dummynet.c

316

pipe.fs.max_th = strtoul(end, &end, 0);

sbin/ipfw3/ipfw3dummynet.c

318

pipe.fs.max_th *= 1024;

sbin/ipfw3/ipfw3dummynet.c

324

pipe.fs.max_p = (int)(max_p * (1 << SCALE_RED));

sbin/ipfw3/ipfw3dummynet.c

330

pipe.fs.flags_fs &= ~(DN_IS_RED|DN_IS_GENTLE_RED);

sbin/ipfw3/ipfw3dummynet.c

360

pipe.fs.weight = strtoul(av[0], &end, 0);

sbin/ipfw3/ipfw3dummynet.c

368

pipe.fs.parent_nr = strtoul(av[0], &end, 0);

sbin/ipfw3/ipfw3dummynet.c

382

if (pipe.fs.parent_nr == 0)

sbin/ipfw3/ipfw3dummynet.c

384

if (pipe.fs.weight >100)

sbin/ipfw3/ipfw3dummynet.c

387

if (pipe.fs.flags_fs & DN_QSIZE_IS_BYTES) {

sbin/ipfw3/ipfw3dummynet.c

388

if (pipe.fs.qsize > 1024*1024)

sbin/ipfw3/ipfw3dummynet.c

391

if (pipe.fs.qsize > 100)

sbin/ipfw3/ipfw3dummynet.c

394

if (pipe.fs.flags_fs & DN_IS_RED) {

sbin/ipfw3/ipfw3dummynet.c

401

if (pipe.fs.min_th >= pipe.fs.max_th)

sbin/ipfw3/ipfw3dummynet.c

403

pipe.fs.min_th, pipe.fs.max_th);

sbin/ipfw3/ipfw3dummynet.c

404

if (pipe.fs.max_th == 0)

sbin/ipfw3/ipfw3dummynet.c

454

w_q = ((double)pipe.fs.w_q) / (1 << SCALE_RED);

sbin/ipfw3/ipfw3dummynet.c

456

pipe.fs.lookup_step = (int)idle / lookup_depth;

sbin/ipfw3/ipfw3dummynet.c

457

if (!pipe.fs.lookup_step)

sbin/ipfw3/ipfw3dummynet.c

458

pipe.fs.lookup_step = 1;

sbin/ipfw3/ipfw3dummynet.c

460

for (t = pipe.fs.lookup_step; t > 0; --t)

sbin/ipfw3/ipfw3dummynet.c

462

pipe.fs.lookup_weight = (int)(weight * (1 << SCALE_RED));

sbin/ipfw3/ipfw3dummynet.c

501

struct dn_ioc_flowset *fs;

sbin/ipfw3/ipfw3dummynet.c

514

if (p->fs.fs_type != DN_IS_PIPE)

sbin/ipfw3/ipfw3dummynet.c

520

l = sizeof(*p) + p->fs.rq_elements * sizeof(*q);

sbin/ipfw3/ipfw3dummynet.c

541

show_flowset_parms(&p->fs, prefix);

sbin/ipfw3/ipfw3dummynet.c

546

show_queues(&p->fs, q);

sbin/ipfw3/ipfw3dummynet.c

549

for (fs = next; nbytes >= sizeof(*fs); fs = next) {

sbin/ipfw3/ipfw3dummynet.c

552

if (fs->fs_type != DN_IS_QUEUE)

sbin/ipfw3/ipfw3dummynet.c

554

l = sizeof(*fs) + fs->rq_elements * sizeof(*q);

sbin/ipfw3/ipfw3dummynet.c

555

next = (void *)fs + l;

sbin/ipfw3/ipfw3dummynet.c

557

q = (struct dn_ioc_flowqueue *)(fs+1);

sbin/ipfw3/ipfw3dummynet.c

559

fs->fs_nr, fs->weight, fs->parent_nr);

sbin/ipfw3/ipfw3dummynet.c

560

show_flowset_parms(fs, prefix);

sbin/ipfw3/ipfw3dummynet.c

561

show_queues(fs, q);

sbin/ipfw3/ipfw3dummynet.c

566

show_queues(struct dn_ioc_flowset *fs, struct dn_ioc_flowqueue *q)

sbin/ipfw3/ipfw3dummynet.c

571

fs->flow_mask.u.ip.proto,

sbin/ipfw3/ipfw3dummynet.c

572

fs->flow_mask.u.ip.src_ip, fs->flow_mask.u.ip.src_port,

sbin/ipfw3/ipfw3dummynet.c

573

fs->flow_mask.u.ip.dst_ip, fs->flow_mask.u.ip.dst_port);

sbin/ipfw3/ipfw3dummynet.c

574

if (fs->rq_elements == 0)

sbin/ipfw3/ipfw3dummynet.c

580

heapsort(q, fs->rq_elements, sizeof(*q), sort_q);

sbin/ipfw3/ipfw3dummynet.c

581

for (l = 0; l < fs->rq_elements; l++) {

sbin/ipfw3/ipfw3dummynet.c

607

show_flowset_parms(struct dn_ioc_flowset *fs, char *prefix)

sbin/ipfw3/ipfw3dummynet.c

614

l = fs->qsize;

sbin/ipfw3/ipfw3dummynet.c

615

if (fs->flags_fs & DN_QSIZE_IS_BYTES) {

sbin/ipfw3/ipfw3dummynet.c

622

if (fs->plr)

sbin/ipfw3/ipfw3dummynet.c

623

sprintf(plr, "plr %f", 1.0 * fs->plr / (double)(0x7fffffff));

sbin/ipfw3/ipfw3dummynet.c

626

if (fs->flags_fs & DN_IS_RED) /* RED parameters */

sbin/ipfw3/ipfw3dummynet.c

629

(fs->flags_fs & DN_IS_GENTLE_RED) ? 'G' : ' ',

sbin/ipfw3/ipfw3dummynet.c

630

1.0 * fs->w_q / (double)(1 << SCALE_RED),

sbin/ipfw3/ipfw3dummynet.c

631

SCALE_VAL(fs->min_th),

sbin/ipfw3/ipfw3dummynet.c

632

SCALE_VAL(fs->max_th),

sbin/ipfw3/ipfw3dummynet.c

633

1.0 * fs->max_p / (double)(1 << SCALE_RED));

sbin/ipfw3/ipfw3dummynet.c

638

prefix, qs, plr, fs->rq_elements, fs->rq_size, red);

sbin/ipfw3/ipfw3dummynet.h

45

void show_queues(struct dn_ioc_flowset *fs, struct dn_ioc_flowqueue *q);

sbin/ipfw3/ipfw3dummynet.h

46

void show_flowset_parms(struct dn_ioc_flowset *fs, char *prefix);

sbin/mount/mount.c

124

struct fstab *fs;

sbin/mount/mount.c

192

while ((fs = getfsent()) != NULL) {

sbin/mount/mount.c

193

if (BADTYPE(fs->fs_type))

sbin/mount/mount.c

195

if (checkvfsname(fs->fs_vfstype, vfslist))

sbin/mount/mount.c

197

if (hasopt(fs->fs_mntops, "noauto"))

sbin/mount/mount.c

200

ismounted(fs, mntbuf, mntsize))

sbin/mount/mount.c

203

fs->fs_mntops, mntbuf->f_flags);

sbin/mount/mount.c

204

if (mountfs(fs->fs_vfstype, fs->fs_spec,

sbin/mount/mount.c

205

fs->fs_file, init_flags, options,

sbin/mount/mount.c

206

fs->fs_mntops))

sbin/mount/mount.c

242

if ((fs = getfsfile(mntbuf->f_mntonname)) != NULL) {

sbin/mount/mount.c

243

if (strcmp(fs->fs_spec,

sbin/mount/mount.c

245

strcmp(fs->fs_file,

sbin/mount/mount.c

251

fs = getfsfile("/");

sbin/mount/mount.c

253

mntfromname = fs->fs_spec;

sbin/mount/mount.c

257

options = update_options(options, fs->fs_mntops,

sbin/mount/mount.c

268

if ((fs = getfsfile(*argv)) == NULL &&

sbin/mount/mount.c

269

(fs = getfsspec(*argv)) == NULL)

sbin/mount/mount.c

272

if (BADTYPE(fs->fs_type))

sbin/mount/mount.c

275

rval = mountfs(fs->fs_vfstype, fs->fs_spec, fs->fs_file,

sbin/mount/mount.c

276

init_flags, options, fs->fs_mntops);

sbin/mount/mount.c

326

ismounted(struct fstab *fs, struct statfs *mntbuf, int mntsize)

sbin/mount/mount.c

330

if (fs->fs_file[0] == '/' && fs->fs_file[1] == '\0')

sbin/mount/mount.c

335

if (strcmp(fs->fs_file, mntbuf[i].f_mntonname) == 0 &&

sbin/mount/mount.c

336

(!isremountable(fs->fs_vfstype) ||

sbin/mount/mount.c

337

strcmp(fs->fs_spec, mntbuf[i].f_mntfromname) == 0))

sbin/mount_ufs/mount.c

165

while ((fs = getfsent()) != NULL) {

sbin/mount_ufs/mount.c

166

if (BADTYPE(fs->fs_type))

sbin/mount_ufs/mount.c

168

if (checkvfsname(fs->fs_vfstype, vfslist))

sbin/mount_ufs/mount.c

170

if (hasopt(fs->fs_mntops, "noauto"))

sbin/mount_ufs/mount.c

173

ismounted(fs, mntbuf, mntsize))

sbin/mount_ufs/mount.c

176

fs->fs_mntops, mntbuf->f_flags);

sbin/mount_ufs/mount.c

177

if (mountfs(fs->fs_vfstype, fs->fs_spec,

sbin/mount_ufs/mount.c

178

fs->fs_file, init_flags, options,

sbin/mount_ufs/mount.c

179

fs->fs_mntops))

sbin/mount_ufs/mount.c

215

if ((fs = getfsfile(mntbuf->f_mntonname)) != NULL) {

sbin/mount_ufs/mount.c

216

if (strcmp(fs->fs_spec,

sbin/mount_ufs/mount.c

218

strcmp(fs->fs_file,

sbin/mount_ufs/mount.c

224

fs = getfsfile("/");

sbin/mount_ufs/mount.c

226

mntfromname = fs->fs_spec;

sbin/mount_ufs/mount.c

230

options = update_options(options, fs->fs_mntops,

sbin/mount_ufs/mount.c

241

if ((fs = getfsfile(*argv)) == NULL &&

sbin/mount_ufs/mount.c

242

(fs = getfsspec(*argv)) == NULL)

sbin/mount_ufs/mount.c

245

if (BADTYPE(fs->fs_type))

sbin/mount_ufs/mount.c

248

rval = mountfs(fs->fs_vfstype, fs->fs_spec, fs->fs_file,

sbin/mount_ufs/mount.c

249

init_flags, options, fs->fs_mntops);

sbin/mount_ufs/mount.c

285

ismounted(struct fstab *fs, struct statfs *mntbuf, int mntsize)

sbin/mount_ufs/mount.c

289

if (fs->fs_file[0] == '/' && fs->fs_file[1] == '\0')

sbin/mount_ufs/mount.c

294

if (strcmp(fs->fs_file, mntbuf[i].f_mntonname) == 0 &&

sbin/mount_ufs/mount.c

295

(!isremountable(fs->fs_vfstype) ||

sbin/mount_ufs/mount.c

296

strcmp(fs->fs_spec, mntbuf[i].f_mntfromname) == 0))

sbin/mount_ufs/mount.c

96

struct fstab *fs;

sbin/newfs/mkfs.c

105

struct fs fs;

sbin/newfs/mkfs.c

108

#define sblock fsun.fs

sbin/newfs/mkfs.c

128

void clrblock(struct fs *, unsigned char *, int);

sbin/newfs/mkfs.c

131

int isblock(struct fs *, unsigned char *, int);

sbin/newfs/mkfs.c

1322

isblock(struct fs *fs, unsigned char *cp, int h)

sbin/newfs/mkfs.c

1326

switch (fs->fs_frag) {

sbin/newfs/mkfs.c

1339

fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);

sbin/newfs/mkfs.c

1348

clrblock(struct fs *fs, unsigned char *cp, int h)

sbin/newfs/mkfs.c

1350

switch ((fs)->fs_frag) {

sbin/newfs/mkfs.c

136

void setblock(struct fs *, unsigned char *, int);

sbin/newfs/mkfs.c

1364

fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag);

sbin/newfs/mkfs.c

1373

setblock(struct fs *fs, unsigned char *cp, int h)

sbin/newfs/mkfs.c

1375

switch (fs->fs_frag) {

sbin/newfs/mkfs.c

1389

fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);

sbin/newfs/mkfs.c

51

#define MAXIPG(fs) roundup((fs)->fs_bsize * NBBY / 3, INOPB(fs))

sbin/newfs/mkfs.c

528

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

sbin/newfs/mkfs.c

537

totalsbsize = sizeof(struct fs) + rotblsize;

sbin/quotacheck/quotacheck.c

119

struct fstab *fs;

sbin/quotacheck/quotacheck.c

173

while ((fs = getfsent()) != NULL) {

sbin/quotacheck/quotacheck.c

174

if (((argnum = oneof(fs->fs_file, argv, argc)) >= 0 ||

sbin/quotacheck/quotacheck.c

175

(argnum = oneof(fs->fs_spec, argv, argc)) >= 0) &&

sbin/quotacheck/quotacheck.c

176

(auxdata = needchk(fs)) &&

sbin/quotacheck/quotacheck.c

177

(name = blockcheck(fs->fs_spec))) {

sbin/quotacheck/quotacheck.c

179

errs += chkquota(name, fs->fs_file, auxdata);

sbin/quotacheck/quotacheck.c

200

needchk(struct fstab *fs)

sbin/quotacheck/quotacheck.c

205

if (strcmp(fs->fs_vfstype, "ufs") ||

sbin/quotacheck/quotacheck.c

206

strcmp(fs->fs_type, FSTAB_RW))

sbin/quotacheck/quotacheck.c

211

if (gflag && hasquota(fs, GRPQUOTA, &qfnp)) {

sbin/quotacheck/quotacheck.c

215

if (uflag && hasquota(fs, USRQUOTA, &qfnp)) {

sbin/quotacheck/quotacheck.c

418

hasquota(struct fstab *fs, int type, char **qfnamep)

sbin/quotacheck/quotacheck.c

432

strcpy(buf, fs->fs_mntops);

sbin/quotacheck/quotacheck.c

447

"%s/%s.%s", fs->fs_file, qfname, qfextension[type]);

sbin/quotacheck/quotacheck.c

63

struct fs sblk;

sbin/svc/execute.c

921

struct statfs fs;

sbin/svc/execute.c

930

if (statfs(path, &fs) == 0 &&

sbin/svc/execute.c

931

strcmp(fs.f_fstypename, "devfs") == 0) {

sbin/svc/execute.c

940

if (statfs(path, &fs) < 0 ||

sbin/svc/execute.c

941

strcmp(fs.f_fstypename, "devfs") != 0) {

sbin/tunefs/tunefs.c

111

if (fs == NULL && (st.st_mode & S_IFMT) == S_IFDIR)

sbin/tunefs/tunefs.c

279

if (mount("ufs", fs->fs_file,

sbin/tunefs/tunefs.c

298

getsb(struct fs *fs, const char *file)

sbin/tunefs/tunefs.c

304

if (bread((daddr_t)SBOFF, (char *)fs, SBSIZE))

sbin/tunefs/tunefs.c

306

if (fs->fs_magic != FS_MAGIC)

sbin/tunefs/tunefs.c

308

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

sbin/tunefs/tunefs.c

312

putsb(struct fs *fs, const char *file, int all)

sbin/tunefs/tunefs.c

326

bwrite((daddr_t)SBOFF / dev_bsize, (const char *)fs, SBSIZE);

sbin/tunefs/tunefs.c

328

for (i = 0; i < fs->fs_ncg; i++)

sbin/tunefs/tunefs.c

329

bwrite(fsbtodb(fs, cgsblock(fs, i)),

sbin/tunefs/tunefs.c

330

(const char *)fs, SBSIZE);

sbin/tunefs/tunefs.c

58

struct fs sb;

sbin/tunefs/tunefs.c

68

void getsb(struct fs *, const char *);

sbin/tunefs/tunefs.c

69

void putsb(struct fs *, const char *, int);

sbin/tunefs/tunefs.c

81

struct fstab *fs;

sbin/tunefs/tunefs.c

91

fs = getfsfile(special);

sbin/tunefs/tunefs.c

92

if (fs) {

sbin/tunefs/tunefs.c

97

special = fs->fs_spec;

sbin/umount/umount.c

197

struct fstab *fs;

sbin/umount/umount.c

202

if ((fs = getfsent()) != NULL)

sbin/umount/umount.c

210

if (strcmp(fs->fs_file, "/") == 0)

sbin/umount/umount.c

216

if (strcmp(fs->fs_type, FSTAB_RW) &&

sbin/umount/umount.c

217

strcmp(fs->fs_type, FSTAB_RO) &&

sbin/umount/umount.c

218

strcmp(fs->fs_type, FSTAB_RQ))

sbin/umount/umount.c

221

if (getvfsbyname(fs->fs_vfstype, &vfc) == -1)

sbin/umount/umount.c

223

if (checkvfsname(fs->fs_vfstype, typelist))

sbin/umount/umount.c

231

if ((cp = malloc((size_t)strlen(fs->fs_file) + 1)) == NULL)

sbin/umount/umount.c

233

strcpy(cp, fs->fs_file);

sbin/umount/umount.c

238

} while ((fs = getfsent()) != NULL);

stand/boot/common/fs.h

357

CTASSERT(sizeof(struct fs) == 1376);

stand/boot/common/fs.h

412

#define ACTIVECGNUM(fs, cg) ((fs)->fs_active[(cg) / (NBBY * sizeof(int))])

stand/boot/common/fs.h

421

#define CGSIZE(fs) \

stand/boot/common/fs.h

423

/* old btotoff */ (fs)->fs_old_cpg * sizeof(int32_t) + \

stand/boot/common/fs.h

424

/* old boff */ (fs)->fs_old_cpg * sizeof(u_int16_t) + \

stand/boot/common/fs.h

425

/* inode map */ howmany((fs)->fs_ipg, NBBY) + \

stand/boot/common/fs.h

426

/* block map */ howmany((fs)->fs_fpg, NBBY) +\

stand/boot/common/fs.h

427

/* if present */ ((fs)->fs_contigsumsize <= 0 ? 0 : \

stand/boot/common/fs.h

428

/* cluster sum */ (fs)->fs_contigsumsize * sizeof(int32_t) + \

stand/boot/common/fs.h

429

/* cluster map */ howmany(fragstoblks(fs, (fs)->fs_fpg), NBBY)))

stand/boot/common/fs.h

439

#define fs_cs(fs, indx) fs_csp[indx]

stand/boot/common/fs.h

492

#define fsbtodb(fs, b) ((b) << (fs)->fs_fsbtodb)

stand/boot/common/fs.h

493

#define dbtofsb(fs, b) ((b) >> (fs)->fs_fsbtodb)

stand/boot/common/fs.h

499

#define cgbase(fs, c) (((ufs2_daddr_t)(fs)->fs_fpg) * (c))

stand/boot/common/fs.h

500

#define cgdmin(fs, c) (cgstart(fs, c) + (fs)->fs_dblkno) /* 1st data */

stand/boot/common/fs.h

501

#define cgimin(fs, c) (cgstart(fs, c) + (fs)->fs_iblkno) /* inode blk */

stand/boot/common/fs.h

502

#define cgsblock(fs, c) (cgstart(fs, c) + (fs)->fs_sblkno) /* super blk */

stand/boot/common/fs.h

503

#define cgtod(fs, c) (cgstart(fs, c) + (fs)->fs_cblkno) /* cg block */

stand/boot/common/fs.h

504

#define cgstart(fs, c) \

stand/boot/common/fs.h

505

((fs)->fs_magic == FS_UFS2_MAGIC ? cgbase(fs, c) : \

stand/boot/common/fs.h

506

(cgbase(fs, c) + (fs)->fs_old_cgoffset * ((c) & ~((fs)->fs_old_cgmask))))

stand/boot/common/fs.h

514

#define ino_to_cg(fs, x) ((x) / (fs)->fs_ipg)

stand/boot/common/fs.h

515

#define ino_to_fsba(fs, x) \

stand/boot/common/fs.h

516

((ufs2_daddr_t)(cgimin(fs, ino_to_cg(fs, x)) + \

stand/boot/common/fs.h

517

(blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))

stand/boot/common/fs.h

518

#define ino_to_fsbo(fs, x) ((x) % INOPB(fs))

stand/boot/common/fs.h

524

#define dtog(fs, d) ((d) / (fs)->fs_fpg)

stand/boot/common/fs.h

525

#define dtogd(fs, d) ((d) % (fs)->fs_fpg)

stand/boot/common/fs.h

531

#define blkmap(fs, map, loc) \

stand/boot/common/fs.h

532

(((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))

stand/boot/common/fs.h

539

#define blkoff(fs, loc) /* calculates (loc % fs->fs_bsize) */ \

stand/boot/common/fs.h

540

((loc) & (fs)->fs_qbmask)

stand/boot/common/fs.h

541

#define fragoff(fs, loc) /* calculates (loc % fs->fs_fsize) */ \

stand/boot/common/fs.h

542

((loc) & (fs)->fs_qfmask)

stand/boot/common/fs.h

543

#define lfragtosize(fs, frag) /* calculates ((off_t)frag * fs->fs_fsize) */ \

stand/boot/common/fs.h

544

(((off_t)(frag)) << (fs)->fs_fshift)

stand/boot/common/fs.h

545

#define lblktosize(fs, blk) /* calculates ((off_t)blk * fs->fs_bsize) */ \

stand/boot/common/fs.h

546

(((off_t)(blk)) << (fs)->fs_bshift)

stand/boot/common/fs.h

548

#define smalllblktosize(fs, blk) /* calculates (blk * fs->fs_bsize) */ \

stand/boot/common/fs.h

549

((blk) << (fs)->fs_bshift)

stand/boot/common/fs.h

550

#define lblkno(fs, loc) /* calculates (loc / fs->fs_bsize) */ \

stand/boot/common/fs.h

551

((loc) >> (fs)->fs_bshift)

stand/boot/common/fs.h

552

#define numfrags(fs, loc) /* calculates (loc / fs->fs_fsize) */ \

stand/boot/common/fs.h

553

((loc) >> (fs)->fs_fshift)

stand/boot/common/fs.h

554

#define blkroundup(fs, size) /* calculates roundup(size, fs->fs_bsize) */ \

stand/boot/common/fs.h

555

(((size) + (fs)->fs_qbmask) & (fs)->fs_bmask)

stand/boot/common/fs.h

556

#define fragroundup(fs, size) /* calculates roundup(size, fs->fs_fsize) */ \

stand/boot/common/fs.h

557

(((size) + (fs)->fs_qfmask) & (fs)->fs_fmask)

stand/boot/common/fs.h

558

#define fragstoblks(fs, frags) /* calculates (frags / fs->fs_frag) */ \

stand/boot/common/fs.h

559

((frags) >> (fs)->fs_fragshift)

stand/boot/common/fs.h

560

#define blkstofrags(fs, blks) /* calculates (blks * fs->fs_frag) */ \

stand/boot/common/fs.h

561

((blks) << (fs)->fs_fragshift)

stand/boot/common/fs.h

562

#define fragnum(fs, fsb) /* calculates (fsb % fs->fs_frag) */ \

stand/boot/common/fs.h

563

((fsb) & ((fs)->fs_frag - 1))

stand/boot/common/fs.h

564

#define blknum(fs, fsb) /* calculates rounddown(fsb, fs->fs_frag) */ \

stand/boot/common/fs.h

565

((fsb) &~ ((fs)->fs_frag - 1))

stand/boot/common/fs.h

571

#define freespace(fs, percentreserved) \

stand/boot/common/fs.h

572

(blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \

stand/boot/common/fs.h

573

(fs)->fs_cstotal.cs_nffree - \

stand/boot/common/fs.h

574

(((off_t)((fs)->fs_dsize)) * (percentreserved) / 100))

stand/boot/common/fs.h

579

#define blksize(fs, ip, lbn) \

stand/boot/common/fs.h

580

(((lbn) >= NDADDR || (ip)->i_size >= smalllblktosize(fs, (lbn) + 1)) \

stand/boot/common/fs.h

581

? (fs)->fs_bsize \

stand/boot/common/fs.h

582

: (fragroundup(fs, blkoff(fs, (ip)->i_size))))

stand/boot/common/fs.h

583

#define sblksize(fs, size, lbn) \

stand/boot/common/fs.h

584

(((lbn) >= NDADDR || (size) >= ((lbn) + 1) << (fs)->fs_bshift) \

stand/boot/common/fs.h

585

? (fs)->fs_bsize \

stand/boot/common/fs.h

586

: (fragroundup(fs, blkoff(fs, (size)))))

stand/boot/common/fs.h

592

#define INOPB(fs) ((fs)->fs_inopb)

stand/boot/common/fs.h

593

#define INOPF(fs) ((fs)->fs_inopb >> (fs)->fs_fragshift)

stand/boot/common/fs.h

598

#define NINDIR(fs) ((fs)->fs_nindir)

stand/boot/common/ufsread.c

165

#define DIP(field) fs->fs_magic == FS_UFS1_MAGIC ? dp1.field : dp2.field

stand/boot/common/ufsread.c

174

struct fs *fs;

stand/boot/common/ufsread.c

178

fs = (struct fs *)fsdmadat->sbbuf;

stand/boot/common/ufsread.c

181

if (dskread(fs, sblock_try[n] / DEV_BSIZE,

stand/boot/common/ufsread.c

187

fs->fs_magic == FS_UFS1_MAGIC

stand/boot/common/ufsread.c

189

(fs->fs_magic == FS_UFS2_MAGIC &&

stand/boot/common/ufsread.c

190

fs->fs_sblockloc == sblock_try[n])

stand/boot/common/ufsread.c

192

fs->fs_magic == FS_UFS1_MAGIC ||

stand/boot/common/ufsread.c

193

(fs->fs_magic == FS_UFS2_MAGIC &&

stand/boot/common/ufsread.c

194

fs->fs_sblockloc == sblock_try[n])

stand/boot/common/ufsread.c

197

fs->fs_bsize <= MAXBSIZE &&

stand/boot/common/ufsread.c

198

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

stand/boot/common/ufsread.c

223

struct fs *fs;

stand/boot/common/ufsread.c

232

fs = (struct fs *)fsdmadat->sbbuf;

stand/boot/common/ufsread.c

255

n = IPERVBLK(fs);

stand/boot/common/ufsread.c

256

if (dskread(blkbuf, INO_TO_VBA(fs, n, ufs_inode), DBPERVBLK))

stand/boot/common/ufsread.c

264

if (fs->fs_magic == FS_UFS1_MAGIC)

stand/boot/common/ufsread.c

280

lbn = lblkno(fs, fs_off);

stand/boot/common/ufsread.c

281

off = blkoff(fs, fs_off);

stand/boot/common/ufsread.c

284

} else if (lbn < NDADDR + NINDIR(fs)) {

stand/boot/common/ufsread.c

285

n = INDIRPERVBLK(fs);

stand/boot/common/ufsread.c

288

vbaddr = fsbtodb(fs, addr) + u;

stand/boot/common/ufsread.c

300

if (fs->fs_magic == FS_UFS1_MAGIC)

stand/boot/common/ufsread.c

308

vbaddr = fsbtodb(fs, addr) + (off >> VBLKSHIFT) * DBPERVBLK;

stand/boot/common/ufsread.c

310

n = sblksize(fs, (ssize_t)size, lbn) - (off & ~VBLKMASK);

stand/boot/common/ufsread.c

46

#define cgbase(fs, c) ((ufs2_daddr_t)((fs)->fs_fpg * (c)))

stand/boot/common/ufsread.c

57

#define INDIRPERVBLK(fs) (NINDIR(fs) / ((fs)->fs_bsize >> VBLKSHIFT))

stand/boot/common/ufsread.c

58

#define IPERVBLK(fs) (INOPB(fs) / ((fs)->fs_bsize >> VBLKSHIFT))

stand/boot/common/ufsread.c

59

#define INO_TO_VBA(fs, ipervblk, x) \

stand/boot/common/ufsread.c

60

(fsbtodb(fs, cgimin(fs, ino_to_cg(fs, x))) + \

stand/boot/common/ufsread.c

61

(((x) % (fs)->fs_ipg) / (ipervblk) * DBPERVBLK))

stand/boot/common/ufsread.c

63

#define FS_TO_VBA(fs, fsb, off) (fsbtodb(fs, fsb) + \

stand/boot/common/ufsread.c

65

#define FS_TO_VBO(fs, fsb, off) ((off) & VBLKMASK)

stand/boot/pc32/btx/lib/btxv86.h

35

uint32_t fs; /* V86 FS register */

stand/lib/dosfs.c

111

#define bytblk(fs, n) ((n) >> (fs)->bshift)

stand/lib/dosfs.c

112

#define blkbyt(fs, b) ((b) << (fs)->bshift)

stand/lib/dosfs.c

113

#define secblk(fs, s) ((s) >> ((fs)->bshift - SSHIFT))

stand/lib/dosfs.c

114

#define blksec(fs, b) ((b) << ((fs)->bshift - SSHIFT))

stand/lib/dosfs.c

117

#define blkoff(fs, b) (secbyt((fs)->lsndta) + blkbyt(fs, (b) - LOCLUS))

stand/lib/dosfs.c

120

#define blklsn(fs, b) ((fs)->lsndta + blksec(fs, (b) - LOCLUS))

stand/lib/dosfs.c

128

#define okclus(fs, c) ((c) >= LOCLUS && (c) <= (fs)->xclus)

stand/lib/dosfs.c

153

dos_mount(DOS_FS *fs, struct open_file *fd)

stand/lib/dosfs.c

157

bzero(fs, sizeof(DOS_FS));

stand/lib/dosfs.c

158

fs->fd = fd;

stand/lib/dosfs.c

159

if ((err = !(fs->buf = malloc(SECSIZ)) ? errno : 0) ||

stand/lib/dosfs.c

160

(err = ioget(fs->fd, 0, fs->buf, 1)) ||

stand/lib/dosfs.c

161

(err = parsebs(fs, (DOS_BS *)fs->buf))) {

stand/lib/dosfs.c

162

(void)dosunmount(fs);

stand/lib/dosfs.c

165

fs->root = dot[0];

stand/lib/dosfs.c

166

fs->root.name[0] = ' ';

stand/lib/dosfs.c

167

if (fs->fatsz == 32) {

stand/lib/dosfs.c

168

fs->root.clus[0] = fs->rdcl & 0xff;

stand/lib/dosfs.c

169

fs->root.clus[1] = (fs->rdcl >> 8) & 0xff;

stand/lib/dosfs.c

170

fs->root.dex.h_clus[0] = (fs->rdcl >> 16) & 0xff;

stand/lib/dosfs.c

171

fs->root.dex.h_clus[1] = (fs->rdcl >> 24) & 0xff;

stand/lib/dosfs.c

180

dos_unmount(DOS_FS *fs)

stand/lib/dosfs.c

184

if (fs->links)

stand/lib/dosfs.c

186

if ((err = dosunmount(fs)))

stand/lib/dosfs.c

195

dosunmount(DOS_FS *fs)

stand/lib/dosfs.c

197

if (fs->buf)

stand/lib/dosfs.c

198

free(fs->buf);

stand/lib/dosfs.c

199

free(fs);

stand/lib/dosfs.c

211

DOS_FS *fs;

stand/lib/dosfs.c

216

fs = malloc(sizeof(DOS_FS));

stand/lib/dosfs.c

218

if ((err = dos_mount(fs, fd)))

stand/lib/dosfs.c

221

if ((err = namede(fs, path, &de)))

stand/lib/dosfs.c

224

clus = stclus(fs->fatsz, de);

stand/lib/dosfs.c

229

(clus && !okclus(fs, clus))) {

stand/lib/dosfs.c

235

f->fs = fs;

stand/lib/dosfs.c

236

fs->links++;

stand/lib/dosfs.c

256

if ((size = fsize(f->fs, &f->de)) == -1)

stand/lib/dosfs.c

261

if ((clus = stclus(f->fs->fatsz, &f->de)))

stand/lib/dosfs.c

262

off &= f->fs->bsize - 1;

stand/lib/dosfs.c

269

n = bytblk(f->fs, f->offset);

stand/lib/dosfs.c

273

if ((err = fatget(f->fs, &c)))

stand/lib/dosfs.c

275

if (!okclus(f->fs, c)) {

stand/lib/dosfs.c

280

if (!clus || (n = f->fs->bsize - off) > cnt)

stand/lib/dosfs.c

282

if ((err = ioread(f->fs, (c ? blkoff(f->fs, c) :

stand/lib/dosfs.c

283

secbyt(f->fs->lsndir)) + off,

stand/lib/dosfs.c

337

DOS_FS *fs;

stand/lib/dosfs.c

341

fs = f->fs;

stand/lib/dosfs.c

342

f->fs = NULL;

stand/lib/dosfs.c

343

fs->links--;

stand/lib/dosfs.c

345

dos_unmount(fs);

stand/lib/dosfs.c

363

if ((sb->st_size = fsize(f->fs, &f->de)) == -1)

stand/lib/dosfs.c

448

parsebs(DOS_FS *fs, DOS_BS *bs)

stand/lib/dosfs.c

459

if (!(fs->spc = bs->bpb.spc) || fs->spc & (fs->spc - 1))

stand/lib/dosfs.c

461

fs->bsize = secbyt(fs->spc);

stand/lib/dosfs.c

462

fs->bshift = ffs(fs->bsize) - 1;

stand/lib/dosfs.c

463

if ((fs->spf = cv2(bs->bpb.spf))) {

stand/lib/dosfs.c

466

if (!(fs->dirents = cv2(bs->bpb.dirents)))

stand/lib/dosfs.c

469

if (!(fs->spf = cv4(bs->bpb.lspf)))

stand/lib/dosfs.c

473

if ((fs->rdcl = cv4(bs->bpb.rdcl)) < LOCLUS)

stand/lib/dosfs.c

476

if (!(fs->lsnfat = cv2(bs->bpb.ressec)))

stand/lib/dosfs.c

478

fs->lsndir = fs->lsnfat + fs->spf * bs->bpb.fats;

stand/lib/dosfs.c

479

fs->lsndta = fs->lsndir + entsec(fs->dirents);

stand/lib/dosfs.c

482

if (fs->lsndta > sc)

stand/lib/dosfs.c

484

if ((fs->xclus = secblk(fs, sc - fs->lsndta) + 1) < LOCLUS)

stand/lib/dosfs.c

486

fs->fatsz = fs->dirents ? fs->xclus < 0xff6 ? 12 : 16 : 32;

stand/lib/dosfs.c

487

sc = (secbyt(fs->spf) << 1) / (fs->fatsz >> 2) - 1;

stand/lib/dosfs.c

488

if (fs->xclus > sc)

stand/lib/dosfs.c

489

fs->xclus = sc;

stand/lib/dosfs.c

497

namede(DOS_FS *fs, const char *path, DOS_DE **dep)

stand/lib/dosfs.c

506

de = &fs->root;

stand/lib/dosfs.c

521

if ((err = lookup(fs, stclus(fs->fatsz, de), name, &de)))

stand/lib/dosfs.c

532

lookup(DOS_FS *fs, u_int clus, const char *name, DOS_DE **dep)

stand/lib/dosfs.c

546

if (!clus && fs->fatsz == 32)

stand/lib/dosfs.c

547

clus = fs->rdcl;

stand/lib/dosfs.c

548

nsec = !clus ? entsec(fs->dirents) : fs->spc;

stand/lib/dosfs.c

553

lsec = fs->lsndir;

stand/lib/dosfs.c

554

else if (okclus(fs, clus))

stand/lib/dosfs.c

555

lsec = blklsn(fs, clus);

stand/lib/dosfs.c

559

if ((err = ioget(fs->fd, lsec + sec, dir, 1)))

stand/lib/dosfs.c

604

if ((err = fatget(fs, &clus)))

stand/lib/dosfs.c

606

if (fatend(fs->fatsz, clus))

stand/lib/dosfs.c

672

fsize(DOS_FS *fs, DOS_DE *de)

stand/lib/dosfs.c

680

size = fs->dirents * sizeof(DOS_DE);

stand/lib/dosfs.c

682

if ((n = fatcnt(fs, c)) == -1)

stand/lib/dosfs.c

684

size = blkbyt(fs, n);

stand/lib/dosfs.c

694

fatcnt(DOS_FS *fs, u_int c)

stand/lib/dosfs.c

698

for (n = 0; okclus(fs, c); n++)

stand/lib/dosfs.c

699

if (fatget(fs, &c))

stand/lib/dosfs.c

701

return fatend(fs->fatsz, c) ? n : -1;

stand/lib/dosfs.c

708

fatget(DOS_FS *fs, u_int *c)

stand/lib/dosfs.c

714

err = ioread(fs, secbyt(fs->lsnfat) + fatoff(fs->fatsz, *c), buf,

stand/lib/dosfs.c

715

fs->fatsz != 32 ? 2 : 4);

stand/lib/dosfs.c

718

x = fs->fatsz != 32 ? cv2(buf) : cv4(buf);

stand/lib/dosfs.c

719

*c = fs->fatsz == 12 ? *c & 1 ? x >> 4 : x & 0xfff : x;

stand/lib/dosfs.c

736

ioread(DOS_FS *fs, u_int offset, void *buf, u_int nbyte)

stand/lib/dosfs.c

745

if ((err = iobuf(fs, bytsec(offset))))

stand/lib/dosfs.c

750

memcpy(s, fs->buf + off, n);

stand/lib/dosfs.c

756

if ((err = ioget(fs->fd, bytsec(offset), s, bytsec(nbyte))))

stand/lib/dosfs.c

762

if ((err = iobuf(fs, bytsec(offset))))

stand/lib/dosfs.c

764

memcpy(s, fs->buf, n);

stand/lib/dosfs.c

773

iobuf(DOS_FS *fs, u_int lsec)

stand/lib/dosfs.c

777

if (fs->bufsec != lsec) {

stand/lib/dosfs.c

778

if ((err = ioget(fs->fd, lsec, fs->buf, 1)))

stand/lib/dosfs.c

780

fs->bufsec = lsec;

stand/lib/dosfs.h

115

DOS_FS *fs; /* associated filesystem */

stand/lib/ext2fs.c

132

#define fsb_to_db(fs, blk) ((blk) << (fs)->fs_fsbtodb)

stand/lib/ext2fs.c

140

#define ino_to_bgo(fs, ino) (((ino) - 1) % (fs)->fs_ipg)

stand/lib/ext2fs.c

141

#define ino_to_bg(fs, ino) (((ino) - 1) / (fs)->fs_ipg)

stand/lib/ext2fs.c

142

#define ino_to_db(fs, bg, ino) \

stand/lib/ext2fs.c

143

fsb_to_db(fs, ((bg)[ino_to_bg(fs, ino)].bg_inotbl + \

stand/lib/ext2fs.c

144

ino_to_bgo(fs, ino) / (fs)->fs_ipb))

stand/lib/ext2fs.c

145

#define ino_to_bo(fs, ino) (ino_to_bgo(fs, ino) % (fs)->fs_ipb)

stand/lib/ext2fs.c

147

#define nindir(fs) \

stand/lib/ext2fs.c

148

((fs)->fs_bsize / sizeof(u_int32_t))

stand/lib/ext2fs.c

149

#define lblkno(fs, loc) /* loc / bsize */ \

stand/lib/ext2fs.c

150

((loc) >> (fs)->fs_bshift)

stand/lib/ext2fs.c

151

#define smalllblktosize(fs, blk) /* blk * bsize */ \

stand/lib/ext2fs.c

152

((blk) << (fs)->fs_bshift)

stand/lib/ext2fs.c

153

#define blkoff(fs, loc) /* loc % bsize */ \

stand/lib/ext2fs.c

154

((loc) & (fs)->fs_bmask)

stand/lib/ext2fs.c

155

#define fragroundup(fs, size) /* roundup(size, fsize) */ \

stand/lib/ext2fs.c

156

(((size) + (fs)->fs_fmask) & ~(fs)->fs_fmask)

stand/lib/ext2fs.c

157

#define dblksize(fs, dip, lbn) \

stand/lib/ext2fs.c

158

(((lbn) >= NDADDR || (dip)->di_size >= smalllblktosize(fs, (lbn) + 1)) \

stand/lib/ext2fs.c

159

? (fs)->fs_bsize \

stand/lib/ext2fs.c

160

: (fragroundup(fs, blkoff(fs, (dip)->di_size))))

stand/lib/ext2fs.c

329

struct ext2fs *fs;

stand/lib/ext2fs.c

347

fs = (struct ext2fs *)malloc(sizeof(*fs));

stand/lib/ext2fs.c

348

fp->f_fs = fs;

stand/lib/ext2fs.c

351

EXT2_SBLOCK, EXT2_SBSIZE, (char *)fs, &buf_size);

stand/lib/ext2fs.c

355

if (buf_size != EXT2_SBSIZE || fs->fs_magic != EXT2_MAGIC) {

stand/lib/ext2fs.c

363

fs->fs_bshift = EXT2_MINBSHIFT + fs->fs_fd.fd_bsize;

stand/lib/ext2fs.c

364

fs->fs_bsize = 1 << fs->fs_bshift;

stand/lib/ext2fs.c

365

fs->fs_bmask = fs->fs_bsize - 1;

stand/lib/ext2fs.c

367

fs->fs_fshift = EXT2_MINFSHIFT + fs->fs_fd.fd_fsize;

stand/lib/ext2fs.c

368

fs->fs_fsize = 1 << fs->fs_fshift;

stand/lib/ext2fs.c

369

fs->fs_fmask = fs->fs_fsize - 1;

stand/lib/ext2fs.c

371

if (fs->fs_revision == EXT2_REV0) {

stand/lib/ext2fs.c

372

fs->fs_isize = EXT2_R0_ISIZE;

stand/lib/ext2fs.c

373

fs->fs_firstino = EXT2_R0_FIRSTINO;

stand/lib/ext2fs.c

375

fs->fs_isize = fs->fs_fd.fd_isize;

stand/lib/ext2fs.c

376

fs->fs_firstino = fs->fs_fd.fd_firstino;

stand/lib/ext2fs.c

378

fs->fs_imask = fs->fs_isize - 1;

stand/lib/ext2fs.c

379

fs->fs_ipb = fs->fs_bsize / fs->fs_isize;

stand/lib/ext2fs.c

380

fs->fs_fsbtodb = (fs->fs_bsize / DEV_BSIZE) - 1;

stand/lib/ext2fs.c

385

groups = howmany(fs->fs_blocks - fs->fs_firstblk, fs->fs_bpg);

stand/lib/ext2fs.c

386

bg_per_blk = fs->fs_bsize / sizeof(struct ext2blkgrp);

stand/lib/ext2fs.c

388

len = blkgrps * fs->fs_bsize;

stand/lib/ext2fs.c

408

mult *= nindir(fs);

stand/lib/ext2fs.c

493

struct ext2fs *fs = fp->f_fs;

stand/lib/ext2fs.c

498

buf = malloc(fs->fs_bsize);

stand/lib/ext2fs.c

505

F_READ, fsb_to_db(fs, disk_block),

stand/lib/ext2fs.c

506

fs->fs_bsize, buf, &buf_size);

stand/lib/ext2fs.c

554

struct ext2fs *fs = fp->f_fs;

stand/lib/ext2fs.c

563

buf = malloc(fs->fs_bsize);

stand/lib/ext2fs.c

566

ino_to_db(fs, fp->f_bg, inumber), fs->fs_bsize, buf, &rsize);

stand/lib/ext2fs.c

569

if (rsize != fs->fs_bsize) {

stand/lib/ext2fs.c

575

fp->f_di = dp[ino_to_bo(fs, inumber)];

stand/lib/ext2fs.c

595

struct ext2fs *fs = fp->f_fs;

stand/lib/ext2fs.c

659

malloc(fs->fs_bsize);

stand/lib/ext2fs.c

662

fsb_to_db(fp->f_fs, ind_block_num), fs->fs_bsize,

stand/lib/ext2fs.c

666

if (fp->f_blksize[level] != fs->fs_bsize)

stand/lib/ext2fs.c

695

struct ext2fs *fs = fp->f_fs;

stand/lib/ext2fs.c

702

off = blkoff(fs, fp->f_seekp);

stand/lib/ext2fs.c

703

file_block = lblkno(fs, fp->f_seekp);

stand/lib/ext2fs.c

704

block_size = dblksize(fs, &fp->f_di, file_block);

stand/lib/ext2fs.c

712

fp->f_buf = malloc(fs->fs_bsize);

stand/lib/ext2fs.c

720

fsb_to_db(fs, disk_block), block_size,

stand/lib/ufs.c

119

static void ffs_oldfscompat(struct fs *);

stand/lib/ufs.c

129

struct fs *fs = fp->f_fs;

stand/lib/ufs.c

134

if (fs == NULL)

stand/lib/ufs.c

140

buf = malloc(fs->fs_bsize);

stand/lib/ufs.c

143

fsbtodb(fs, ino_to_fsba(fs, inumber)), fs->fs_bsize,

stand/lib/ufs.c

147

if (rsize != fs->fs_bsize) {

stand/lib/ufs.c

156

fp->f_di = dp[ino_to_fsbo(fs, inumber)];

stand/lib/ufs.c

185

struct fs *fs = fp->f_fs;

stand/lib/ufs.c

250

malloc(fs->fs_bsize);

stand/lib/ufs.c

254

fs->fs_bsize,

stand/lib/ufs.c

259

if (fp->f_blksize[level] != fs->fs_bsize)

stand/lib/ufs.c

292

struct fs *fs = fp->f_fs;

stand/lib/ufs.c

299

off = blkoff(fs, fp->f_seekp);

stand/lib/ufs.c

300

file_block = lblkno(fs, fp->f_seekp);

stand/lib/ufs.c

301

block_size = dblksize(fs, &fp->f_di, file_block);

stand/lib/ufs.c

309

fp->f_buf = malloc(fs->fs_bsize);

stand/lib/ufs.c

317

fsbtodb(fs, disk_block),

stand/lib/ufs.c

406

struct fs *fs;

stand/lib/ufs.c

420

fs = malloc(SBSIZE);

stand/lib/ufs.c

421

fp->f_fs = fs;

stand/lib/ufs.c

424

SBOFF / DEV_BSIZE, SBSIZE, (char *)fs, &buf_size);

stand/lib/ufs.c

428

if (buf_size != SBSIZE || fs->fs_magic != FS_MAGIC ||

stand/lib/ufs.c

429

fs->fs_bsize > MAXBSIZE || fs->fs_bsize < sizeof(struct fs)) {

stand/lib/ufs.c

434

ffs_oldfscompat(fs);

stand/lib/ufs.c

448

mult *= NINDIR(fs);

stand/lib/ufs.c

534

if (link_len < fs->fs_maxsymlinklen) {

stand/lib/ufs.c

543

struct fs *fs = fp->f_fs;

stand/lib/ufs.c

546

buf = malloc(fs->fs_bsize);

stand/lib/ufs.c

553

F_READ, fsbtodb(fs, disk_block),

stand/lib/ufs.c

554

fs->fs_bsize, buf, &buf_size);

stand/lib/ufs.c

725

ffs_oldfscompat(struct fs *fs)

stand/lib/ufs.c

729

fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect); /* XXX */

stand/lib/ufs.c

730

fs->fs_interleave = max(fs->fs_interleave, 1); /* XXX */

stand/lib/ufs.c

731

if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */

stand/lib/ufs.c

732

fs->fs_nrpos = 8; /* XXX */

stand/lib/ufs.c

733

if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */

stand/lib/ufs.c

734

quad_t sizepb = fs->fs_bsize; /* XXX */

stand/lib/ufs.c

736

fs->fs_maxfilesize = fs->fs_bsize * UFS_NDADDR - 1; /* XXX */

stand/lib/ufs.c

738

sizepb *= NINDIR(fs); /* XXX */

stand/lib/ufs.c

739

fs->fs_maxfilesize += sizepb; /* XXX */

stand/lib/ufs.c

741

fs->fs_qbmask = ~fs->fs_bmask; /* XXX */

stand/lib/ufs.c

742

fs->fs_qfmask = ~fs->fs_fmask; /* XXX */

stand/lib/ufs.c

99

struct fs *f_fs; /* pointer to super-block */

sys/bus/firewire/iec68113.h

82

u_int8_t fs:1, /* 50/60 field system

sys/bus/firewire/iec68113.h

89

fs:1; /* 50/60 field system

sys/bus/u4b/uvc/uvc_drv.c

793

struct v4l2_frmsizeenum *fs)

sys/bus/u4b/uvc/uvc_drv.c

801

if (loop->fcc == fs->pixel_format) {

sys/bus/u4b/uvc/uvc_drv.c

810

if (fs->index >= fmt->nfrm)

sys/bus/u4b/uvc/uvc_drv.c

813

frm = fmt->frm + fs->index;

sys/bus/u4b/uvc/uvc_drv.c

814

fs->type = V4L2_FRMSIZE_TYPE_DISCRETE;

sys/bus/u4b/uvc/uvc_drv.c

815

fs->x.discrete.width = frm->width;

sys/bus/u4b/uvc/uvc_drv.c

816

fs->x.discrete.height = frm->height;

sys/bus/u4b/uvc/uvc_drv.h

757

struct v4l2_frmsizeenum *fs);

sys/dev/netif/re/re.c

8005

int fs = 1, ls = 0, TxLen = 0, PktLen;

sys/dev/netif/re/re.c

8081

WritePacket(sc,ptr->m_data,ptr->m_len,fs,ls,opts2,opts1);

sys/dev/netif/re/re.c

8083

fs=0;

sys/dev/virtual/nvmm/x86/nvmm_x86_svm.c

1939

&vmcb->state.fs);

sys/dev/virtual/nvmm/x86/nvmm_x86_svm.c

2089

&vmcb->state.fs);

sys/dev/virtual/nvmm/x86/nvmm_x86_svm.c

431

struct vmcb_segment fs;

sys/net/dummynet/ip_dummynet.c

1004

struct dn_flow_set *fs = NULL;

sys/net/dummynet/ip_dummynet.c

1007

fs = dn_find_flowset(pipe_nr);

sys/net/dummynet/ip_dummynet.c

1013

fs = &p->fs;

sys/net/dummynet/ip_dummynet.c

1015

return fs;

sys/net/dummynet/ip_dummynet.c

1037

struct dn_flow_set *fs;

sys/net/dummynet/ip_dummynet.c

1052

fs = dn_locate_flowset(pipe_nr, is_pipe);

sys/net/dummynet/ip_dummynet.c

1053

if (fs == NULL)

sys/net/dummynet/ip_dummynet.c

1056

pipe = fs->pipe;

sys/net/dummynet/ip_dummynet.c

1058

pipe = dn_find_pipe(fs->parent_nr);

sys/net/dummynet/ip_dummynet.c

1060

fs->pipe = pipe;

sys/net/dummynet/ip_dummynet.c

1063

fs->parent_nr, fs->fs_nr);

sys/net/dummynet/ip_dummynet.c

1068

q = find_queue(fs, &pkt->id);

sys/net/dummynet/ip_dummynet.c

1078

if (fs->plr && krandom() < fs->plr)

sys/net/dummynet/ip_dummynet.c

1081

if (fs->flags_fs & DN_QSIZE_IS_BYTES) {

sys/net/dummynet/ip_dummynet.c

1082

if (q->len_bytes > fs->qsize)

sys/net/dummynet/ip_dummynet.c

1085

if (q->len >= fs->qsize)

sys/net/dummynet/ip_dummynet.c

1089

if ((fs->flags_fs & DN_IS_RED) && red_drops(fs, q, len))

sys/net/dummynet/ip_dummynet.c

1131

pipe->sum += fs->weight; /* Add weight of new queue */

sys/net/dummynet/ip_dummynet.c

1136

q->F = q->S + (len << MY_M) / (uint64_t)fs->weight;

sys/net/dummynet/ip_dummynet.c

1142

fs->backlogged++;

sys/net/dummynet/ip_dummynet.c

1189

purge_flow_set(struct dn_flow_set *fs, int all)

sys/net/dummynet/ip_dummynet.c

1196

for (i = 0; i <= fs->rq_size; i++) {

sys/net/dummynet/ip_dummynet.c

1199

while ((q = LIST_FIRST(&fs->rq[i])) != NULL) {

sys/net/dummynet/ip_dummynet.c

1215

KASSERT(rq_elements == fs->rq_elements,

sys/net/dummynet/ip_dummynet.c

1217

rq_elements, fs->rq_elements));

sys/net/dummynet/ip_dummynet.c

1218

fs->rq_elements = 0;

sys/net/dummynet/ip_dummynet.c

1222

if (fs->w_q_lookup)

sys/net/dummynet/ip_dummynet.c

1223

kfree(fs->w_q_lookup, M_DUMMYNET);

sys/net/dummynet/ip_dummynet.c

1225

if (fs->rq)

sys/net/dummynet/ip_dummynet.c

1226

kfree(fs->rq, M_DUMMYNET);

sys/net/dummynet/ip_dummynet.c

1236

if (fs->pipe == NULL || (fs->pipe && fs != &fs->pipe->fs))

sys/net/dummynet/ip_dummynet.c

1237

kfree(fs, M_DUMMYNET);

sys/net/dummynet/ip_dummynet.c

1251

purge_flow_set(&pipe->fs, 1);

sys/net/dummynet/ip_dummynet.c

1272

struct dn_flow_set *fs;

sys/net/dummynet/ip_dummynet.c

1295

while ((fs = LIST_FIRST(fs_hdr)) != NULL) {

sys/net/dummynet/ip_dummynet.c

1296

LIST_REMOVE(fs, fs_link);

sys/net/dummynet/ip_dummynet.c

1297

LIST_INSERT_HEAD(&fs_list, fs, fs_link);

sys/net/dummynet/ip_dummynet.c

1311

while ((fs = LIST_FIRST(&fs_list)) != NULL) {

sys/net/dummynet/ip_dummynet.c

1312

LIST_REMOVE(fs, fs_link);

sys/net/dummynet/ip_dummynet.c

1313

purge_flow_set(fs, 1);

sys/net/dummynet/ip_dummynet.c

1457

struct dn_ioc_flowset *ioc_fs = &ioc_pipe->fs;

sys/net/dummynet/ip_dummynet.c

1494

x->fs.pipe = x;

sys/net/dummynet/ip_dummynet.c

1508

for (i = 0; i <= x->fs.rq_size; i++) {

sys/net/dummynet/ip_dummynet.c

1511

LIST_FOREACH(q, &x->fs.rq[i], q_link)

sys/net/dummynet/ip_dummynet.c

1520

set_fs_parms(&x->fs, ioc_fs);

sys/net/dummynet/ip_dummynet.c

1522

if (x->fs.rq == NULL) { /* A new pipe */

sys/net/dummynet/ip_dummynet.c

1525

alloc_hash(&x->fs, ioc_fs);

sys/net/dummynet/ip_dummynet.c

1532

struct dn_flow_set *x, *fs;

sys/net/dummynet/ip_dummynet.c

1535

fs = dn_find_flowset(ioc_fs->fs_nr);

sys/net/dummynet/ip_dummynet.c

1537

if (fs == NULL) { /* New flow_set */

sys/net/dummynet/ip_dummynet.c

1552

if (ioc_fs->parent_nr != 0 && fs->parent_nr != ioc_fs->parent_nr)

sys/net/dummynet/ip_dummynet.c

1554

x = fs;

sys/net/dummynet/ip_dummynet.c

1590

fs_remove_from_heap(struct dn_heap *h, struct dn_flow_set *fs)

sys/net/dummynet/ip_dummynet.c

1595

if (((struct dn_flow_queue *)h->p[i].object)->fs == fs) {

sys/net/dummynet/ip_dummynet.c

1628

dn_unref_pipe_cb(struct dn_flow_set *fs, void *pipe0)

sys/net/dummynet/ip_dummynet.c

1632

if (fs->pipe == pipe) {

sys/net/dummynet/ip_dummynet.c

1634

pipe->pipe_nr, fs->fs_nr);

sys/net/dummynet/ip_dummynet.c

1635

fs->pipe = NULL;

sys/net/dummynet/ip_dummynet.c

1636

purge_flow_set(fs, 0);

sys/net/dummynet/ip_dummynet.c

1649

if (ioc_pipe->pipe_nr == 0 && ioc_pipe->fs.fs_nr == 0)

sys/net/dummynet/ip_dummynet.c

1651

if (ioc_pipe->pipe_nr != 0 && ioc_pipe->fs.fs_nr != 0)

sys/net/dummynet/ip_dummynet.c

1673

fs_remove_from_heap(&ready_heap, &p->fs);

sys/net/dummynet/ip_dummynet.c

1682

struct dn_flow_set *fs;

sys/net/dummynet/ip_dummynet.c

1685

fs = dn_find_flowset(ioc_pipe->fs.fs_nr);

sys/net/dummynet/ip_dummynet.c

1686

if (fs == NULL)

sys/net/dummynet/ip_dummynet.c

1689

LIST_REMOVE(fs, fs_link);

sys/net/dummynet/ip_dummynet.c

1692

if ((p = fs->pipe) != NULL) {

sys/net/dummynet/ip_dummynet.c

1694

p->sum -= fs->weight * fs->backlogged;

sys/net/dummynet/ip_dummynet.c

1695

fs_remove_from_heap(&p->not_eligible_heap, fs);

sys/net/dummynet/ip_dummynet.c

1696

fs_remove_from_heap(&p->scheduler_heap, fs);

sys/net/dummynet/ip_dummynet.c

1698

fs_remove_from_heap(&p->idle_heap, fs);

sys/net/dummynet/ip_dummynet.c

1701

purge_flow_set(fs, 1);

sys/net/dummynet/ip_dummynet.c

1734

dn_copy_flowqueues(const struct dn_flow_set *fs, void *bp)

sys/net/dummynet/ip_dummynet.c

1739

for (i = 0; i <= fs->rq_size; i++) {

sys/net/dummynet/ip_dummynet.c

1742

LIST_FOREACH(q, &fs->rq[i], q_link) {

sys/net/dummynet/ip_dummynet.c

1747

if (q->fs != fs) { /* XXX ASSERT */

sys/net/dummynet/ip_dummynet.c

1749

i, q->fs, fs);

sys/net/dummynet/ip_dummynet.c

1768

if (copied != fs->rq_elements) { /* XXX ASSERT */

sys/net/dummynet/ip_dummynet.c

1770

copied, fs->rq_elements);

sys/net/dummynet/ip_dummynet.c

1776

dn_copy_flowset(const struct dn_flow_set *fs, struct dn_ioc_flowset *ioc_fs,

sys/net/dummynet/ip_dummynet.c

1781

ioc_fs->fs_nr = fs->fs_nr;

sys/net/dummynet/ip_dummynet.c

1782

ioc_fs->flags_fs = fs->flags_fs;

sys/net/dummynet/ip_dummynet.c

1783

ioc_fs->parent_nr = fs->parent_nr;

sys/net/dummynet/ip_dummynet.c

1785

ioc_fs->weight = fs->weight;

sys/net/dummynet/ip_dummynet.c

1786

ioc_fs->qsize = fs->qsize;

sys/net/dummynet/ip_dummynet.c

1787

ioc_fs->plr = fs->plr;

sys/net/dummynet/ip_dummynet.c

1789

ioc_fs->rq_size = fs->rq_size;

sys/net/dummynet/ip_dummynet.c

1790

ioc_fs->rq_elements = fs->rq_elements;

sys/net/dummynet/ip_dummynet.c

1792

ioc_fs->w_q = fs->w_q;

sys/net/dummynet/ip_dummynet.c

1793

ioc_fs->max_th = fs->max_th;

sys/net/dummynet/ip_dummynet.c

1794

ioc_fs->min_th = fs->min_th;

sys/net/dummynet/ip_dummynet.c

1795

ioc_fs->max_p = fs->max_p;

sys/net/dummynet/ip_dummynet.c

1797

dn_copy_flowid(&fs->flow_mask, &ioc_fs->flow_mask);

sys/net/dummynet/ip_dummynet.c

1806

pipe->fs.rq_elements * sizeof(struct dn_ioc_flowqueue);

sys/net/dummynet/ip_dummynet.c

1810

dn_calc_fs_size_cb(struct dn_flow_set *fs, void *sz)

sys/net/dummynet/ip_dummynet.c

1815

fs->rq_elements * sizeof(struct dn_ioc_flowqueue);

sys/net/dummynet/ip_dummynet.c

1827

dn_copy_flowset(&pipe->fs, &ioc_pipe->fs, DN_IS_PIPE);

sys/net/dummynet/ip_dummynet.c

1842

*bp = dn_copy_flowqueues(&pipe->fs, *bp);

sys/net/dummynet/ip_dummynet.c

1846

dn_copyout_fs_cb(struct dn_flow_set *fs, void *bp0)

sys/net/dummynet/ip_dummynet.c

1854

dn_copy_flowset(fs, ioc_fs, DN_IS_QUEUE);

sys/net/dummynet/ip_dummynet.c

1860

*bp = dn_copy_flowqueues(fs, *bp);

sys/net/dummynet/ip_dummynet.c

463

struct dn_pipe *p = q->fs->pipe;

sys/net/dummynet/ip_dummynet.c

547

struct dn_flow_set *fs = q->fs;

sys/net/dummynet/ip_dummynet.c

559

fs->backlogged--;

sys/net/dummynet/ip_dummynet.c

567

q->F += (len << MY_M) / (uint64_t)fs->weight;

sys/net/dummynet/ip_dummynet.c

650

pipe->sum -= q->fs->weight;

sys/net/dummynet/ip_dummynet.c

705

expire_queues(struct dn_flow_set *fs)

sys/net/dummynet/ip_dummynet.c

707

int i, initial_elements = fs->rq_elements;

sys/net/dummynet/ip_dummynet.c

709

if (fs->last_expired == time_uptime)

sys/net/dummynet/ip_dummynet.c

712

fs->last_expired = time_uptime;

sys/net/dummynet/ip_dummynet.c

714

for (i = 0; i <= fs->rq_size; i++) { /* Last one is overflow */

sys/net/dummynet/ip_dummynet.c

717

LIST_FOREACH_MUTABLE(q, &fs->rq[i], q_link, qn) {

sys/net/dummynet/ip_dummynet.c

727

KASSERT(fs->rq_elements > 0,

sys/net/dummynet/ip_dummynet.c

728

("invalid rq_elements %d", fs->rq_elements));

sys/net/dummynet/ip_dummynet.c

729

fs->rq_elements--;

sys/net/dummynet/ip_dummynet.c

732

return initial_elements - fs->rq_elements;

sys/net/dummynet/ip_dummynet.c

740

create_queue(struct dn_flow_set *fs, int i)

sys/net/dummynet/ip_dummynet.c

744

if (fs->rq_elements > fs->rq_size * dn_max_ratio &&

sys/net/dummynet/ip_dummynet.c

745

expire_queues(fs) == 0) {

sys/net/dummynet/ip_dummynet.c

749

i = fs->rq_size;

sys/net/dummynet/ip_dummynet.c

750

if (!LIST_EMPTY(&fs->rq[i]))

sys/net/dummynet/ip_dummynet.c

751

return LIST_FIRST(&fs->rq[i]);

sys/net/dummynet/ip_dummynet.c

758

q->fs = fs;

sys/net/dummynet/ip_dummynet.c

763

LIST_INSERT_HEAD(&fs->rq[i], q, q_link);

sys/net/dummynet/ip_dummynet.c

764

fs->rq_elements++;

sys/net/dummynet/ip_dummynet.c

775

find_queue(struct dn_flow_set *fs, struct dn_flow_id *id)

sys/net/dummynet/ip_dummynet.c

780

if (!(fs->flags_fs & DN_HAVE_FLOW_MASK)) {

sys/net/dummynet/ip_dummynet.c

781

q = LIST_FIRST(&fs->rq[0]);

sys/net/dummynet/ip_dummynet.c

786

id->fid_dst_ip &= fs->flow_mask.fid_dst_ip;

sys/net/dummynet/ip_dummynet.c

787

id->fid_src_ip &= fs->flow_mask.fid_src_ip;

sys/net/dummynet/ip_dummynet.c

788

id->fid_dst_port &= fs->flow_mask.fid_dst_port;

sys/net/dummynet/ip_dummynet.c

789

id->fid_src_port &= fs->flow_mask.fid_src_port;

sys/net/dummynet/ip_dummynet.c

790

id->fid_proto &= fs->flow_mask.fid_proto;

sys/net/dummynet/ip_dummynet.c

800

i = i % fs->rq_size;

sys/net/dummynet/ip_dummynet.c

807

LIST_FOREACH_MUTABLE(q, &fs->rq[i], q_link, qn) {

sys/net/dummynet/ip_dummynet.c

824

KASSERT(fs->rq_elements > 0,

sys/net/dummynet/ip_dummynet.c

825

("invalid rq_elements %d", fs->rq_elements));

sys/net/dummynet/ip_dummynet.c

826

fs->rq_elements--;

sys/net/dummynet/ip_dummynet.c

829

if (q && LIST_FIRST(&fs->rq[i]) != q) { /* Found and not in front */

sys/net/dummynet/ip_dummynet.c

831

LIST_INSERT_HEAD(&fs->rq[i], q, q_link);

sys/net/dummynet/ip_dummynet.c

835

q = create_queue(fs, i);

sys/net/dummynet/ip_dummynet.c

843

red_drops(struct dn_flow_set *fs, struct dn_flow_queue *q, int len)

sys/net/dummynet/ip_dummynet.c

863

u_int q_size = (fs->flags_fs & DN_QSIZE_IS_BYTES) ? q->len_bytes : q->len;

sys/net/dummynet/ip_dummynet.c

873

int64_t v = SCALE_MUL((int64_t)diff, (int64_t)fs->w_q);

sys/net/dummynet/ip_dummynet.c

885

u_int t = (curr_time - q->q_time) / fs->lookup_step;

sys/net/dummynet/ip_dummynet.c

887

q->avg = (t < fs->lookup_depth) ?

sys/net/dummynet/ip_dummynet.c

888

SCALE_MUL(q->avg, fs->w_q_lookup[t]) : 0;

sys/net/dummynet/ip_dummynet.c

895

if (q->avg < fs->min_th) {

sys/net/dummynet/ip_dummynet.c

901

if (q->avg >= fs->max_th) { /* Average queue >= Max threshold */

sys/net/dummynet/ip_dummynet.c

902

if (fs->flags_fs & DN_IS_GENTLE_RED) {

sys/net/dummynet/ip_dummynet.c

909

p_b = SCALE_MUL((int64_t)fs->c_3, (int64_t)q->avg) - fs->c_4;

sys/net/dummynet/ip_dummynet.c

915

} else if (q->avg > fs->min_th) {

sys/net/dummynet/ip_dummynet.c

921

p_b = SCALE_MUL((int64_t)fs->c_1, (int64_t)q->avg) - fs->c_2;

sys/net/dummynet/ip_dummynet.c

923

if (fs->flags_fs & DN_QSIZE_IS_BYTES)

sys/net/dummynet/ip_dummynet.c

924

p_b = (p_b * len) / fs->max_pkt_size;

sys/net/dummynet/ip_dummynet.c

966

struct dn_flow_set *fs, *fs_next;

sys/net/dummynet/ip_dummynet.c

968

LIST_FOREACH_MUTABLE(fs, fs_hdr, fs_link, fs_next)

sys/net/dummynet/ip_dummynet.c

969

func(fs, arg);

sys/net/dummynet/ip_dummynet.c

991

struct dn_flow_set *fs;

sys/net/dummynet/ip_dummynet.c

994

LIST_FOREACH(fs, fs_hdr, fs_link) {

sys/net/dummynet/ip_dummynet.c

995

if (fs->fs_nr == fs_nr)

sys/net/dummynet/ip_dummynet.c

998

return fs;

sys/net/dummynet/ip_dummynet.h

240

struct dn_flow_set *fs; /* parent flow set */

sys/net/dummynet/ip_dummynet.h

335

struct dn_flow_set fs; /* used with fixed-rate flows */

sys/net/dummynet/ip_dummynet.h

420

struct dn_ioc_flowset fs; /* MUST be first */

sys/net/dummynet3/ip_dummynet3.c

1010

struct dn_flow_set *fs;

sys/net/dummynet3/ip_dummynet3.c

1013

LIST_FOREACH(fs, fs_hdr, fs_link) {

sys/net/dummynet3/ip_dummynet3.c

1014

if (fs->fs_nr == fs_nr)

sys/net/dummynet3/ip_dummynet3.c

1017

return fs;

sys/net/dummynet3/ip_dummynet3.c

1023

struct dn_flow_set *fs = NULL;

sys/net/dummynet3/ip_dummynet3.c

1026

fs = dn_find_flowset(pipe_nr);

sys/net/dummynet3/ip_dummynet3.c

1032

fs = &p->fs;

sys/net/dummynet3/ip_dummynet3.c

1034

return fs;

sys/net/dummynet3/ip_dummynet3.c

1056

struct dn_flow_set *fs;

sys/net/dummynet3/ip_dummynet3.c

1071

fs = dn_locate_flowset(pipe_nr, is_pipe);

sys/net/dummynet3/ip_dummynet3.c

1072

if (fs == NULL)

sys/net/dummynet3/ip_dummynet3.c

1075

pipe = fs->pipe;

sys/net/dummynet3/ip_dummynet3.c

1077

pipe = dn_find_pipe(fs->parent_nr);

sys/net/dummynet3/ip_dummynet3.c

1079

fs->pipe = pipe;

sys/net/dummynet3/ip_dummynet3.c

1082

fs->parent_nr, fs->fs_nr);

sys/net/dummynet3/ip_dummynet3.c

1087

q = find_queue(fs, &pkt->id);

sys/net/dummynet3/ip_dummynet3.c

1097

if (fs->plr && krandom() < fs->plr)

sys/net/dummynet3/ip_dummynet3.c

1100

if (fs->flags_fs & DN_QSIZE_IS_BYTES) {

sys/net/dummynet3/ip_dummynet3.c

1101

if (q->len_bytes > fs->qsize)

sys/net/dummynet3/ip_dummynet3.c

1104

if (q->len >= fs->qsize)

sys/net/dummynet3/ip_dummynet3.c

1108

if ((fs->flags_fs & DN_IS_RED) && red_drops(fs, q, len))

sys/net/dummynet3/ip_dummynet3.c

1150

pipe->sum += fs->weight; /* Add weight of new queue */

sys/net/dummynet3/ip_dummynet3.c

1155

q->F = q->S + (len << MY_M) / (uint64_t)fs->weight;

sys/net/dummynet3/ip_dummynet3.c

1161

fs->backlogged++;

sys/net/dummynet3/ip_dummynet3.c

1208

purge_flow_set(struct dn_flow_set *fs, int all)

sys/net/dummynet3/ip_dummynet3.c

1215

for (i = 0; i <= fs->rq_size; i++) {

sys/net/dummynet3/ip_dummynet3.c

1218

while ((q = LIST_FIRST(&fs->rq[i])) != NULL) {

sys/net/dummynet3/ip_dummynet3.c

1234

KASSERT(rq_elements == fs->rq_elements,

sys/net/dummynet3/ip_dummynet3.c

1236

rq_elements, fs->rq_elements));

sys/net/dummynet3/ip_dummynet3.c

1237

fs->rq_elements = 0;

sys/net/dummynet3/ip_dummynet3.c

1241

if (fs->w_q_lookup)

sys/net/dummynet3/ip_dummynet3.c

1242

kfree(fs->w_q_lookup, M_DUMMYNET);

sys/net/dummynet3/ip_dummynet3.c

1244

if (fs->rq)

sys/net/dummynet3/ip_dummynet3.c

1245

kfree(fs->rq, M_DUMMYNET);

sys/net/dummynet3/ip_dummynet3.c

1255

if (fs->pipe == NULL || (fs->pipe && fs != &fs->pipe->fs))

sys/net/dummynet3/ip_dummynet3.c

1256

kfree(fs, M_DUMMYNET);

sys/net/dummynet3/ip_dummynet3.c

1270

purge_flow_set(&pipe->fs, 1);

sys/net/dummynet3/ip_dummynet3.c

1291

struct dn_flow_set *fs;

sys/net/dummynet3/ip_dummynet3.c

1311

while ((fs = LIST_FIRST(fs_hdr)) != NULL) {

sys/net/dummynet3/ip_dummynet3.c

1312

LIST_REMOVE(fs, fs_link);

sys/net/dummynet3/ip_dummynet3.c

1313

LIST_INSERT_HEAD(&fs_list, fs, fs_link);

sys/net/dummynet3/ip_dummynet3.c

1326

while ((fs = LIST_FIRST(&fs_list)) != NULL) {

sys/net/dummynet3/ip_dummynet3.c

1327

LIST_REMOVE(fs, fs_link);

sys/net/dummynet3/ip_dummynet3.c

1328

purge_flow_set(fs, 1);

sys/net/dummynet3/ip_dummynet3.c

1462

struct dn_ioc_flowset *ioc_fs = &ioc_pipe->fs;

sys/net/dummynet3/ip_dummynet3.c

1497

x->fs.pipe = x;

sys/net/dummynet3/ip_dummynet3.c

1511

for (i = 0; i <= x->fs.rq_size; i++) {

sys/net/dummynet3/ip_dummynet3.c

1514

LIST_FOREACH(q, &x->fs.rq[i], q_link)

sys/net/dummynet3/ip_dummynet3.c

1523

set_fs_parms(&x->fs, ioc_fs);

sys/net/dummynet3/ip_dummynet3.c

1525

if (x->fs.rq == NULL) { /* A new pipe */

sys/net/dummynet3/ip_dummynet3.c

1528

alloc_hash(&x->fs, ioc_fs);

sys/net/dummynet3/ip_dummynet3.c

1534

struct dn_flow_set *x, *fs;

sys/net/dummynet3/ip_dummynet3.c

1537

fs = dn_find_flowset(ioc_fs->fs_nr);

sys/net/dummynet3/ip_dummynet3.c

1539

if (fs == NULL) { /* New flow_set */

sys/net/dummynet3/ip_dummynet3.c

1554

if (ioc_fs->parent_nr != 0 && fs->parent_nr != ioc_fs->parent_nr)

sys/net/dummynet3/ip_dummynet3.c

1556

x = fs;

sys/net/dummynet3/ip_dummynet3.c

1581

fs_remove_from_heap(struct dn_heap *h, struct dn_flow_set *fs)

sys/net/dummynet3/ip_dummynet3.c

1586

if (((struct dn_flow_queue *)h->p[i].object)->fs == fs) {

sys/net/dummynet3/ip_dummynet3.c

1619

dn_unref_pipe_cb(struct dn_flow_set *fs, void *pipe0)

sys/net/dummynet3/ip_dummynet3.c

1623

if (fs->pipe == pipe) {

sys/net/dummynet3/ip_dummynet3.c

1625

pipe->pipe_nr, fs->fs_nr);

sys/net/dummynet3/ip_dummynet3.c

1626

fs->pipe = NULL;

sys/net/dummynet3/ip_dummynet3.c

1627

purge_flow_set(fs, 0);

sys/net/dummynet3/ip_dummynet3.c

1640

if (ioc_pipe->pipe_nr == 0 && ioc_pipe->fs.fs_nr == 0)

sys/net/dummynet3/ip_dummynet3.c

1642

if (ioc_pipe->pipe_nr != 0 && ioc_pipe->fs.fs_nr != 0)

sys/net/dummynet3/ip_dummynet3.c

1661

fs_remove_from_heap(&ready_heap, &p->fs);

sys/net/dummynet3/ip_dummynet3.c

1670

struct dn_flow_set *fs;

sys/net/dummynet3/ip_dummynet3.c

1673

fs = dn_find_flowset(ioc_pipe->fs.fs_nr);

sys/net/dummynet3/ip_dummynet3.c

1674

if (fs == NULL)

sys/net/dummynet3/ip_dummynet3.c

1677

LIST_REMOVE(fs, fs_link);

sys/net/dummynet3/ip_dummynet3.c

1679

if ((p = fs->pipe) != NULL) {

sys/net/dummynet3/ip_dummynet3.c

1681

p->sum -= fs->weight * fs->backlogged;

sys/net/dummynet3/ip_dummynet3.c

1682

fs_remove_from_heap(&p->not_eligible_heap, fs);

sys/net/dummynet3/ip_dummynet3.c

1683

fs_remove_from_heap(&p->scheduler_heap, fs);

sys/net/dummynet3/ip_dummynet3.c

1685

fs_remove_from_heap(&p->idle_heap, fs);

sys/net/dummynet3/ip_dummynet3.c

1688

purge_flow_set(fs, 1);

sys/net/dummynet3/ip_dummynet3.c

1712

dn_copy_flowqueues(const struct dn_flow_set *fs, void *bp)

sys/net/dummynet3/ip_dummynet3.c

1717

for (i = 0; i <= fs->rq_size; i++) {

sys/net/dummynet3/ip_dummynet3.c

1720

LIST_FOREACH(q, &fs->rq[i], q_link) {

sys/net/dummynet3/ip_dummynet3.c

1726

if (q->fs != fs) { /* XXX ASSERT */

sys/net/dummynet3/ip_dummynet3.c

1728

i, q->fs, fs);

sys/net/dummynet3/ip_dummynet3.c

1747

if (copied != fs->rq_elements) { /* XXX ASSERT */

sys/net/dummynet3/ip_dummynet3.c

1749

copied, fs->rq_elements);

sys/net/dummynet3/ip_dummynet3.c

1755

dn_copy_flowset(const struct dn_flow_set *fs, struct dn_ioc_flowset *ioc_fs,

sys/net/dummynet3/ip_dummynet3.c

1760

ioc_fs->fs_nr = fs->fs_nr;

sys/net/dummynet3/ip_dummynet3.c

1761

ioc_fs->flags_fs = fs->flags_fs;

sys/net/dummynet3/ip_dummynet3.c

1762

ioc_fs->parent_nr = fs->parent_nr;

sys/net/dummynet3/ip_dummynet3.c

1764

ioc_fs->weight = fs->weight;

sys/net/dummynet3/ip_dummynet3.c

1765

ioc_fs->qsize = fs->qsize;

sys/net/dummynet3/ip_dummynet3.c

1766

ioc_fs->plr = fs->plr;

sys/net/dummynet3/ip_dummynet3.c

1768

ioc_fs->rq_size = fs->rq_size;

sys/net/dummynet3/ip_dummynet3.c

1769

ioc_fs->rq_elements = fs->rq_elements;

sys/net/dummynet3/ip_dummynet3.c

1771

ioc_fs->w_q = fs->w_q;

sys/net/dummynet3/ip_dummynet3.c

1772

ioc_fs->max_th = fs->max_th;

sys/net/dummynet3/ip_dummynet3.c

1773

ioc_fs->min_th = fs->min_th;

sys/net/dummynet3/ip_dummynet3.c

1774

ioc_fs->max_p = fs->max_p;

sys/net/dummynet3/ip_dummynet3.c

1776

dn_copy_flowid(&fs->flow_mask, &ioc_fs->flow_mask);

sys/net/dummynet3/ip_dummynet3.c

1785

pipe->fs.rq_elements * sizeof(struct dn_ioc_flowqueue);

sys/net/dummynet3/ip_dummynet3.c

1789

dn_calc_fs_size_cb(struct dn_flow_set *fs, void *sz)

sys/net/dummynet3/ip_dummynet3.c

1794

fs->rq_elements * sizeof(struct dn_ioc_flowqueue);

sys/net/dummynet3/ip_dummynet3.c

1806

dn_copy_flowset(&pipe->fs, &ioc_pipe->fs, DN_IS_PIPE);

sys/net/dummynet3/ip_dummynet3.c

1821

*bp = dn_copy_flowqueues(&pipe->fs, *bp);

sys/net/dummynet3/ip_dummynet3.c

1825

dn_copyout_fs_cb(struct dn_flow_set *fs, void *bp0)

sys/net/dummynet3/ip_dummynet3.c

1833

dn_copy_flowset(fs, ioc_fs, DN_IS_QUEUE);

sys/net/dummynet3/ip_dummynet3.c

1839

*bp = dn_copy_flowqueues(fs, *bp);

sys/net/dummynet3/ip_dummynet3.c

482

struct dn_pipe *p = q->fs->pipe;

sys/net/dummynet3/ip_dummynet3.c

566

struct dn_flow_set *fs = q->fs;

sys/net/dummynet3/ip_dummynet3.c

578

fs->backlogged--;

sys/net/dummynet3/ip_dummynet3.c

586

q->F += (len << MY_M) / (uint64_t)fs->weight;

sys/net/dummynet3/ip_dummynet3.c

669

pipe->sum -= q->fs->weight;

sys/net/dummynet3/ip_dummynet3.c

724

expire_queues(struct dn_flow_set *fs)

sys/net/dummynet3/ip_dummynet3.c

726

int i, initial_elements = fs->rq_elements;

sys/net/dummynet3/ip_dummynet3.c

728

if (fs->last_expired == time_uptime)

sys/net/dummynet3/ip_dummynet3.c

731

fs->last_expired = time_uptime;

sys/net/dummynet3/ip_dummynet3.c

733

for (i = 0; i <= fs->rq_size; i++) { /* Last one is overflow */

sys/net/dummynet3/ip_dummynet3.c

736

LIST_FOREACH_MUTABLE(q, &fs->rq[i], q_link, qn) {

sys/net/dummynet3/ip_dummynet3.c

746

KASSERT(fs->rq_elements > 0,

sys/net/dummynet3/ip_dummynet3.c

747

("invalid rq_elements %d", fs->rq_elements));

sys/net/dummynet3/ip_dummynet3.c

748

fs->rq_elements--;

sys/net/dummynet3/ip_dummynet3.c

751

return initial_elements - fs->rq_elements;

sys/net/dummynet3/ip_dummynet3.c

759

create_queue(struct dn_flow_set *fs, int i)

sys/net/dummynet3/ip_dummynet3.c

763

if (fs->rq_elements > fs->rq_size * dn_max_ratio &&

sys/net/dummynet3/ip_dummynet3.c

764

expire_queues(fs) == 0) {

sys/net/dummynet3/ip_dummynet3.c

768

i = fs->rq_size;

sys/net/dummynet3/ip_dummynet3.c

769

if (!LIST_EMPTY(&fs->rq[i]))

sys/net/dummynet3/ip_dummynet3.c

770

return LIST_FIRST(&fs->rq[i]);

sys/net/dummynet3/ip_dummynet3.c

777

q->fs = fs;

sys/net/dummynet3/ip_dummynet3.c

782

LIST_INSERT_HEAD(&fs->rq[i], q, q_link);

sys/net/dummynet3/ip_dummynet3.c

783

fs->rq_elements++;

sys/net/dummynet3/ip_dummynet3.c

794

find_queue(struct dn_flow_set *fs, struct dn_flow_id *id)

sys/net/dummynet3/ip_dummynet3.c

799

if (!(fs->flags_fs & DN_HAVE_FLOW_MASK)) {

sys/net/dummynet3/ip_dummynet3.c

800

q = LIST_FIRST(&fs->rq[0]);

sys/net/dummynet3/ip_dummynet3.c

805

id->fid_dst_ip &= fs->flow_mask.fid_dst_ip;

sys/net/dummynet3/ip_dummynet3.c

806

id->fid_src_ip &= fs->flow_mask.fid_src_ip;

sys/net/dummynet3/ip_dummynet3.c

807

id->fid_dst_port &= fs->flow_mask.fid_dst_port;

sys/net/dummynet3/ip_dummynet3.c

808

id->fid_src_port &= fs->flow_mask.fid_src_port;

sys/net/dummynet3/ip_dummynet3.c

809

id->fid_proto &= fs->flow_mask.fid_proto;

sys/net/dummynet3/ip_dummynet3.c

819

i = i % fs->rq_size;

sys/net/dummynet3/ip_dummynet3.c

826

LIST_FOREACH_MUTABLE(q, &fs->rq[i], q_link, qn) {

sys/net/dummynet3/ip_dummynet3.c

843

KASSERT(fs->rq_elements > 0,

sys/net/dummynet3/ip_dummynet3.c

844

("invalid rq_elements %d", fs->rq_elements));

sys/net/dummynet3/ip_dummynet3.c

845

fs->rq_elements--;

sys/net/dummynet3/ip_dummynet3.c

848

if (q && LIST_FIRST(&fs->rq[i]) != q) { /* Found and not in front */

sys/net/dummynet3/ip_dummynet3.c

850

LIST_INSERT_HEAD(&fs->rq[i], q, q_link);

sys/net/dummynet3/ip_dummynet3.c

854

q = create_queue(fs, i);

sys/net/dummynet3/ip_dummynet3.c

862

red_drops(struct dn_flow_set *fs, struct dn_flow_queue *q, int len)

sys/net/dummynet3/ip_dummynet3.c

882

u_int q_size = (fs->flags_fs & DN_QSIZE_IS_BYTES) ? q->len_bytes : q->len;

sys/net/dummynet3/ip_dummynet3.c

892

int64_t v = SCALE_MUL((int64_t)diff, (int64_t)fs->w_q);

sys/net/dummynet3/ip_dummynet3.c

904

u_int t = (curr_time - q->q_time) / fs->lookup_step;

sys/net/dummynet3/ip_dummynet3.c

906

q->avg = (t < fs->lookup_depth) ?

sys/net/dummynet3/ip_dummynet3.c

907

SCALE_MUL(q->avg, fs->w_q_lookup[t]) : 0;

sys/net/dummynet3/ip_dummynet3.c

914

if (q->avg < fs->min_th) {

sys/net/dummynet3/ip_dummynet3.c

920

if (q->avg >= fs->max_th) { /* Average queue >= Max threshold */

sys/net/dummynet3/ip_dummynet3.c

921

if (fs->flags_fs & DN_IS_GENTLE_RED) {

sys/net/dummynet3/ip_dummynet3.c

928

p_b = SCALE_MUL((int64_t)fs->c_3, (int64_t)q->avg) - fs->c_4;

sys/net/dummynet3/ip_dummynet3.c

934

} else if (q->avg > fs->min_th) {

sys/net/dummynet3/ip_dummynet3.c

940

p_b = SCALE_MUL((int64_t)fs->c_1, (int64_t)q->avg) - fs->c_2;

sys/net/dummynet3/ip_dummynet3.c

942

if (fs->flags_fs & DN_QSIZE_IS_BYTES)

sys/net/dummynet3/ip_dummynet3.c

943

p_b = (p_b * len) / fs->max_pkt_size;

sys/net/dummynet3/ip_dummynet3.c

985

struct dn_flow_set *fs, *fs_next;

sys/net/dummynet3/ip_dummynet3.c

987

LIST_FOREACH_MUTABLE(fs, fs_hdr, fs_link, fs_next)

sys/net/dummynet3/ip_dummynet3.c

988

func(fs, arg);

sys/net/dummynet3/ip_dummynet3.h

255

struct dn_flow_set *fs; /* parent flow set */

sys/net/dummynet3/ip_dummynet3.h

350

struct dn_flow_set fs; /* used with fixed-rate flows */

sys/net/dummynet3/ip_dummynet3.h

435

struct dn_ioc_flowset fs; /* MUST be first */

sys/vfs/ext2fs/ext2_alloc.c

1000

(int)fs->e2fs_bsize, &bp);

sys/vfs/ext2fs/ext2_alloc.c

1004

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||

sys/vfs/ext2fs/ext2_alloc.c

1005

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/vfs/ext2fs/ext2_alloc.c

1006

error = ext2_cg_block_bitmap_init(fs, cg, bp);

sys/vfs/ext2fs/ext2_alloc.c

1010

ext2_gd_b_bitmap_csum_set(fs, cg, bp);

sys/vfs/ext2fs/ext2_alloc.c

1012

error = ext2_gd_b_bitmap_csum_verify(fs, cg, bp);

sys/vfs/ext2fs/ext2_alloc.c

1016

error = ext2_b_bitmap_validate(fs,bp, cg);

sys/vfs/ext2fs/ext2_alloc.c

1024

if (e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) == 0)

sys/vfs/ext2fs/ext2_alloc.c

1029

if (dtog(fs, bpref) != cg)

sys/vfs/ext2fs/ext2_alloc.c

1032

bpref = dtogd(fs, bpref);

sys/vfs/ext2fs/ext2_alloc.c

1048

start = dtogd(fs, bpref) / NBBY;

sys/vfs/ext2fs/ext2_alloc.c

1051

end = howmany(fs->e2fs_fpg, NBBY) - start;

sys/vfs/ext2fs/ext2_alloc.c

107

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

1098

bno = ext2_mapsearch(fs, bbp, bpref);

sys/vfs/ext2fs/ext2_alloc.c

1106

cg, (intmax_t)bno, fs->e2fs_fsmnt);

sys/vfs/ext2fs/ext2_alloc.c

1112

ext2_clusteracct(fs, bbp, cg, bno, -1);

sys/vfs/ext2fs/ext2_alloc.c

1113

fs->e2fs_fbcount--;

sys/vfs/ext2fs/ext2_alloc.c

1114

e2fs_gd_set_nbfree(&fs->e2fs_gd[cg],

sys/vfs/ext2fs/ext2_alloc.c

1115

e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) - 1);

sys/vfs/ext2fs/ext2_alloc.c

1116

fs->e2fs_fmod = 1;

sys/vfs/ext2fs/ext2_alloc.c

1118

ext2_gd_b_bitmap_csum_set(fs, cg, bp);

sys/vfs/ext2fs/ext2_alloc.c

1120

return (((uint64_t)cg) * fs->e2fs_fpg +

sys/vfs/ext2fs/ext2_alloc.c

1121

le32toh(fs->e2fs->e2fs_first_dblock) + bno);

sys/vfs/ext2fs/ext2_alloc.c

113

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

1135

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

1143

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

1146

if (fs->e2fs_maxcluster[cg] < len)

sys/vfs/ext2fs/ext2_alloc.c

1151

fsbtodoff(fs, e2fs_gd_get_b_bitmap(&fs->e2fs_gd[cg])),

sys/vfs/ext2fs/ext2_alloc.c

1152

(int)fs->e2fs_bsize, &bp);

sys/vfs/ext2fs/ext2_alloc.c

1162

lp = &fs->e2fs_clustersum[cg].cs_sum[len];

sys/vfs/ext2fs/ext2_alloc.c

1163

for (i = len; i <= fs->e2fs_contigsumsize; i++)

sys/vfs/ext2fs/ext2_alloc.c

1166

if (i > fs->e2fs_contigsumsize) {

sys/vfs/ext2fs/ext2_alloc.c

117

if ((u_int)size > fs->e2fs_bsize || blkoff(fs, size) != 0) {

sys/vfs/ext2fs/ext2_alloc.c

1173

lp = &fs->e2fs_clustersum[cg].cs_sum[len - 1];

sys/vfs/ext2fs/ext2_alloc.c

1177

fs->e2fs_maxcluster[cg] = i;

sys/vfs/ext2fs/ext2_alloc.c

1183

if (dtog(fs, bpref) != cg)

sys/vfs/ext2fs/ext2_alloc.c

1186

bpref = dtogd(fs, bpref);

sys/vfs/ext2fs/ext2_alloc.c

1189

for (run = 0, got = bpref; got < fs->e2fs_fpg; got++) {

sys/vfs/ext2fs/ext2_alloc.c

119

(long unsigned int)fs->e2fs_bsize, size, fs->e2fs_fsmnt);

sys/vfs/ext2fs/ext2_alloc.c

1205

if (got >= fs->e2fs_fpg)

sys/vfs/ext2fs/ext2_alloc.c

1214

if (bno >= fs->e2fs_fpg)

sys/vfs/ext2fs/ext2_alloc.c

1218

for (i = 0; i < len; i += fs->e2fs_fpb) {

sys/vfs/ext2fs/ext2_alloc.c

1220

ext2_clusteracct(fs, bbp, cg, bno + i, -1);

sys/vfs/ext2fs/ext2_alloc.c

1221

fs->e2fs_fbcount--;

sys/vfs/ext2fs/ext2_alloc.c

1222

e2fs_gd_set_nbfree(&fs->e2fs_gd[cg],

sys/vfs/ext2fs/ext2_alloc.c

1223

e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) - 1);

sys/vfs/ext2fs/ext2_alloc.c

1225

fs->e2fs_fmod = 1;

sys/vfs/ext2fs/ext2_alloc.c

1229

return (cg * fs->e2fs_fpg + le32toh(fs->e2fs->e2fs_first_dblock)

sys/vfs/ext2fs/ext2_alloc.c

1242

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

1246

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

1248

if (le16toh(fs->e2fs_gd[cg].ext4bgd_flags) & EXT2_BG_INODE_ZEROED)

sys/vfs/ext2fs/ext2_alloc.c

125

if (size == fs->e2fs_bsize && fs->e2fs_fbcount == 0)

sys/vfs/ext2fs/ext2_alloc.c

1251

all_blks = le16toh(fs->e2fs->e2fs_inode_size) * fs->e2fs_ipg /

sys/vfs/ext2fs/ext2_alloc.c

1252

fs->e2fs_bsize;

sys/vfs/ext2fs/ext2_alloc.c

1254

used_blks = howmany(fs->e2fs_ipg -

sys/vfs/ext2fs/ext2_alloc.c

1255

e2fs_gd_get_i_unused(&fs->e2fs_gd[cg]),

sys/vfs/ext2fs/ext2_alloc.c

1256

fs->e2fs_bsize / EXT2_INODE_SIZE(fs));

sys/vfs/ext2fs/ext2_alloc.c

1259

bp = getblk(ip->i_devvp, fsbtodoff(fs,

sys/vfs/ext2fs/ext2_alloc.c

1260

e2fs_gd_get_i_tables(&fs->e2fs_gd[cg]) + used_blks + i),

sys/vfs/ext2fs/ext2_alloc.c

1261

fs->e2fs_bsize, 0, 0);

sys/vfs/ext2fs/ext2_alloc.c

1269

fs->e2fs_gd[cg].ext4bgd_flags = htole16(le16toh(

sys/vfs/ext2fs/ext2_alloc.c

1270

fs->e2fs_gd[cg].ext4bgd_flags) | EXT2_BG_INODE_ZEROED);

sys/vfs/ext2fs/ext2_alloc.c

128

fs->e2fs_fbcount < fs->e2fs_rbcount)

sys/vfs/ext2fs/ext2_alloc.c

1293

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

130

if (bpref >= fs->e2fs_bcount)

sys/vfs/ext2fs/ext2_alloc.c

1302

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

1304

if (e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) == 0)

sys/vfs/ext2fs/ext2_alloc.c

1307

error = bread(ip->i_devvp, fsbtodoff(fs,

sys/vfs/ext2fs/ext2_alloc.c

1308

e2fs_gd_get_i_bitmap(&fs->e2fs_gd[cg])),

sys/vfs/ext2fs/ext2_alloc.c

1309

(int)fs->e2fs_bsize, &bp);

sys/vfs/ext2fs/ext2_alloc.c

1315

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||

sys/vfs/ext2fs/ext2_alloc.c

1316

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/vfs/ext2fs/ext2_alloc.c

1317

if (le16toh(fs->e2fs_gd[cg].ext4bgd_flags) &

sys/vfs/ext2fs/ext2_alloc.c

1319

ibytes = fs->e2fs_ipg / 8;

sys/vfs/ext2fs/ext2_alloc.c

1322

fs->e2fs_bsize - 1);

sys/vfs/ext2fs/ext2_alloc.c

1323

fs->e2fs_gd[cg].ext4bgd_flags = htole16(le16toh(

sys/vfs/ext2fs/ext2_alloc.c

1324

fs->e2fs_gd[cg].ext4bgd_flags) &

sys/vfs/ext2fs/ext2_alloc.c

1327

ext2_gd_i_bitmap_csum_set(fs, cg, bp);

sys/vfs/ext2fs/ext2_alloc.c

133

cg = ino_to_cg(fs, ip->i_number);

sys/vfs/ext2fs/ext2_alloc.c

1335

error = ext2_gd_i_bitmap_csum_verify(fs, cg, bp);

sys/vfs/ext2fs/ext2_alloc.c

1341

if (e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) == 0) {

sys/vfs/ext2fs/ext2_alloc.c

135

cg = dtog(fs, bpref);

sys/vfs/ext2fs/ext2_alloc.c

1352

ipref %= fs->e2fs_ipg;

sys/vfs/ext2fs/ext2_alloc.c

1357

len = howmany(fs->e2fs_ipg - ipref, NBBY);

sys/vfs/ext2fs/ext2_alloc.c

136

bno = (daddr_t)ext2_hashalloc(ip, cg, bpref, fs->e2fs_bsize,

sys/vfs/ext2fs/ext2_alloc.c

1366

fs->e2fs_fsmnt);

sys/vfs/ext2fs/ext2_alloc.c

1376

e2fs_gd_set_nifree(&fs->e2fs_gd[cg],

sys/vfs/ext2fs/ext2_alloc.c

1377

e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) - 1);

sys/vfs/ext2fs/ext2_alloc.c

1378

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||

sys/vfs/ext2fs/ext2_alloc.c

1379

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/vfs/ext2fs/ext2_alloc.c

1380

ifree = fs->e2fs_ipg - e2fs_gd_get_i_unused(&fs->e2fs_gd[cg]);

sys/vfs/ext2fs/ext2_alloc.c

1382

e2fs_gd_set_i_unused(&fs->e2fs_gd[cg],

sys/vfs/ext2fs/ext2_alloc.c

1383

fs->e2fs_ipg - (ipref + 1));

sys/vfs/ext2fs/ext2_alloc.c

1385

fs->e2fs_ficount--;

sys/vfs/ext2fs/ext2_alloc.c

1386

fs->e2fs_fmod = 1;

sys/vfs/ext2fs/ext2_alloc.c

1388

e2fs_gd_set_ndirs(&fs->e2fs_gd[cg],

sys/vfs/ext2fs/ext2_alloc.c

1389

e2fs_gd_get_ndirs(&fs->e2fs_gd[cg]) + 1);

sys/vfs/ext2fs/ext2_alloc.c

1390

fs->e2fs_total_dir++;

sys/vfs/ext2fs/ext2_alloc.c

1393

ext2_gd_i_bitmap_csum_set(fs, cg, bp);

sys/vfs/ext2fs/ext2_alloc.c

1395

return ((uint64_t)cg * fs->e2fs_ipg + ipref + 1);

sys/vfs/ext2fs/ext2_alloc.c

1405

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

1411

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

1413

cg = dtog(fs, bno);

sys/vfs/ext2fs/ext2_alloc.c

1414

if (bno >= fs->e2fs_bcount) {

sys/vfs/ext2fs/ext2_alloc.c

1420

fsbtodoff(fs, e2fs_gd_get_b_bitmap(&fs->e2fs_gd[cg])),

sys/vfs/ext2fs/ext2_alloc.c

1421

(int)fs->e2fs_bsize, &bp);

sys/vfs/ext2fs/ext2_alloc.c

1427

bno = dtogd(fs, bno);

sys/vfs/ext2fs/ext2_alloc.c

143

ip->i_blocks += btodb(fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_alloc.c

1430

(long long)bno, fs->e2fs_fsmnt);

sys/vfs/ext2fs/ext2_alloc.c

1434

ext2_clusteracct(fs, bbp, cg, bno, 1);

sys/vfs/ext2fs/ext2_alloc.c

1435

fs->e2fs_fbcount++;

sys/vfs/ext2fs/ext2_alloc.c

1436

e2fs_gd_set_nbfree(&fs->e2fs_gd[cg],

sys/vfs/ext2fs/ext2_alloc.c

1437

e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) + 1);

sys/vfs/ext2fs/ext2_alloc.c

1438

fs->e2fs_fmod = 1;

sys/vfs/ext2fs/ext2_alloc.c

1440

ext2_gd_b_bitmap_csum_set(fs, cg, bp);

sys/vfs/ext2fs/ext2_alloc.c

1451

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

1459

fs = pip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

1461

if ((u_int)ino > fs->e2fs_ipg * fs->e2fs_gcount)

sys/vfs/ext2fs/ext2_alloc.c

1463

pip->i_devvp, (uintmax_t)ino, fs->e2fs_fsmnt);

sys/vfs/ext2fs/ext2_alloc.c

1465

cg = ino_to_cg(fs, ino);

sys/vfs/ext2fs/ext2_alloc.c

1467

fsbtodoff(fs, e2fs_gd_get_i_bitmap(&fs->e2fs_gd[cg])),

sys/vfs/ext2fs/ext2_alloc.c

1468

(int)fs->e2fs_bsize, &bp);

sys/vfs/ext2fs/ext2_alloc.c

1474

ino = (ino - 1) % fs->e2fs_ipg;

sys/vfs/ext2fs/ext2_alloc.c

1477

fs->e2fs_fsmnt, ino);

sys/vfs/ext2fs/ext2_alloc.c

1478

if (fs->e2fs_ronly == 0)

sys/vfs/ext2fs/ext2_alloc.c

1483

fs->e2fs_ficount++;

sys/vfs/ext2fs/ext2_alloc.c

1484

e2fs_gd_set_nifree(&fs->e2fs_gd[cg],

sys/vfs/ext2fs/ext2_alloc.c

1485

e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) + 1);

sys/vfs/ext2fs/ext2_alloc.c

1487

e2fs_gd_set_ndirs(&fs->e2fs_gd[cg],

sys/vfs/ext2fs/ext2_alloc.c

1488

e2fs_gd_get_ndirs(&fs->e2fs_gd[cg]) - 1);

sys/vfs/ext2fs/ext2_alloc.c

1489

fs->e2fs_total_dir--;

sys/vfs/ext2fs/ext2_alloc.c

1491

fs->e2fs_fmod = 1;

sys/vfs/ext2fs/ext2_alloc.c

1493

ext2_gd_i_bitmap_csum_set(fs, cg, bp);

sys/vfs/ext2fs/ext2_alloc.c

1505

ext2_mapsearch(struct m_ext2fs *fs, char *bbp, daddr_t bpref)

sys/vfs/ext2fs/ext2_alloc.c

1515

start = dtogd(fs, bpref) / NBBY;

sys/vfs/ext2fs/ext2_alloc.c

1518

len = howmany(fs->e2fs_fpg, NBBY) - start;

sys/vfs/ext2fs/ext2_alloc.c

1526

"fs=%s", start, len, fs->e2fs_fsmnt);

sys/vfs/ext2fs/ext2_alloc.c

1534

ext2_cg_has_sb(struct m_ext2fs *fs, int cg)

sys/vfs/ext2fs/ext2_alloc.c

1541

if (EXT2_HAS_COMPAT_FEATURE(fs, EXT2F_COMPAT_SPARSESUPER2)) {

sys/vfs/ext2fs/ext2_alloc.c

1542

if (cg == le32toh(fs->e2fs->e4fs_backup_bgs[0]) ||

sys/vfs/ext2fs/ext2_alloc.c

1543

cg == le32toh(fs->e2fs->e4fs_backup_bgs[1]))

sys/vfs/ext2fs/ext2_alloc.c

1549

!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_SPARSESUPER))

sys/vfs/ext2fs/ext2_alloc.c

160

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

163

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

166

blk = ext2_hashalloc(ip, ino_to_cg(fs, ip->i_number), 0, fs->e2fs_bsize,

sys/vfs/ext2fs/ext2_alloc.c

205

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

223

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

226

if (fs->e2fs_contigsumsize <= 0 || ip->i_flag & IN_E4EXTENTS)

sys/vfs/ext2fs/ext2_alloc.c

231

start_lbn = lblkno(fs, buflist->bs_children[0]->b_loffset);

sys/vfs/ext2fs/ext2_alloc.c

235

if (buflist->bs_children[i]->b_loffset != lblktodoff(fs, start_lbn + i))

sys/vfs/ext2fs/ext2_alloc.c

255

if (dtog(fs, dofftofsb(fs, buflist->bs_children[0]->b_bio2.bio_offset)) !=

sys/vfs/ext2fs/ext2_alloc.c

256

dtog(fs, dofftofsb(fs, buflist->bs_children[len - 1]->b_bio2.bio_offset)))

sys/vfs/ext2fs/ext2_alloc.c

269

if (bread(vp, lblktodoff(fs, idp->in_lbn), (int)fs->e2fs_bsize,

sys/vfs/ext2fs/ext2_alloc.c

289

if (bread(vp, lblktodoff(fs, idp->in_lbn), (int)fs->e2fs_bsize,

sys/vfs/ext2fs/ext2_alloc.c

302

if ((newblk = (e2fs_daddr_t)ext2_hashalloc(ip, dtog(fs, pref), pref,

sys/vfs/ext2fs/ext2_alloc.c

317

for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->e2fs_fpb) {

sys/vfs/ext2fs/ext2_alloc.c

324

fsbtodoff(fs, *bap))

sys/vfs/ext2fs/ext2_alloc.c

363

for (blkno = newblk, i = 0; i < len; i++, blkno += fs->e2fs_fpb) {

sys/vfs/ext2fs/ext2_alloc.c

364

ext2_blkfree(ip, dofftofsb(fs, buflist->bs_children[i]->b_bio2.bio_offset),

sys/vfs/ext2fs/ext2_alloc.c

365

fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_alloc.c

366

buflist->bs_children[i]->b_bio2.bio_offset = fsbtodoff(fs, blkno);

sys/vfs/ext2fs/ext2_alloc.c

388

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

398

fs = pip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

402

if (fs->e2fs_ficount == 0)

sys/vfs/ext2fs/ext2_alloc.c

411

if (fs->e2fs_contigdirs[cg] < 255)

sys/vfs/ext2fs/ext2_alloc.c

412

fs->e2fs_contigdirs[cg]++;

sys/vfs/ext2fs/ext2_alloc.c

414

cg = ino_to_cg(fs, pip->i_number);

sys/vfs/ext2fs/ext2_alloc.c

415

if (fs->e2fs_contigdirs[cg] > 0)

sys/vfs/ext2fs/ext2_alloc.c

416

fs->e2fs_contigdirs[cg]--;

sys/vfs/ext2fs/ext2_alloc.c

418

ipref = cg * fs->e2fs_ipg + 1;

sys/vfs/ext2fs/ext2_alloc.c

438

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_EXTENTS)

sys/vfs/ext2fs/ext2_alloc.c

581

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

590

fs = pip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

592

avgifree = fs->e2fs_ficount / fs->e2fs_gcount;

sys/vfs/ext2fs/ext2_alloc.c

593

avgbfree = fs->e2fs_fbcount / fs->e2fs_gcount;

sys/vfs/ext2fs/ext2_alloc.c

594

avgndir = fs->e2fs_total_dir / fs->e2fs_gcount;

sys/vfs/ext2fs/ext2_alloc.c

601

prefcg = karc4random() % fs->e2fs_gcount;

sys/vfs/ext2fs/ext2_alloc.c

603

minndir = fs->e2fs_ipg;

sys/vfs/ext2fs/ext2_alloc.c

604

for (cg = prefcg; cg < fs->e2fs_gcount; cg++)

sys/vfs/ext2fs/ext2_alloc.c

605

if (e2fs_gd_get_ndirs(&fs->e2fs_gd[cg]) < minndir &&

sys/vfs/ext2fs/ext2_alloc.c

606

e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) >= avgifree &&

sys/vfs/ext2fs/ext2_alloc.c

607

e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) >= avgbfree) {

sys/vfs/ext2fs/ext2_alloc.c

609

minndir = e2fs_gd_get_ndirs(&fs->e2fs_gd[cg]);

sys/vfs/ext2fs/ext2_alloc.c

612

if (e2fs_gd_get_ndirs(&fs->e2fs_gd[cg]) < minndir &&

sys/vfs/ext2fs/ext2_alloc.c

613

e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) >= avgifree &&

sys/vfs/ext2fs/ext2_alloc.c

614

e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) >= avgbfree) {

sys/vfs/ext2fs/ext2_alloc.c

616

minndir = e2fs_gd_get_ndirs(&fs->e2fs_gd[cg]);

sys/vfs/ext2fs/ext2_alloc.c

624

maxndir = min(avgndir + fs->e2fs_ipg / 16, fs->e2fs_ipg);

sys/vfs/ext2fs/ext2_alloc.c

631

cgsize = fs->e2fs_fsize * fs->e2fs_fpg;

sys/vfs/ext2fs/ext2_alloc.c

634

(cgsize - avgbfree * fs->e2fs_bsize) / avgndir : 0;

sys/vfs/ext2fs/ext2_alloc.c

637

maxcontigdirs = min((avgbfree * fs->e2fs_bsize) / dirsize, 255);

sys/vfs/ext2fs/ext2_alloc.c

638

maxcontigdirs = min(maxcontigdirs, fs->e2fs_ipg / AFPDIR);

sys/vfs/ext2fs/ext2_alloc.c

647

prefcg = ino_to_cg(fs, pip->i_number);

sys/vfs/ext2fs/ext2_alloc.c

648

for (cg = prefcg; cg < fs->e2fs_gcount; cg++)

sys/vfs/ext2fs/ext2_alloc.c

649

if (e2fs_gd_get_ndirs(&fs->e2fs_gd[cg]) < maxndir &&

sys/vfs/ext2fs/ext2_alloc.c

650

e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) >= minifree &&

sys/vfs/ext2fs/ext2_alloc.c

651

e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) >= minbfree) {

sys/vfs/ext2fs/ext2_alloc.c

652

if (fs->e2fs_contigdirs[cg] < maxcontigdirs)

sys/vfs/ext2fs/ext2_alloc.c

656

if (e2fs_gd_get_ndirs(&fs->e2fs_gd[cg]) < maxndir &&

sys/vfs/ext2fs/ext2_alloc.c

657

e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) >= minifree &&

sys/vfs/ext2fs/ext2_alloc.c

658

e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) >= minbfree) {

sys/vfs/ext2fs/ext2_alloc.c

659

if (fs->e2fs_contigdirs[cg] < maxcontigdirs)

sys/vfs/ext2fs/ext2_alloc.c

665

for (cg = prefcg; cg < fs->e2fs_gcount; cg++)

sys/vfs/ext2fs/ext2_alloc.c

666

if (e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) >= avgifree)

sys/vfs/ext2fs/ext2_alloc.c

669

if (e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) >= avgifree)

sys/vfs/ext2fs/ext2_alloc.c

691

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

694

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

720

EXT2_BLOCKS_PER_GROUP(fs)) + le32toh(fs->e2fs->e2fs_first_dblock));

sys/vfs/ext2fs/ext2_alloc.c

735

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

740

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

750

for (i = 1; i < fs->e2fs_gcount; i *= 2) {

sys/vfs/ext2fs/ext2_alloc.c

752

if (cg >= fs->e2fs_gcount)

sys/vfs/ext2fs/ext2_alloc.c

753

cg -= fs->e2fs_gcount;

sys/vfs/ext2fs/ext2_alloc.c

763

cg = (icg + 2) % fs->e2fs_gcount;

sys/vfs/ext2fs/ext2_alloc.c

764

for (i = 2; i < fs->e2fs_gcount; i++) {

sys/vfs/ext2fs/ext2_alloc.c

769

if (cg == fs->e2fs_gcount)

sys/vfs/ext2fs/ext2_alloc.c

776

ext2_cg_number_gdb_nometa(struct m_ext2fs *fs, int cg)

sys/vfs/ext2fs/ext2_alloc.c

779

if (!ext2_cg_has_sb(fs, cg))

sys/vfs/ext2fs/ext2_alloc.c

782

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG))

sys/vfs/ext2fs/ext2_alloc.c

783

return (le32toh(fs->e2fs->e3fs_first_meta_bg));

sys/vfs/ext2fs/ext2_alloc.c

785

return ((fs->e2fs_gcount + EXT2_DESCS_PER_BLOCK(fs) - 1) /

sys/vfs/ext2fs/ext2_alloc.c

786

EXT2_DESCS_PER_BLOCK(fs));

sys/vfs/ext2fs/ext2_alloc.c

790

ext2_cg_number_gdb_meta(struct m_ext2fs *fs, int cg)

sys/vfs/ext2fs/ext2_alloc.c

795

metagroup = cg / EXT2_DESCS_PER_BLOCK(fs);

sys/vfs/ext2fs/ext2_alloc.c

796

first = metagroup * EXT2_DESCS_PER_BLOCK(fs);

sys/vfs/ext2fs/ext2_alloc.c

797

last = first + EXT2_DESCS_PER_BLOCK(fs) - 1;

sys/vfs/ext2fs/ext2_alloc.c

806

ext2_cg_number_gdb(struct m_ext2fs *fs, int cg)

sys/vfs/ext2fs/ext2_alloc.c

810

first_meta_bg = le32toh(fs->e2fs->e3fs_first_meta_bg);

sys/vfs/ext2fs/ext2_alloc.c

811

metagroup = cg / EXT2_DESCS_PER_BLOCK(fs);

sys/vfs/ext2fs/ext2_alloc.c

813

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) ||

sys/vfs/ext2fs/ext2_alloc.c

815

return (ext2_cg_number_gdb_nometa(fs, cg));

sys/vfs/ext2fs/ext2_alloc.c

817

return ext2_cg_number_gdb_meta(fs, cg);

sys/vfs/ext2fs/ext2_alloc.c

821

ext2_number_base_meta_blocks(struct m_ext2fs *fs, int cg)

sys/vfs/ext2fs/ext2_alloc.c

825

number = ext2_cg_has_sb(fs, cg);

sys/vfs/ext2fs/ext2_alloc.c

827

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) ||

sys/vfs/ext2fs/ext2_alloc.c

828

cg < le32toh(fs->e2fs->e3fs_first_meta_bg) *

sys/vfs/ext2fs/ext2_alloc.c

829

EXT2_DESCS_PER_BLOCK(fs)) {

sys/vfs/ext2fs/ext2_alloc.c

831

number += ext2_cg_number_gdb(fs, cg);

sys/vfs/ext2fs/ext2_alloc.c

832

number += le16toh(fs->e2fs->e2fs_reserved_ngdb);

sys/vfs/ext2fs/ext2_alloc.c

835

number += ext2_cg_number_gdb(fs, cg);

sys/vfs/ext2fs/ext2_alloc.c

856

ext2_get_group_number(struct m_ext2fs *fs, e4fs_daddr_t block)

sys/vfs/ext2fs/ext2_alloc.c

859

return ((block - le32toh(fs->e2fs->e2fs_first_dblock)) /

sys/vfs/ext2fs/ext2_alloc.c

860

fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_alloc.c

864

ext2_block_in_group(struct m_ext2fs *fs, e4fs_daddr_t block, int cg)

sys/vfs/ext2fs/ext2_alloc.c

867

return ((ext2_get_group_number(fs, block) == cg) ? 1 : 0);

sys/vfs/ext2fs/ext2_alloc.c

871

ext2_cg_block_bitmap_init(struct m_ext2fs *fs, int cg, struct buf *bp)

sys/vfs/ext2fs/ext2_alloc.c

876

if (!(le16toh(fs->e2fs_gd[cg].ext4bgd_flags) & EXT2_BG_BLOCK_UNINIT))

sys/vfs/ext2fs/ext2_alloc.c

879

memset(bp->b_data, 0, fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_alloc.c

881

bit_max = ext2_number_base_meta_blocks(fs, cg);

sys/vfs/ext2fs/ext2_alloc.c

882

if ((bit_max >> 3) >= fs->e2fs_bsize)

sys/vfs/ext2fs/ext2_alloc.c

888

start = (uint64_t)cg * fs->e2fs_bpg +

sys/vfs/ext2fs/ext2_alloc.c

889

le32toh(fs->e2fs->e2fs_first_dblock);

sys/vfs/ext2fs/ext2_alloc.c

892

tmp = e2fs_gd_get_b_bitmap(&fs->e2fs_gd[cg]);

sys/vfs/ext2fs/ext2_alloc.c

893

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) ||

sys/vfs/ext2fs/ext2_alloc.c

894

ext2_block_in_group(fs, tmp, cg))

sys/vfs/ext2fs/ext2_alloc.c

897

tmp = e2fs_gd_get_i_bitmap(&fs->e2fs_gd[cg]);

sys/vfs/ext2fs/ext2_alloc.c

898

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) ||

sys/vfs/ext2fs/ext2_alloc.c

899

ext2_block_in_group(fs, tmp, cg))

sys/vfs/ext2fs/ext2_alloc.c

902

tmp = e2fs_gd_get_i_tables(&fs->e2fs_gd[cg]);

sys/vfs/ext2fs/ext2_alloc.c

903

inodes_per_block = fs->e2fs_bsize/EXT2_INODE_SIZE(fs);

sys/vfs/ext2fs/ext2_alloc.c

904

while( tmp < e2fs_gd_get_i_tables(&fs->e2fs_gd[cg]) +

sys/vfs/ext2fs/ext2_alloc.c

905

fs->e2fs_ipg / inodes_per_block ) {

sys/vfs/ext2fs/ext2_alloc.c

906

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) ||

sys/vfs/ext2fs/ext2_alloc.c

907

ext2_block_in_group(fs, tmp, cg))

sys/vfs/ext2fs/ext2_alloc.c

917

ext2_mark_bitmap_end(fs->e2fs_bpg, fs->e2fs_bsize * 8,

sys/vfs/ext2fs/ext2_alloc.c

921

fs->e2fs_gd[cg].ext4bgd_flags = htole16(le16toh(

sys/vfs/ext2fs/ext2_alloc.c

922

fs->e2fs_gd[cg].ext4bgd_flags) & ~EXT2_BG_BLOCK_UNINIT);

sys/vfs/ext2fs/ext2_alloc.c

928

ext2_b_bitmap_validate(struct m_ext2fs *fs, struct buf *bp, int cg)

sys/vfs/ext2fs/ext2_alloc.c

934

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG)) {

sys/vfs/ext2fs/ext2_alloc.c

944

gd = &fs->e2fs_gd[cg];

sys/vfs/ext2fs/ext2_alloc.c

945

max_bit = fs->e2fs_fpg;

sys/vfs/ext2fs/ext2_alloc.c

946

group_first_block = ((uint64_t)cg) * fs->e2fs_fpg +

sys/vfs/ext2fs/ext2_alloc.c

947

le32toh(fs->e2fs->e2fs_first_dblock);

sys/vfs/ext2fs/ext2_alloc.c

967

if (offset >= max_bit || offset + fs->e2fs_itpg >= max_bit) {

sys/vfs/ext2fs/ext2_alloc.c

985

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_alloc.c

992

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_alloc.c

994

if (e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) == 0)

sys/vfs/ext2fs/ext2_alloc.c

998

error = bread(ip->i_devvp, fsbtodoff(fs,

sys/vfs/ext2fs/ext2_alloc.c

999

e2fs_gd_get_b_bitmap(&fs->e2fs_gd[cg])),

sys/vfs/ext2fs/ext2_balloc.c

113

error = bread(vp, lblktodoff(fs, lbn), fs->e2fs_bsize,

sys/vfs/ext2fs/ext2_balloc.c

119

bp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ext2fs/ext2_balloc.c

120

if (ip->i_size >= (lbn + 1) * fs->e2fs_bsize) {

sys/vfs/ext2fs/ext2_balloc.c

128

fs->e2fs_bsize, cred, &newb);

sys/vfs/ext2fs/ext2_balloc.c

137

bp = getblk(vp, lblktodoff(fs, lbn), fs->e2fs_bsize, 0, 0);

sys/vfs/ext2fs/ext2_balloc.c

138

bp->b_bio2.bio_offset = fsbtodoff(fs, newb);

sys/vfs/ext2fs/ext2_balloc.c

142

ip->i_db[lbn] = dofftofsb(fs, bp->b_bio2.bio_offset);

sys/vfs/ext2fs/ext2_balloc.c

166

if ((error = ext2_alloc(ip, lbn, pref, fs->e2fs_bsize, cred,

sys/vfs/ext2fs/ext2_balloc.c

172

bp = getblk(vp, lblktodoff(fs, indirs[1].in_lbn),

sys/vfs/ext2fs/ext2_balloc.c

173

fs->e2fs_bsize, 0, 0);

sys/vfs/ext2fs/ext2_balloc.c

174

bp->b_bio2.bio_offset = fsbtodoff(fs, newb);

sys/vfs/ext2fs/ext2_balloc.c

181

ext2_blkfree(ip, nb, fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_balloc.c

191

error = bread(vp, lblktodoff(fs, indirs[i].in_lbn),

sys/vfs/ext2fs/ext2_balloc.c

192

(int)fs->e2fs_bsize, &bp);

sys/vfs/ext2fs/ext2_balloc.c

209

lblkno(fs, bp->b_loffset));

sys/vfs/ext2fs/ext2_balloc.c

210

error = ext2_alloc(ip, lbn, pref, (int)fs->e2fs_bsize, cred, &newb);

sys/vfs/ext2fs/ext2_balloc.c

220

nbp = getblk(vp, lblktodoff(fs, indirs[i].in_lbn),

sys/vfs/ext2fs/ext2_balloc.c

221

fs->e2fs_bsize, 0, 0);

sys/vfs/ext2fs/ext2_balloc.c

222

nbp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ext2fs/ext2_balloc.c

229

ext2_blkfree(ip, nb, fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_balloc.c

241

if (bp->b_bufsize == fs->e2fs_bsize)

sys/vfs/ext2fs/ext2_balloc.c

252

lblkno(fs, bp->b_loffset));

sys/vfs/ext2fs/ext2_balloc.c

254

lbn, pref, (int)fs->e2fs_bsize, cred, &newb)) != 0) {

sys/vfs/ext2fs/ext2_balloc.c

263

nbp = getblk(vp, lblktodoff(fs, lbn), fs->e2fs_bsize, 0, 0);

sys/vfs/ext2fs/ext2_balloc.c

264

nbp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ext2fs/ext2_balloc.c

275

if (bp->b_bufsize == fs->e2fs_bsize)

sys/vfs/ext2fs/ext2_balloc.c

288

lblktodoff(fs, lbn), (int)fs->e2fs_bsize,

sys/vfs/ext2fs/ext2_balloc.c

291

error = bread(vp, lblktodoff(fs, lbn),

sys/vfs/ext2fs/ext2_balloc.c

292

(int)fs->e2fs_bsize, &nbp);

sys/vfs/ext2fs/ext2_balloc.c

299

nbp = getblk(vp, lblktodoff(fs, lbn), fs->e2fs_bsize, 0, 0);

sys/vfs/ext2fs/ext2_balloc.c

300

nbp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ext2fs/ext2_balloc.c

75

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_balloc.c

87

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_bmap.c

119

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_bmap.c

124

fs = VTOI(vp)->i_e2fs;

sys/vfs/ext2fs/ext2_bmap.c

126

bp = getblk(vp, lblktodoff(fs, lbn), mp->mnt_stat.f_iosize, 0, 0);

sys/vfs/ext2fs/ext2_bmap.c

137

bp->b_bio2.bio_offset = fsbtodoff(fs, daddr);

sys/vfs/ext2fs/ext2_bmap.c

180

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_bmap.c

191

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_bmap.c

242

!findblk(vp, dbtodoff(fs, metalbn), FINDBLK_TEST)) ||

sys/vfs/ext2fs/ext2_bmap.c

69

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_bmap.c

80

fs = VTOI(ap->a_vp)->i_e2fs;

sys/vfs/ext2fs/ext2_bmap.c

81

KKASSERT(((int)ap->a_loffset & ((1 << fs->e2fs_bshift) - 1)) == 0);

sys/vfs/ext2fs/ext2_bmap.c

82

lbn = ap->a_loffset >> fs->e2fs_bshift;

sys/vfs/ext2fs/ext2_bmap.c

94

*ap->a_doffsetp = dbtodoff(fs, dbn);

sys/vfs/ext2fs/ext2_bmap.c

96

*ap->a_runp = (*ap->a_runp + 1) << fs->e2fs_bshift;

sys/vfs/ext2fs/ext2_bmap.c

98

*ap->a_runb = *ap->a_runb << fs->e2fs_bshift;

sys/vfs/ext2fs/ext2_csum.c

100

fs->e2fs_fsmnt, le32toh(fs->e2fs->e4fs_sbchksum),

sys/vfs/ext2fs/ext2_csum.c

101

calculate_crc32c(~0, (const char *)fs->e2fs,

sys/vfs/ext2fs/ext2_csum.c

110

ext2_sb_csum_set(struct m_ext2fs *fs)

sys/vfs/ext2fs/ext2_csum.c

113

fs->e2fs->e4fs_sbchksum =

sys/vfs/ext2fs/ext2_csum.c

114

htole32(calculate_crc32c(~0, (const char *)fs->e2fs,

sys/vfs/ext2fs/ext2_csum.c

129

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

132

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

134

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

177

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

181

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

187

crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum));

sys/vfs/ext2fs/ext2_csum.c

244

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

249

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

259

crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum));

sys/vfs/ext2fs/ext2_csum.c

298

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

302

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

304

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

323

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

326

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

328

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

342

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

347

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

349

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

369

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

373

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

380

crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum));

sys/vfs/ext2fs/ext2_csum.c

390

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

395

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

397

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

418

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

422

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

424

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

436

ext2_gd_i_bitmap_csum_verify(struct m_ext2fs *fs, int cg, struct buf *bp)

sys/vfs/ext2fs/ext2_csum.c

440

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

443

provided = le16toh(fs->e2fs_gd[cg].ext4bgd_i_bmap_csum);

sys/vfs/ext2fs/ext2_csum.c

444

calculated = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data,

sys/vfs/ext2fs/ext2_csum.c

445

fs->e2fs_ipg / 8);

sys/vfs/ext2fs/ext2_csum.c

446

if (le16toh(fs->e2fs->e3fs_desc_size) >=

sys/vfs/ext2fs/ext2_csum.c

448

hi = le16toh(fs->e2fs_gd[cg].ext4bgd_i_bmap_csum_hi);

sys/vfs/ext2fs/ext2_csum.c

462

ext2_gd_i_bitmap_csum_set(struct m_ext2fs *fs, int cg, struct buf *bp)

sys/vfs/ext2fs/ext2_csum.c

466

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

469

csum = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data,

sys/vfs/ext2fs/ext2_csum.c

470

fs->e2fs_ipg / 8);

sys/vfs/ext2fs/ext2_csum.c

471

fs->e2fs_gd[cg].ext4bgd_i_bmap_csum = htole16(csum & 0xFFFF);

sys/vfs/ext2fs/ext2_csum.c

472

if (le16toh(fs->e2fs->e3fs_desc_size) >= EXT2_BG_INODE_BITMAP_CSUM_HI_END)

sys/vfs/ext2fs/ext2_csum.c

473

fs->e2fs_gd[cg].ext4bgd_i_bmap_csum_hi = htole16(csum >> 16);

sys/vfs/ext2fs/ext2_csum.c

477

ext2_gd_b_bitmap_csum_verify(struct m_ext2fs *fs, int cg, struct buf *bp)

sys/vfs/ext2fs/ext2_csum.c

481

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

484

size = fs->e2fs_fpg / 8;

sys/vfs/ext2fs/ext2_csum.c

485

provided = le16toh(fs->e2fs_gd[cg].ext4bgd_b_bmap_csum);

sys/vfs/ext2fs/ext2_csum.c

486

calculated = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data, size);

sys/vfs/ext2fs/ext2_csum.c

487

if (le16toh(fs->e2fs->e3fs_desc_size) >=

sys/vfs/ext2fs/ext2_csum.c

489

hi = le16toh(fs->e2fs_gd[cg].ext4bgd_b_bmap_csum_hi);

sys/vfs/ext2fs/ext2_csum.c

503

ext2_gd_b_bitmap_csum_set(struct m_ext2fs *fs, int cg, struct buf *bp)

sys/vfs/ext2fs/ext2_csum.c

507

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

510

size = fs->e2fs_fpg / 8;

sys/vfs/ext2fs/ext2_csum.c

511

csum = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data, size);

sys/vfs/ext2fs/ext2_csum.c

512

fs->e2fs_gd[cg].ext4bgd_b_bmap_csum = htole16(csum & 0xFFFF);

sys/vfs/ext2fs/ext2_csum.c

513

if (le16toh(fs->e2fs->e3fs_desc_size) >= EXT2_BG_BLOCK_BITMAP_CSUM_HI_LOCATION)

sys/vfs/ext2fs/ext2_csum.c

514

fs->e2fs_gd[cg].ext4bgd_b_bmap_csum_hi = htole16(csum >> 16);

sys/vfs/ext2fs/ext2_csum.c

520

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

525

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

529

crc = calculate_crc32c(fs->e2fs_csum_seed,

sys/vfs/ext2fs/ext2_csum.c

541

if (EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE) {

sys/vfs/ext2fs/ext2_csum.c

555

EXT2_INODE_SIZE(fs) - offset);

sys/vfs/ext2fs/ext2_csum.c

564

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

568

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

570

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

576

if ((EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE &&

sys/vfs/ext2fs/ext2_csum.c

603

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_csum.c

606

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_csum.c

608

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_csum.c

614

if ((EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE &&

sys/vfs/ext2fs/ext2_csum.c

666

ext2_gd_csum(struct m_ext2fs *fs, uint32_t block_group, struct ext2_gd *gd)

sys/vfs/ext2fs/ext2_csum.c

676

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/vfs/ext2fs/ext2_csum.c

677

csum32 = calculate_crc32c(fs->e2fs_csum_seed,

sys/vfs/ext2fs/ext2_csum.c

684

if (offset < le16toh(fs->e2fs->e3fs_desc_size))

sys/vfs/ext2fs/ext2_csum.c

686

le16toh(fs->e2fs->e3fs_desc_size) - offset);

sys/vfs/ext2fs/ext2_csum.c

690

} else if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM)) {

sys/vfs/ext2fs/ext2_csum.c

691

crc = ext2_crc16(~0, fs->e2fs->e2fs_uuid,

sys/vfs/ext2fs/ext2_csum.c

692

sizeof(fs->e2fs->e2fs_uuid));

sys/vfs/ext2fs/ext2_csum.c

697

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT) &&

sys/vfs/ext2fs/ext2_csum.c

698

offset < le16toh(fs->e2fs->e3fs_desc_size))

sys/vfs/ext2fs/ext2_csum.c

700

le16toh(fs->e2fs->e3fs_desc_size) - offset);

sys/vfs/ext2fs/ext2_csum.c

708

ext2_gd_csum_verify(struct m_ext2fs *fs, struct cdev *dev)

sys/vfs/ext2fs/ext2_csum.c

713

for (i = 0; i < fs->e2fs_gcount; i++) {

sys/vfs/ext2fs/ext2_csum.c

714

if (fs->e2fs_gd[i].ext4bgd_csum !=

sys/vfs/ext2fs/ext2_csum.c

715

ext2_gd_csum(fs, i, &fs->e2fs_gd[i])) {

sys/vfs/ext2fs/ext2_csum.c

718

devtoname(dev), i, fs->e2fs_gd[i].ext4bgd_csum,

sys/vfs/ext2fs/ext2_csum.c

719

ext2_gd_csum(fs, i, &fs->e2fs_gd[i]));

sys/vfs/ext2fs/ext2_csum.c

729

ext2_gd_csum_set(struct m_ext2fs *fs)

sys/vfs/ext2fs/ext2_csum.c

73

ext2_sb_csum_set_seed(struct m_ext2fs *fs)

sys/vfs/ext2fs/ext2_csum.c

733

for (i = 0; i < fs->e2fs_gcount; i++)

sys/vfs/ext2fs/ext2_csum.c

734

fs->e2fs_gd[i].ext4bgd_csum = ext2_gd_csum(fs, i, &fs->e2fs_gd[i]);

sys/vfs/ext2fs/ext2_csum.c

76

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_CSUM_SEED))

sys/vfs/ext2fs/ext2_csum.c

77

fs->e2fs_csum_seed = le32toh(fs->e2fs->e4fs_chksum_seed);

sys/vfs/ext2fs/ext2_csum.c

78

else if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/vfs/ext2fs/ext2_csum.c

79

fs->e2fs_csum_seed = calculate_crc32c(~0, fs->e2fs->e2fs_uuid,

sys/vfs/ext2fs/ext2_csum.c

80

sizeof(fs->e2fs->e2fs_uuid));

sys/vfs/ext2fs/ext2_csum.c

83

fs->e2fs_csum_seed = 0;

sys/vfs/ext2fs/ext2_csum.c

87

ext2_sb_csum_verify(struct m_ext2fs *fs)

sys/vfs/ext2fs/ext2_csum.c

90

if (fs->e2fs->e4fs_chksum_type != EXT4_CRC32C_CHKSUM) {

sys/vfs/ext2fs/ext2_csum.c

92

"WARNING: mount of %s denied due bad sb csum type\n", fs->e2fs_fsmnt);

sys/vfs/ext2fs/ext2_csum.c

95

if (le32toh(fs->e2fs->e4fs_sbchksum) !=

sys/vfs/ext2fs/ext2_csum.c

96

calculate_crc32c(~0, (const char *)fs->e2fs,

sys/vfs/ext2fs/ext2_extern.h

92

int ext2_cg_has_sb(struct m_ext2fs *fs, int cg);

sys/vfs/ext2fs/ext2_extern.h

93

uint64_t ext2_cg_number_gdb(struct m_ext2fs *fs, int cg);

sys/vfs/ext2fs/ext2_htree.c

221

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_htree.c

224

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_htree.c

228

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_htree.c

237

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_htree.c

240

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_htree.c

241

space = fs->e2fs_bsize - EXT2_DIR_REC_LEN(0);

sys/vfs/ext2fs/ext2_htree.c

243

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_htree.c

263

struct ext2fs *fs;

sys/vfs/ext2fs/ext2_htree.c

278

fs = ip->i_e2fs->e2fs;

sys/vfs/ext2fs/ext2_htree.c

297

ext2_get_hash_seed(fs, hash_seed);

sys/vfs/ext2fs/ext2_htree.c

540

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_htree.c

551

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_htree.c

557

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_htree.c

672

struct ext2fs *fs;

sys/vfs/ext2fs/ext2_htree.c

685

fs = dp->i_e2fs->e2fs;

sys/vfs/ext2fs/ext2_htree.c

714

root->h_info.h_hash_version = fs->e3fs_def_hash_version;

sys/vfs/ext2fs/ext2_htree.c

729

ext2_get_hash_seed(fs, hash_seed);

sys/vfs/ext2fs/ext2_htree.c

784

struct ext2fs *fs;

sys/vfs/ext2fs/ext2_htree.c

803

fs = m_fs->e2fs;

sys/vfs/ext2fs/ext2_htree.c

920

ext2_get_hash_seed(fs, hash_seed);

sys/vfs/ext2fs/ext2_inode.c

123

struct m_ext2fs *fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_inode.c

137

factor *= NINDIR(fs);

sys/vfs/ext2fs/ext2_inode.c

141

nblocks = btodb(fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_inode.c

151

bp = getblk(vp, lblktodoff(fs, lbn), (int)fs->e2fs_bsize, 0, 0);

sys/vfs/ext2fs/ext2_inode.c

157

bp->b_bio2.bio_offset = dbtodoff(fs, dbn);

sys/vfs/ext2fs/ext2_inode.c

170

copy = malloc(fs->e2fs_bsize, M_TEMP, M_WAITOK);

sys/vfs/ext2fs/ext2_inode.c

171

bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_inode.c

173

(NINDIR(fs) - (last + 1)) * sizeof(e2fs_daddr_t));

sys/vfs/ext2fs/ext2_inode.c

188

for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;

sys/vfs/ext2fs/ext2_inode.c

195

fsbtodb(fs, nb), (int32_t)-1, level - 1, &blkcount)) != 0)

sys/vfs/ext2fs/ext2_inode.c

199

ext2_blkfree(ip, nb, fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_inode.c

210

if ((error = ext2_indirtrunc(ip, nlbn, fsbtodb(fs, nb),

sys/vfs/ext2fs/ext2_inode.c

234

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_inode.c

243

fs = oip->i_e2fs;

sys/vfs/ext2fs/ext2_inode.c

254

offset = blkoff(fs, length - 1);

sys/vfs/ext2fs/ext2_inode.c

255

lbn = lblkno(fs, length - 1);

sys/vfs/ext2fs/ext2_inode.c

263

if (bp->b_bufsize == fs->e2fs_bsize)

sys/vfs/ext2fs/ext2_inode.c

282

offset = blkoff(fs, length);

sys/vfs/ext2fs/ext2_inode.c

286

lbn = lblkno(fs, length);

sys/vfs/ext2fs/ext2_inode.c

292

size = blksize(fs, oip, lbn);

sys/vfs/ext2fs/ext2_inode.c

295

if (bp->b_bufsize == fs->e2fs_bsize)

sys/vfs/ext2fs/ext2_inode.c

310

lastblock = lblkno(fs, length + fs->e2fs_bsize - 1) - 1;

sys/vfs/ext2fs/ext2_inode.c

312

lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);

sys/vfs/ext2fs/ext2_inode.c

313

lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);

sys/vfs/ext2fs/ext2_inode.c

314

nblocks = btodb(fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_inode.c

351

error = vtruncbuf(ovp, length, (int)fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_inode.c

360

indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;

sys/vfs/ext2fs/ext2_inode.c

361

indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;

sys/vfs/ext2fs/ext2_inode.c

366

fsbtodb(fs, bn), lastiblock[level], level, &count);

sys/vfs/ext2fs/ext2_inode.c

372

ext2_blkfree(oip, bn, fs->e2fs_fsize);

sys/vfs/ext2fs/ext2_inode.c

390

bsize = blksize(fs, oip, i);

sys/vfs/ext2fs/ext2_inode.c

409

oldspace = blksize(fs, oip, lastblock);

sys/vfs/ext2fs/ext2_inode.c

411

newspace = blksize(fs, oip, lastblock);

sys/vfs/ext2fs/ext2_inode.c

420

bn += numfrags(fs, newspace);

sys/vfs/ext2fs/ext2_inode.c

71

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_inode.c

82

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_inode.c

83

if (fs->e2fs_ronly)

sys/vfs/ext2fs/ext2_inode.c

86

fsbtodoff(fs, ino_to_fsba(fs, ip->i_number)),

sys/vfs/ext2fs/ext2_inode.c

87

(int)fs->e2fs_bsize, &bp)) != 0) {

sys/vfs/ext2fs/ext2_inode.c

92

EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)));

sys/vfs/ext2fs/ext2_inode_cnv.c

111

struct m_ext2fs *fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_inode_cnv.c

116

if ((ip->i_number < EXT2_FIRST_INO(fs) && ip->i_number != EXT2_ROOTINO) ||

sys/vfs/ext2fs/ext2_inode_cnv.c

118

(ip->i_number > le32toh(fs->e2fs->e2fs_icount))) {

sys/vfs/ext2fs/ext2_inode_cnv.c

139

if (EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE) {

sys/vfs/ext2fs/ext2_inode_cnv.c

141

EXT2_INODE_SIZE(fs) || (ei_extra_isize_le & 3)) {

sys/vfs/ext2fs/ext2_inode_cnv.c

215

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_inode_cnv.c

218

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_inode_cnv.c

252

!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE)) {

sys/vfs/ext2fs/ext2_inode_cnv.c

261

ei->e2di_nblock = htole32(dbtofsb(fs, ip->i_blocks));

sys/vfs/ext2fs/ext2_inode_cnv.c

262

ei->e2di_nblock_high = htole16(dbtofsb(fs, ip->i_blocks) >> 32 & 0xffff);

sys/vfs/ext2fs/ext2_lookup.c

798

struct m_ext2fs *fs = VTOI(dp)->i_e2fs;

sys/vfs/ext2fs/ext2_lookup.c

807

else if (entryoffsetinblock + le16toh(de->e2d_reclen)> fs->e2fs_bsize)

sys/vfs/ext2fs/ext2_lookup.c

809

else if (le32toh(de->e2d_ino) > fs->e2fs->e2fs_icount)

sys/vfs/ext2fs/ext2_subr.c

101

*res = (char *)bp->b_data + blkoff(fs, offset);

sys/vfs/ext2fs/ext2_subr.c

114

ext2_clusteracct(struct m_ext2fs *fs, char *bbp, int cg, e4fs_daddr_t bno, int cnt)

sys/vfs/ext2fs/ext2_subr.c

116

int32_t *sump = fs->e2fs_clustersum[cg].cs_sum;

sys/vfs/ext2fs/ext2_subr.c

122

if (fs->e2fs_clustersum[cg].cs_init == 0) {

sys/vfs/ext2fs/ext2_subr.c

128

for (i = 0; i < fs->e2fs_fpg; i++) {

sys/vfs/ext2fs/ext2_subr.c

132

if (run > fs->e2fs_contigsumsize)

sys/vfs/ext2fs/ext2_subr.c

133

run = fs->e2fs_contigsumsize;

sys/vfs/ext2fs/ext2_subr.c

145

if (run > fs->e2fs_contigsumsize)

sys/vfs/ext2fs/ext2_subr.c

146

run = fs->e2fs_contigsumsize;

sys/vfs/ext2fs/ext2_subr.c

149

fs->e2fs_clustersum[cg].cs_init = 1;

sys/vfs/ext2fs/ext2_subr.c

152

if (fs->e2fs_contigsumsize <= 0)

sys/vfs/ext2fs/ext2_subr.c

157

end = start + fs->e2fs_contigsumsize;

sys/vfs/ext2fs/ext2_subr.c

158

if (end > fs->e2fs_fpg)

sys/vfs/ext2fs/ext2_subr.c

159

end = fs->e2fs_fpg;

sys/vfs/ext2fs/ext2_subr.c

176

end = start - fs->e2fs_contigsumsize;

sys/vfs/ext2fs/ext2_subr.c

198

if (i > fs->e2fs_contigsumsize)

sys/vfs/ext2fs/ext2_subr.c

199

i = fs->e2fs_contigsumsize;

sys/vfs/ext2fs/ext2_subr.c

207

lp = &sump[fs->e2fs_contigsumsize];

sys/vfs/ext2fs/ext2_subr.c

208

for (i = fs->e2fs_contigsumsize; i > 0; i--)

sys/vfs/ext2fs/ext2_subr.c

211

fs->e2fs_maxcluster[cg] = i;

sys/vfs/ext2fs/ext2_subr.c

81

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_subr.c

87

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_subr.c

88

lbn = lblkno(fs, offset);

sys/vfs/ext2fs/ext2_subr.c

89

bsize = blksize(fs, ip, lbn);

sys/vfs/ext2fs/ext2_subr.c

91

if ((error = bread(vp, lblktodoff(fs, lbn), bsize, &bp)) != 0) {

sys/vfs/ext2fs/ext2_vfsops.c

1028

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vfsops.c

1041

fs = ump->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

1042

ronly = fs->e2fs_ronly;

sys/vfs/ext2fs/ext2_vfsops.c

1044

if (fs->e2fs_wasvalid)

sys/vfs/ext2fs/ext2_vfsops.c

1045

fs->e2fs->e2fs_state =

sys/vfs/ext2fs/ext2_vfsops.c

1046

htole16(le16toh(fs->e2fs->e2fs_state) | E2FS_ISCLEAN);

sys/vfs/ext2fs/ext2_vfsops.c

1057

sump = fs->e2fs_clustersum;

sys/vfs/ext2fs/ext2_vfsops.c

1058

for (i = 0; i < fs->e2fs_gcount; i++, sump++)

sys/vfs/ext2fs/ext2_vfsops.c

1060

free(fs->e2fs_clustersum, M_EXT2MNT);

sys/vfs/ext2fs/ext2_vfsops.c

1061

free(fs->e2fs_maxcluster, M_EXT2MNT);

sys/vfs/ext2fs/ext2_vfsops.c

1062

free(fs->e2fs_gd, M_EXT2MNT);

sys/vfs/ext2fs/ext2_vfsops.c

1063

free(fs->e2fs_contigdirs, M_EXT2MNT);

sys/vfs/ext2fs/ext2_vfsops.c

1064

free(fs->e2fs, M_EXT2MNT);

sys/vfs/ext2fs/ext2_vfsops.c

1065

free(fs, M_EXT2MNT);

sys/vfs/ext2fs/ext2_vfsops.c

1091

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vfsops.c

1096

fs = ump->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

1097

if (le16toh(fs->e2fs->e2fs_magic) != E2FS_MAGIC)

sys/vfs/ext2fs/ext2_vfsops.c

1106

fs->e2fs_itpg;

sys/vfs/ext2fs/ext2_vfsops.c

1107

overhead = le32toh(fs->e2fs->e2fs_first_dblock) +

sys/vfs/ext2fs/ext2_vfsops.c

1108

fs->e2fs_gcount * overhead_per_group;

sys/vfs/ext2fs/ext2_vfsops.c

1109

if (le32toh(fs->e2fs->e2fs_rev) > E2FS_REV0 &&

sys/vfs/ext2fs/ext2_vfsops.c

1110

le32toh(fs->e2fs->e2fs_features_rocompat) & EXT2F_ROCOMPAT_SPARSESUPER) {

sys/vfs/ext2fs/ext2_vfsops.c

1111

for (i = 0, ngroups = 0; i < fs->e2fs_gcount; i++) {

sys/vfs/ext2fs/ext2_vfsops.c

1112

if (ext2_cg_has_sb(fs, i))

sys/vfs/ext2fs/ext2_vfsops.c

1116

ngroups = fs->e2fs_gcount;

sys/vfs/ext2fs/ext2_vfsops.c

1118

ngdb = fs->e2fs_gdbcount;

sys/vfs/ext2fs/ext2_vfsops.c

1119

if (le32toh(fs->e2fs->e2fs_rev) > E2FS_REV0 &&

sys/vfs/ext2fs/ext2_vfsops.c

1120

le32toh(fs->e2fs->e2fs_features_compat) & EXT2F_COMPAT_RESIZE)

sys/vfs/ext2fs/ext2_vfsops.c

1121

ngdb += le16toh(fs->e2fs->e2fs_reserved_ngdb);

sys/vfs/ext2fs/ext2_vfsops.c

1125

sbp->f_bsize = EXT2_FRAG_SIZE(fs);

sys/vfs/ext2fs/ext2_vfsops.c

1126

sbp->f_iosize = EXT2_BLOCK_SIZE(fs);

sys/vfs/ext2fs/ext2_vfsops.c

1127

sbp->f_blocks = fs->e2fs_bcount - overhead;

sys/vfs/ext2fs/ext2_vfsops.c

1128

sbp->f_bfree = fs->e2fs_fbcount;

sys/vfs/ext2fs/ext2_vfsops.c

1129

sbp->f_bavail = sbp->f_bfree - fs->e2fs_rbcount;

sys/vfs/ext2fs/ext2_vfsops.c

1130

sbp->f_files = le32toh(fs->e2fs->e2fs_icount);

sys/vfs/ext2fs/ext2_vfsops.c

1131

sbp->f_ffree = fs->e2fs_ficount;

sys/vfs/ext2fs/ext2_vfsops.c

1143

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vfsops.c

1148

fs = ump->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

1149

if (le16toh(fs->e2fs->e2fs_magic) != E2FS_MAGIC)

sys/vfs/ext2fs/ext2_vfsops.c

1158

fs->e2fs_itpg;

sys/vfs/ext2fs/ext2_vfsops.c

1159

overhead = le32toh(fs->e2fs->e2fs_first_dblock) +

sys/vfs/ext2fs/ext2_vfsops.c

1160

fs->e2fs_gcount * overhead_per_group;

sys/vfs/ext2fs/ext2_vfsops.c

1161

if (le32toh(fs->e2fs->e2fs_rev) > E2FS_REV0 &&

sys/vfs/ext2fs/ext2_vfsops.c

1162

le32toh(fs->e2fs->e2fs_features_rocompat) & EXT2F_ROCOMPAT_SPARSESUPER) {

sys/vfs/ext2fs/ext2_vfsops.c

1163

for (i = 0, ngroups = 0; i < fs->e2fs_gcount; i++) {

sys/vfs/ext2fs/ext2_vfsops.c

1164

if (ext2_cg_has_sb(fs, i))

sys/vfs/ext2fs/ext2_vfsops.c

1168

ngroups = fs->e2fs_gcount;

sys/vfs/ext2fs/ext2_vfsops.c

1170

ngdb = fs->e2fs_gdbcount;

sys/vfs/ext2fs/ext2_vfsops.c

1171

if (le32toh(fs->e2fs->e2fs_rev) > E2FS_REV0 &&

sys/vfs/ext2fs/ext2_vfsops.c

1172

le32toh(fs->e2fs->e2fs_features_compat) & EXT2F_COMPAT_RESIZE)

sys/vfs/ext2fs/ext2_vfsops.c

1173

ngdb += le16toh(fs->e2fs->e2fs_reserved_ngdb);

sys/vfs/ext2fs/ext2_vfsops.c

1177

sbp->f_bsize = EXT2_FRAG_SIZE(fs);

sys/vfs/ext2fs/ext2_vfsops.c

1178

sbp->f_frsize = EXT2_BLOCK_SIZE(fs);

sys/vfs/ext2fs/ext2_vfsops.c

1179

sbp->f_blocks = fs->e2fs_bcount - overhead;

sys/vfs/ext2fs/ext2_vfsops.c

1180

sbp->f_bfree = fs->e2fs_fbcount;

sys/vfs/ext2fs/ext2_vfsops.c

1181

sbp->f_bavail = sbp->f_bfree - fs->e2fs_rbcount;

sys/vfs/ext2fs/ext2_vfsops.c

1182

sbp->f_files = le32toh(fs->e2fs->e2fs_icount);

sys/vfs/ext2fs/ext2_vfsops.c

1183

sbp->f_ffree = fs->e2fs_ficount;

sys/vfs/ext2fs/ext2_vfsops.c

121

struct ext2fs * es, struct m_ext2fs * fs);

sys/vfs/ext2fs/ext2_vfsops.c

1218

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vfsops.c

1222

fs = ump->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

1223

if (fs->e2fs_fmod != 0 && fs->e2fs_ronly != 0) { /* XXX */

sys/vfs/ext2fs/ext2_vfsops.c

1224

panic("ext2_sync: rofs mod fs=%s", fs->e2fs_fsmnt);

sys/vfs/ext2fs/ext2_vfsops.c

1252

if (fs->e2fs_fmod != 0) {

sys/vfs/ext2fs/ext2_vfsops.c

1253

fs->e2fs_fmod = 0;

sys/vfs/ext2fs/ext2_vfsops.c

1254

fs->e2fs->e2fs_wtime = htole32(time_second);

sys/vfs/ext2fs/ext2_vfsops.c

1340

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vfsops.c

1355

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

1358

if ((error = bread(ump->um_devvp, fsbtodoff(fs, ino_to_fsba(fs, ino)),

sys/vfs/ext2fs/ext2_vfsops.c

1359

(int)fs->e2fs_bsize, &bp)) != 0) {

sys/vfs/ext2fs/ext2_vfsops.c

136

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vfsops.c

1374

EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ino)), ip);

sys/vfs/ext2fs/ext2_vfsops.c

1392

used_blocks = howmany(ip->i_size, fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_vfsops.c

1451

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vfsops.c

1455

fs = VFSTOEXT2(mp)->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

1457

ufhp->ufid_ino > fs->e2fs_gcount * fs->e2fs_ipg)

sys/vfs/ext2fs/ext2_vfsops.c

151

fs = ump->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

1526

struct m_ext2fs *fs = mp->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

1527

struct ext2fs *es = fs->e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

1531

es->e2fs_bcount = htole32(fs->e2fs_bcount & 0xffffffff);

sys/vfs/ext2fs/ext2_vfsops.c

1532

es->e2fs_rbcount = htole32(fs->e2fs_rbcount & 0xffffffff);

sys/vfs/ext2fs/ext2_vfsops.c

1533

es->e2fs_fbcount = htole32(fs->e2fs_fbcount & 0xffffffff);

sys/vfs/ext2fs/ext2_vfsops.c

1534

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {

sys/vfs/ext2fs/ext2_vfsops.c

1535

es->e4fs_bcount_hi = htole32(fs->e2fs_bcount >> 32);

sys/vfs/ext2fs/ext2_vfsops.c

1536

es->e4fs_rbcount_hi = htole32(fs->e2fs_rbcount >> 32);

sys/vfs/ext2fs/ext2_vfsops.c

1537

es->e4fs_fbcount_hi = htole32(fs->e2fs_fbcount >> 32);

sys/vfs/ext2fs/ext2_vfsops.c

154

if (fs->e2fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {

sys/vfs/ext2fs/ext2_vfsops.c

1540

es->e2fs_ficount = htole32(fs->e2fs_ficount);

sys/vfs/ext2fs/ext2_vfsops.c

1542

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_vfsops.c

1543

ext2_sb_csum_set(fs);

sys/vfs/ext2fs/ext2_vfsops.c

1563

struct m_ext2fs *fs = mp->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

1570

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||

sys/vfs/ext2fs/ext2_vfsops.c

1571

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_vfsops.c

1572

ext2_gd_csum_set(fs);

sys/vfs/ext2fs/ext2_vfsops.c

1574

for (i = 0; i < fs->e2fs_gdbcount; i++) {

sys/vfs/ext2fs/ext2_vfsops.c

1575

bp = getblk(mp->um_devvp, fsbtodoff(fs,

sys/vfs/ext2fs/ext2_vfsops.c

1576

ext2_cg_location(fs, i)),

sys/vfs/ext2fs/ext2_vfsops.c

1577

fs->e2fs_bsize, 0, 0);

sys/vfs/ext2fs/ext2_vfsops.c

1578

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {

sys/vfs/ext2fs/ext2_vfsops.c

1579

memcpy(bp->b_data, &fs->e2fs_gd[

sys/vfs/ext2fs/ext2_vfsops.c

1580

i * fs->e2fs_bsize / sizeof(struct ext2_gd)],

sys/vfs/ext2fs/ext2_vfsops.c

1581

fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_vfsops.c

1583

for (j = 0; j < fs->e2fs_bsize / E2FS_REV0_GD_SIZE &&

sys/vfs/ext2fs/ext2_vfsops.c

1584

g_count < fs->e2fs_gcount; j++, g_count++)

sys/vfs/ext2fs/ext2_vfsops.c

1586

&fs->e2fs_gd[g_count], E2FS_REV0_GD_SIZE);

sys/vfs/ext2fs/ext2_vfsops.c

165

if (error == 0 && fs->e2fs_wasvalid &&

sys/vfs/ext2fs/ext2_vfsops.c

167

fs->e2fs->e2fs_state =

sys/vfs/ext2fs/ext2_vfsops.c

168

htole16((le16toh(fs->e2fs->e2fs_state) |

sys/vfs/ext2fs/ext2_vfsops.c

172

fs->e2fs_ronly = 1;

sys/vfs/ext2fs/ext2_vfsops.c

183

if (fs->e2fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {

sys/vfs/ext2fs/ext2_vfsops.c

184

if (ext2_check_sb_compat(fs->e2fs, devvp->v_rdev, 0))

sys/vfs/ext2fs/ext2_vfsops.c

201

if ((le16toh(fs->e2fs->e2fs_state) & E2FS_ISCLEAN) == 0 ||

sys/vfs/ext2fs/ext2_vfsops.c

202

(le16toh(fs->e2fs->e2fs_state) & E2FS_ERRORS)) {

sys/vfs/ext2fs/ext2_vfsops.c

205

"WARNING: %s was not properly dismounted\n", fs->e2fs_fsmnt);

sys/vfs/ext2fs/ext2_vfsops.c

209

fs->e2fs_fsmnt);

sys/vfs/ext2fs/ext2_vfsops.c

213

fs->e2fs->e2fs_state =

sys/vfs/ext2fs/ext2_vfsops.c

214

htole16(le16toh(fs->e2fs->e2fs_state) & ~E2FS_ISCLEAN);

sys/vfs/ext2fs/ext2_vfsops.c

216

fs->e2fs_ronly = 0;

sys/vfs/ext2fs/ext2_vfsops.c

282

fs = ump->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

288

copyinstr(path, fs->e2fs_fsmnt, sizeof(fs->e2fs_fsmnt) - 1, &size);

sys/vfs/ext2fs/ext2_vfsops.c

289

bzero(fs->e2fs_fsmnt + size, sizeof(fs->e2fs_fsmnt) - size);

sys/vfs/ext2fs/ext2_vfsops.c

336

ext2_cg_location(struct m_ext2fs *fs, int number)

sys/vfs/ext2fs/ext2_vfsops.c

345

logical_sb = fs->e2fs_bsize > SBSIZE ? 0 : 1;

sys/vfs/ext2fs/ext2_vfsops.c

347

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) ||

sys/vfs/ext2fs/ext2_vfsops.c

348

number < le32toh(fs->e2fs->e3fs_first_meta_bg))

sys/vfs/ext2fs/ext2_vfsops.c

351

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT))

sys/vfs/ext2fs/ext2_vfsops.c

352

descpb = fs->e2fs_bsize / sizeof(struct ext2_gd);

sys/vfs/ext2fs/ext2_vfsops.c

354

descpb = fs->e2fs_bsize / E2FS_REV0_GD_SIZE;

sys/vfs/ext2fs/ext2_vfsops.c

358

if (ext2_cg_has_sb(fs, cg))

sys/vfs/ext2fs/ext2_vfsops.c

361

return (has_super + cg * (e4fs_daddr_t)EXT2_BLOCKS_PER_GROUP(fs) +

sys/vfs/ext2fs/ext2_vfsops.c

362

le32toh(fs->e2fs->e2fs_first_dblock));

sys/vfs/ext2fs/ext2_vfsops.c

366

ext2_cg_validate(struct m_ext2fs *fs)

sys/vfs/ext2fs/ext2_vfsops.c

375

first_block = le32toh(fs->e2fs->e2fs_first_dblock);

sys/vfs/ext2fs/ext2_vfsops.c

376

last_cg_block = ext2_cg_number_gdb(fs, 0);

sys/vfs/ext2fs/ext2_vfsops.c

377

cg_count = fs->e2fs_gcount;

sys/vfs/ext2fs/ext2_vfsops.c

379

for (i = 0; i < fs->e2fs_gcount; i++) {

sys/vfs/ext2fs/ext2_vfsops.c

380

gd = &fs->e2fs_gd[i];

sys/vfs/ext2fs/ext2_vfsops.c

382

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) ||

sys/vfs/ext2fs/ext2_vfsops.c

383

i == fs->e2fs_gcount - 1) {

sys/vfs/ext2fs/ext2_vfsops.c

384

last_block = fs->e2fs_bcount - 1;

sys/vfs/ext2fs/ext2_vfsops.c

387

(EXT2_BLOCKS_PER_GROUP(fs) - 1);

sys/vfs/ext2fs/ext2_vfsops.c

390

if ((cg_count == fs->e2fs_gcount) &&

sys/vfs/ext2fs/ext2_vfsops.c

440

i_tables + fs->e2fs_itpg - 1 > last_block) {

sys/vfs/ext2fs/ext2_vfsops.c

446

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG))

sys/vfs/ext2fs/ext2_vfsops.c

447

first_block += EXT2_BLOCKS_PER_GROUP(fs);

sys/vfs/ext2fs/ext2_vfsops.c

459

struct m_ext2fs *fs)

sys/vfs/ext2fs/ext2_vfsops.c

468

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) &&

sys/vfs/ext2fs/ext2_vfsops.c

469

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/vfs/ext2fs/ext2_vfsops.c

476

ext2_sb_csum_set_seed(fs);

sys/vfs/ext2fs/ext2_vfsops.c

479

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/vfs/ext2fs/ext2_vfsops.c

480

error = ext2_sb_csum_verify(fs);

sys/vfs/ext2fs/ext2_vfsops.c

493

fs->e2fs_bshift = EXT2_MIN_BLOCK_LOG_SIZE + le32toh(es->e2fs_log_bsize);

sys/vfs/ext2fs/ext2_vfsops.c

494

fs->e2fs_bsize = 1U << fs->e2fs_bshift;

sys/vfs/ext2fs/ext2_vfsops.c

495

fs->e2fs_fsbtodb = le32toh(es->e2fs_log_bsize) + 1;

sys/vfs/ext2fs/ext2_vfsops.c

496

fs->e2fs_qbmask = fs->e2fs_bsize - 1;

sys/vfs/ext2fs/ext2_vfsops.c

506

fs->e2fs_fsize = EXT2_MIN_FRAG_SIZE << le32toh(es->e2fs_log_fsize);

sys/vfs/ext2fs/ext2_vfsops.c

507

if (fs->e2fs_fsize != fs->e2fs_bsize) {

sys/vfs/ext2fs/ext2_vfsops.c

513

fs->e2fs_fpb = fs->e2fs_bsize / fs->e2fs_fsize;

sys/vfs/ext2fs/ext2_vfsops.c

516

if (le16toh(es->e2fs_reserved_ngdb) > (fs->e2fs_bsize / 4)) {

sys/vfs/ext2fs/ext2_vfsops.c

523

fs->e2fs_isize = E2FS_REV0_INODE_SIZE;

sys/vfs/ext2fs/ext2_vfsops.c

525

fs->e2fs_isize = le16toh(es->e2fs_inode_size);

sys/vfs/ext2fs/ext2_vfsops.c

539

if (EXT2_INODE_SIZE(fs) < E2FS_REV0_INODE_SIZE ||

sys/vfs/ext2fs/ext2_vfsops.c

540

EXT2_INODE_SIZE(fs) > fs->e2fs_bsize ||

sys/vfs/ext2fs/ext2_vfsops.c

541

(fs->e2fs_isize & (fs->e2fs_isize - 1)) != 0) {

sys/vfs/ext2fs/ext2_vfsops.c

549

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT) &&

sys/vfs/ext2fs/ext2_vfsops.c

556

fs->e2fs_bpg = le32toh(es->e2fs_bpg);

sys/vfs/ext2fs/ext2_vfsops.c

557

fs->e2fs_fpg = le32toh(es->e2fs_fpg);

sys/vfs/ext2fs/ext2_vfsops.c

558

if (fs->e2fs_bpg == 0 || fs->e2fs_fpg == 0) {

sys/vfs/ext2fs/ext2_vfsops.c

562

} else if (fs->e2fs_bpg != fs->e2fs_fpg) {

sys/vfs/ext2fs/ext2_vfsops.c

568

if (fs->e2fs_bpg != fs->e2fs_bsize * 8) {

sys/vfs/ext2fs/ext2_vfsops.c

574

fs->e2fs_ipb = fs->e2fs_bsize / EXT2_INODE_SIZE(fs);

sys/vfs/ext2fs/ext2_vfsops.c

575

if (fs->e2fs_ipb == 0 ||

sys/vfs/ext2fs/ext2_vfsops.c

576

fs->e2fs_ipb > fs->e2fs_bsize / E2FS_REV0_INODE_SIZE) {

sys/vfs/ext2fs/ext2_vfsops.c

582

fs->e2fs_ipg = le32toh(es->e2fs_ipg);

sys/vfs/ext2fs/ext2_vfsops.c

583

if (fs->e2fs_ipg < fs->e2fs_ipb || fs->e2fs_ipg > fs->e2fs_bsize * 8) {

sys/vfs/ext2fs/ext2_vfsops.c

589

fs->e2fs_itpg = fs->e2fs_ipg / fs->e2fs_ipb;

sys/vfs/ext2fs/ext2_vfsops.c

591

fs->e2fs_bcount = le32toh(es->e2fs_bcount);

sys/vfs/ext2fs/ext2_vfsops.c

592

fs->e2fs_rbcount = le32toh(es->e2fs_rbcount);

sys/vfs/ext2fs/ext2_vfsops.c

593

fs->e2fs_fbcount = le32toh(es->e2fs_fbcount);

sys/vfs/ext2fs/ext2_vfsops.c

594

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {

sys/vfs/ext2fs/ext2_vfsops.c

595

fs->e2fs_bcount |= (uint64_t)(le32toh(es->e4fs_bcount_hi)) << 32;

sys/vfs/ext2fs/ext2_vfsops.c

596

fs->e2fs_rbcount |= (uint64_t)(le32toh(es->e4fs_rbcount_hi)) << 32;

sys/vfs/ext2fs/ext2_vfsops.c

597

fs->e2fs_fbcount |= (uint64_t)(le32toh(es->e4fs_fbcount_hi)) << 32;

sys/vfs/ext2fs/ext2_vfsops.c

599

if (fs->e2fs_rbcount > fs->e2fs_bcount ||

sys/vfs/ext2fs/ext2_vfsops.c

600

fs->e2fs_fbcount > fs->e2fs_bcount) {

sys/vfs/ext2fs/ext2_vfsops.c

606

fs->e2fs_ficount = le32toh(es->e2fs_ficount);

sys/vfs/ext2fs/ext2_vfsops.c

607

if (fs->e2fs_ficount > le32toh(es->e2fs_icount)) {

sys/vfs/ext2fs/ext2_vfsops.c

613

if (le32toh(es->e2fs_first_dblock) != (fs->e2fs_bsize > 1024 ? 0 : 1) ||

sys/vfs/ext2fs/ext2_vfsops.c

614

le32toh(es->e2fs_first_dblock) >= fs->e2fs_bcount) {

sys/vfs/ext2fs/ext2_vfsops.c

620

fs->e2fs_gcount = howmany(fs->e2fs_bcount -

sys/vfs/ext2fs/ext2_vfsops.c

621

le32toh(es->e2fs_first_dblock), EXT2_BLOCKS_PER_GROUP(fs));

sys/vfs/ext2fs/ext2_vfsops.c

622

if (fs->e2fs_gcount > ((uint64_t)1 << 32) - EXT2_DESCS_PER_BLOCK(fs)) {

sys/vfs/ext2fs/ext2_vfsops.c

629

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_EXTRA_ISIZE) &&

sys/vfs/ext2fs/ext2_vfsops.c

630

EXT2_INODE_SIZE(fs) < sizeof(struct ext2fs_dinode)) {

sys/vfs/ext2fs/ext2_vfsops.c

638

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {

sys/vfs/ext2fs/ext2_vfsops.c

639

e2fs_descpb = fs->e2fs_bsize / E2FS_64BIT_GD_SIZE;

sys/vfs/ext2fs/ext2_vfsops.c

640

e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount, e2fs_descpb);

sys/vfs/ext2fs/ext2_vfsops.c

642

e2fs_descpb = fs->e2fs_bsize / E2FS_REV0_GD_SIZE;

sys/vfs/ext2fs/ext2_vfsops.c

643

e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount,

sys/vfs/ext2fs/ext2_vfsops.c

644

fs->e2fs_bsize / sizeof(struct ext2_gd));

sys/vfs/ext2fs/ext2_vfsops.c

646

fs->e2fs_gdbcount = howmany(fs->e2fs_gcount, e2fs_descpb);

sys/vfs/ext2fs/ext2_vfsops.c

647

fs->e2fs_gd = malloc(e2fs_gdbcount_alloc * fs->e2fs_bsize,

sys/vfs/ext2fs/ext2_vfsops.c

649

fs->e2fs_contigdirs = malloc(fs->e2fs_gcount *

sys/vfs/ext2fs/ext2_vfsops.c

650

sizeof(*fs->e2fs_contigdirs), M_EXT2MNT, M_WAITOK | M_ZERO);

sys/vfs/ext2fs/ext2_vfsops.c

652

for (i = 0; i < fs->e2fs_gdbcount; i++) {

sys/vfs/ext2fs/ext2_vfsops.c

653

error = bread(devvp, fsbtodoff(fs, ext2_cg_location(fs, i)),

sys/vfs/ext2fs/ext2_vfsops.c

654

fs->e2fs_bsize, &bp);

sys/vfs/ext2fs/ext2_vfsops.c

665

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {

sys/vfs/ext2fs/ext2_vfsops.c

666

memcpy(&fs->e2fs_gd[

sys/vfs/ext2fs/ext2_vfsops.c

667

i * fs->e2fs_bsize / sizeof(struct ext2_gd)],

sys/vfs/ext2fs/ext2_vfsops.c

668

bp->b_data, fs->e2fs_bsize);

sys/vfs/ext2fs/ext2_vfsops.c

671

g_count < fs->e2fs_gcount; j++, g_count++)

sys/vfs/ext2fs/ext2_vfsops.c

672

memcpy(&fs->e2fs_gd[g_count],

sys/vfs/ext2fs/ext2_vfsops.c

681

error = ext2_cg_validate(fs);

sys/vfs/ext2fs/ext2_vfsops.c

686

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||

sys/vfs/ext2fs/ext2_vfsops.c

687

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/vfs/ext2fs/ext2_vfsops.c

688

error = ext2_gd_csum_verify(fs, devvp->v_rdev);

sys/vfs/ext2fs/ext2_vfsops.c

693

fs->e2fs_total_dir = 0;

sys/vfs/ext2fs/ext2_vfsops.c

694

for (i = 0; i < fs->e2fs_gcount; i++)

sys/vfs/ext2fs/ext2_vfsops.c

695

fs->e2fs_total_dir += e2fs_gd_get_ndirs(&fs->e2fs_gd[i]);

sys/vfs/ext2fs/ext2_vfsops.c

698

!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_LARGEFILE))

sys/vfs/ext2fs/ext2_vfsops.c

699

fs->e2fs_maxfilesize = 0x7fffffff;

sys/vfs/ext2fs/ext2_vfsops.c

701

fs->e2fs_maxfilesize = 0xffffffffffff;

sys/vfs/ext2fs/ext2_vfsops.c

702

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE))

sys/vfs/ext2fs/ext2_vfsops.c

703

fs->e2fs_maxfilesize = 0x7fffffffffffffff;

sys/vfs/ext2fs/ext2_vfsops.c

706

fs->e2fs_uhash = 3;

sys/vfs/ext2fs/ext2_vfsops.c

710

fs->e2fs_uhash = 3;

sys/vfs/ext2fs/ext2_vfsops.c

715

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/vfs/ext2fs/ext2_vfsops.c

716

error = ext2_sb_csum_verify(fs);

sys/vfs/ext2fs/ext2_vfsops.c

726

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vfsops.c

753

fsbtodoff(info->fs, ino_to_fsba(info->fs, ip->i_number)),

sys/vfs/ext2fs/ext2_vfsops.c

754

(int)info->fs->e2fs_bsize, &bp);

sys/vfs/ext2fs/ext2_vfsops.c

761

EXT2_INODE_SIZE(info->fs) * ino_to_fsbo(info->fs, ip->i_number)),

sys/vfs/ext2fs/ext2_vfsops.c

788

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vfsops.c

818

fs = VFSTOEXT2(mp)->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

819

bcopy(bp->b_data, fs->e2fs, sizeof(struct ext2fs));

sys/vfs/ext2fs/ext2_vfsops.c

821

if ((error = ext2_compute_sb_data(devvp, es, fs)) != 0) {

sys/vfs/ext2fs/ext2_vfsops.c

826

if (fs->fs_sbsize < SBSIZE)

sys/vfs/ext2fs/ext2_vfsops.c

834

if (fs->e2fs_contigsumsize > 0) {

sys/vfs/ext2fs/ext2_vfsops.c

835

lp = fs->e2fs_maxcluster;

sys/vfs/ext2fs/ext2_vfsops.c

836

sump = fs->e2fs_clustersum;

sys/vfs/ext2fs/ext2_vfsops.c

837

for (i = 0; i < fs->e2fs_gcount; i++, sump++) {

sys/vfs/ext2fs/ext2_vfsops.c

838

*lp++ = fs->e2fs_contigsumsize;

sys/vfs/ext2fs/ext2_vfsops.c

840

bzero(sump->cs_sum, fs->e2fs_contigsumsize + 1);

sys/vfs/ext2fs/ext2_vfsops.c

846

scaninfo.fs = fs;

sys/vfs/ext2fs/ext2_vfsops.c

863

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vfsops.c

964

fs = ump->um_e2fs;

sys/vfs/ext2fs/ext2_vfsops.c

965

fs->e2fs_ronly = ronly; /* ronly is set according to mnt_flags */

sys/vfs/ext2fs/ext2_vfsops.c

971

fs->e2fs_wasvalid = le16toh(fs->e2fs->e2fs_state) & E2FS_ISCLEAN ? 1 : 0;

sys/vfs/ext2fs/ext2_vfsops.c

973

fs->e2fs_fmod = 1; /* mark it modified and set fs invalid */

sys/vfs/ext2fs/ext2_vfsops.c

974

fs->e2fs->e2fs_state =

sys/vfs/ext2fs/ext2_vfsops.c

975

htole16(le16toh(fs->e2fs->e2fs_state) & ~E2FS_ISCLEAN);

sys/vfs/ext2fs/ext2_vfsops.c

991

ump->um_nindir = EXT2_ADDR_PER_BLOCK(fs);

sys/vfs/ext2fs/ext2_vfsops.c

992

ump->um_bptrtodb = le32toh(fs->e2fs->e2fs_log_bsize) + 1;

sys/vfs/ext2fs/ext2_vfsops.c

993

ump->um_seqinc = EXT2_FRAGS_PER_BLOCK(fs);

sys/vfs/ext2fs/ext2_vnops.c

1111

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vnops.c

1138

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_vnops.c

1204

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/vfs/ext2fs/ext2_vnops.c

1811

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vnops.c

1843

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_vnops.c

1845

uio->uio_offset >= fs->e2fs_maxfilesize)

sys/vfs/ext2fs/ext2_vnops.c

1851

lbn = lblkno(fs, uio->uio_offset);

sys/vfs/ext2fs/ext2_vnops.c

1853

nextloffset = lblktodoff(fs, nextlbn);

sys/vfs/ext2fs/ext2_vnops.c

1854

size = blksize(fs, ip, lbn);

sys/vfs/ext2fs/ext2_vnops.c

1855

blkoffset = blkoff(fs, uio->uio_offset);

sys/vfs/ext2fs/ext2_vnops.c

1857

xfersize = fs->e2fs_fsize - blkoffset;

sys/vfs/ext2fs/ext2_vnops.c

1864

error = bread(vp, lblktodoff(fs, lbn), size, &bp);

sys/vfs/ext2fs/ext2_vnops.c

1867

lblktodoff(fs, lbn), size, uio->uio_resid,

sys/vfs/ext2fs/ext2_vnops.c

1870

u_int nextsize = blksize(fs, ip, nextlbn);

sys/vfs/ext2fs/ext2_vnops.c

1872

error = breadn(vp, lblktodoff(fs, lbn), size,

sys/vfs/ext2fs/ext2_vnops.c

1875

error = bread(vp, lblktodoff(fs, lbn), size, &bp);

sys/vfs/ext2fs/ext2_vnops.c

1940

struct m_ext2fs *fs;

sys/vfs/ext2fs/ext2_vnops.c

1981

fs = ip->i_e2fs;

sys/vfs/ext2fs/ext2_vnops.c

1982

if ((uoff_t)uio->uio_offset + uio->uio_resid > fs->e2fs_maxfilesize)

sys/vfs/ext2fs/ext2_vnops.c

2006

lbn = lblkno(fs, uio->uio_offset);

sys/vfs/ext2fs/ext2_vnops.c

2007

blkoffset = blkoff(fs, uio->uio_offset);

sys/vfs/ext2fs/ext2_vnops.c

2008

xfersize = fs->e2fs_fsize - blkoffset;

sys/vfs/ext2fs/ext2_vnops.c

2018

if (fs->e2fs_bsize > xfersize)

sys/vfs/ext2fs/ext2_vnops.c

2031

size = blksize(fs, ip, lbn) - bp->b_resid;

sys/vfs/ext2fs/ext2_vnops.c

2058

fs->e2fs_bsize == xfersize)

sys/vfs/ext2fs/ext2_vnops.c

2076

} else if (xfersize + blkoffset == fs->e2fs_fsize) {

sys/vfs/ext2fs/fs.h

104

#define fsbtodb(fs, b) ((daddr_t)(b) << (fs)->e2fs_fsbtodb)

sys/vfs/ext2fs/fs.h

105

#define dbtofsb(fs, b) ((b) >> (fs)->e2fs_fsbtodb)

sys/vfs/ext2fs/fs.h

108

#define ino_to_cg(fs, x) (((x) - 1) / (fs->e2fs_ipg))

sys/vfs/ext2fs/fs.h

111

#define ino_to_fsba(fs, x) \

sys/vfs/ext2fs/fs.h

112

(e2fs_gd_get_i_tables(&(fs)->e2fs_gd[ino_to_cg((fs), (x))]) + \

sys/vfs/ext2fs/fs.h

113

(((x) - 1) % (fs)->e2fs_ipg) / (fs)->e2fs_ipb)

sys/vfs/ext2fs/fs.h

116

#define ino_to_fsbo(fs, x) ((x-1) % (fs->e2fs_ipb))

sys/vfs/ext2fs/fs.h

122

#define dtog(fs, d) (((d) - le32toh(fs->e2fs->e2fs_first_dblock)) / \

sys/vfs/ext2fs/fs.h

123

EXT2_BLOCKS_PER_GROUP(fs))

sys/vfs/ext2fs/fs.h

124

#define dtogd(fs, d) (((d) - le32toh(fs->e2fs->e2fs_first_dblock)) % \

sys/vfs/ext2fs/fs.h

125

EXT2_BLOCKS_PER_GROUP(fs))

sys/vfs/ext2fs/fs.h

132

#define blkoff(fs, loc) /* calculates (loc % fs->fs_bsize) */ \

sys/vfs/ext2fs/fs.h

133

((loc) & (fs)->e2fs_qbmask)

sys/vfs/ext2fs/fs.h

135

#define lblktosize(fs, blk) /* calculates (blk * fs->fs_bsize) */ \

sys/vfs/ext2fs/fs.h

136

((blk) << (fs->e2fs_bshift))

sys/vfs/ext2fs/fs.h

138

#define lblkno(fs, loc) /* calculates (loc / fs->fs_bsize) */ \

sys/vfs/ext2fs/fs.h

139

((loc) >> (fs->e2fs_bshift))

sys/vfs/ext2fs/fs.h

144

#define lblktodoff(fs, blk) /* calculates (blk * fs->fs_bsize) */ \

sys/vfs/ext2fs/fs.h

145

((off_t)(blk) << (fs)->e2fs_bshift)

sys/vfs/ext2fs/fs.h

147

#define fsbtodoff(fs, blk) /* calculates (blk * fs->fs_fsize) */ \

sys/vfs/ext2fs/fs.h

148

((off_t)(blk) * (fs)->e2fs_fsize)

sys/vfs/ext2fs/fs.h

150

#define dofftofsb(fs, blk) /* calculates blk / fs->fs_fsize */ \

sys/vfs/ext2fs/fs.h

151

((daddr_t)((blk) / (fs)->e2fs_fsize))

sys/vfs/ext2fs/fs.h

153

#define dbtodoff(fs, b) /* calculates diskblk * sectorsize */ \

sys/vfs/ext2fs/fs.h

154

((off_t)(b) * ((fs)->e2fs_fsize >> (fs)->e2fs_fsbtodb))

sys/vfs/ext2fs/fs.h

157

#define numfrags(fs, loc) /* calculates (loc / fs->fs_fsize) */ \

sys/vfs/ext2fs/fs.h

158

((loc) >> (fs->e2fs_bshift))

sys/vfs/ext2fs/fs.h

160

#define fragroundup(fs, size) /* calculates roundup(size, fs->fs_fsize) */ \

sys/vfs/ext2fs/fs.h

161

roundup(size, fs->e2fs_fsize)

sys/vfs/ext2fs/fs.h

168

#define blksize(fs, ip, lbn) ((fs)->e2fs_fsize)

sys/vfs/ext2fs/fs.h

173

#define INOPB(fs) (fs->e2fs_ipb)

sys/vfs/ext2fs/fs.h

178

#define NINDIR(fs) (EXT2_ADDR_PER_BLOCK(fs))

sys/vfs/mfs/mfs_vfsops.c

248

struct fs *fs;

sys/vfs/mfs/mfs_vfsops.c

296

fs = ump->um_fs;

sys/vfs/mfs/mfs_vfsops.c

297

if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {

sys/vfs/mfs/mfs_vfsops.c

305

if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {

sys/vfs/mfs/mfs_vfsops.c

307

fs->fs_ronly = 0;

sys/vfs/ufs/ffs_alloc.c

1001

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

1009

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

1010

if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)

sys/vfs/ufs/ffs_alloc.c

1012

error = bread(ip->i_devvp, fsbtodoff(fs, cgtod(fs, cg)),

sys/vfs/ufs/ffs_alloc.c

1013

(int)fs->fs_cgsize, &bp);

sys/vfs/ufs/ffs_alloc.c

1020

(cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize)) {

sys/vfs/ufs/ffs_alloc.c

1025

if (size == fs->fs_bsize) {

sys/vfs/ufs/ffs_alloc.c

1036

frags = numfrags(fs, size);

sys/vfs/ufs/ffs_alloc.c

1037

for (allocsiz = frags; allocsiz < fs->fs_frag; allocsiz++) {

sys/vfs/ufs/ffs_alloc.c

1041

if (allocsiz == fs->fs_frag) {

sys/vfs/ufs/ffs_alloc.c

1051

bpref = dtogd(fs, bno);

sys/vfs/ufs/ffs_alloc.c

1052

for (i = frags; i < fs->fs_frag; i++)

sys/vfs/ufs/ffs_alloc.c

1061

i = fs->fs_frag - frags;

sys/vfs/ufs/ffs_alloc.c

1063

fs->fs_cstotal.cs_nffree += i;

sys/vfs/ufs/ffs_alloc.c

1064

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

sys/vfs/ufs/ffs_alloc.c

1065

fs->fs_fmod = 1;

sys/vfs/ufs/ffs_alloc.c

107

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

1076

bno = ffs_mapsearch(fs, cgp, bpref, allocsiz);

sys/vfs/ufs/ffs_alloc.c

1084

fs->fs_cstotal.cs_nffree -= frags;

sys/vfs/ufs/ffs_alloc.c

1085

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

sys/vfs/ufs/ffs_alloc.c

1086

fs->fs_fmod = 1;

sys/vfs/ufs/ffs_alloc.c

1096

blkno = cg * fs->fs_fpg + bno;

sys/vfs/ufs/ffs_alloc.c

1098

softdep_setup_blkmapdep(bp, fs, blkno);

sys/vfs/ufs/ffs_alloc.c

1117

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

1125

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

1128

if (bpref == 0 || dtog(fs, bpref) != cgp->cg_cgx) {

sys/vfs/ufs/ffs_alloc.c

1132

bpref = blknum(fs, bpref);

sys/vfs/ufs/ffs_alloc.c

1133

bpref = dtogd(fs, bpref);

sys/vfs/ufs/ffs_alloc.c

1137

if (ffs_isblock(fs, blksfree, fragstoblks(fs, bpref))) {

sys/vfs/ufs/ffs_alloc.c

1141

if (fs->fs_nrpos <= 1 || fs->fs_cpc == 0) {

sys/vfs/ufs/ffs_alloc.c

115

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

1155

cylno = cbtocylno(fs, bpref);

sys/vfs/ufs/ffs_alloc.c

1163

cylbp = cg_blks(fs, cgp, cylno);

sys/vfs/ufs/ffs_alloc.c

1164

pos = cbtorpos(fs, bpref);

sys/vfs/ufs/ffs_alloc.c

1165

for (i = pos; i < fs->fs_nrpos; i++)

sys/vfs/ufs/ffs_alloc.c

1168

if (i == fs->fs_nrpos)

sys/vfs/ufs/ffs_alloc.c

117

if ((uint)size > fs->fs_bsize || fragoff(fs, size) != 0) {

sys/vfs/ufs/ffs_alloc.c

1177

pos = cylno % fs->fs_cpc;

sys/vfs/ufs/ffs_alloc.c

1178

bno = (cylno - pos) * fs->fs_spc / NSPB(fs);

sys/vfs/ufs/ffs_alloc.c

1179

if (fs_postbl(fs, pos)[i] == -1) {

sys/vfs/ufs/ffs_alloc.c

1181

pos, i, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1184

for (i = fs_postbl(fs, pos)[i];; ) {

sys/vfs/ufs/ffs_alloc.c

1185

if (ffs_isblock(fs, blksfree, bno + i)) {

sys/vfs/ufs/ffs_alloc.c

1186

bno = blkstofrags(fs, (bno + i));

sys/vfs/ufs/ffs_alloc.c

1189

delta = fs_rotbl(fs)[i];

sys/vfs/ufs/ffs_alloc.c

119

devtoname(ip->i_dev), (long)fs->fs_bsize, size,

sys/vfs/ufs/ffs_alloc.c

1191

delta + i > fragstoblks(fs, fs->fs_fpg))

sys/vfs/ufs/ffs_alloc.c

1195

kprintf("pos = %d, i = %d, fs = %s\n", pos, i, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

120

fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1203

bno = ffs_mapsearch(fs, cgp, bpref, (int)fs->fs_frag);

sys/vfs/ufs/ffs_alloc.c

1208

blkno = fragstoblks(fs, bno);

sys/vfs/ufs/ffs_alloc.c

1209

ffs_clrblock(fs, blksfree, (long)blkno);

sys/vfs/ufs/ffs_alloc.c

1210

ffs_clusteracct(fs, cgp, blkno, -1);

sys/vfs/ufs/ffs_alloc.c

1212

fs->fs_cstotal.cs_nbfree--;

sys/vfs/ufs/ffs_alloc.c

1213

fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--;

sys/vfs/ufs/ffs_alloc.c

1214

cylno = cbtocylno(fs, bno);

sys/vfs/ufs/ffs_alloc.c

1215

cg_blks(fs, cgp, cylno)[cbtorpos(fs, bno)]--;

sys/vfs/ufs/ffs_alloc.c

1217

fs->fs_fmod = 1;

sys/vfs/ufs/ffs_alloc.c

1218

blkno = cgp->cg_cgx * fs->fs_fpg + bno;

sys/vfs/ufs/ffs_alloc.c

1220

softdep_setup_blkmapdep(bp, fs, blkno);

sys/vfs/ufs/ffs_alloc.c

1234

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

1242

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

1243

if (fs->fs_maxcluster[cg] < len)

sys/vfs/ufs/ffs_alloc.c

1245

if (bread(ip->i_devvp, fsbtodoff(fs, cgtod(fs, cg)),

sys/vfs/ufs/ffs_alloc.c

1246

(int)fs->fs_cgsize, &bp)) {

sys/vfs/ufs/ffs_alloc.c

1258

for (i = len; i <= fs->fs_contigsumsize; i++)

sys/vfs/ufs/ffs_alloc.c

126

if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)

sys/vfs/ufs/ffs_alloc.c

1261

if (i > fs->fs_contigsumsize) {

sys/vfs/ufs/ffs_alloc.c

1273

fs->fs_maxcluster[cg] = i;

sys/vfs/ufs/ffs_alloc.c

1287

if (dtog(fs, bpref) != cg)

sys/vfs/ufs/ffs_alloc.c

129

freespace(fs, fs->fs_minfree) - numfrags(fs, size) < 0)

sys/vfs/ufs/ffs_alloc.c

1290

bpref = fragstoblks(fs, dtogd(fs, blknum(fs, bpref)));

sys/vfs/ufs/ffs_alloc.c

1316

if (!ffs_isblock(fs, blksfree, got - run + i))

sys/vfs/ufs/ffs_alloc.c

1319

bno = cg * fs->fs_fpg + blkstofrags(fs, got - run + 1);

sys/vfs/ufs/ffs_alloc.c

1320

if (dtog(fs, bno) != cg)

sys/vfs/ufs/ffs_alloc.c

1322

len = blkstofrags(fs, len);

sys/vfs/ufs/ffs_alloc.c

1323

for (i = 0; i < len; i += fs->fs_frag) {

sys/vfs/ufs/ffs_alloc.c

1357

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

136

if (bpref >= fs->fs_size)

sys/vfs/ufs/ffs_alloc.c

1369

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

1370

if (fs->fs_cs(fs, cg).cs_nifree == 0)

sys/vfs/ufs/ffs_alloc.c

1372

error = bread(ip->i_devvp, fsbtodoff(fs, cgtod(fs, cg)),

sys/vfs/ufs/ffs_alloc.c

1373

(int)fs->fs_cgsize, &bp);

sys/vfs/ufs/ffs_alloc.c

139

cg = ino_to_cg(fs, ip->i_number);

sys/vfs/ufs/ffs_alloc.c

1390

ibase = cg * fs->fs_ipg;

sys/vfs/ufs/ffs_alloc.c

1392

ipref %= fs->fs_ipg;

sys/vfs/ufs/ffs_alloc.c

141

cg = dtog(fs, bpref);

sys/vfs/ufs/ffs_alloc.c

1410

ipref = (cgp->cg_irotor % fs->fs_ipg) >> 3; /* byte index */

sys/vfs/ufs/ffs_alloc.c

1411

len = (fs->fs_ipg + 7) >> 3; /* byte size */

sys/vfs/ufs/ffs_alloc.c

1430

cgp->cg_irotor = (ipref + 1) % fs->fs_ipg;

sys/vfs/ufs/ffs_alloc.c

1450

kprintf("fs = %s\n", fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1459

KKASSERT(ipref >= 0 && ipref < fs->fs_ipg);

sys/vfs/ufs/ffs_alloc.c

1465

fs->fs_cstotal.cs_nifree--;

sys/vfs/ufs/ffs_alloc.c

1466

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

sys/vfs/ufs/ffs_alloc.c

1467

fs->fs_fmod = 1;

sys/vfs/ufs/ffs_alloc.c

1470

fs->fs_cstotal.cs_ndir++;

sys/vfs/ufs/ffs_alloc.c

1471

fs->fs_cs(fs, cg).cs_ndir++;

sys/vfs/ufs/ffs_alloc.c

1485

ffs_blkfree_cg(struct fs * fs, struct vnode * i_devvp, cdev_t i_dev, ino_t i_number,

sys/vfs/ufs/ffs_alloc.c

1501

if ((uint)size > fs->fs_bsize || fragoff(fs, size) != 0 ||

sys/vfs/ufs/ffs_alloc.c

1502

fragnum(fs, bno) + numfrags(fs, size) > fs->fs_frag) {

sys/vfs/ufs/ffs_alloc.c

1504

devtoname(i_dev), (long)bno, (long)fs->fs_bsize, size,

sys/vfs/ufs/ffs_alloc.c

1505

fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1508

cg = dtog(fs, bno);

sys/vfs/ufs/ffs_alloc.c

1509

if ((uint)bno >= fs->fs_size) {

sys/vfs/ufs/ffs_alloc.c

1512

ffs_fserr(fs, i_din_uid, "bad block");

sys/vfs/ufs/ffs_alloc.c

1519

error = bread(i_devvp, fsbtodoff(fs, cgtod(fs, cg)),

sys/vfs/ufs/ffs_alloc.c

1520

(int)fs->fs_cgsize, &bp);

sys/vfs/ufs/ffs_alloc.c

1531

bno = dtogd(fs, bno);

sys/vfs/ufs/ffs_alloc.c

1534

if (size == fs->fs_bsize) {

sys/vfs/ufs/ffs_alloc.c

1538

blkno = fragstoblks(fs, bno);

sys/vfs/ufs/ffs_alloc.c

1539

if (!ffs_isfreeblock(fs, blksfree, blkno)) {

sys/vfs/ufs/ffs_alloc.c

1541

devtoname(i_dev), (long)bno, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1544

ffs_setblock(fs, blksfree, blkno);

sys/vfs/ufs/ffs_alloc.c

1545

ffs_clusteracct(fs, cgp, blkno, 1);

sys/vfs/ufs/ffs_alloc.c

1547

fs->fs_cstotal.cs_nbfree++;

sys/vfs/ufs/ffs_alloc.c

1548

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

sys/vfs/ufs/ffs_alloc.c

1549

i = cbtocylno(fs, bno);

sys/vfs/ufs/ffs_alloc.c

1550

cg_blks(fs, cgp, i)[cbtorpos(fs, bno)]++;

sys/vfs/ufs/ffs_alloc.c

157

ffs_fserr(fs, cred->cr_uid, "filesystem full");

sys/vfs/ufs/ffs_alloc.c

1572

bbase = bno - fragnum(fs, bno);

sys/vfs/ufs/ffs_alloc.c

1573

blk = blkmap(fs, blksfree, bbase);

sys/vfs/ufs/ffs_alloc.c

1574

ffs_fragacct(fs, blk, cgp->cg_frsum, -1);

sys/vfs/ufs/ffs_alloc.c

1575

frags = numfrags(fs, size);

sys/vfs/ufs/ffs_alloc.c

158

uprintf("\n%s: write failed, filesystem is full\n", fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1580

fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1586

fs->fs_cstotal.cs_nffree += i;

sys/vfs/ufs/ffs_alloc.c

1587

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

sys/vfs/ufs/ffs_alloc.c

1592

blk = blkmap(fs, blksfree, bbase);

sys/vfs/ufs/ffs_alloc.c

1593

ffs_fragacct(fs, blk, cgp->cg_frsum, 1);

sys/vfs/ufs/ffs_alloc.c

1598

blkno = fragstoblks(fs, bbase);

sys/vfs/ufs/ffs_alloc.c

1599

if (ffs_isblock(fs, blksfree, blkno)) {

sys/vfs/ufs/ffs_alloc.c

1600

cgp->cg_cs.cs_nffree -= fs->fs_frag;

sys/vfs/ufs/ffs_alloc.c

1601

fs->fs_cstotal.cs_nffree -= fs->fs_frag;

sys/vfs/ufs/ffs_alloc.c

1602

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

sys/vfs/ufs/ffs_alloc.c

1603

ffs_clusteracct(fs, cgp, blkno, 1);

sys/vfs/ufs/ffs_alloc.c

1605

fs->fs_cstotal.cs_nbfree++;

sys/vfs/ufs/ffs_alloc.c

1606

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

sys/vfs/ufs/ffs_alloc.c

1607

i = cbtocylno(fs, bbase);

sys/vfs/ufs/ffs_alloc.c

1608

cg_blks(fs, cgp, i)[cbtorpos(fs, bbase)]++;

sys/vfs/ufs/ffs_alloc.c

1612

fs->fs_fmod = 1;

sys/vfs/ufs/ffs_alloc.c

1626

struct fs *i_fs;

sys/vfs/ufs/ffs_alloc.c

1708

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

1714

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

1715

if ((uint)size > fs->fs_bsize || fragoff(fs, size) != 0) {

sys/vfs/ufs/ffs_alloc.c

1717

(long)fs->fs_bsize, size, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1720

if ((uint)bno >= fs->fs_size)

sys/vfs/ufs/ffs_alloc.c

1722

error = bread(ip->i_devvp, fsbtodoff(fs, cgtod(fs, dtog(fs, bno))),

sys/vfs/ufs/ffs_alloc.c

1723

(int)fs->fs_cgsize, &bp);

sys/vfs/ufs/ffs_alloc.c

1730

bno = dtogd(fs, bno);

sys/vfs/ufs/ffs_alloc.c

1731

if (size == fs->fs_bsize) {

sys/vfs/ufs/ffs_alloc.c

1732

free = ffs_isblock(fs, blksfree, fragstoblks(fs, bno));

sys/vfs/ufs/ffs_alloc.c

1734

frags = numfrags(fs, size);

sys/vfs/ufs/ffs_alloc.c

174

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

1766

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

1774

fs = pip->i_fs;

sys/vfs/ufs/ffs_alloc.c

1775

if ((uint)ino >= fs->fs_ipg * fs->fs_ncg)

sys/vfs/ufs/ffs_alloc.c

1777

major(pip->i_dev), minor(pip->i_dev), ino, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1778

cg = ino_to_cg(fs, ino);

sys/vfs/ufs/ffs_alloc.c

1779

error = bread(pip->i_devvp, fsbtodoff(fs, cgtod(fs, cg)),

sys/vfs/ufs/ffs_alloc.c

1780

(int)fs->fs_cgsize, &bp);

sys/vfs/ufs/ffs_alloc.c

1792

ino %= fs->fs_ipg;

sys/vfs/ufs/ffs_alloc.c

1795

devtoname(pip->i_dev), (u_long)ino, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1796

if (fs->fs_ronly == 0)

sys/vfs/ufs/ffs_alloc.c

180

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

1803

fs->fs_cstotal.cs_nifree++;

sys/vfs/ufs/ffs_alloc.c

1804

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

sys/vfs/ufs/ffs_alloc.c

1807

fs->fs_cstotal.cs_ndir--;

sys/vfs/ufs/ffs_alloc.c

1808

fs->fs_cs(fs, cg).cs_ndir--;

sys/vfs/ufs/ffs_alloc.c

1810

fs->fs_fmod = 1;

sys/vfs/ufs/ffs_alloc.c

182

if ((uint)osize > fs->fs_bsize || fragoff(fs, osize) != 0 ||

sys/vfs/ufs/ffs_alloc.c

1822

ffs_mapsearch(struct fs *fs, struct cg *cgp, ufs_daddr_t bpref, int allocsiz)

sys/vfs/ufs/ffs_alloc.c

183

(uint)nsize > fs->fs_bsize || fragoff(fs, nsize) != 0) {

sys/vfs/ufs/ffs_alloc.c

1834

start = dtogd(fs, bpref) / NBBY;

sys/vfs/ufs/ffs_alloc.c

1838

len = howmany(fs->fs_fpg, NBBY) - start;

sys/vfs/ufs/ffs_alloc.c

1840

(u_char *)fragtbl[fs->fs_frag],

sys/vfs/ufs/ffs_alloc.c

1841

(u_char)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

sys/vfs/ufs/ffs_alloc.c

1846

(u_char *)fragtbl[fs->fs_frag],

sys/vfs/ufs/ffs_alloc.c

1847

(u_char)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

sys/vfs/ufs/ffs_alloc.c

1850

start, len, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

186

devtoname(ip->i_dev), (long)fs->fs_bsize, osize,

sys/vfs/ufs/ffs_alloc.c

1861

for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {

sys/vfs/ufs/ffs_alloc.c

1862

blk = blkmap(fs, blksfree, bno);

sys/vfs/ufs/ffs_alloc.c

1866

for (pos = 0; pos <= fs->fs_frag - allocsiz; pos++) {

sys/vfs/ufs/ffs_alloc.c

187

nsize, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1873

kprintf("bno = %lu, fs = %s\n", (u_long)bno, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

1884

ffs_clusteracct(struct fs *fs, struct cg *cgp, ufs_daddr_t blkno, int cnt)

sys/vfs/ufs/ffs_alloc.c

1891

if (fs->fs_contigsumsize <= 0)

sys/vfs/ufs/ffs_alloc.c

1906

end = start + fs->fs_contigsumsize;

sys/vfs/ufs/ffs_alloc.c

1927

end = start - fs->fs_contigsumsize;

sys/vfs/ufs/ffs_alloc.c

194

freespace(fs, fs->fs_minfree) - numfrags(fs, nsize - osize) < 0)

sys/vfs/ufs/ffs_alloc.c

1949

if (i > fs->fs_contigsumsize)

sys/vfs/ufs/ffs_alloc.c

1950

i = fs->fs_contigsumsize;

sys/vfs/ufs/ffs_alloc.c

1959

lp = &sump[fs->fs_contigsumsize];

sys/vfs/ufs/ffs_alloc.c

1960

for (i = fs->fs_contigsumsize; i > 0; i--)

sys/vfs/ufs/ffs_alloc.c

1963

fs->fs_maxcluster[cgp->cg_cgx] = i;

sys/vfs/ufs/ffs_alloc.c

1973

ffs_fserr(struct fs *fs, uint uid, char *cp)

sys/vfs/ufs/ffs_alloc.c

198

devtoname(ip->i_dev), (long)fs->fs_bsize, (long)bprev,

sys/vfs/ufs/ffs_alloc.c

1980

p ? p->p_comm : "-", uid, fs->fs_fsmnt, cp);

sys/vfs/ufs/ffs_alloc.c

1983

td, uid, fs->fs_fsmnt, cp);

sys/vfs/ufs/ffs_alloc.c

199

fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

205

error = bread(ITOV(ip), lblktodoff(fs, lbprev), osize, &bp);

sys/vfs/ufs/ffs_alloc.c

214

bp->b_bio2.bio_offset = fsbtodoff(fs, bprev);

sys/vfs/ufs/ffs_alloc.c

227

cg = dtog(fs, bprev);

sys/vfs/ufs/ffs_alloc.c

230

if (bp->b_bio2.bio_offset != fsbtodoff(fs, bno))

sys/vfs/ufs/ffs_alloc.c

242

if (bpref >= fs->fs_size)

sys/vfs/ufs/ffs_alloc.c

244

switch ((int)fs->fs_optim) {

sys/vfs/ufs/ffs_alloc.c

254

if (fs->fs_minfree <= 5 ||

sys/vfs/ufs/ffs_alloc.c

255

fs->fs_cstotal.cs_nffree >

sys/vfs/ufs/ffs_alloc.c

256

(off_t)fs->fs_dsize * fs->fs_minfree / (2 * 100))

sys/vfs/ufs/ffs_alloc.c

259

fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

260

fs->fs_optim = FS_OPTTIME;

sys/vfs/ufs/ffs_alloc.c

273

request = fs->fs_bsize;

sys/vfs/ufs/ffs_alloc.c

274

if (fs->fs_cstotal.cs_nffree <

sys/vfs/ufs/ffs_alloc.c

275

(off_t)fs->fs_dsize * (fs->fs_minfree - 2) / 100)

sys/vfs/ufs/ffs_alloc.c

278

fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

279

fs->fs_optim = FS_OPTSPACE;

sys/vfs/ufs/ffs_alloc.c

283

devtoname(ip->i_dev), (long)fs->fs_optim, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

290

bp->b_bio2.bio_offset = fsbtodoff(fs, bno);

sys/vfs/ufs/ffs_alloc.c

294

ffs_blkfree(ip, bno + numfrags(fs, nsize),

sys/vfs/ufs/ffs_alloc.c

314

ffs_fserr(fs, cred->cr_uid, "filesystem full");

sys/vfs/ufs/ffs_alloc.c

315

uprintf("\n%s: write failed, filesystem is full\n", fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

351

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

368

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

369

if (fs->fs_contigsumsize <= 0)

sys/vfs/ufs/ffs_alloc.c

373

start_lbn = lblkno(fs, buflist->bs_children[0]->b_loffset);

sys/vfs/ufs/ffs_alloc.c

378

dofftofsb(fs, buflist->bs_children[i]->b_bio2.bio_offset), fs->fs_bsize))

sys/vfs/ufs/ffs_alloc.c

381

if (buflist->bs_children[i]->b_loffset != lblktodoff(fs, start_lbn) + lblktodoff(fs, i))

sys/vfs/ufs/ffs_alloc.c

385

ssize = (int)fsbtodoff(fs, fs->fs_frag);

sys/vfs/ufs/ffs_alloc.c

395

if (dtog(fs, dofftofsb(fs, buflist->bs_children[0]->b_bio2.bio_offset)) !=

sys/vfs/ufs/ffs_alloc.c

396

dtog(fs, dofftofsb(fs, buflist->bs_children[len - 1]->b_bio2.bio_offset)))

sys/vfs/ufs/ffs_alloc.c

411

if (bread(vp, lblktodoff(fs, idp->in_lbn), (int)fs->fs_bsize, &sbp)) {

sys/vfs/ufs/ffs_alloc.c

417

slen = fs->fs_nindir - soff;

sys/vfs/ufs/ffs_alloc.c

435

if (bread(vp, lblktodoff(fs, idp->in_lbn), (int)fs->fs_bsize, &ebp))

sys/vfs/ufs/ffs_alloc.c

454

if ((newblk = (ufs_daddr_t)ffs_hashalloc(ip, dtog(fs, pref), (long)pref,

sys/vfs/ufs/ffs_alloc.c

470

for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->fs_frag) {

sys/vfs/ufs/ffs_alloc.c

477

dofftofsb(fs, buflist->bs_children[i]->b_bio2.bio_offset), fs->fs_bsize))

sys/vfs/ufs/ffs_alloc.c

479

if (dofftofsb(fs, buflist->bs_children[i]->b_bio2.bio_offset) != *bap)

sys/vfs/ufs/ffs_alloc.c

489

blkno, *bap, fs->fs_bsize, fs->fs_bsize,

sys/vfs/ufs/ffs_alloc.c

535

for (blkno = newblk, i = 0; i < len; i++, blkno += fs->fs_frag) {

sys/vfs/ufs/ffs_alloc.c

539

dofftofsb(fs, buflist->bs_children[i]->b_bio2.bio_offset),

sys/vfs/ufs/ffs_alloc.c

540

fs->fs_bsize);

sys/vfs/ufs/ffs_alloc.c

542

buflist->bs_children[i]->b_bio2.bio_offset = fsbtodoff(fs, blkno);

sys/vfs/ufs/ffs_alloc.c

545

dofftofsb(fs, buflist->bs_children[i]->b_bio2.bio_offset), fs->fs_bsize))

sys/vfs/ufs/ffs_alloc.c

588

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

595

fs = pip->i_fs;

sys/vfs/ufs/ffs_alloc.c

596

if (fs->fs_cstotal.cs_nifree == 0)

sys/vfs/ufs/ffs_alloc.c

603

if (ipref >= fs->fs_ncg * fs->fs_ipg)

sys/vfs/ufs/ffs_alloc.c

605

cg = ino_to_cg(fs, ipref);

sys/vfs/ufs/ffs_alloc.c

611

if (fs->fs_contigdirs[cg] < 255)

sys/vfs/ufs/ffs_alloc.c

612

fs->fs_contigdirs[cg]++;

sys/vfs/ufs/ffs_alloc.c

614

if (fs->fs_contigdirs[cg] > 0)

sys/vfs/ufs/ffs_alloc.c

615

fs->fs_contigdirs[cg]--;

sys/vfs/ufs/ffs_alloc.c

629

ip->i_mode, (u_long)ip->i_number, fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

634

fs->fs_fsmnt, (u_long)ino, (long)ip->i_blocks);

sys/vfs/ufs/ffs_alloc.c

645

ffs_fserr(fs, cred->cr_uid, "out of inodes");

sys/vfs/ufs/ffs_alloc.c

646

uprintf("\n%s: create/symlink failed, no inodes free\n", fs->fs_fsmnt);

sys/vfs/ufs/ffs_alloc.c

66

static void ffs_blkfree_cg(struct fs *, struct vnode *, cdev_t , ino_t,

sys/vfs/ufs/ffs_alloc.c

666

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

674

fs = pip->i_fs;

sys/vfs/ufs/ffs_alloc.c

676

avgifree = fs->fs_cstotal.cs_nifree / fs->fs_ncg;

sys/vfs/ufs/ffs_alloc.c

677

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

sys/vfs/ufs/ffs_alloc.c

678

avgndir = fs->fs_cstotal.cs_ndir / fs->fs_ncg;

sys/vfs/ufs/ffs_alloc.c

684

prefcg = karc4random() % fs->fs_ncg;

sys/vfs/ufs/ffs_alloc.c

686

minndir = fs->fs_ipg;

sys/vfs/ufs/ffs_alloc.c

687

for (cg = prefcg; cg < fs->fs_ncg; cg++)

sys/vfs/ufs/ffs_alloc.c

688

if (fs->fs_cs(fs, cg).cs_ndir < minndir &&

sys/vfs/ufs/ffs_alloc.c

689

fs->fs_cs(fs, cg).cs_nifree >= avgifree &&

sys/vfs/ufs/ffs_alloc.c

690

fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/vfs/ufs/ffs_alloc.c

692

minndir = fs->fs_cs(fs, cg).cs_ndir;

sys/vfs/ufs/ffs_alloc.c

695

if (fs->fs_cs(fs, cg).cs_ndir < minndir &&

sys/vfs/ufs/ffs_alloc.c

696

fs->fs_cs(fs, cg).cs_nifree >= avgifree &&

sys/vfs/ufs/ffs_alloc.c

697

fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/vfs/ufs/ffs_alloc.c

699

minndir = fs->fs_cs(fs, cg).cs_ndir;

sys/vfs/ufs/ffs_alloc.c

701

return ((ino_t)(fs->fs_ipg * mincg));

sys/vfs/ufs/ffs_alloc.c

708

maxndir = min(avgndir + fs->fs_ipg / 16, fs->fs_ipg);

sys/vfs/ufs/ffs_alloc.c

71

static void ffs_clusteracct (struct fs *, struct cg *, ufs_daddr_t,

sys/vfs/ufs/ffs_alloc.c

715

cgsize = fs->fs_fsize * fs->fs_fpg;

sys/vfs/ufs/ffs_alloc.c

721

dirsize64 = fs->fs_avgfilesize * (int64_t)fs->fs_avgfpdir;

sys/vfs/ufs/ffs_alloc.c

727

(cgsize - avgbfree * fs->fs_bsize) / avgndir : 0;

sys/vfs/ufs/ffs_alloc.c

730

maxcontigdirs = min((avgbfree * fs->fs_bsize) / dirsize, 255);

sys/vfs/ufs/ffs_alloc.c

731

if (fs->fs_avgfpdir > 0)

sys/vfs/ufs/ffs_alloc.c

733

fs->fs_ipg / fs->fs_avgfpdir);

sys/vfs/ufs/ffs_alloc.c

743

prefcg = ino_to_cg(fs, pip->i_number);

sys/vfs/ufs/ffs_alloc.c

744

for (cg = prefcg; cg < fs->fs_ncg; cg++)

sys/vfs/ufs/ffs_alloc.c

745

if (fs->fs_cs(fs, cg).cs_ndir < maxndir &&

sys/vfs/ufs/ffs_alloc.c

746

fs->fs_cs(fs, cg).cs_nifree >= minifree &&

sys/vfs/ufs/ffs_alloc.c

747

fs->fs_cs(fs, cg).cs_nbfree >= minbfree) {

sys/vfs/ufs/ffs_alloc.c

748

if (fs->fs_contigdirs[cg] < maxcontigdirs)

sys/vfs/ufs/ffs_alloc.c

749

return ((ino_t)(fs->fs_ipg * cg));

sys/vfs/ufs/ffs_alloc.c

752

if (fs->fs_cs(fs, cg).cs_ndir < maxndir &&

sys/vfs/ufs/ffs_alloc.c

753

fs->fs_cs(fs, cg).cs_nifree >= minifree &&

sys/vfs/ufs/ffs_alloc.c

754

fs->fs_cs(fs, cg).cs_nbfree >= minbfree) {

sys/vfs/ufs/ffs_alloc.c

755

if (fs->fs_contigdirs[cg] < maxcontigdirs)

sys/vfs/ufs/ffs_alloc.c

756

return ((ino_t)(fs->fs_ipg * cg));

sys/vfs/ufs/ffs_alloc.c

761

for (cg = prefcg; cg < fs->fs_ncg; cg++)

sys/vfs/ufs/ffs_alloc.c

762

if (fs->fs_cs(fs, cg).cs_nifree >= avgifree)

sys/vfs/ufs/ffs_alloc.c

763

return ((ino_t)(fs->fs_ipg * cg));

sys/vfs/ufs/ffs_alloc.c

765

if (fs->fs_cs(fs, cg).cs_nifree >= avgifree)

sys/vfs/ufs/ffs_alloc.c

767

return ((ino_t)(fs->fs_ipg * cg));

sys/vfs/ufs/ffs_alloc.c

77

static void ffs_fserr (struct fs *, uint, char *);

sys/vfs/ufs/ffs_alloc.c

799

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

804

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

805

if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {

sys/vfs/ufs/ffs_alloc.c

806

if (lbn < UFS_NDADDR + NINDIR(fs)) {

sys/vfs/ufs/ffs_alloc.c

807

cg = ino_to_cg(fs, ip->i_number);

sys/vfs/ufs/ffs_alloc.c

808

return (fs->fs_fpg * cg + fs->fs_frag);

sys/vfs/ufs/ffs_alloc.c

81

static ufs_daddr_t ffs_mapsearch (struct fs *, struct cg *, ufs_daddr_t,

sys/vfs/ufs/ffs_alloc.c

816

ino_to_cg(fs, ip->i_number) + lbn / fs->fs_maxbpg;

sys/vfs/ufs/ffs_alloc.c

818

startcg = dtog(fs, bap[indx - 1]) + 1;

sys/vfs/ufs/ffs_alloc.c

819

startcg %= fs->fs_ncg;

sys/vfs/ufs/ffs_alloc.c

820

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

sys/vfs/ufs/ffs_alloc.c

821

for (cg = startcg; cg < fs->fs_ncg; cg++)

sys/vfs/ufs/ffs_alloc.c

822

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/vfs/ufs/ffs_alloc.c

823

fs->fs_cgrotor = cg;

sys/vfs/ufs/ffs_alloc.c

824

return (fs->fs_fpg * cg + fs->fs_frag);

sys/vfs/ufs/ffs_alloc.c

827

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/vfs/ufs/ffs_alloc.c

828

fs->fs_cgrotor = cg;

sys/vfs/ufs/ffs_alloc.c

829

return (fs->fs_fpg * cg + fs->fs_frag);

sys/vfs/ufs/ffs_alloc.c

839

nextblk = bap[indx - 1] + fs->fs_frag;

sys/vfs/ufs/ffs_alloc.c

840

if (fs->fs_rotdelay == 0 || indx < fs->fs_maxcontig ||

sys/vfs/ufs/ffs_alloc.c

841

bap[indx - fs->fs_maxcontig] +

sys/vfs/ufs/ffs_alloc.c

842

blkstofrags(fs, fs->fs_maxcontig) != nextblk)

sys/vfs/ufs/ffs_alloc.c

850

nextblk += roundup(fs->fs_rotdelay * fs->fs_rps * fs->fs_nsect /

sys/vfs/ufs/ffs_alloc.c

851

(NSPF(fs) * 1000), fs->fs_frag);

sys/vfs/ufs/ffs_alloc.c

869

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

873

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

883

for (i = 1; i < fs->fs_ncg; i *= 2) {

sys/vfs/ufs/ffs_alloc.c

885

if (cg >= fs->fs_ncg)

sys/vfs/ufs/ffs_alloc.c

886

cg -= fs->fs_ncg;

sys/vfs/ufs/ffs_alloc.c

896

cg = (icg + 2) % fs->fs_ncg;

sys/vfs/ufs/ffs_alloc.c

897

for (i = 2; i < fs->fs_ncg; i++) {

sys/vfs/ufs/ffs_alloc.c

902

if (cg == fs->fs_ncg)

sys/vfs/ufs/ffs_alloc.c

917

struct fs *fs;

sys/vfs/ufs/ffs_alloc.c

925

fs = ip->i_fs;

sys/vfs/ufs/ffs_alloc.c

926

if (fs->fs_cs(fs, cg).cs_nffree < numfrags(fs, nsize - osize))

sys/vfs/ufs/ffs_alloc.c

928

frags = numfrags(fs, nsize);

sys/vfs/ufs/ffs_alloc.c

929

bbase = fragnum(fs, bprev);

sys/vfs/ufs/ffs_alloc.c

930

if (bbase > fragnum(fs, (bprev + frags - 1))) {

sys/vfs/ufs/ffs_alloc.c

934

KKASSERT(blknum(fs, bprev) == blknum(fs, bprev + frags - 1));

sys/vfs/ufs/ffs_alloc.c

935

error = bread(ip->i_devvp, fsbtodoff(fs, cgtod(fs, cg)),

sys/vfs/ufs/ffs_alloc.c

936

(int)fs->fs_cgsize, &bp);

sys/vfs/ufs/ffs_alloc.c

947

bno = dtogd(fs, bprev);

sys/vfs/ufs/ffs_alloc.c

949

for (i = numfrags(fs, osize); i < frags; i++) {

sys/vfs/ufs/ffs_alloc.c

967

for (i = frags; i < fs->fs_frag - bbase; i++) {

sys/vfs/ufs/ffs_alloc.c

976

cgp->cg_frsum[i - numfrags(fs, osize)]--;

sys/vfs/ufs/ffs_alloc.c

979

for (i = numfrags(fs, osize); i < frags; i++) {

sys/vfs/ufs/ffs_alloc.c

982

fs->fs_cstotal.cs_nffree--;

sys/vfs/ufs/ffs_alloc.c

983

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

sys/vfs/ufs/ffs_alloc.c

985

fs->fs_fmod = 1;

sys/vfs/ufs/ffs_alloc.c

987

softdep_setup_blkmapdep(bp, fs, bprev);

sys/vfs/ufs/ffs_balloc.c

111

nb = lblkno(fs, ip->i_size);

sys/vfs/ufs/ffs_balloc.c

119

osize = blksize(fs, ip, nb);

sys/vfs/ufs/ffs_balloc.c

124

if (osize < fs->fs_bsize && osize > 0) {

sys/vfs/ufs/ffs_balloc.c

131

osize, (int)fs->fs_bsize, cred, &bp);

sys/vfs/ufs/ffs_balloc.c

136

dofftofsb(fs, bp->b_bio2.bio_offset),

sys/vfs/ufs/ffs_balloc.c

137

ip->i_db[nb], fs->fs_bsize, osize, bp);

sys/vfs/ufs/ffs_balloc.c

139

ip->i_size = smalllblktosize(fs, nb + 1);

sys/vfs/ufs/ffs_balloc.c

140

ip->i_db[nb] = dofftofsb(fs, bp->b_bio2.bio_offset);

sys/vfs/ufs/ffs_balloc.c

154

if (nb != 0 && ip->i_size >= smalllblktosize(fs, lbn + 1)) {

sys/vfs/ufs/ffs_balloc.c

155

error = bread(vp, lblktodoff(fs, lbn), fs->fs_bsize, &bp);

sys/vfs/ufs/ffs_balloc.c

160

bp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ufs/ffs_balloc.c

168

osize = fragroundup(fs, blkoff(fs, ip->i_size));

sys/vfs/ufs/ffs_balloc.c

169

nsize = fragroundup(fs, size);

sys/vfs/ufs/ffs_balloc.c

171

error = bread(vp, lblktodoff(fs, lbn),

sys/vfs/ufs/ffs_balloc.c

177

bp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ufs/ffs_balloc.c

189

dofftofsb(fs, bp->b_bio2.bio_offset),

sys/vfs/ufs/ffs_balloc.c

193

if (ip->i_size < smalllblktosize(fs, lbn + 1))

sys/vfs/ufs/ffs_balloc.c

194

nsize = fragroundup(fs, size);

sys/vfs/ufs/ffs_balloc.c

196

nsize = fs->fs_bsize;

sys/vfs/ufs/ffs_balloc.c

202

bp = getblk(vp, lblktodoff(fs, lbn), nsize, 0, 0);

sys/vfs/ufs/ffs_balloc.c

203

bp->b_bio2.bio_offset = fsbtodoff(fs, newb);

sys/vfs/ufs/ffs_balloc.c

210

ip->i_db[lbn] = dofftofsb(fs, bp->b_bio2.bio_offset);

sys/vfs/ufs/ffs_balloc.c

233

dbp = getblk(vp, lblktodoff(fs, lbn), fs->fs_bsize, 0, 0);

sys/vfs/ufs/ffs_balloc.c

257

if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/vfs/ufs/ffs_balloc.c

263

bp = getblk(vp, lblktodoff(fs, indirs[1].in_lbn),

sys/vfs/ufs/ffs_balloc.c

264

fs->fs_bsize, 0, 0);

sys/vfs/ufs/ffs_balloc.c

265

bp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ufs/ffs_balloc.c

270

newb, 0, fs->fs_bsize, 0, bp);

sys/vfs/ufs/ffs_balloc.c

291

error = bread(vp, lblktodoff(fs, indirs[i].in_lbn), (int)fs->fs_bsize, &bp);

sys/vfs/ufs/ffs_balloc.c

308

ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred, &newb)) != 0) {

sys/vfs/ufs/ffs_balloc.c

315

nbp = getblk(vp, lblktodoff(fs, indirs[i].in_lbn),

sys/vfs/ufs/ffs_balloc.c

316

fs->fs_bsize, 0, 0);

sys/vfs/ufs/ffs_balloc.c

317

nbp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ufs/ffs_balloc.c

343

if (bp->b_bufsize == fs->fs_bsize)

sys/vfs/ufs/ffs_balloc.c

364

lbn, pref, (int)fs->fs_bsize, cred, &newb);

sys/vfs/ufs/ffs_balloc.c

372

dbp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ufs/ffs_balloc.c

386

if (bp->b_bufsize == fs->fs_bsize)

sys/vfs/ufs/ffs_balloc.c

419

lblktodoff(fs, lbn),

sys/vfs/ufs/ffs_balloc.c

420

(int)fs->fs_bsize,

sys/vfs/ufs/ffs_balloc.c

421

fs->fs_bsize,

sys/vfs/ufs/ffs_balloc.c

425

error = bread(vp, lblktodoff(fs, lbn),

sys/vfs/ufs/ffs_balloc.c

426

(int)fs->fs_bsize, &dbp);

sys/vfs/ufs/ffs_balloc.c

431

dbp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ufs/ffs_balloc.c

439

dbp->b_bio2.bio_offset = fsbtodoff(fs, nb);

sys/vfs/ufs/ffs_balloc.c

462

bp = getblk(vp, lblktodoff(fs, *lbns_remfree), fs->fs_bsize, 0, 0);

sys/vfs/ufs/ffs_balloc.c

465

deallocated += fs->fs_bsize;

sys/vfs/ufs/ffs_balloc.c

473

r = bread(vp, lblktodoff(fs, indirs[unwindidx].in_lbn), (int)fs->fs_bsize, &bp);

sys/vfs/ufs/ffs_balloc.c

483

if (bp->b_bufsize == fs->fs_bsize)

sys/vfs/ufs/ffs_balloc.c

506

ffs_blkfree(ip, *blkp, fs->fs_bsize);

sys/vfs/ufs/ffs_balloc.c

73

struct fs *fs;

sys/vfs/ufs/ffs_balloc.c

87

fs = ip->i_fs;

sys/vfs/ufs/ffs_balloc.c

88

lbn = lblkno(fs, ap->a_startoffset);

sys/vfs/ufs/ffs_balloc.c

89

size = blkoff(fs, ap->a_startoffset) + ap->a_size;

sys/vfs/ufs/ffs_balloc.c

90

if (size > fs->fs_bsize)

sys/vfs/ufs/ffs_extern.h

106

int softdep_mount(struct vnode *, struct mount *, struct fs *);

sys/vfs/ufs/ffs_extern.h

113

void softdep_setup_blkmapdep(struct buf *, struct fs *, ufs_daddr_t);

sys/vfs/ufs/ffs_extern.h

54

struct fs;

sys/vfs/ufs/ffs_extern.h

77

void ffs_clrblock(struct fs *, u_char *, ufs_daddr_t);

sys/vfs/ufs/ffs_extern.h

81

void ffs_fragacct(struct fs *, int, int32_t [], int);

sys/vfs/ufs/ffs_extern.h

83

int ffs_isblock(struct fs *, u_char *, ufs_daddr_t);

sys/vfs/ufs/ffs_extern.h

84

int ffs_isfreeblock(struct fs *, unsigned char *, ufs_daddr_t);

sys/vfs/ufs/ffs_extern.h

90

void ffs_setblock(struct fs *, u_char *, ufs_daddr_t);

sys/vfs/ufs/ffs_inode.c

100

if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */

sys/vfs/ufs/ffs_inode.c

105

fsbtodoff(fs, ino_to_fsba(fs, ip->i_number)),

sys/vfs/ufs/ffs_inode.c

106

(int)fs->fs_bsize, &bp);

sys/vfs/ufs/ffs_inode.c

116

ino_to_fsbo(fs, ip->i_number)) = ip->i_din;

sys/vfs/ufs/ffs_inode.c

122

if (bp->b_bufsize == fs->fs_bsize)

sys/vfs/ufs/ffs_inode.c

145

struct fs *fs;

sys/vfs/ufs/ffs_inode.c

154

fs = oip->i_fs;

sys/vfs/ufs/ffs_inode.c

157

if (length > fs->fs_maxfilesize)

sys/vfs/ufs/ffs_inode.c

174

if (fs->fs_ronly)

sys/vfs/ufs/ffs_inode.c

200

nvnode_pager_setsize(ovp, 0, fs->fs_bsize, 0);

sys/vfs/ufs/ffs_inode.c

218

blkoffsize(fs, oip, osize), /* oblksize */

sys/vfs/ufs/ffs_inode.c

219

blkoffresize(fs, length), /* nblksize */

sys/vfs/ufs/ffs_inode.c

220

blkoff(fs, osize),

sys/vfs/ufs/ffs_inode.c

221

blkoff(fs, length),

sys/vfs/ufs/ffs_inode.c

232

if (bp->b_bufsize == fs->fs_bsize)

sys/vfs/ufs/ffs_inode.c

249

allerror = nvtruncbuf(ovp, length, blkoffsize(fs, oip, length),

sys/vfs/ufs/ffs_inode.c

250

blkoff(fs, length), 0);

sys/vfs/ufs/ffs_inode.c

251

offset = blkoff(fs, length);

sys/vfs/ufs/ffs_inode.c

255

lbn = lblkno(fs, length);

sys/vfs/ufs/ffs_inode.c

280

fragroundup(fs, blkoff(fs, length)) < fs->fs_bsize) {

sys/vfs/ufs/ffs_inode.c

289

size = blksize(fs, oip, lbn);

sys/vfs/ufs/ffs_inode.c

298

if (bp->b_bufsize == fs->fs_bsize)

sys/vfs/ufs/ffs_inode.c

311

lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;

sys/vfs/ufs/ffs_inode.c

313

lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);

sys/vfs/ufs/ffs_inode.c

314

lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);

sys/vfs/ufs/ffs_inode.c

315

nblocks = btodb(fs->fs_bsize);

sys/vfs/ufs/ffs_inode.c

363

indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;

sys/vfs/ufs/ffs_inode.c

364

indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;

sys/vfs/ufs/ffs_inode.c

369

fsbtodb(fs, bn), lastiblock[level], level, &count);

sys/vfs/ufs/ffs_inode.c

375

ffs_blkfree(oip, bn, fs->fs_bsize);

sys/vfs/ufs/ffs_inode.c

393

bsize = blksize(fs, oip, i);

sys/vfs/ufs/ffs_inode.c

412

oldspace = blksize(fs, oip, lastblock);

sys/vfs/ufs/ffs_inode.c

414

newspace = blksize(fs, oip, lastblock);

sys/vfs/ufs/ffs_inode.c

423

bn += numfrags(fs, newspace);

sys/vfs/ufs/ffs_inode.c

469

struct fs *fs = ip->i_fs;

sys/vfs/ufs/ffs_inode.c

484

factor *= NINDIR(fs);

sys/vfs/ufs/ffs_inode.c

488

nblocks = btodb(fs->fs_bsize);

sys/vfs/ufs/ffs_inode.c

498

bp = getblk(vp, lblktodoff(fs, lbn), (int)fs->fs_bsize, 0, 0);

sys/vfs/ufs/ffs_inode.c

508

bp->b_bio2.bio_offset = dbtodoff(fs, dbn);

sys/vfs/ufs/ffs_inode.c

533

copy = kmalloc(fs->fs_bsize, M_TEMP, M_WAITOK);

sys/vfs/ufs/ffs_inode.c

534

bcopy((caddr_t)bap, (caddr_t)copy, (uint)fs->fs_bsize);

sys/vfs/ufs/ffs_inode.c

536

(uint)(NINDIR(fs) - (last + 1)) * sizeof (ufs_daddr_t));

sys/vfs/ufs/ffs_inode.c

550

for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;

sys/vfs/ufs/ffs_inode.c

556

if ((error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),

sys/vfs/ufs/ffs_inode.c

561

ffs_blkfree(ip, nb, fs->fs_bsize);

sys/vfs/ufs/ffs_inode.c

572

error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),

sys/vfs/ufs/ffs_inode.c

75

struct fs *fs;

sys/vfs/ufs/ffs_inode.c

85

fs = ip->i_fs;

sys/vfs/ufs/ffs_inode.c

86

if (fs->fs_ronly)

sys/vfs/ufs/ffs_softdep.c

1004

newblk_lookup(struct fs *fs, ufs_daddr_t newblkno, int flags,

sys/vfs/ufs/ffs_softdep.c

1010

newblkhd = NEWBLK_HASH(fs, newblkno);

sys/vfs/ufs/ffs_softdep.c

1012

*newblkpp = newblk_find(newblkhd, fs, newblkno);

sys/vfs/ufs/ffs_softdep.c

1023

if (newblk_find(newblkhd, fs, newblkno)) {

sys/vfs/ufs/ffs_softdep.c

1030

newblk->nb_fs = fs;

sys/vfs/ufs/ffs_softdep.c

1072

softdep_mount(struct vnode *devvp, struct mount *mp, struct fs *fs)

sys/vfs/ufs/ffs_softdep.c

1087

if (fs->fs_clean != 0)

sys/vfs/ufs/ffs_softdep.c

1090

for (cyl = 0; cyl < fs->fs_ncg; cyl++) {

sys/vfs/ufs/ffs_softdep.c

1091

if ((error = bread(devvp, fsbtodoff(fs, cgtod(fs, cyl)),

sys/vfs/ufs/ffs_softdep.c

1092

fs->fs_cgsize, &bp)) != 0) {

sys/vfs/ufs/ffs_softdep.c

1101

fs->fs_cs(fs, cyl) = cgp->cg_cs;

sys/vfs/ufs/ffs_softdep.c

1105

if (bcmp(&cstotal, &fs->fs_cstotal, sizeof cstotal))

sys/vfs/ufs/ffs_softdep.c

1108

bcopy(&cstotal, &fs->fs_cstotal, sizeof cstotal);

sys/vfs/ufs/ffs_softdep.c

1185

softdep_setup_blkmapdep(struct buf *bp, struct fs *fs,

sys/vfs/ufs/ffs_softdep.c

1196

if (newblk_lookup(fs, newblkno, DEPALLOC, &newblk) != 0)

sys/vfs/ufs/ffs_softdep.c

1433

struct fs *fs;

sys/vfs/ufs/ffs_softdep.c

1437

fs = ip->i_fs;

sys/vfs/ufs/ffs_softdep.c

1438

if (fragnum(fs, blkno) + numfrags(fs, size) > fs->fs_frag)

sys/vfs/ufs/ffs_softdep.c

1445

freefrag->ff_fs = fs;

sys/vfs/ufs/ffs_softdep.c

155

static int flush_inodedep_deps(struct fs *, ino_t);

sys/vfs/ufs/ffs_softdep.c

1724

struct fs *fs;

sys/vfs/ufs/ffs_softdep.c

1744

struct fs *fs;

sys/vfs/ufs/ffs_softdep.c

1748

fs = ip->i_fs;

sys/vfs/ufs/ffs_softdep.c

1758

freeblks->fb_fs = fs;

sys/vfs/ufs/ffs_softdep.c

1778

fsbtodoff(fs, ino_to_fsba(fs, ip->i_number)),

sys/vfs/ufs/ffs_softdep.c

1779

(int)fs->fs_bsize, &bp)) != 0)

sys/vfs/ufs/ffs_softdep.c

1781

*((struct ufs1_dinode *)bp->b_data + ino_to_fsbo(fs, ip->i_number)) =

sys/vfs/ufs/ffs_softdep.c

1787

(void) inodedep_lookup(fs, ip->i_number, DEPALLOC, &inodedep);

sys/vfs/ufs/ffs_softdep.c

1823

info.fs = fs;

sys/vfs/ufs/ffs_softdep.c

1832

if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) != 0)

sys/vfs/ufs/ffs_softdep.c

187

static int newblk_lookup(struct fs *, ufs_daddr_t, int,

sys/vfs/ufs/ffs_softdep.c

1873

(void) inodedep_lookup(info->fs, info->ip->i_number, 0, &inodedep);

sys/vfs/ufs/ffs_softdep.c

189

static int inodedep_lookup(struct fs *, ino_t, int, struct inodedep **);

sys/vfs/ufs/ffs_softdep.c

2141

struct fs *fs;

sys/vfs/ufs/ffs_softdep.c

2153

fs = freeblks->fb_fs;

sys/vfs/ufs/ffs_softdep.c

2157

tmpval *= NINDIR(fs);

sys/vfs/ufs/ffs_softdep.c

2160

nblocks = btodb(fs->fs_bsize);

sys/vfs/ufs/ffs_softdep.c

2168

if ((error = indir_trunc(&tip, fsbtodoff(fs, bn), level,

sys/vfs/ufs/ffs_softdep.c

2171

ffs_blkfree(&tip, bn, fs->fs_bsize);

sys/vfs/ufs/ffs_softdep.c

2180

bsize = blksize(fs, &tip, i);

sys/vfs/ufs/ffs_softdep.c

2207

struct fs *fs;

sys/vfs/ufs/ffs_softdep.c

2213

fs = ip->i_fs;

sys/vfs/ufs/ffs_softdep.c

2216

lbnadd *= NINDIR(fs);

sys/vfs/ufs/ffs_softdep.c

2248

error = bread(ip->i_devvp, doffset, (int)fs->fs_bsize, &bp);

sys/vfs/ufs/ffs_softdep.c

2256

nblocks = btodb(fs->fs_bsize);

sys/vfs/ufs/ffs_softdep.c

2257

for (i = NINDIR(fs) - 1; i >= 0; i--) {

sys/vfs/ufs/ffs_softdep.c

2261

if ((error = indir_trunc(ip, fsbtodoff(fs, nb),

sys/vfs/ufs/ffs_softdep.c

2265

ffs_blkfree(ip, nb, fs->fs_bsize);

sys/vfs/ufs/ffs_softdep.c

2335

struct fs *fs;

sys/vfs/ufs/ffs_softdep.c

2350

fs = dp->i_fs;

sys/vfs/ufs/ffs_softdep.c

2351

lbn = lblkno(fs, diroffset);

sys/vfs/ufs/ffs_softdep.c

2352

offset = blkoff(fs, diroffset);

sys/vfs/ufs/ffs_softdep.c

2409

(void) inodedep_lookup(fs, newinum, DEPALLOC, &inodedep);

sys/vfs/ufs/ffs_softdep.c

3162

struct fs *fs;

sys/vfs/ufs/ffs_softdep.c

3169

fs = inodedep->id_fs;

sys/vfs/ufs/ffs_softdep.c

3171

ino_to_fsbo(fs, inodedep->id_ino);

sys/vfs/ufs/ffs_softdep.c

3239

if (adp->ad_oldsize == 0 || adp->ad_oldsize == fs->fs_bsize)

sys/vfs/ufs/ffs_softdep.c

3241

dp->di_size = fs->fs_bsize * adp->ad_lbn + adp->ad_oldsize;

sys/vfs/ufs/ffs_softdep.c

3269

dp->di_size <= (lastadp->ad_lbn + 1) * fs->fs_bsize) {

sys/vfs/ufs/ffs_softdep.c

3273

dp->di_size = (i + 1) * fs->fs_bsize;

sys/vfs/ufs/ffs_softdep.c

4008

struct fs *fs;

sys/vfs/ufs/ffs_softdep.c

4021

fs = ip->i_fs;

sys/vfs/ufs/ffs_softdep.c

4023

if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) == 0) {

sys/vfs/ufs/ffs_softdep.c

4089

error = bread(pvp, lblktodoff(fs, lbn), blksize(fs, VTOI(pvp), lbn), &bp);

sys/vfs/ufs/ffs_softdep.c

4097

if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) == 0)

sys/vfs/ufs/ffs_softdep.c

4458

flush_inodedep_deps(struct fs *fs, ino_t ino)

sys/vfs/ufs/ffs_softdep.c

4481

if (inodedep_lookup(fs, ino, 0, &inodedep) == 0)

sys/vfs/ufs/ffs_softdep.c

4535

if (inodedep_lookup(fs, ino, 0, &inodedep) != 0)

sys/vfs/ufs/ffs_softdep.c

4821

struct fs *fs;

sys/vfs/ufs/ffs_softdep.c

4830

if ((mp->mnt_flag & MNT_SOFTDEP) && info->fs == VFSTOUFS(mp)->um_fs) {

sys/vfs/ufs/ffs_softdep.c

4845

struct fs *fs;

sys/vfs/ufs/ffs_softdep.c

4870

fs = inodedep->id_fs;

sys/vfs/ufs/ffs_softdep.c

4872

info.fs = fs;

sys/vfs/ufs/ffs_softdep.c

4878

firstino = rounddown2(inodedep->id_ino, INOPB(fs));

sys/vfs/ufs/ffs_softdep.c

4879

for (lastino = firstino + INOPB(fs) - 1; lastino > firstino; lastino--)

sys/vfs/ufs/ffs_softdep.c

4880

if (inodedep_lookup(fs, lastino, 0, &inodedep) != 0)

sys/vfs/ufs/ffs_softdep.c

4888

if (inodedep_lookup(fs, ino, 0, &inodedep) == 0)

sys/vfs/ufs/ffs_softdep.c

601

struct fs *matchfs;

sys/vfs/ufs/ffs_softdep.c

886

#define INODEDEP_HASH(fs, inum) \

sys/vfs/ufs/ffs_softdep.c

887

(&inodedep_hashtbl[((((register_t)(fs)) >> 13) + (inum)) & inodedep_hash])

sys/vfs/ufs/ffs_softdep.c

895

inodedep_find(struct inodedep_hashhead *inodedephd, struct fs *fs, ino_t inum)

sys/vfs/ufs/ffs_softdep.c

900

if (inum == inodedep->id_ino && fs == inodedep->id_fs)

sys/vfs/ufs/ffs_softdep.c

913

inodedep_lookup(struct fs *fs, ino_t inum, int flags,

sys/vfs/ufs/ffs_softdep.c

921

inodedephd = INODEDEP_HASH(fs, inum);

sys/vfs/ufs/ffs_softdep.c

923

*inodedeppp = inodedep_find(inodedephd, fs, inum);

sys/vfs/ufs/ffs_softdep.c

946

if (inodedep_find(inodedephd, fs, inum)) {

sys/vfs/ufs/ffs_softdep.c

953

inodedep->id_fs = fs;

sys/vfs/ufs/ffs_softdep.c

977

#define NEWBLK_HASH(fs, inum) \

sys/vfs/ufs/ffs_softdep.c

978

(&newblk_hashtbl[((((register_t)(fs)) >> 13) + (inum)) & newblk_hash])

sys/vfs/ufs/ffs_softdep.c

986

newblk_find(struct newblk_hashhead *newblkhd, struct fs *fs,

sys/vfs/ufs/ffs_softdep.c

992

if (newblkno == newblk->nb_newblkno && fs == newblk->nb_fs)

sys/vfs/ufs/ffs_softdep_stub.c

64

softdep_mount(struct vnode *devvp, struct mount *mp, struct fs *fs)

sys/vfs/ufs/ffs_softdep_stub.c

82

softdep_setup_blkmapdep(struct buf *bp, struct fs *fs, ufs_daddr_t newblkno)

sys/vfs/ufs/ffs_subr.c

107

fs = ip->i_fs;

sys/vfs/ufs/ffs_subr.c

108

lbn = lblkno(fs, uoffset);

sys/vfs/ufs/ffs_subr.c

109

base_loffset = lblktodoff(fs, lbn);

sys/vfs/ufs/ffs_subr.c

110

bsize = blksize(fs, ip, lbn);

sys/vfs/ufs/ffs_subr.c

113

next_loffset = lblktodoff(fs, nextlbn);

sys/vfs/ufs/ffs_subr.c

135

nextbsize = blksize(fs, ip, nextlbn);

sys/vfs/ufs/ffs_subr.c

163

ffs_fragacct(struct fs *fs, int fragmap, int32_t fraglist[], int cnt)

sys/vfs/ufs/ffs_subr.c

195

inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1;

sys/vfs/ufs/ffs_subr.c

197

for (siz = 1; siz < fs->fs_frag; siz++) {

sys/vfs/ufs/ffs_subr.c

198

if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0)

sys/vfs/ufs/ffs_subr.c

202

for (pos = siz; pos <= fs->fs_frag; pos++) {

sys/vfs/ufs/ffs_subr.c

221

ffs_isblock(struct fs *fs, unsigned char *cp, ufs_daddr_t h)

sys/vfs/ufs/ffs_subr.c

225

switch ((int)fs->fs_frag) {

sys/vfs/ufs/ffs_subr.c

246

ffs_isfreeblock(struct fs *fs, unsigned char *cp, ufs_daddr_t h)

sys/vfs/ufs/ffs_subr.c

248

switch ((int)fs->fs_frag) {

sys/vfs/ufs/ffs_subr.c

266

ffs_clrblock(struct fs *fs, u_char *cp, ufs_daddr_t h)

sys/vfs/ufs/ffs_subr.c

268

switch ((int)fs->fs_frag) {

sys/vfs/ufs/ffs_subr.c

290

ffs_setblock(struct fs *fs, unsigned char *cp, ufs_daddr_t h)

sys/vfs/ufs/ffs_subr.c

292

switch ((int)fs->fs_frag) {

sys/vfs/ufs/ffs_subr.c

63

struct fs *fs;

sys/vfs/ufs/ffs_subr.c

69

fs = ip->i_fs;

sys/vfs/ufs/ffs_subr.c

70

lbn = lblkno(fs, uoffset);

sys/vfs/ufs/ffs_subr.c

71

bsize = blksize(fs, ip, lbn);

sys/vfs/ufs/ffs_subr.c

74

error = bread(vp, lblktodoff(fs, lbn), bsize, &bp);

sys/vfs/ufs/ffs_subr.c

80

*res = (char *)bp->b_data + blkoff(fs, uoffset);

sys/vfs/ufs/ffs_subr.c

97

struct fs *fs;

sys/vfs/ufs/ffs_vfsops.c

1069

struct fs *fs;

sys/vfs/ufs/ffs_vfsops.c

1106

ip->i_fs = fs = ump->um_fs;

sys/vfs/ufs/ffs_vfsops.c

1132

error = bread(ump->um_devvp, fsbtodoff(fs, ino_to_fsba(fs, ino)),

sys/vfs/ufs/ffs_vfsops.c

1133

(int)fs->fs_bsize, &bp);

sys/vfs/ufs/ffs_vfsops.c

1147

ip->i_din = *((struct ufs1_dinode *)bp->b_data + ino_to_fsbo(fs, ino));

sys/vfs/ufs/ffs_vfsops.c

1183

if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */

sys/vfs/ufs/ffs_vfsops.c

1213

struct fs *fs;

sys/vfs/ufs/ffs_vfsops.c

1216

fs = VFSTOUFS(mp)->um_fs;

sys/vfs/ufs/ffs_vfsops.c

1218

ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)

sys/vfs/ufs/ffs_vfsops.c

1258

struct fs *dfs, *fs = mp->um_fs;

sys/vfs/ufs/ffs_vfsops.c

1270

blks = howmany(fs->fs_cssize, fs->fs_fsize);

sys/vfs/ufs/ffs_vfsops.c

1271

space = fs->fs_csp;

sys/vfs/ufs/ffs_vfsops.c

1272

for (i = 0; i < blks; i += fs->fs_frag) {

sys/vfs/ufs/ffs_vfsops.c

1273

size = fs->fs_bsize;

sys/vfs/ufs/ffs_vfsops.c

1274

if (i + fs->fs_frag > blks)

sys/vfs/ufs/ffs_vfsops.c

1275

size = (blks - i) * fs->fs_fsize;

sys/vfs/ufs/ffs_vfsops.c

1276

bp = getblk(mp->um_devvp, fsbtodoff(fs, fs->fs_csaddr + i),

sys/vfs/ufs/ffs_vfsops.c

1292

bp = getblk(mp->um_devvp, SBOFF, (int)fs->fs_sbsize, 0, 0);

sys/vfs/ufs/ffs_vfsops.c

1293

fs->fs_fmod = 0;

sys/vfs/ufs/ffs_vfsops.c

1294

fs->fs_time = time_second;

sys/vfs/ufs/ffs_vfsops.c

1295

bcopy((caddr_t)fs, bp->b_data, (uint)fs->fs_sbsize);

sys/vfs/ufs/ffs_vfsops.c

1297

dfs = (struct fs *)bp->b_data; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

1298

if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */

sys/vfs/ufs/ffs_vfsops.c

1300

if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */

sys/vfs/ufs/ffs_vfsops.c

138

struct fs *fs;

sys/vfs/ufs/ffs_vfsops.c

189

fs = ump->um_fs;

sys/vfs/ufs/ffs_vfsops.c

192

ronly = fs->fs_ronly; /* MNT_RELOAD might change this */

sys/vfs/ufs/ffs_vfsops.c

233

fs->fs_flags &= ~FS_UNCLEAN;

sys/vfs/ufs/ffs_vfsops.c

234

if (fs->fs_clean == 0) {

sys/vfs/ufs/ffs_vfsops.c

235

fs->fs_flags |= FS_UNCLEAN;

sys/vfs/ufs/ffs_vfsops.c

239

fs->fs_fsmnt);

sys/vfs/ufs/ffs_vfsops.c

243

fs->fs_fsmnt);

sys/vfs/ufs/ffs_vfsops.c

250

if (fs->fs_flags & FS_DOSOFTDEP) {

sys/vfs/ufs/ffs_vfsops.c

251

error = softdep_mount(devvp, mp, fs);

sys/vfs/ufs/ffs_vfsops.c

397

fs = ump->um_fs;

sys/vfs/ufs/ffs_vfsops.c

398

if (ronly != fs->fs_ronly) {

sys/vfs/ufs/ffs_vfsops.c

399

fs->fs_ronly = ronly;

sys/vfs/ufs/ffs_vfsops.c

400

fs->fs_clean = ronly &&

sys/vfs/ufs/ffs_vfsops.c

401

(fs->fs_flags & FS_UNCLEAN) == 0 ? 1 : 0;

sys/vfs/ufs/ffs_vfsops.c

440

struct fs *fs;

sys/vfs/ufs/ffs_vfsops.c

452

struct fs *fs, *newfs;

sys/vfs/ufs/ffs_vfsops.c

483

newfs = (struct fs *)bp->b_data;

sys/vfs/ufs/ffs_vfsops.c

485

newfs->fs_bsize < sizeof(struct fs)) {

sys/vfs/ufs/ffs_vfsops.c

489

fs = VFSTOUFS(mp)->um_fs;

sys/vfs/ufs/ffs_vfsops.c

495

newfs->fs_csp = fs->fs_csp;

sys/vfs/ufs/ffs_vfsops.c

496

newfs->fs_maxcluster = fs->fs_maxcluster;

sys/vfs/ufs/ffs_vfsops.c

497

newfs->fs_contigdirs = fs->fs_contigdirs;

sys/vfs/ufs/ffs_vfsops.c

500

bcopy(newfs, fs, (uint)fs->fs_sbsize);

sys/vfs/ufs/ffs_vfsops.c

501

if (fs->fs_sbsize < SBSIZE)

sys/vfs/ufs/ffs_vfsops.c

504

mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;

sys/vfs/ufs/ffs_vfsops.c

505

ffs_oldfscompat(fs);

sys/vfs/ufs/ffs_vfsops.c

507

if (fs->fs_avgfilesize <= 0) /* XXX */

sys/vfs/ufs/ffs_vfsops.c

508

fs->fs_avgfilesize = AVFILESIZ; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

509

if (fs->fs_avgfpdir <= 0) /* XXX */

sys/vfs/ufs/ffs_vfsops.c

510

fs->fs_avgfpdir = AFPDIR; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

515

blks = howmany(fs->fs_cssize, fs->fs_fsize);

sys/vfs/ufs/ffs_vfsops.c

516

space = fs->fs_csp;

sys/vfs/ufs/ffs_vfsops.c

517

for (i = 0; i < blks; i += fs->fs_frag) {

sys/vfs/ufs/ffs_vfsops.c

518

size = fs->fs_bsize;

sys/vfs/ufs/ffs_vfsops.c

519

if (i + fs->fs_frag > blks)

sys/vfs/ufs/ffs_vfsops.c

520

size = (blks - i) * fs->fs_fsize;

sys/vfs/ufs/ffs_vfsops.c

521

error = bread(devvp, fsbtodoff(fs, fs->fs_csaddr + i), size, &bp);

sys/vfs/ufs/ffs_vfsops.c

533

if (fs->fs_contigsumsize > 0) {

sys/vfs/ufs/ffs_vfsops.c

534

lp = fs->fs_maxcluster;

sys/vfs/ufs/ffs_vfsops.c

535

for (i = 0; i < fs->fs_ncg; i++)

sys/vfs/ufs/ffs_vfsops.c

536

*lp++ = fs->fs_contigsumsize;

sys/vfs/ufs/ffs_vfsops.c

540

scaninfo.fs = fs;

sys/vfs/ufs/ffs_vfsops.c

571

fsbtodoff(info->fs, ino_to_fsba(info->fs, ip->i_number)),

sys/vfs/ufs/ffs_vfsops.c

572

(int)info->fs->fs_bsize, &bp);

sys/vfs/ufs/ffs_vfsops.c

578

ino_to_fsbo(info->fs, ip->i_number));

sys/vfs/ufs/ffs_vfsops.c

593

struct fs *fs;

sys/vfs/ufs/ffs_vfsops.c

641

fs = (struct fs *)bp->b_data;

sys/vfs/ufs/ffs_vfsops.c

642

if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||

sys/vfs/ufs/ffs_vfsops.c

643

fs->fs_bsize < sizeof(struct fs)) {

sys/vfs/ufs/ffs_vfsops.c

647

fs->fs_fmod = 0;

sys/vfs/ufs/ffs_vfsops.c

648

fs->fs_flags &= ~FS_UNCLEAN;

sys/vfs/ufs/ffs_vfsops.c

649

if (fs->fs_clean == 0) {

sys/vfs/ufs/ffs_vfsops.c

650

fs->fs_flags |= FS_UNCLEAN;

sys/vfs/ufs/ffs_vfsops.c

654

fs->fs_fsmnt);

sys/vfs/ufs/ffs_vfsops.c

658

fs->fs_fsmnt);

sys/vfs/ufs/ffs_vfsops.c

664

if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) {

sys/vfs/ufs/ffs_vfsops.c

67

static int ffs_oldfscompat (struct fs *);

sys/vfs/ufs/ffs_vfsops.c

671

ump->um_fs = kmalloc((u_long)fs->fs_sbsize, M_UFSMNT,

sys/vfs/ufs/ffs_vfsops.c

673

bcopy(bp->b_data, ump->um_fs, (uint)fs->fs_sbsize);

sys/vfs/ufs/ffs_vfsops.c

674

if (fs->fs_sbsize < SBSIZE)

sys/vfs/ufs/ffs_vfsops.c

678

fs = ump->um_fs;

sys/vfs/ufs/ffs_vfsops.c

679

fs->fs_ronly = ronly;

sys/vfs/ufs/ffs_vfsops.c

680

size = fs->fs_cssize;

sys/vfs/ufs/ffs_vfsops.c

681

blks = howmany(size, fs->fs_fsize);

sys/vfs/ufs/ffs_vfsops.c

682

if (fs->fs_contigsumsize > 0)

sys/vfs/ufs/ffs_vfsops.c

683

size += fs->fs_ncg * sizeof(int32_t);

sys/vfs/ufs/ffs_vfsops.c

684

size += fs->fs_ncg * sizeof(uint8_t);

sys/vfs/ufs/ffs_vfsops.c

686

fs->fs_csp = space;

sys/vfs/ufs/ffs_vfsops.c

687

for (i = 0; i < blks; i += fs->fs_frag) {

sys/vfs/ufs/ffs_vfsops.c

688

size = fs->fs_bsize;

sys/vfs/ufs/ffs_vfsops.c

689

if (i + fs->fs_frag > blks)

sys/vfs/ufs/ffs_vfsops.c

690

size = (blks - i) * fs->fs_fsize;

sys/vfs/ufs/ffs_vfsops.c

691

if ((error = bread(devvp, fsbtodoff(fs, fs->fs_csaddr + i),

sys/vfs/ufs/ffs_vfsops.c

693

kfree(fs->fs_csp, M_UFSMNT);

sys/vfs/ufs/ffs_vfsops.c

701

if (fs->fs_contigsumsize > 0) {

sys/vfs/ufs/ffs_vfsops.c

702

fs->fs_maxcluster = lp = space;

sys/vfs/ufs/ffs_vfsops.c

703

for (i = 0; i < fs->fs_ncg; i++)

sys/vfs/ufs/ffs_vfsops.c

704

*lp++ = fs->fs_contigsumsize;

sys/vfs/ufs/ffs_vfsops.c

707

size = fs->fs_ncg * sizeof(uint8_t);

sys/vfs/ufs/ffs_vfsops.c

708

fs->fs_contigdirs = (uint8_t *)space;

sys/vfs/ufs/ffs_vfsops.c

709

bzero(fs->fs_contigdirs, size);

sys/vfs/ufs/ffs_vfsops.c

711

if (fs->fs_avgfilesize <= 0) /* XXX */

sys/vfs/ufs/ffs_vfsops.c

712

fs->fs_avgfilesize = AVFILESIZ; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

713

if (fs->fs_avgfpdir <= 0) /* XXX */

sys/vfs/ufs/ffs_vfsops.c

714

fs->fs_avgfpdir = AFPDIR; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

716

mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0];

sys/vfs/ufs/ffs_vfsops.c

717

mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];

sys/vfs/ufs/ffs_vfsops.c

718

if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0) {

sys/vfs/ufs/ffs_vfsops.c

724

mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;

sys/vfs/ufs/ffs_vfsops.c

729

ump->um_nindir = fs->fs_nindir;

sys/vfs/ufs/ffs_vfsops.c

730

ump->um_bptrtodb = fs->fs_fsbtodb;

sys/vfs/ufs/ffs_vfsops.c

731

ump->um_seqinc = fs->fs_frag;

sys/vfs/ufs/ffs_vfsops.c

735

ffs_oldfscompat(fs);

sys/vfs/ufs/ffs_vfsops.c

738

bzero(fs->fs_fsmnt, sizeof(fs->fs_fsmnt));

sys/vfs/ufs/ffs_vfsops.c

739

ksnprintf(fs->fs_fsmnt, sizeof(fs->fs_fsmnt),

sys/vfs/ufs/ffs_vfsops.c

748

mp->mnt_time = fs->fs_time;

sys/vfs/ufs/ffs_vfsops.c

752

ump->um_savedmaxfilesize = fs->fs_maxfilesize; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

753

maxfilesize = (uint64_t)0x40000000 * fs->fs_bsize - 1; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

757

if (fs->fs_maxfilesize > maxfilesize) /* XXX */

sys/vfs/ufs/ffs_vfsops.c

758

fs->fs_maxfilesize = maxfilesize; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

760

if ((fs->fs_flags & FS_DOSOFTDEP) &&

sys/vfs/ufs/ffs_vfsops.c

761

(error = softdep_mount(devvp, mp, fs)) != 0) {

sys/vfs/ufs/ffs_vfsops.c

762

kfree(fs->fs_csp, M_UFSMNT);

sys/vfs/ufs/ffs_vfsops.c

765

fs->fs_fmod = 1;

sys/vfs/ufs/ffs_vfsops.c

766

fs->fs_clean = 0;

sys/vfs/ufs/ffs_vfsops.c

796

ffs_oldfscompat(struct fs *fs)

sys/vfs/ufs/ffs_vfsops.c

798

fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect); /* XXX */

sys/vfs/ufs/ffs_vfsops.c

799

fs->fs_interleave = max(fs->fs_interleave, 1); /* XXX */

sys/vfs/ufs/ffs_vfsops.c

800

if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */

sys/vfs/ufs/ffs_vfsops.c

801

fs->fs_nrpos = 8; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

802

if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */

sys/vfs/ufs/ffs_vfsops.c

805

uint64_t sizepb = fs->fs_bsize; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

807

fs->fs_maxfilesize = fs->fs_bsize * UFS_NDADDR - 1; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

809

sizepb *= NINDIR(fs); /* XXX */

sys/vfs/ufs/ffs_vfsops.c

810

fs->fs_maxfilesize += sizepb; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

813

fs->fs_maxfilesize = (u_quad_t) 1LL << 39;

sys/vfs/ufs/ffs_vfsops.c

814

fs->fs_qbmask = ~fs->fs_bmask; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

815

fs->fs_qfmask = ~fs->fs_fmask; /* XXX */

sys/vfs/ufs/ffs_vfsops.c

827

struct fs *fs;

sys/vfs/ufs/ffs_vfsops.c

842

fs = ump->um_fs;

sys/vfs/ufs/ffs_vfsops.c

843

if (fs->fs_ronly == 0) {

sys/vfs/ufs/ffs_vfsops.c

844

fs->fs_clean = fs->fs_flags & FS_UNCLEAN ? 0 : 1;

sys/vfs/ufs/ffs_vfsops.c

847

fs->fs_clean = 0;

sys/vfs/ufs/ffs_vfsops.c

856

fs->fs_ronly ? FREAD : FREAD|FWRITE,

sys/vfs/ufs/ffs_vfsops.c

863

kfree(fs->fs_csp, M_UFSMNT);

sys/vfs/ufs/ffs_vfsops.c

864

kfree(fs, M_UFSMNT);

sys/vfs/ufs/ffs_vfsops.c

920

struct fs *fs;

sys/vfs/ufs/ffs_vfsops.c

923

fs = ump->um_fs;

sys/vfs/ufs/ffs_vfsops.c

924

if (fs->fs_magic != FS_MAGIC)

sys/vfs/ufs/ffs_vfsops.c

926

sbp->f_bsize = fs->fs_fsize;

sys/vfs/ufs/ffs_vfsops.c

927

sbp->f_iosize = fs->fs_bsize;

sys/vfs/ufs/ffs_vfsops.c

928

sbp->f_blocks = fs->fs_dsize;

sys/vfs/ufs/ffs_vfsops.c

929

sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +

sys/vfs/ufs/ffs_vfsops.c

930

fs->fs_cstotal.cs_nffree;

sys/vfs/ufs/ffs_vfsops.c

931

sbp->f_bavail = freespace(fs, fs->fs_minfree);

sys/vfs/ufs/ffs_vfsops.c

932

sbp->f_files = fs->fs_ncg * fs->fs_ipg - UFS_ROOTINO;

sys/vfs/ufs/ffs_vfsops.c

933

sbp->f_ffree = fs->fs_cstotal.cs_nifree;

sys/vfs/ufs/ffs_vfsops.c

958

struct fs *fs;

sys/vfs/ufs/ffs_vfsops.c

962

fs = ump->um_fs;

sys/vfs/ufs/ffs_vfsops.c

963

if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */

sys/vfs/ufs/ffs_vfsops.c

964

kprintf("fs = %s\n", fs->fs_fsmnt);

sys/vfs/ufs/ffs_vfsops.c

997

if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0)

sys/vfs/ufs/fs.h

317

#define fs_postbl(fs, cylno) \

sys/vfs/ufs/fs.h

318

(((fs)->fs_postblformat == FS_42POSTBLFMT) \

sys/vfs/ufs/fs.h

319

? ((fs)->fs_opostbl[cylno]) \

sys/vfs/ufs/fs.h

320

: ((int16_t *)((uint8_t *)(fs) + \

sys/vfs/ufs/fs.h

321

(fs)->fs_postbloff) + (cylno) * (fs)->fs_nrpos))

sys/vfs/ufs/fs.h

322

#define fs_rotbl(fs) \

sys/vfs/ufs/fs.h

323

(((fs)->fs_postblformat == FS_42POSTBLFMT) \

sys/vfs/ufs/fs.h

324

? ((fs)->fs_space) \

sys/vfs/ufs/fs.h

325

: ((uint8_t *)((uint8_t *)(fs) + (fs)->fs_rotbloff)))

sys/vfs/ufs/fs.h

333

#define CGSIZE(fs) \

sys/vfs/ufs/fs.h

335

/* blktot size */ (fs)->fs_cpg * sizeof(int32_t) + \

sys/vfs/ufs/fs.h

336

/* blks size */ (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(int16_t) + \

sys/vfs/ufs/fs.h

337

/* inode map */ howmany((fs)->fs_ipg, NBBY) + \

sys/vfs/ufs/fs.h

338

/* block map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPF(fs), NBBY) +\

sys/vfs/ufs/fs.h

339

/* if present */ ((fs)->fs_contigsumsize <= 0 ? 0 : \

sys/vfs/ufs/fs.h

340

/* cluster sum */ (fs)->fs_contigsumsize * sizeof(int32_t) + \

sys/vfs/ufs/fs.h

341

/* cluster map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPB(fs), NBBY)))

sys/vfs/ufs/fs.h

346

#define fs_cs(fs, indx) fs_csp[indx]

sys/vfs/ufs/fs.h

385

#define cg_blks(fs, cgp, cylno) \

sys/vfs/ufs/fs.h

389

(cgp)->cg_boff) + (cylno) * (fs)->fs_nrpos))

sys/vfs/ufs/fs.h

434

#define fsbtodb(fs, b) ((b) << (fs)->fs_fsbtodb)

sys/vfs/ufs/fs.h

435

#define dbtofsb(fs, b) ((b) >> (fs)->fs_fsbtodb)

sys/vfs/ufs/fs.h

436

#define btofsb(fs, b) ((daddr_t)((b) >> ((fs)->fs_fsbtodb + DEV_BSHIFT)))

sys/vfs/ufs/fs.h

442

#define cgbase(fs, c) ((ufs_daddr_t)((fs)->fs_fpg * (c)))

sys/vfs/ufs/fs.h

443

#define cgdmin(fs, c) (cgstart(fs, c) + (fs)->fs_dblkno) /* 1st data */

sys/vfs/ufs/fs.h

444

#define cgimin(fs, c) (cgstart(fs, c) + (fs)->fs_iblkno) /* inode blk */

sys/vfs/ufs/fs.h

445

#define cgsblock(fs, c) (cgstart(fs, c) + (fs)->fs_sblkno) /* super blk */

sys/vfs/ufs/fs.h

446

#define cgtod(fs, c) (cgstart(fs, c) + (fs)->fs_cblkno) /* cg block */

sys/vfs/ufs/fs.h

447

#define cgstart(fs, c) \

sys/vfs/ufs/fs.h

448

(cgbase(fs, c) + (fs)->fs_cgoffset * ((c) & ~((fs)->fs_cgmask)))

sys/vfs/ufs/fs.h

456

#define ino_to_cg(fs, x) ((x) / (fs)->fs_ipg)

sys/vfs/ufs/fs.h

457

#define ino_to_fsba(fs, x) \

sys/vfs/ufs/fs.h

458

((ufs_daddr_t)(cgimin(fs, ino_to_cg(fs, x)) + \

sys/vfs/ufs/fs.h

459

(blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))

sys/vfs/ufs/fs.h

460

#define ino_to_fsbo(fs, x) ((x) % INOPB(fs))

sys/vfs/ufs/fs.h

466

#define dtog(fs, d) ((d) / (fs)->fs_fpg)

sys/vfs/ufs/fs.h

467

#define dtogd(fs, d) ((d) % (fs)->fs_fpg)

sys/vfs/ufs/fs.h

473

#define blkmap(fs, map, loc) \

sys/vfs/ufs/fs.h

474

(((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))

sys/vfs/ufs/fs.h

475

#define cbtocylno(fs, bno) \

sys/vfs/ufs/fs.h

476

((bno) * NSPF(fs) / (fs)->fs_spc)

sys/vfs/ufs/fs.h

477

#define cbtorpos(fs, bno) \

sys/vfs/ufs/fs.h

478

(((bno) * NSPF(fs) % (fs)->fs_spc / (fs)->fs_nsect * (fs)->fs_trackskew + \

sys/vfs/ufs/fs.h

479

(bno) * NSPF(fs) % (fs)->fs_spc % (fs)->fs_nsect * (fs)->fs_interleave) % \

sys/vfs/ufs/fs.h

480

(fs)->fs_nsect * (fs)->fs_nrpos / (fs)->fs_npsect)

sys/vfs/ufs/fs.h

487

#define blkoff(fs, loc) /* calculates (loc % fs->fs_bsize) */ \

sys/vfs/ufs/fs.h

488

((loc) & (fs)->fs_qbmask)

sys/vfs/ufs/fs.h

489

#define fragoff(fs, loc) /* calculates (loc % fs->fs_fsize) */ \

sys/vfs/ufs/fs.h

490

((loc) & (fs)->fs_qfmask)

sys/vfs/ufs/fs.h

491

#define lblktosize(fs, blk) /* calculates ((off_t)blk * fs->fs_bsize) */ \

sys/vfs/ufs/fs.h

492

((off_t)(blk) << (fs)->fs_bshift)

sys/vfs/ufs/fs.h

502

#define lblktodoff(fs, blk) ((off_t)(blk) << (fs)->fs_bshift)

sys/vfs/ufs/fs.h

503

#define fsbtodoff(fs, b) ((off_t)(b) << (fs)->fs_fshift)

sys/vfs/ufs/fs.h

504

#define dbtodoff(fs, b) ((off_t)(b) * ((fs)->fs_fsize / (fs)->fs_nspf))

sys/vfs/ufs/fs.h

505

#define dofftofsb(fs, b) ((ufs_daddr_t)((b) >> (fs)->fs_fshift))

sys/vfs/ufs/fs.h

508

#define smalllblktosize(fs, blk) /* calculates (blk * fs->fs_bsize) */ \

sys/vfs/ufs/fs.h

509

((blk) << (fs)->fs_bshift)

sys/vfs/ufs/fs.h

510

#define lblkno(fs, loc) /* calculates (loc / fs->fs_bsize) */ \

sys/vfs/ufs/fs.h

511

((loc) >> (fs)->fs_bshift)

sys/vfs/ufs/fs.h

512

#define numfrags(fs, loc) /* calculates (loc / fs->fs_fsize) */ \

sys/vfs/ufs/fs.h

513

((loc) >> (fs)->fs_fshift)

sys/vfs/ufs/fs.h

514

#define blkroundup(fs, size) /* calculates roundup(size, fs->fs_bsize) */ \

sys/vfs/ufs/fs.h

515

(((size) + (fs)->fs_qbmask) & (fs)->fs_bmask)

sys/vfs/ufs/fs.h

516

#define fragroundup(fs, size) /* calculates roundup(size, fs->fs_fsize) */ \

sys/vfs/ufs/fs.h

517

(((size) + (fs)->fs_qfmask) & (fs)->fs_fmask)

sys/vfs/ufs/fs.h

518

#define fragstoblks(fs, frags) /* calculates (frags / fs->fs_frag) */ \

sys/vfs/ufs/fs.h

519

((frags) >> (fs)->fs_fragshift)

sys/vfs/ufs/fs.h

520

#define blkstofrags(fs, blks) /* calculates (blks * fs->fs_frag) */ \

sys/vfs/ufs/fs.h

521

((blks) << (fs)->fs_fragshift)

sys/vfs/ufs/fs.h

522

#define fragnum(fs, fsb) /* calculates (fsb % fs->fs_frag) */ \

sys/vfs/ufs/fs.h

523

((fsb) & ((fs)->fs_frag - 1))

sys/vfs/ufs/fs.h

524

#define blknum(fs, fsb) /* calculates rounddown(fsb, fs->fs_frag) */ \

sys/vfs/ufs/fs.h

525

((fsb) &~ ((fs)->fs_frag - 1))

sys/vfs/ufs/fs.h

531

#define freespace(fs, percentreserved) \

sys/vfs/ufs/fs.h

532

(blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \

sys/vfs/ufs/fs.h

533

(fs)->fs_cstotal.cs_nffree - \

sys/vfs/ufs/fs.h

534

((off_t)((fs)->fs_dsize) * (percentreserved) / 100))

sys/vfs/ufs/fs.h

539

#define blksize(fs, ip, lbn) \

sys/vfs/ufs/fs.h

541

(ip)->i_size >= smalllblktosize(fs, (lbn) + 1)) \

sys/vfs/ufs/fs.h

542

? (fs)->fs_bsize \

sys/vfs/ufs/fs.h

543

: (fragroundup(fs, blkoff(fs, (ip)->i_size))))

sys/vfs/ufs/fs.h

544

#define dblksize(fs, dip, lbn) \

sys/vfs/ufs/fs.h

546

(dip)->di_size >= smalllblktosize(fs, (lbn) + 1)) \

sys/vfs/ufs/fs.h

547

? (fs)->fs_bsize \

sys/vfs/ufs/fs.h

548

: (fragroundup(fs, blkoff(fs, (dip)->di_size))))

sys/vfs/ufs/fs.h

549

#define sblksize(fs, size, lbn) \

sys/vfs/ufs/fs.h

550

(((lbn) >= UFS_NDADDR || (size) >= ((lbn) + 1) << (fs)->fs_bshift) \

sys/vfs/ufs/fs.h

551

? (fs)->fs_bsize \

sys/vfs/ufs/fs.h

552

: (fragroundup(fs, blkoff(fs, (size)))))

sys/vfs/ufs/fs.h

558

#define blkoffsize(fs, ip, loc) blksize(fs, ip, lblkno(fs, loc))

sys/vfs/ufs/fs.h

559

#define blkoffresize(fs, loc) sblksize(fs, loc, lblkno(fs, loc))

sys/vfs/ufs/fs.h

565

#define NSPB(fs) ((fs)->fs_nspf << (fs)->fs_fragshift)

sys/vfs/ufs/fs.h

566

#define NSPF(fs) ((fs)->fs_nspf)

sys/vfs/ufs/fs.h

571

#define INOPB(fs) ((fs)->fs_inopb)

sys/vfs/ufs/fs.h

572

#define INOPF(fs) ((fs)->fs_inopb >> (fs)->fs_fragshift)

sys/vfs/ufs/fs.h

577

#define NINDIR(fs) ((fs)->fs_nindir)

sys/vfs/ufs/inode.h

86

struct fs *i_fs; /* Associated filesystem */

sys/vfs/ufs/softdep.h

237

struct fs *id_fs; /* associated filesystem */

sys/vfs/ufs/softdep.h

261

struct fs *nb_fs; /* associated filesystem */

sys/vfs/ufs/softdep.h

385

struct fs *ff_fs; /* addr of superblock */

sys/vfs/ufs/softdep.h

402

struct fs *fb_fs; /* addr of superblock */

sys/vfs/ufs/softdep.h

422

struct fs *fx_fs; /* addr of superblock */

sys/vfs/ufs/ufs_bmap.c

119

struct fs *fs;

sys/vfs/ufs/ufs_bmap.c

128

fs = ip->i_fs;

sys/vfs/ufs/ufs_bmap.c

184

!findblk(vp, dbtodoff(fs, metalbn), FINDBLK_TEST)) ||

sys/vfs/ufs/ufs_bmap.c

195

bp = getblk(vp, lblktodoff(fs, metalbn),

sys/vfs/ufs/ufs_bmap.c

209

bp->b_bio2.bio_offset = fsbtodoff(fs, daddr);

sys/vfs/ufs/ufs_bmap.c

67

struct fs *fs;

sys/vfs/ufs/ufs_bmap.c

79

fs = VTOI(ap->a_vp)->i_fs;

sys/vfs/ufs/ufs_bmap.c

80

KKASSERT(((int)ap->a_loffset & ((1 << fs->fs_bshift) - 1)) == 0);

sys/vfs/ufs/ufs_bmap.c

81

lbn = ap->a_loffset >> fs->fs_bshift;

sys/vfs/ufs/ufs_bmap.c

89

*ap->a_doffsetp = dbtodoff(fs, dbn);

sys/vfs/ufs/ufs_bmap.c

91

*ap->a_runp = (*ap->a_runp + 1) << fs->fs_bshift;

sys/vfs/ufs/ufs_bmap.c

93

*ap->a_runb = *ap->a_runb << fs->fs_bshift;

sys/vfs/ufs/ufs_readwrite.c

141

blkoffset = blkoff(fs, uio->uio_offset);

sys/vfs/ufs/ufs_readwrite.c

214

FS *fs;

sys/vfs/ufs/ufs_readwrite.c

254

fs = ip->I_FS;

sys/vfs/ufs/ufs_readwrite.c

256

(uint64_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize) {

sys/vfs/ufs/ufs_readwrite.c

291

lbn = lblkno(fs, uio->uio_offset);

sys/vfs/ufs/ufs_readwrite.c

292

blkoffset = blkoff(fs, uio->uio_offset);

sys/vfs/ufs/ufs_readwrite.c

293

xfersize = fs->fs_bsize - blkoffset;

sys/vfs/ufs/ufs_readwrite.c

300

blkoffresize(fs, nsize), blkoff(fs, nsize));

sys/vfs/ufs/ufs_readwrite.c

324

if (xfersize < fs->fs_bsize || uio->uio_segflg == UIO_NOCOPY)

sys/vfs/ufs/ufs_readwrite.c

34

#define FS struct fs

sys/vfs/ufs/ufs_readwrite.c

352

size = BLKSIZE(fs, ip, lbn) - bp->b_resid;

sys/vfs/ufs/ufs_readwrite.c

377

} else if (xfersize + blkoffset == fs->fs_bsize) {

sys/vfs/ufs/ufs_readwrite.c

380

cluster_write(bp, (off_t)ip->i_size, fs->fs_bsize, seqcount);

sys/vfs/ufs/ufs_readwrite.c

64

FS *fs;

sys/vfs/ufs/ufs_readwrite.c

87

fs = ip->I_FS;

sys/vfs/ufs/ufs_readwrite.c

88

if ((uint64_t)uio->uio_offset > fs->fs_maxfilesize)

sys/vfs/ufs/ufsmount.h

74

struct fs *um_fs; /* FFS */

sys/vm/vm_fault.c

1008

if (fs->prot & VM_PROT_WRITE) {

sys/vm/vm_fault.c

1018

vm_set_nosync(m, fs->entry);

sys/vm/vm_fault.c

1031

fs->msoftonly = 1;

sys/vm/vm_fault.c

1032

fs->mary[0] = m;

sys/vm/vm_fault.c

1052

if (fs->prot & VM_PROT_WRITE) {

sys/vm/vm_fault.c

1062

fs->mary[n] = m;

sys/vm/vm_fault.c

1122

struct faultstate fs;

sys/vm/vm_fault.c

1131

fs.hardfault = 0;

sys/vm/vm_fault.c

1132

fs.fault_flags = fault_flags;

sys/vm/vm_fault.c

1148

fs.mary[0] = pmap_fault_page_quick(map->pmap, vaddr, fault_type, busyp);

sys/vm/vm_fault.c

1149

if (fs.mary[0]) {

sys/vm/vm_fault.c

1151

return(fs.mary[0]);

sys/vm/vm_fault.c

1158

fs.vp = NULL;

sys/vm/vm_fault.c

1159

fs.shared = vm_shared_fault;

sys/vm/vm_fault.c

1160

fs.first_shared = vm_shared_fault;

sys/vm/vm_fault.c

1161

fs.msoftonly = 0;

sys/vm/vm_fault.c

1170

fs.first_shared = 0;

sys/vm/vm_fault.c

1188

fs.map = map;

sys/vm/vm_fault.c

1189

fs.first_ba_held = 0;

sys/vm/vm_fault.c

1190

result = vm_map_lookup(&fs.map, vaddr, fault_type,

sys/vm/vm_fault.c

1191

&fs.entry, &fs.first_ba,

sys/vm/vm_fault.c

1193

&fs.first_prot, &fs.wflags);

sys/vm/vm_fault.c

1198

fs.mary[0] = NULL;

sys/vm/vm_fault.c

1202

(fs.fault_flags & VM_FAULT_WIRE_MASK) != VM_FAULT_USER_WIRE)

sys/vm/vm_fault.c

1214

fs.mary[0] = NULL;

sys/vm/vm_fault.c

1226

result = vm_map_lookup(&fs.map, vaddr,

sys/vm/vm_fault.c

1229

&fs.entry, &fs.first_ba,

sys/vm/vm_fault.c

1231

&fs.first_prot, &fs.wflags);

sys/vm/vm_fault.c

1235

fs.mary[0] = NULL;

sys/vm/vm_fault.c

1247

if ((fs.first_prot & VM_PROT_WRITE) == 0) {

sys/vm/vm_fault.c

1248

atomic_clear_char(&fs.entry->max_protection,

sys/vm/vm_fault.c

1258

fs.lookup_still_valid = 1;

sys/vm/vm_fault.c

1259

fs.first_m = NULL;

sys/vm/vm_fault.c

1260

fs.ba = fs.first_ba;

sys/vm/vm_fault.c

1262

if (fs.entry->eflags & MAP_ENTRY_NOFAULT) {

sys/vm/vm_fault.c

1273

if (fs.entry->maptype == VM_MAPTYPE_UKSMAP) {

sys/vm/vm_fault.c

1282

if (fs.entry->ba.uksmap(&fs.entry->ba, UKSMAPOP_FAULT,

sys/vm/vm_fault.c

1283

fs.entry->aux.dev, &fakem)) {

sys/vm/vm_fault.c

1285

fs.mary[0] = NULL;

sys/vm/vm_fault.c

1286

unlock_things(&fs);

sys/vm/vm_fault.c

1289

fs.mary[0] = PHYS_TO_VM_PAGE(fakem.phys_addr);

sys/vm/vm_fault.c

1290

vm_page_hold(fs.mary[0]);

sys/vm/vm_fault.c

1293

unlock_things(&fs);

sys/vm/vm_fault.c

1303

if (fs.first_ba == NULL) {

sys/vm/vm_fault.c

1305

(void *)vaddr, fs.entry);

sys/vm/vm_fault.c

1318

fs.first_ba->object->type == OBJT_VNODE ||

sys/vm/vm_fault.c

1319

fs.first_ba->object->type == OBJT_SWAP ||

sys/vm/vm_fault.c

1320

fs.first_ba->backing_ba)) {

sys/vm/vm_fault.c

1322

unlock_things(&fs);

sys/vm/vm_fault.c

1323

fs.mary[0] = NULL;

sys/vm/vm_fault.c

1339

if (fs.wflags & FW_WIRED)

sys/vm/vm_fault.c

1340

fault_type = fs.first_prot;

sys/vm/vm_fault.c

1357

if (fs.first_ba->flags & VM_MAP_BACK_EXCL_HEUR)

sys/vm/vm_fault.c

1358

fs.first_shared = 0;

sys/vm/vm_fault.c

1360

if (fs.first_shared)

sys/vm/vm_fault.c

1361

vm_object_hold_shared(fs.first_ba->object);

sys/vm/vm_fault.c

1363

vm_object_hold(fs.first_ba->object);

sys/vm/vm_fault.c

1364

fs.first_ba_held = 1;

sys/vm/vm_fault.c

1365

if (fs.vp == NULL)

sys/vm/vm_fault.c

1366

fs.vp = vnode_pager_lock(fs.first_ba); /* shared */

sys/vm/vm_fault.c

1376

if (fs.entry->maptype == VM_MAPTYPE_VPAGETABLE) {

sys/vm/vm_fault.c

1377

result = vm_fault_vpagetable(&fs, &first_pindex,

sys/vm/vm_fault.c

1378

fs.entry->aux.master_pde,

sys/vm/vm_fault.c

1387

fs.mary[0] = NULL;

sys/vm/vm_fault.c

1398

fs.mary[0] = NULL;

sys/vm/vm_fault.c

1399

result = vm_fault_object(&fs, first_pindex, fault_type, 1);

sys/vm/vm_fault.c

1402

KKASSERT(fs.first_ba_held == 0);

sys/vm/vm_fault.c

1404

didcow |= fs.wflags & FW_DIDCOW;

sys/vm/vm_fault.c

1409

fs.mary[0] = NULL;

sys/vm/vm_fault.c

1414

(fs.prot & VM_PROT_WRITE) == 0) {

sys/vm/vm_fault.c

1416

unlock_things(&fs);

sys/vm/vm_fault.c

1417

fs.mary[0] = NULL;

sys/vm/vm_fault.c

1433

vm_page_flag_set(fs.mary[0], PG_REFERENCED);

sys/vm/vm_fault.c

1440

if (fs.entry->maptype == VM_MAPTYPE_VPAGETABLE)

sys/vm/vm_fault.c

1441

vm_page_flag_set(fs.mary[0], PG_VPTMAPPED);

sys/vm/vm_fault.c

1445

pmap_enter(fs.map->pmap, vaddr, fs.mary[0], fs.prot,

sys/vm/vm_fault.c

1446

fs.wflags & FW_WIRED, NULL);

sys/vm/vm_fault.c

1451

if ((fs.wflags | didcow) & FW_DIDCOW) {

sys/vm/vm_fault.c

1452

pmap_remove(fs.map->pmap,

sys/vm/vm_fault.c

1464

pmap_enter(fs.map->pmap, vaddr, fs.mary[0],

sys/vm/vm_fault.c

1465

fs.prot, fs.wflags & FW_WIRED, NULL);

sys/vm/vm_fault.c

1474

unlock_things(&fs);

sys/vm/vm_fault.c

1484

vm_page_dirty(fs.mary[0]);

sys/vm/vm_fault.c

1485

vm_page_activate(fs.mary[0]);

sys/vm/vm_fault.c

1488

if (fs.hardfault) {

sys/vm/vm_fault.c

1500

vm_page_dirty(fs.mary[0]);

sys/vm/vm_fault.c

1504

vm_page_hold(fs.mary[0]);

sys/vm/vm_fault.c

1505

vm_page_wakeup(fs.mary[0]);

sys/vm/vm_fault.c

1508

vm_page_hold(fs.mary[0]);

sys/vm/vm_fault.c

1509

vm_page_wakeup(fs.mary[0]);

sys/vm/vm_fault.c

1515

KKASSERT(fs.first_ba_held == 0);

sys/vm/vm_fault.c

1517

return(fs.mary[0]);

sys/vm/vm_fault.c

1538

struct faultstate fs;

sys/vm/vm_fault.c

1553

fs.hardfault = 0;

sys/vm/vm_fault.c

1554

fs.fault_flags = fault_flags;

sys/vm/vm_fault.c

1555

fs.map = NULL;

sys/vm/vm_fault.c

1556

fs.shared = vm_shared_fault;

sys/vm/vm_fault.c

1557

fs.first_shared = *sharedp;

sys/vm/vm_fault.c

1558

fs.msoftonly = 0;

sys/vm/vm_fault.c

1559

fs.vp = NULL;

sys/vm/vm_fault.c

1560

fs.first_ba_held = -1; /* object held across call, prevent drop */

sys/vm/vm_fault.c

1568

if (fs.first_shared && (fault_flags & VM_FAULT_UNSWAP)) {

sys/vm/vm_fault.c

1569

fs.first_shared = 0;

sys/vm/vm_fault.c

1577

*sharedp = fs.first_shared;

sys/vm/vm_fault.c

1580

fs.first_ba = &entry.ba;

sys/vm/vm_fault.c

1581

fs.ba = fs.first_ba;

sys/vm/vm_fault.c

1582

fs.entry = &entry;

sys/vm/vm_fault.c

1583

fs.first_prot = fault_type;

sys/vm/vm_fault.c

1584

fs.wflags = 0;

sys/vm/vm_fault.c

1600

if (fs.vp == NULL)

sys/vm/vm_fault.c

1601

fs.vp = vnode_pager_lock(fs.first_ba);

sys/vm/vm_fault.c

1603

fs.lookup_still_valid = 1;

sys/vm/vm_fault.c

1604

fs.first_m = NULL;

sys/vm/vm_fault.c

1615

result = vm_fault_object(&fs, first_pindex, fault_type, 0);

sys/vm/vm_fault.c

1618

if (fs.first_shared == 0 && *sharedp)

sys/vm/vm_fault.c

1627

if ((fault_type & VM_PROT_WRITE) && (fs.prot & VM_PROT_WRITE) == 0) {

sys/vm/vm_fault.c

1629

unlock_things(&fs);

sys/vm/vm_fault.c

1637

unlock_things(&fs);

sys/vm/vm_fault.c

1646

vm_page_hold(fs.mary[0]);

sys/vm/vm_fault.c

1647

vm_page_activate(fs.mary[0]);

sys/vm/vm_fault.c

1649

vm_page_dirty(fs.mary[0]);

sys/vm/vm_fault.c

1651

swap_pager_unswapped(fs.mary[0]);

sys/vm/vm_fault.c

1656

vm_page_flag_set(fs.mary[0], PG_REFERENCED);

sys/vm/vm_fault.c

1659

if (fs.hardfault) {

sys/vm/vm_fault.c

1669

vm_page_wakeup(fs.mary[0]);

sys/vm/vm_fault.c

1673

return(fs.mary[0]);

sys/vm/vm_fault.c

1690

vm_fault_vpagetable(struct faultstate *fs, vm_pindex_t *pindex,

sys/vm/vm_fault.c

1699

ASSERT_LWKT_TOKEN_HELD(vm_object_token(fs->first_ba->object));

sys/vm/vm_fault.c

1707

unlock_things(fs);

sys/vm/vm_fault.c

1711

unlock_things(fs);

sys/vm/vm_fault.c

1715

unlock_things(fs);

sys/vm/vm_fault.c

1728

result = vm_fault_object(fs, (vpte & VPTE_FRAME) >> PAGE_SHIFT,

sys/vm/vm_fault.c

1739

lwb = lwbuf_alloc(fs->mary[0], &lwb_cache);

sys/vm/vm_fault.c

1742

vm_page_activate(fs->mary[0]);

sys/vm/vm_fault.c

1777

vm_page_dirty(fs->mary[0]);

sys/vm/vm_fault.c

1782

vm_page_flag_set(fs->mary[0], PG_REFERENCED);

sys/vm/vm_fault.c

1783

vm_page_wakeup(fs->mary[0]);

sys/vm/vm_fault.c

1784

fs->mary[0] = NULL;

sys/vm/vm_fault.c

1785

cleanup_fault(fs);

sys/vm/vm_fault.c

1802

fs->first_prot &= ~VM_PROT_WRITE;

sys/vm/vm_fault.c

1809

fs->first_prot &= ~VM_PROT_EXECUTE;

sys/vm/vm_fault.c

1847

vm_fault_object(struct faultstate *fs, vm_pindex_t first_pindex,

sys/vm/vm_fault.c

1854

ASSERT_LWKT_TOKEN_HELD(vm_object_token(fs->first_ba->object));

sys/vm/vm_fault.c

1855

fs->prot = fs->first_prot;

sys/vm/vm_fault.c

1857

KKASSERT(fs->ba == fs->first_ba);

sys/vm/vm_fault.c

1859

vm_object_pip_add(fs->first_ba->object, 1);

sys/vm/vm_fault.c

1878

fs->prot &= ~VM_PROT_WRITE;

sys/vm/vm_fault.c

1887

if (fs->ba->object->flags & OBJ_DEAD) {

sys/vm/vm_fault.c

1888

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

1889

unlock_things(fs);

sys/vm/vm_fault.c

1906

fs->mary[0] = vm_page_lookup_busy_try(fs->ba->object, pindex,

sys/vm/vm_fault.c

1909

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

1910

unlock_things(fs);

sys/vm/vm_fault.c

1911

vm_page_sleep_busy(fs->mary[0], TRUE, "vmpfw");

sys/vm/vm_fault.c

1913

fs->mary[0] = NULL;

sys/vm/vm_fault.c

1916

if (fs->mary[0]) {

sys/vm/vm_fault.c

1923

int queue = fs->mary[0]->queue;

sys/vm/vm_fault.c

1924

vm_page_unqueue_nowakeup(fs->mary[0]);

sys/vm/vm_fault.c

1926

if ((queue - fs->mary[0]->pc) == PQ_CACHE &&

sys/vm/vm_fault.c

1928

vm_page_activate(fs->mary[0]);

sys/vm/vm_fault.c

1929

vm_page_wakeup(fs->mary[0]);

sys/vm/vm_fault.c

1930

fs->mary[0] = NULL;

sys/vm/vm_fault.c

1931

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

1932

unlock_things(fs);

sys/vm/vm_fault.c

1954

if (fs->mary[0]->object != kernel_object) {

sys/vm/vm_fault.c

1955

if ((fs->mary[0]->valid & VM_PAGE_BITS_ALL) !=

sys/vm/vm_fault.c

1959

if (fs->mary[0]->flags & PG_RAM) {

sys/vm/vm_fault.c

1962

vm_page_flag_clear(fs->mary[0], PG_RAM);

sys/vm/vm_fault.c

1966

atomic_clear_int(&fs->first_ba->flags,

sys/vm/vm_fault.c

1975

if (TRYPAGER(fs) || fs->ba == fs->first_ba) {

sys/vm/vm_fault.c

1985

if (fs->ba != fs->first_ba &&

sys/vm/vm_fault.c

1986

fs->ba->object->type == OBJT_SWAP) {

sys/vm/vm_fault.c

1987

if (swap_pager_haspage_locked(fs->ba->object,

sys/vm/vm_fault.c

1996

atomic_set_int(&fs->first_ba->flags,

sys/vm/vm_fault.c

1998

if (fs->ba == fs->first_ba && fs->first_shared) {

sys/vm/vm_fault.c

1999

fs->first_shared = 0;

sys/vm/vm_fault.c

2000

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

2001

unlock_things(fs);

sys/vm/vm_fault.c

2004

if (fs->ba != fs->first_ba && fs->shared) {

sys/vm/vm_fault.c

2005

fs->first_shared = 0;

sys/vm/vm_fault.c

2006

fs->shared = 0;

sys/vm/vm_fault.c

2007

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

2008

unlock_things(fs);

sys/vm/vm_fault.c

2015

if (pindex >= fs->ba->object->size) {

sys/vm/vm_fault.c

2016

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

2017

unlock_things(fs);

sys/vm/vm_fault.c

2032

fs->mary[0] = NULL;

sys/vm/vm_fault.c

2033

if (fs->ba->object->type == OBJT_MGTDEVICE)

sys/vm/vm_fault.c

2037

fs->mary[0] = vm_page_alloc(fs->ba->object,

sys/vm/vm_fault.c

2039

((fs->vp || fs->ba->backing_ba) ?

sys/vm/vm_fault.c

2044

if (fs->mary[0] == NULL) {

sys/vm/vm_fault.c

2045

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

2046

unlock_things(fs);

sys/vm/vm_fault.c

206

static int vm_fault_bypass(struct faultstate *fs, vm_pindex_t first_pindex,

sys/vm/vm_fault.c

2079

if (TRYPAGER(fs)) {

sys/vm/vm_fault.c

2080

u_char behavior = vm_map_entry_behavior(fs->entry);

sys/vm/vm_fault.c

2100

if (fs->ba == fs->first_ba && fs->first_shared) {

sys/vm/vm_fault.c

2101

if (fs->mary[0]) {

sys/vm/vm_fault.c

2102

vm_page_deactivate(fs->mary[0]);

sys/vm/vm_fault.c

2103

vm_page_wakeup(fs->mary[0]);

sys/vm/vm_fault.c

2104

fs->mary[0]= NULL;

sys/vm/vm_fault.c

2106

fs->first_shared = 0;

sys/vm/vm_fault.c

2107

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

2108

unlock_things(fs);

sys/vm/vm_fault.c

2111

if (fs->ba != fs->first_ba && fs->shared) {

sys/vm/vm_fault.c

2112

if (fs->mary[0]) {

sys/vm/vm_fault.c

2113

vm_page_deactivate(fs->mary[0]);

sys/vm/vm_fault.c

2114

vm_page_wakeup(fs->mary[0]);

sys/vm/vm_fault.c

2115

fs->mary[0] = NULL;

sys/vm/vm_fault.c

2117

fs->first_shared = 0;

sys/vm/vm_fault.c

2118

fs->shared = 0;

sys/vm/vm_fault.c

2119

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

2120

unlock_things(fs);

sys/vm/vm_fault.c

2124

object = fs->ba->object;

sys/vm/vm_fault.c

2163

&fs->mary[0], seqaccess);

sys/vm/vm_fault.c

2166

++fs->hardfault;

sys/vm/vm_fault.c

2171

fs->mary[0] = vm_page_lookup(object, pindex);

sys/vm/vm_fault.c

2172

if (fs->mary[0]) {

sys/vm/vm_fault.c

2173

vm_page_activate(fs->mary[0]);

sys/vm/vm_fault.c

2174

vm_page_wakeup(fs->mary[0]);

sys/vm/vm_fault.c

2175

fs->mary[0] = NULL;

sys/vm/vm_fault.c

2178

if (fs->mary[0]) {

sys/vm/vm_fault.c

2183

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

2184

unlock_things(fs);

sys/vm/vm_fault.c

2195

if (fs->ba != fs->first_ba) {

sys/vm/vm_fault.c

2196

if (fs->mary[0]) {

sys/vm/vm_fault.c

2197

vm_page_free(fs->mary[0]);

sys/vm/vm_fault.c

2198

fs->mary[0] = NULL;

sys/vm/vm_fault.c

223

release_page(struct faultstate *fs)

sys/vm/vm_fault.c

2233

if (fs->mary[0]) {

sys/vm/vm_fault.c

2234

vnode_pager_freepage(fs->mary[0]);

sys/vm/vm_fault.c

2235

fs->mary[0] = NULL;

sys/vm/vm_fault.c

2242

unlock_things(fs);

sys/vm/vm_fault.c

225

vm_page_deactivate(fs->mary[0]);

sys/vm/vm_fault.c

226

vm_page_wakeup(fs->mary[0]);

sys/vm/vm_fault.c

2264

if (fs->ba != fs->first_ba) {

sys/vm/vm_fault.c

227

fs->mary[0] = NULL;

sys/vm/vm_fault.c

2277

if (((fs->map != kernel_map) &&

sys/vm/vm_fault.c

2279

if (fs->m) {

sys/vm/vm_fault.c

2281

KKASSERT(fs->first_shared == 0);

sys/vm/vm_fault.c

2282

vnode_pager_freepage(fs->m);

sys/vm/vm_fault.c

2283

fs->m = NULL;

sys/vm/vm_fault.c

2299

if (fs->ba == fs->first_ba)

sys/vm/vm_fault.c

2300

fs->first_m = fs->mary[0];

sys/vm/vm_fault.c

2309

next_ba = fs->ba->backing_ba;

sys/vm/vm_fault.c

231

unlock_map(struct faultstate *fs)

sys/vm/vm_fault.c

2315

if (fs->ba != fs->first_ba) {

sys/vm/vm_fault.c

2316

vm_object_pip_wakeup(fs->ba->object);

sys/vm/vm_fault.c

2317

vm_object_drop(fs->ba->object);

sys/vm/vm_fault.c

2318

fs->ba = fs->first_ba;

sys/vm/vm_fault.c

2320

fs->mary[0] = fs->first_m;

sys/vm/vm_fault.c

2322

fs->first_m = NULL;

sys/vm/vm_fault.c

2327

vm_page_zero_fill(fs->mary[0]);

sys/vm/vm_fault.c

2329

fs->mary[0]->valid = VM_PAGE_BITS_ALL;

sys/vm/vm_fault.c

233

if (fs->ba != fs->first_ba)

sys/vm/vm_fault.c

2333

if (fs->shared)

sys/vm/vm_fault.c

2337

KKASSERT(next_ba == fs->ba->backing_ba);

sys/vm/vm_fault.c

2338

pindex -= OFF_TO_IDX(fs->ba->offset);

sys/vm/vm_fault.c

234

vm_object_drop(fs->ba->object);

sys/vm/vm_fault.c

2341

if (fs->ba != fs->first_ba) {

sys/vm/vm_fault.c

2342

vm_object_pip_wakeup(fs->ba->object);

sys/vm/vm_fault.c

2344

vm_object_drop(fs->ba->object);

sys/vm/vm_fault.c

2346

fs->ba = next_ba;

sys/vm/vm_fault.c

235

if (fs->first_ba && fs->first_ba_held == 1) {

sys/vm/vm_fault.c

236

vm_object_drop(fs->first_ba->object);

sys/vm/vm_fault.c

2363

KASSERT((fs->mary[0]->busy_count & PBUSY_LOCKED) != 0,

sys/vm/vm_fault.c

2366

if (fs->ba != fs->first_ba) {

sys/vm/vm_fault.c

237

fs->first_ba_held = 0;

sys/vm/vm_fault.c

238

fs->first_ba = NULL;

sys/vm/vm_fault.c

2383

if (virtual_copy_ok(fs)) {

sys/vm/vm_fault.c

2395

vm_page_protect(fs->first_m, VM_PROT_NONE);

sys/vm/vm_fault.c

2396

vm_page_remove(fs->first_m);

sys/vm/vm_fault.c

2397

vm_page_rename(fs->mary[0],

sys/vm/vm_fault.c

2398

fs->first_ba->object,

sys/vm/vm_fault.c

240

fs->ba = NULL;

sys/vm/vm_fault.c

2400

vm_page_free(fs->first_m);

sys/vm/vm_fault.c

2401

fs->first_m = fs->mary[0];

sys/vm/vm_fault.c

2402

fs->mary[0] = NULL;

sys/vm/vm_fault.c

2425

KKASSERT(fs->first_shared == 0);

sys/vm/vm_fault.c

2426

vm_page_copy(fs->mary[0], fs->first_m);

sys/vm/vm_fault.c

2435

if (fs->mary[0])

sys/vm/vm_fault.c

2436

release_page(fs);

sys/vm/vm_fault.c

2441

vm_object_pip_wakeup(fs->ba->object);

sys/vm/vm_fault.c

2442

vm_object_drop(fs->ba->object);

sys/vm/vm_fault.c

2443

fs->ba = fs->first_ba;

sys/vm/vm_fault.c

2453

fs->wflags |= FW_DIDCOW;

sys/vm/vm_fault.c

2454

fs->mary[0] = fs->first_m;

sys/vm/vm_fault.c

246

if (fs->lookup_still_valid == 1 && fs->map) {

sys/vm/vm_fault.c

2463

fs->prot &= ~VM_PROT_WRITE;

sys/vm/vm_fault.c

247

vm_map_lookup_done(fs->map, fs->entry, 0);

sys/vm/vm_fault.c

2478

KKASSERT(fs->lookup_still_valid != 0);

sys/vm/vm_fault.c

248

fs->lookup_still_valid = 0;

sys/vm/vm_fault.c

2480

if (fs->lookup_still_valid == 0 && fs->map) {

sys/vm/vm_fault.c

2481

if (relock_map(fs) ||

sys/vm/vm_fault.c

2482

fs->map->timestamp != fs->map_generation) {

sys/vm/vm_fault.c

2483

release_page(fs);

sys/vm/vm_fault.c

2484

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

2485

unlock_things(fs);

sys/vm/vm_fault.c

249

fs->entry = NULL;

sys/vm/vm_fault.c

2506

vm_page_activate(fs->mary[0]);

sys/vm/vm_fault.c

2507

if (fs->prot & VM_PROT_WRITE) {

sys/vm/vm_fault.c

2508

vm_object_set_writeable_dirty(fs->first_ba->object);

sys/vm/vm_fault.c

2509

vm_set_nosync(fs->mary[0], fs->entry);

sys/vm/vm_fault.c

2510

if (fs->fault_flags & VM_FAULT_DIRTY) {

sys/vm/vm_fault.c

2511

vm_page_dirty(fs->mary[0]);

sys/vm/vm_fault.c

2512

if (fs->mary[0]->flags & PG_SWAPPED) {

sys/vm/vm_fault.c

2519

if ((fs->ba == fs->first_ba &&

sys/vm/vm_fault.c

2520

fs->first_shared) ||

sys/vm/vm_fault.c

2521

(fs->ba != fs->first_ba && fs->shared)) {

sys/vm/vm_fault.c

2522

vm_page_wakeup(fs->mary[0]);

sys/vm/vm_fault.c

2523

fs->mary[0] = NULL;

sys/vm/vm_fault.c

2524

if (fs->ba == fs->first_ba)

sys/vm/vm_fault.c

2525

fs->first_shared = 0;

sys/vm/vm_fault.c

2527

fs->shared = 0;

sys/vm/vm_fault.c

2529

fs->first_ba->object);

sys/vm/vm_fault.c

2530

unlock_things(fs);

sys/vm/vm_fault.c

2533

swap_pager_unswapped(fs->mary[0]);

sys/vm/vm_fault.c

2543

vm_object_pip_wakeup(fs->first_ba->object);

sys/vm/vm_fault.c

2545

if (fs->ba != fs->first_ba)

sys/vm/vm_fault.c

2546

vm_object_drop(fs->ba->object);

sys/vm/vm_fault.c

2554

KASSERT(fs->mary[0]->busy_count & PBUSY_LOCKED,

sys/vm/vm_fault.c

2555

("vm_fault: page %p not busy!", fs->mary[0]));

sys/vm/vm_fault.c

2561

if (fs->mary[0]->valid != VM_PAGE_BITS_ALL) {

sys/vm/vm_fault.c

2562

vm_page_zero_invalid(fs->mary[0], TRUE);

sys/vm/vm_fault.c

2564

fs->mary[0]);

sys/vm/vm_fault.c

258

cleanup_fault(struct faultstate *fs)

sys/vm/vm_fault.c

264

if (fs->ba != fs->first_ba) {

sys/vm/vm_fault.c

265

KKASSERT(fs->first_shared == 0);

sys/vm/vm_fault.c

271

if ((fs->first_m->valid & VM_PAGE_BITS_ALL) ==

sys/vm/vm_fault.c

2710

struct faultstate fs;

sys/vm/vm_fault.c

2717

bzero(&fs, sizeof(fs));

sys/vm/vm_fault.c

2720

fs.first_prot = entry->max_protection | /* optional VM_PROT_EXECUTE */

sys/vm/vm_fault.c

2722

fs.fault_flags = VM_FAULT_NORMAL;

sys/vm/vm_fault.c

2723

fs.map = map;

sys/vm/vm_fault.c

2724

fs.entry = entry;

sys/vm/vm_fault.c

2725

fs.lookup_still_valid = -1; /* leave map atomically locked */

sys/vm/vm_fault.c

2726

fs.first_ba = &entry->ba;

sys/vm/vm_fault.c

2727

fs.first_ba_held = -1; /* leave object held */

sys/vm/vm_fault.c

273

vm_page_wakeup(fs->first_m);

sys/vm/vm_fault.c

2746

fs.ba = fs.first_ba;

sys/vm/vm_fault.c

2747

fs.prot = fs.first_prot;

sys/vm/vm_fault.c

2749

rv = vm_fault_object(&fs, pindex, fs.first_prot, 1);

sys/vm/vm_fault.c

275

vm_page_free(fs->first_m);

sys/vm/vm_fault.c

2754

vm_page_flag_set(fs.mary[0], PG_REFERENCED);

sys/vm/vm_fault.c

2755

vm_page_activate(fs.mary[0]);

sys/vm/vm_fault.c

2756

vm_page_wakeup(fs.mary[0]);

sys/vm/vm_fault.c

277

vm_object_pip_wakeup(fs->ba->object);

sys/vm/vm_fault.c

278

fs->first_m = NULL;

sys/vm/vm_fault.c

284

vm_object_drop(fs->ba->object);

sys/vm/vm_fault.c

285

fs->ba = fs->first_ba;

sys/vm/vm_fault.c

290

unlock_things(struct faultstate *fs)

sys/vm/vm_fault.c

292

cleanup_fault(fs);

sys/vm/vm_fault.c

293

unlock_map(fs);

sys/vm/vm_fault.c

294

if (fs->vp != NULL) {

sys/vm/vm_fault.c

295

vput(fs->vp);

sys/vm/vm_fault.c

296

fs->vp = NULL;

sys/vm/vm_fault.c

307

virtual_copy_test(struct faultstate *fs)

sys/vm/vm_fault.c

312

if (fs->first_shared || fs->shared || virtual_copy_enable == 0)

sys/vm/vm_fault.c

318

if (fs->map && fs->map_generation != fs->map->timestamp)

sys/vm/vm_fault.c

324

if (fs->ba->object->ref_count != 1)

sys/vm/vm_fault.c

330

if (fs->ba->object->handle != NULL)

sys/vm/vm_fault.c

336

if (fs->ba->object->type != OBJT_DEFAULT &&

sys/vm/vm_fault.c

337

fs->ba->object->type != OBJT_SWAP)

sys/vm/vm_fault.c

343

if (fs->ba != fs->first_ba->backing_ba)

sys/vm/vm_fault.c

350

virtual_copy_ok(struct faultstate *fs)

sys/vm/vm_fault.c

352

if (virtual_copy_test(fs)) {

sys/vm/vm_fault.c

356

if (fs->lookup_still_valid == 0 && fs->map) {

sys/vm/vm_fault.c

357

if (lockmgr(&fs->map->lock, LK_EXCLUSIVE|LK_NOWAIT))

sys/vm/vm_fault.c

359

fs->lookup_still_valid = 1;

sys/vm/vm_fault.c

360

if (virtual_copy_test(fs)) {

sys/vm/vm_fault.c

361

fs->map_generation = ++fs->map->timestamp;

sys/vm/vm_fault.c

364

fs->lookup_still_valid = 0;

sys/vm/vm_fault.c

365

lockmgr(&fs->map->lock, LK_RELEASE);

sys/vm/vm_fault.c

383

#define TRYPAGER(fs) \

sys/vm/vm_fault.c

384

(fs->ba->object->type != OBJT_DEFAULT && \

sys/vm/vm_fault.c

385

(((fs->fault_flags & VM_FAULT_WIRE_MASK) == 0)))

sys/vm/vm_fault.c

408

struct faultstate fs;

sys/vm/vm_fault.c

424

fs.hardfault = 0;

sys/vm/vm_fault.c

425

fs.fault_flags = fault_flags;

sys/vm/vm_fault.c

426

fs.vp = NULL;

sys/vm/vm_fault.c

427

fs.shared = vm_shared_fault;

sys/vm/vm_fault.c

428

fs.first_shared = vm_shared_fault;

sys/vm/vm_fault.c

442

fs.msoftonly = 0;

sys/vm/vm_fault.c

443

fs.first_ba_held = 0;

sys/vm/vm_fault.c

461

fs.map = map;

sys/vm/vm_fault.c

462

result = vm_map_lookup(&fs.map, vaddr, fault_type,

sys/vm/vm_fault.c

463

&fs.entry, &fs.first_ba,

sys/vm/vm_fault.c

465

&fs.first_prot, &fs.wflags);

sys/vm/vm_fault.c

483

(fs.fault_flags & VM_FAULT_WIRE_MASK) != VM_FAULT_USER_WIRE)

sys/vm/vm_fault.c

507

result = vm_map_lookup(&fs.map, vaddr,

sys/vm/vm_fault.c

510

&fs.entry, &fs.first_ba,

sys/vm/vm_fault.c

512

&fs.first_prot, &fs.wflags);

sys/vm/vm_fault.c

527

if ((fs.first_prot & VM_PROT_WRITE) == 0) {

sys/vm/vm_fault.c

528

atomic_clear_char(&fs.entry->max_protection,

sys/vm/vm_fault.c

538

fs.lookup_still_valid = 1;

sys/vm/vm_fault.c

539

fs.first_m = NULL;

sys/vm/vm_fault.c

540

fs.ba = fs.first_ba; /* so unlock_things() works */

sys/vm/vm_fault.c

541

fs.prot = fs.first_prot; /* default (used by uksmap) */

sys/vm/vm_fault.c

543

if (fs.entry->eflags & (MAP_ENTRY_NOFAULT | MAP_ENTRY_KSTACK)) {

sys/vm/vm_fault.c

544

if (fs.entry->eflags & MAP_ENTRY_NOFAULT) {

sys/vm/vm_fault.c

548

if ((fs.entry->eflags & MAP_ENTRY_KSTACK) &&

sys/vm/vm_fault.c

549

vaddr >= fs.entry->ba.start &&

sys/vm/vm_fault.c

550

vaddr < fs.entry->ba.start + PAGE_SIZE) {

sys/vm/vm_fault.c

562

if (fs.entry->maptype == VM_MAPTYPE_UKSMAP) {

sys/vm/vm_fault.c

571

if (fs.entry->ba.uksmap(&fs.entry->ba, UKSMAPOP_FAULT,

sys/vm/vm_fault.c

572

fs.entry->aux.dev, &fakem)) {

sys/vm/vm_fault.c

574

unlock_things(&fs);

sys/vm/vm_fault.c

577

pmap_enter(fs.map->pmap, vaddr, &fakem, fs.prot | inherit_prot,

sys/vm/vm_fault.c

578

(fs.wflags & FW_WIRED), fs.entry);

sys/vm/vm_fault.c

586

if (fs.first_ba == NULL) {

sys/vm/vm_fault.c

588

(void *)vaddr, fs.entry);

sys/vm/vm_fault.c

605

fs.first_ba->object->type == OBJT_VNODE ||

sys/vm/vm_fault.c

606

fs.first_ba->object->type == OBJT_SWAP ||

sys/vm/vm_fault.c

607

fs.first_ba->backing_ba)) {

sys/vm/vm_fault.c

609

unlock_things(&fs);

sys/vm/vm_fault.c

625

if (fs.wflags & FW_WIRED)

sys/vm/vm_fault.c

626

fault_type = fs.first_prot;

sys/vm/vm_fault.c

646

if (fs.first_shared && fs.first_object->backing_object &&

sys/vm/vm_fault.c

647

LIST_EMPTY(&fs.first_object->shadow_head) &&

sys/vm/vm_fault.c

649

fs.first_shared = 0;

sys/vm/vm_fault.c

659

fs.first_shared = 0;

sys/vm/vm_fault.c

666

vm_fault_bypass(&fs, first_pindex, first_count,

sys/vm/vm_fault.c

676

if (fs.first_ba->flags & VM_MAP_BACK_EXCL_HEUR)

sys/vm/vm_fault.c

677

fs.first_shared = 0;

sys/vm/vm_fault.c

686

if (fs.first_shared)

sys/vm/vm_fault.c

687

vm_object_hold_shared(fs.first_ba->object);

sys/vm/vm_fault.c

689

vm_object_hold(fs.first_ba->object);

sys/vm/vm_fault.c

690

if (fs.vp == NULL)

sys/vm/vm_fault.c

691

fs.vp = vnode_pager_lock(fs.first_ba);

sys/vm/vm_fault.c

692

fs.first_ba_held = 1;

sys/vm/vm_fault.c

703

if (fs.entry->maptype == VM_MAPTYPE_VPAGETABLE) {

sys/vm/vm_fault.c

707

vaddr, fs.entry->aux.master_pde, fault_type,

sys/vm/vm_fault.c

710

vm_map_interlock(fs.map, &ilock, vaddr, vaddr + PAGE_SIZE);

sys/vm/vm_fault.c

712

result = vm_fault_vpagetable(&fs, &first_pindex,

sys/vm/vm_fault.c

713

fs.entry->aux.master_pde,

sys/vm/vm_fault.c

717

vaddr, fs.mary[0], result);

sys/vm/vm_fault.c

720

vm_map_deinterlock(fs.map, &ilock);

sys/vm/vm_fault.c

725

vm_map_deinterlock(fs.map, &ilock);

sys/vm/vm_fault.c

745

result = vm_fault_object(&fs, first_pindex, fault_type, 1);

sys/vm/vm_fault.c

752

fs.mary[0], fs.prot, fs.wflags, fs.entry);

sys/vm/vm_fault.c

757

vm_map_deinterlock(fs.map, &ilock);

sys/vm/vm_fault.c

763

vm_map_deinterlock(fs.map, &ilock);

sys/vm/vm_fault.c

777

KKASSERT(fs.lookup_still_valid != 0);

sys/vm/vm_fault.c

778

vm_page_flag_set(fs.mary[0], PG_REFERENCED);

sys/vm/vm_fault.c

787

if (fs.entry->maptype == VM_MAPTYPE_VPAGETABLE) {

sys/vm/vm_fault.c

789

vm_page_flag_set(fs.mary[n], PG_VPTMAPPED);

sys/vm/vm_fault.c

794

pmap_enter(fs.map->pmap, vaddr + (n << PAGE_SHIFT),

sys/vm/vm_fault.c

795

fs.mary[n], fs.prot | inherit_prot,

sys/vm/vm_fault.c

796

fs.wflags & FW_WIRED, fs.entry);

sys/vm/vm_fault.c

800

vm_map_deinterlock(fs.map, &ilock);

sys/vm/vm_fault.c

810

if (fs.msoftonly) {

sys/vm/vm_fault.c

811

KKASSERT(fs.mary[n]->busy_count & PBUSY_MASK);

sys/vm/vm_fault.c

812

KKASSERT((fs.fault_flags & VM_FAULT_WIRE_MASK) == 0);

sys/vm/vm_fault.c

813

vm_page_sbusy_drop(fs.mary[n]);

sys/vm/vm_fault.c

815

if (fs.fault_flags & VM_FAULT_WIRE_MASK) {

sys/vm/vm_fault.c

818

if (fs.wflags & FW_WIRED)

sys/vm/vm_fault.c

819

vm_page_wire(fs.mary[n]);

sys/vm/vm_fault.c

821

vm_page_unwire(fs.mary[n], 1);

sys/vm/vm_fault.c

824

vm_page_activate(fs.mary[n]);

sys/vm/vm_fault.c

826

KKASSERT(fs.mary[n]->busy_count & PBUSY_LOCKED);

sys/vm/vm_fault.c

827

vm_page_wakeup(fs.mary[n]);

sys/vm/vm_fault.c

845

(fs.fault_flags & VM_FAULT_WIRE_MASK) == 0 &&

sys/vm/vm_fault.c

846

(fs.wflags & FW_WIRED) == 0) {

sys/vm/vm_fault.c

847

if (fs.first_shared == 0 && fs.shared == 0) {

sys/vm/vm_fault.c

848

vm_prefault(fs.map->pmap, vaddr,

sys/vm/vm_fault.c

849

fs.entry, fs.prot, fault_flags);

sys/vm/vm_fault.c

851

vm_prefault_quick(fs.map->pmap, vaddr,

sys/vm/vm_fault.c

852

fs.entry, fs.prot, fault_flags);

sys/vm/vm_fault.c

860

unlock_things(&fs);

sys/vm/vm_fault.c

864

if (fs.hardfault) {

sys/vm/vm_fault.c

876

if (fs.first_ba && fs.first_ba->object && fs.first_ba_held == 1) {

sys/vm/vm_fault.c

877

vm_object_drop(fs.first_ba->object);

sys/vm/vm_fault.c

878

fs.first_ba_held = 0;

sys/vm/vm_fault.c

917

fs.mary[0], fs.prot, fs.wflags, fs.entry);

sys/vm/vm_fault.c

932

vm_fault_bypass(struct faultstate *fs, vm_pindex_t first_pindex,

sys/vm/vm_fault.c

944

obj = fs->first_ba->object;

sys/vm/vm_fault.c

954

if (fs->fault_flags & VM_FAULT_WIRE_MASK)

sys/vm/vm_fault.c

961

if (fs->entry->maptype == VM_MAPTYPE_VPAGETABLE) {

sys/vm/vm_fault.c

999

fs->prot &= ~VM_PROT_WRITE;

test/stress/stress2/tools/fstool.c

159

sscanf(optarg, "%d%c", &fs, &ch);

test/stress/stress2/tools/fstool.c

161

fs = fs * 1024;

test/stress/stress2/tools/fstool.c

163

fs = fs * 1024 * 1024;

test/stress/stress2/tools/fstool.c

181

if ((buffer = calloc(1, fs)) == NULL)

test/stress/stress2/tools/fstool.c

182

err(1, "calloc(%d)", fs);

test/stress/stress2/tools/fstool.c

42

static int fs = 1024;

test/stress/stress2/tools/fstool.c

74

if (write(fd, buffer, fs) != fs)

tools/tools/net80211/wesside/wesside/wesside.c

1696

void send_fragment(int tx, struct frag_state* fs, struct prga_info *pi) {

tools/tools/net80211/wesside/wesside/wesside.c

1708

memcpy(wh, &fs->wh, sizeof(*wh));

tools/tools/net80211/wesside/wesside/wesside.c

1715

fragsize = fs->data + fs->len - fs->ptr;

tools/tools/net80211/wesside/wesside/wesside.c

1728

memcpy(body, fs->ptr, fragsize);

tools/tools/net80211/wesside/wesside/wesside.c

1745

seq = (unsigned short*) &fs->wh.i_seq;

tools/tools/net80211/wesside/wesside/wesside.c

1747

fs->ptr += fragsize;

tools/tools/net80211/wesside/wesside/wesside.c

1749

if (fs->ptr - fs->data == fs->len) {

tools/tools/net80211/wesside/wesside/wesside.c

1751

fs->waiting_relay = 1;

tools/tools/net80211/wesside/wesside/wesside.c

1755

void prepare_fragstate(struct frag_state* fs, int pad) {

tools/tools/net80211/wesside/wesside/wesside.c

1756

fs->waiting_relay = 0;

tools/tools/net80211/wesside/wesside/wesside.c

1757

fs->len = 8 + 8 + 20 + pad;

tools/tools/net80211/wesside/wesside/wesside.c

1758

fs->data = (unsigned char*) malloc(fs->len);

tools/tools/net80211/wesside/wesside/wesside.c

1760

if(!fs->data) {

tools/tools/net80211/wesside/wesside/wesside.c

1765

fs->ptr = fs->data;

tools/tools/net80211/wesside/wesside/wesside.c

1767

do_llc(fs->data, ETHERTYPE_ARP);

tools/tools/net80211/wesside/wesside/wesside.c

1768

do_arp(&fs->data[8], ARPOP_REQUEST,

tools/tools/net80211/wesside/wesside/wesside.c

1772

memset(&fs->wh, 0, sizeof(fs->wh));

tools/tools/net80211/wesside/wesside/wesside.c

1773

fill_basic(&fs->wh);

tools/tools/net80211/wesside/wesside/wesside.c

1775

memset(fs->wh.i_addr3, 0xff, 6);

tools/tools/net80211/wesside/wesside/wesside.c

1776

fs->wh.i_fc[0] |= IEEE80211_FC0_TYPE_DATA;

tools/tools/net80211/wesside/wesside/wesside.c

1777

fs->wh.i_fc[1] |= IEEE80211_FC1_DIR_TODS |

tools/tools/net80211/wesside/wesside/wesside.c

1781

memset(&fs->data[8+8+20], 0, pad);

usr.bin/compress/compress.c

339

setfile(const char *name, struct stat *fs)

usr.bin/compress/compress.c

343

fs->st_mode &= S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO;

usr.bin/compress/compress.c

345

TIMESPEC_TO_TIMEVAL(&tv[0], &fs->st_atimespec);

usr.bin/compress/compress.c

346

TIMESPEC_TO_TIMEVAL(&tv[1], &fs->st_mtimespec);

usr.bin/compress/compress.c

356

if (chown(name, fs->st_uid, fs->st_gid)) {

usr.bin/compress/compress.c

359

fs->st_mode &= ~(S_ISUID|S_ISGID);

usr.bin/compress/compress.c

361

if (chmod(name, fs->st_mode) && errno != EOPNOTSUPP)

usr.bin/compress/compress.c

364

if (chflags(name, fs->st_flags) && errno != EOPNOTSUPP)

usr.bin/evtranalyze/evtranalyze.c

556

double x, w, fs, y, height;

usr.bin/evtranalyze/evtranalyze.c

597

fs = fontsize_for_rect(height, w, textlen);

usr.bin/evtranalyze/evtranalyze.c

599

fs);

usr.bin/evtranalyze/evtranalyze.c

743

double y, height, fs;

usr.bin/evtranalyze/evtranalyze.c

764

fs = fontsize_for_rect(height, 100.0, textlen);

usr.bin/evtranalyze/evtranalyze.c

768

comm, fs);

usr.bin/hexdump/display.c

152

FS *fs;

usr.bin/hexdump/display.c

161

for (fs = fshead, savebp = bp, saveaddress = address; fs;

usr.bin/hexdump/display.c

162

fs = fs->nextfs, bp = savebp, address = saveaddress)

usr.bin/hexdump/display.c

163

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

146

size(FS *fs)

usr.bin/hexdump/parse.c

154

for (cursize = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

199

rewrite(FS *fs)

usr.bin/hexdump/parse.c

208

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

416

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

417

if (!fu->nextfu && fs->bcnt < blocksize &&

usr.bin/hexdump/parse.c

419

fu->reps += (blocksize - fs->bcnt) / fu->bcnt;

usr.bin/hexdump/parse.c

431

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/quota/quota.c

434

struct fstab *fs;

usr.bin/quota/quota.c

466

if ((fs = getfsspec(fst[i].f_mntfromname)) == NULL)

usr.bin/quota/quota.c

468

if (getufsquota(fs, qup, id, quotatype) == 0)

usr.bin/quota/quota.c

491

ufshasquota(struct fstab *fs, int type, char **qfnamep)

usr.bin/quota/quota.c

502

strcpy(buf, fs->fs_mntops);

usr.bin/quota/quota.c

517

sprintf(buf, "%s/%s.%s", fs->fs_file, qfname, qfextension[type]);

usr.bin/quota/quota.c

523

getufsquota(struct fstab *fs, struct quotause *qup, long id, int quotatype)

usr.bin/quota/quota.c

529

if (!ufshasquota(fs, quotatype, &qfpathname))

usr.bin/quota/quota.c

532

if (quotactl(fs->fs_file, qcmd, id, (char *)&qup->dqblk) != 0) {

usr.sbin/edquota/edquota.c

321

struct fstab *fs;

usr.sbin/edquota/edquota.c

331

while ((fs = getfsent())) {

usr.sbin/edquota/edquota.c

332

if (fspath && *fspath && strcmp(fspath, fs->fs_spec) &&

usr.sbin/edquota/edquota.c

333

strcmp(fspath, fs->fs_file))

usr.sbin/edquota/edquota.c

335

if (strcmp(fs->fs_vfstype, "ufs"))

usr.sbin/edquota/edquota.c

337

if (!hasquota(fs, quotatype, &qfpathname))

usr.sbin/edquota/edquota.c

342

if (quotactl(fs->fs_file, qcmd, id, &qup->dqblk) != 0) {

usr.sbin/edquota/edquota.c

384

strcpy(qup->fsname, fs->fs_file);

usr.sbin/edquota/edquota.c

782

hasquota(struct fstab *fs, int type, char **qfnamep)

usr.sbin/edquota/edquota.c

794

strcpy(buf, fs->fs_mntops);

usr.sbin/edquota/edquota.c

809

sprintf(buf, "%s/%s.%s", fs->fs_file, qfname, qfextension[type]);

usr.sbin/fstyp/ext2fs.c

55

e2sb_t *fs;

usr.sbin/fstyp/ext2fs.c

58

fs = (e2sb_t *)read_buf(fp, EXT2FS_SB_OFFSET, 512);

usr.sbin/fstyp/ext2fs.c

59

if (fs == NULL)

usr.sbin/fstyp/ext2fs.c

63

if (fs->s_magic == EXT2_SUPER_MAGIC &&

usr.sbin/fstyp/ext2fs.c

64

fs->s_rev_level == EXT2_DYNAMIC_REV) {

usr.sbin/fstyp/ext2fs.c

68

free(fs);

usr.sbin/fstyp/ext2fs.c

72

s_volume_name = fs->s_volume_name;

usr.sbin/fstyp/ext2fs.c

74

s_volume_name[sizeof(fs->s_volume_name) - 1] = '\0';

usr.sbin/fstyp/ext2fs.c

80

free(fs);

usr.sbin/fstyp/ufs.c

102

free(fs);

usr.sbin/fstyp/ufs.c

110

fs->fs_ncg < 1 ||

usr.sbin/fstyp/ufs.c

111

fs->fs_bsize < MINBSIZE ||

usr.sbin/fstyp/ufs.c

112

(size_t)fs->fs_bsize < sizeof(struct fs)) {

usr.sbin/fstyp/ufs.c

113

free(fs);

usr.sbin/fstyp/ufs.c

117

strlcpy(label, fs->fs_volname, labelsize);

usr.sbin/fstyp/ufs.c

119

free(fs);

usr.sbin/fstyp/ufs.c

64

struct fs *fs;

usr.sbin/fstyp/ufs.c

74

fs = (struct fs *)read_buf(fp, superblock, SBLOCKSIZE);

usr.sbin/fstyp/ufs.c

75

if (fs == NULL)

usr.sbin/fstyp/ufs.c

84

if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_fsize > 0 &&

usr.sbin/fstyp/ufs.c

85

((pp->mediasize / fs->fs_fsize == fs->fs_old_size) ||

usr.sbin/fstyp/ufs.c

86

(pp->mediasize / fs->fs_fsize == fs->fs_providersize))) {

usr.sbin/fstyp/ufs.c

88

} else if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_fsize > 0 &&

usr.sbin/fstyp/ufs.c

89

((pp->mediasize / fs->fs_fsize == fs->fs_size) ||

usr.sbin/fstyp/ufs.c

90

(pp->mediasize / fs->fs_fsize == fs->fs_providersize))) {

usr.sbin/fstyp/ufs.c

93

g_free(fs);

usr.sbin/fstyp/ufs.c

97

if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_fsize > 0) {

usr.sbin/fstyp/ufs.c

99

} else if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_fsize > 0) {

usr.sbin/fwcontrol/fwdv.c

188

systype = ciph->fdf.dv.fs;

usr.sbin/makefs/ffs.c

1134

struct fs *fs;

usr.sbin/makefs/ffs.c

1151

fs = (struct fs *)fsopts->superblock;

usr.sbin/makefs/ffs.c

1152

cg = ino_to_cg(fs, ino);

usr.sbin/makefs/ffs.c

1153

cgino = ino % fs->fs_ipg;

usr.sbin/makefs/ffs.c

1158

ffs_rdfs(fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize, &sbbuf,

usr.sbin/makefs/ffs.c

1166

buf = emalloc(fs->fs_bsize);

usr.sbin/makefs/ffs.c

1172

if (fs->fs_cstotal.cs_nifree == 0)

usr.sbin/makefs/ffs.c

1175

if (fs->fs_cs(fs, cg).cs_nifree == 0)

usr.sbin/makefs/ffs.c

1181

fs->fs_cstotal.cs_nifree--;

usr.sbin/makefs/ffs.c

1182

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

usr.sbin/makefs/ffs.c

1185

fs->fs_cstotal.cs_ndir++;

usr.sbin/makefs/ffs.c

1186

fs->fs_cs(fs, cg).cs_ndir++;

usr.sbin/makefs/ffs.c

1194

while (ffs_opts->version == 2 && cgino + INOPB(fs) > initediblk &&

usr.sbin/makefs/ffs.c

1196

memset(buf, 0, fs->fs_bsize);

usr.sbin/makefs/ffs.c

1198

for (i = 0; i < INOPB(fs); i++) {

usr.sbin/makefs/ffs.c

1202

ffs_wtfs(fsbtodb(fs, ino_to_fsba(fs,

usr.sbin/makefs/ffs.c

1203

cg * fs->fs_ipg + initediblk)),

usr.sbin/makefs/ffs.c

1204

fs->fs_bsize, buf, fsopts);

usr.sbin/makefs/ffs.c

1205

initediblk += INOPB(fs);

usr.sbin/makefs/ffs.c

1211

ffs_wtfs(fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize, &sbbuf,

usr.sbin/makefs/ffs.c

1215

d = fsbtodb(fs, ino_to_fsba(fs, ino));

usr.sbin/makefs/ffs.c

1216

ffs_rdfs(d, fs->fs_bsize, buf, fsopts);

usr.sbin/makefs/ffs.c

1220

&dp1[ino_to_fsbo(fs, ino)]);

usr.sbin/makefs/ffs.c

1224

&dp2[ino_to_fsbo(fs, ino)]);

usr.sbin/makefs/ffs.c

1228

dp1[ino_to_fsbo(fs, ino)] = dp->ffs1_din;

usr.sbin/makefs/ffs.c

1231

dp2[ino_to_fsbo(fs, ino)] = dp->ffs2_din;

usr.sbin/makefs/ffs.c

1234

ffs_wtfs(d, fs->fs_bsize, buf, fsopts);

usr.sbin/makefs/ffs.c

273

struct fs *superblock;

usr.sbin/makefs/ffs.c

477

ffs_opt_t *fs = f->fs_specific;

usr.sbin/makefs/ffs.c

493

fs->bsize, fs->fsize, fs->cpg, fs->density);

usr.sbin/makefs/ffs.c

495

fs->nsectors, fs->rpm, fs->minfree);

usr.sbin/makefs/ffs.c

497

fs->maxcontig, fs->maxbpg);

usr.sbin/makefs/ffs.c

499

fs->optimization == FS_OPTSPACE ? "space" : "time");

usr.sbin/makefs/ffs.c

509

struct fs *fs;

usr.sbin/makefs/ffs.c

588

fs = ffs_mkfs(image, fsopts, tstamp);

usr.sbin/makefs/ffs.c

589

fsopts->superblock = (void *)fs;

usr.sbin/makefs/ffs.c

593

t = (time_t)((struct fs *)fsopts->superblock)->fs_time;

usr.sbin/makefs/ffs.c

597

(long long)fs->fs_cstotal.cs_nbfree,

usr.sbin/makefs/ffs.c

598

(long long)fs->fs_cstotal.cs_nffree,

usr.sbin/makefs/ffs.c

599

(long long)fs->fs_cstotal.cs_nifree,

usr.sbin/makefs/ffs.c

600

(long long)fs->fs_cstotal.cs_ndir);

usr.sbin/makefs/ffs.c

603

if (fs->fs_cstotal.cs_nifree + (off_t)UFS_ROOTINO < fsopts->inodes) {

usr.sbin/makefs/ffs.c

607

(long long)(fs->fs_cstotal.cs_nifree + UFS_ROOTINO),

usr.sbin/makefs/ffs.c

944

struct m_vnode vp = { .fs = fsopts };

usr.sbin/makefs/ffs.c

956

in.i_fs = (struct fs *)fsopts->superblock;

usr.sbin/makefs/ffs.h

124

#define FBSD_CGSIZE(fs) \

usr.sbin/makefs/ffs.h

126

/* old btotoff */ (fs)->fs_cpg * sizeof(int32_t) + \

usr.sbin/makefs/ffs.h

127

/* old boff */ (fs)->fs_cpg * sizeof(u_int16_t) + \

usr.sbin/makefs/ffs.h

128

/* inode map */ howmany((fs)->fs_ipg, NBBY) + \

usr.sbin/makefs/ffs.h

129

/* block map */ howmany((fs)->fs_fpg, NBBY) +\

usr.sbin/makefs/ffs.h

130

/* if present */ ((fs)->fs_contigsumsize <= 0 ? 0 : \

usr.sbin/makefs/ffs.h

131

/* cluster sum */ (fs)->fs_contigsumsize * sizeof(int32_t) + \

usr.sbin/makefs/ffs.h

132

/* cluster map */ howmany(fragstoblks(fs, (fs)->fs_fpg), NBBY)))

usr.sbin/makefs/ffs/buf.c

134

fsinfo_t *fs = bp->b_fs;

usr.sbin/makefs/ffs/buf.c

137

offset = (off_t)bp->b_blkno * fs->sectorsize + fs->offset;

usr.sbin/makefs/ffs/buf.c

225

bp->b_fs = vp->fs;

usr.sbin/makefs/ffs/buf.c

65

fsinfo_t *fs = vp->fs;

usr.sbin/makefs/ffs/buf.c

73

offset = (off_t)(*bpp)->b_blkno * fs->sectorsize + fs->offset;

usr.sbin/makefs/ffs/buf.h

55

struct makefs_fsinfo *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

101

if (size > fs->fs_bsize || fragoff(fs, size) != 0) {

usr.sbin/makefs/ffs/ffs_alloc.c

103

fs->fs_bsize, size);

usr.sbin/makefs/ffs/ffs_alloc.c

105

if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)

usr.sbin/makefs/ffs/ffs_alloc.c

107

if (bpref >= fs->fs_size)

usr.sbin/makefs/ffs/ffs_alloc.c

110

cg = ino_to_cg(fs, ip->i_number);

usr.sbin/makefs/ffs/ffs_alloc.c

112

cg = dtog(fs, bpref);

usr.sbin/makefs/ffs/ffs_alloc.c

158

struct fs *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

162

fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

163

if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {

usr.sbin/makefs/ffs/ffs_alloc.c

164

if (lbn < UFS_NDADDR + NINDIR(fs)) {

usr.sbin/makefs/ffs/ffs_alloc.c

165

cg = ino_to_cg(fs, ip->i_number);

usr.sbin/makefs/ffs/ffs_alloc.c

166

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

174

ino_to_cg(fs, ip->i_number) + lbn / fs->fs_maxbpg;

usr.sbin/makefs/ffs/ffs_alloc.c

176

startcg = dtog(fs,

usr.sbin/makefs/ffs/ffs_alloc.c

177

ufs_rw32(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + 1);

usr.sbin/makefs/ffs/ffs_alloc.c

178

startcg %= fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

179

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

180

for (cg = startcg; cg < fs->fs_ncg; cg++)

usr.sbin/makefs/ffs/ffs_alloc.c

181

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree)

usr.sbin/makefs/ffs/ffs_alloc.c

182

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

184

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree)

usr.sbin/makefs/ffs/ffs_alloc.c

185

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

191

return ufs_rw32(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + fs->fs_frag;

usr.sbin/makefs/ffs/ffs_alloc.c

198

struct fs *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

202

fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

203

if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {

usr.sbin/makefs/ffs/ffs_alloc.c

204

if (lbn < UFS_NDADDR + NINDIR(fs)) {

usr.sbin/makefs/ffs/ffs_alloc.c

205

cg = ino_to_cg(fs, ip->i_number);

usr.sbin/makefs/ffs/ffs_alloc.c

206

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

214

ino_to_cg(fs, ip->i_number) + lbn / fs->fs_maxbpg;

usr.sbin/makefs/ffs/ffs_alloc.c

216

startcg = dtog(fs,

usr.sbin/makefs/ffs/ffs_alloc.c

217

ufs_rw64(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + 1);

usr.sbin/makefs/ffs/ffs_alloc.c

218

startcg %= fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

219

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

220

for (cg = startcg; cg < fs->fs_ncg; cg++)

usr.sbin/makefs/ffs/ffs_alloc.c

221

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

usr.sbin/makefs/ffs/ffs_alloc.c

222

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

225

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

usr.sbin/makefs/ffs/ffs_alloc.c

226

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

233

return ufs_rw64(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + fs->fs_frag;

usr.sbin/makefs/ffs/ffs_alloc.c

252

struct fs *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

256

fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

266

for (i = 1; i < fs->fs_ncg; i *= 2) {

usr.sbin/makefs/ffs/ffs_alloc.c

268

if (cg >= fs->fs_ncg)

usr.sbin/makefs/ffs/ffs_alloc.c

269

cg -= fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

279

cg = (icg + 2) % fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

280

for (i = 2; i < fs->fs_ncg; i++) {

usr.sbin/makefs/ffs/ffs_alloc.c

285

if (cg == fs->fs_ncg)

usr.sbin/makefs/ffs/ffs_alloc.c

304

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

305

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

307

if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)

usr.sbin/makefs/ffs/ffs_alloc.c

309

error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize,

usr.sbin/makefs/ffs/ffs_alloc.c

317

(cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize)) {

usr.sbin/makefs/ffs/ffs_alloc.c

321

if (size == fs->fs_bsize) {

usr.sbin/makefs/ffs/ffs_alloc.c

331

frags = numfrags(fs, size);

usr.sbin/makefs/ffs/ffs_alloc.c

332

for (allocsiz = frags; allocsiz < fs->fs_frag; allocsiz++)

usr.sbin/makefs/ffs/ffs_alloc.c

335

if (allocsiz == fs->fs_frag) {

usr.sbin/makefs/ffs/ffs_alloc.c

345

bpref = dtogd(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

346

for (i = frags; i < fs->fs_frag; i++)

usr.sbin/makefs/ffs/ffs_alloc.c

348

i = fs->fs_frag - frags;

usr.sbin/makefs/ffs/ffs_alloc.c

350

fs->fs_cstotal.cs_nffree += i;

usr.sbin/makefs/ffs/ffs_alloc.c

351

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

usr.sbin/makefs/ffs/ffs_alloc.c

352

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

357

bno = ffs_mapsearch(fs, cgp, bpref, allocsiz);

usr.sbin/makefs/ffs/ffs_alloc.c

361

fs->fs_cstotal.cs_nffree -= frags;

usr.sbin/makefs/ffs/ffs_alloc.c

362

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

usr.sbin/makefs/ffs/ffs_alloc.c

363

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

367

blkno = cg * fs->fs_fpg + bno;

usr.sbin/makefs/ffs/ffs_alloc.c

389

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

390

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

395

if (bpref == 0 || (uint32_t)dtog(fs, bpref) != ufs_rw32(cgp->cg_cgx, needswap)) {

usr.sbin/makefs/ffs/ffs_alloc.c

398

bpref = blknum(fs, bpref);

usr.sbin/makefs/ffs/ffs_alloc.c

399

bno = dtogd(fs, bpref);

usr.sbin/makefs/ffs/ffs_alloc.c

403

if (ffs_isblock(fs, blksfree_swap, fragstoblks(fs, bno)))

usr.sbin/makefs/ffs/ffs_alloc.c

409

bno = ffs_mapsearch(fs, cgp, bpref, (int)fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

414

blkno = fragstoblks(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

415

ffs_clrblock(fs, blksfree_swap, (long)blkno);

usr.sbin/makefs/ffs/ffs_alloc.c

416

ffs_clusteracct(fs, cgp, blkno, -1);

usr.sbin/makefs/ffs/ffs_alloc.c

418

fs->fs_cstotal.cs_nbfree--;

usr.sbin/makefs/ffs/ffs_alloc.c

419

fs->fs_cs(fs, ufs_rw32(cgp->cg_cgx, needswap)).cs_nbfree--;

usr.sbin/makefs/ffs/ffs_alloc.c

421

cg_blks(fs, cgp, cbtocylno(fs, bno))[cbtorpos(fs, bno)]--;

usr.sbin/makefs/ffs/ffs_alloc.c

422

cg_blktot(cgp)[cbtocylno(fs, bno)]--;

usr.sbin/makefs/ffs/ffs_alloc.c

424

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

425

blkno = ufs_rw32(cgp->cg_cgx, needswap) * fs->fs_fpg + bno;

usr.sbin/makefs/ffs/ffs_alloc.c

443

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

444

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

446

if (size > fs->fs_bsize || fragoff(fs, size) != 0 ||

usr.sbin/makefs/ffs/ffs_alloc.c

447

fragnum(fs, bno) + numfrags(fs, size) > fs->fs_frag) {

usr.sbin/makefs/ffs/ffs_alloc.c

449

(long long)bno, fs->fs_bsize, size);

usr.sbin/makefs/ffs/ffs_alloc.c

451

cg = dtog(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

452

if (bno >= fs->fs_size) {

usr.sbin/makefs/ffs/ffs_alloc.c

457

error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize,

usr.sbin/makefs/ffs/ffs_alloc.c

468

cgbno = dtogd(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

469

if (size == fs->fs_bsize) {

usr.sbin/makefs/ffs/ffs_alloc.c

470

fragno = fragstoblks(fs, cgbno);

usr.sbin/makefs/ffs/ffs_alloc.c

471

if (!ffs_isfreeblock(fs, cg_blksfree_swap(cgp, needswap), fragno)) {

usr.sbin/makefs/ffs/ffs_alloc.c

475

ffs_setblock(fs, cg_blksfree_swap(cgp, needswap), fragno);

usr.sbin/makefs/ffs/ffs_alloc.c

476

ffs_clusteracct(fs, cgp, fragno, 1);

usr.sbin/makefs/ffs/ffs_alloc.c

478

fs->fs_cstotal.cs_nbfree++;

usr.sbin/makefs/ffs/ffs_alloc.c

479

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

usr.sbin/makefs/ffs/ffs_alloc.c

481

cg_blks(fs, cgp, cbtocylno(fs, bno))[cbtorpos(fs, bno)]++;

usr.sbin/makefs/ffs/ffs_alloc.c

482

cg_blktot(cgp)[cbtocylno(fs, bno)]++;

usr.sbin/makefs/ffs/ffs_alloc.c

485

bbase = cgbno - fragnum(fs, cgbno);

usr.sbin/makefs/ffs/ffs_alloc.c

489

blk = blkmap(fs, cg_blksfree_swap(cgp, needswap), bbase);

usr.sbin/makefs/ffs/ffs_alloc.c

490

ffs_fragacct_swap(fs, blk, cgp->cg_frsum, -1, needswap);

usr.sbin/makefs/ffs/ffs_alloc.c

494

frags = numfrags(fs, size);

usr.sbin/makefs/ffs/ffs_alloc.c

503

fs->fs_cstotal.cs_nffree += i;

usr.sbin/makefs/ffs/ffs_alloc.c

504

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

usr.sbin/makefs/ffs/ffs_alloc.c

508

blk = blkmap(fs, cg_blksfree_swap(cgp, needswap), bbase);

usr.sbin/makefs/ffs/ffs_alloc.c

509

ffs_fragacct_swap(fs, blk, cgp->cg_frsum, 1, needswap);

usr.sbin/makefs/ffs/ffs_alloc.c

513

fragno = fragstoblks(fs, bbase);

usr.sbin/makefs/ffs/ffs_alloc.c

514

if (ffs_isblock(fs, cg_blksfree_swap(cgp, needswap), fragno)) {

usr.sbin/makefs/ffs/ffs_alloc.c

515

ufs_add32(cgp->cg_cs.cs_nffree, -fs->fs_frag, needswap);

usr.sbin/makefs/ffs/ffs_alloc.c

516

fs->fs_cstotal.cs_nffree -= fs->fs_frag;

usr.sbin/makefs/ffs/ffs_alloc.c

517

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

usr.sbin/makefs/ffs/ffs_alloc.c

518

ffs_clusteracct(fs, cgp, fragno, 1);

usr.sbin/makefs/ffs/ffs_alloc.c

520

fs->fs_cstotal.cs_nbfree++;

usr.sbin/makefs/ffs/ffs_alloc.c

521

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

usr.sbin/makefs/ffs/ffs_alloc.c

523

cg_blks(fs, cgp,

usr.sbin/makefs/ffs/ffs_alloc.c

524

cbtocylno(fs, bbase))[cbtorpos(fs, bbase)]++;

usr.sbin/makefs/ffs/ffs_alloc.c

525

cg_blktot(cgp)[cbtocylno(fs, bbase)]++;

usr.sbin/makefs/ffs/ffs_alloc.c

529

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

551

ffs_mapsearch(struct fs *fs, struct cg *cgp, makefs_daddr_t bpref, int allocsiz)

usr.sbin/makefs/ffs/ffs_alloc.c

557

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

564

start = dtogd(fs, bpref) / NBBY;

usr.sbin/makefs/ffs/ffs_alloc.c

567

len = howmany(fs->fs_fpg, NBBY) - start;

usr.sbin/makefs/ffs/ffs_alloc.c

572

(const u_char *)fragtbl[fs->fs_frag],

usr.sbin/makefs/ffs/ffs_alloc.c

573

(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

usr.sbin/makefs/ffs/ffs_alloc.c

579

(const u_char *)fragtbl[fs->fs_frag],

usr.sbin/makefs/ffs/ffs_alloc.c

580

(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

usr.sbin/makefs/ffs/ffs_alloc.c

596

for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {

usr.sbin/makefs/ffs/ffs_alloc.c

597

blk = blkmap(fs, cg_blksfree_swap(cgp, needswap), bno);

usr.sbin/makefs/ffs/ffs_alloc.c

601

for (pos = 0; pos <= fs->fs_frag - allocsiz; pos++) {

usr.sbin/makefs/ffs/ffs_alloc.c

618

ffs_clusteracct(struct fs *fs, struct cg *cgp, int32_t blkno, int cnt)

usr.sbin/makefs/ffs/ffs_alloc.c

624

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

626

if (fs->fs_contigsumsize <= 0)

usr.sbin/makefs/ffs/ffs_alloc.c

641

end = start + fs->fs_contigsumsize;

usr.sbin/makefs/ffs/ffs_alloc.c

662

end = start - fs->fs_contigsumsize;

usr.sbin/makefs/ffs/ffs_alloc.c

684

if (i > fs->fs_contigsumsize)

usr.sbin/makefs/ffs/ffs_alloc.c

685

i = fs->fs_contigsumsize;

usr.sbin/makefs/ffs/ffs_alloc.c

695

lp = &sump[fs->fs_contigsumsize];

usr.sbin/makefs/ffs/ffs_alloc.c

696

for (i = fs->fs_contigsumsize; i > 0; i--)

usr.sbin/makefs/ffs/ffs_alloc.c

699

fs->fs_maxcluster[ufs_rw32(cgp->cg_cgx, needswap)] = i;

usr.sbin/makefs/ffs/ffs_alloc.c

71

static int32_t ffs_mapsearch(struct fs *, struct cg *, makefs_daddr_t, int);

usr.sbin/makefs/ffs/ffs_alloc.c

96

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_balloc.c

103

assert(size <= fs->fs_bsize);

usr.sbin/makefs/ffs/ffs_balloc.c

113

lastlbn = lblkno(fs, ip->i_ffs1_size);

usr.sbin/makefs/ffs/ffs_balloc.c

116

osize = blksize(fs, ip, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

117

if (osize < fs->fs_bsize && osize > 0) {

usr.sbin/makefs/ffs/ffs_balloc.c

130

(uint64_t)lblktosize(fs, lbn + 1)) {

usr.sbin/makefs/ffs/ffs_balloc.c

140

error = bread(ip->i_devvp, lbn, fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

155

osize = fragroundup(fs, blkoff(fs, ip->i_ffs1_size));

usr.sbin/makefs/ffs/ffs_balloc.c

156

nsize = fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

185

if (ip->i_ffs1_size < (uint64_t)lblktosize(fs, lbn + 1))

usr.sbin/makefs/ffs/ffs_balloc.c

186

nsize = fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

188

nsize = fs->fs_bsize;

usr.sbin/makefs/ffs/ffs_balloc.c

197

bp->b_blkno = fsbtodb(fs, newb);

usr.sbin/makefs/ffs/ffs_balloc.c

229

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

234

bp = getblk(ip->i_devvp, indirs[1].in_lbn, fs->fs_bsize, 0, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

235

bp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

252

error = bread(ip->i_devvp, indirs[i].in_lbn, fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

269

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

276

nbp = getblk(ip->i_devvp, indirs[i].in_lbn, fs->fs_bsize, 0, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

277

nbp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

299

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

307

nbp = getblk(ip->i_devvp, lbn, fs->fs_bsize, 0, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

308

nbp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

323

error = bread(ip->i_devvp, lbn, (int)fs->fs_bsize, NULL, &nbp);

usr.sbin/makefs/ffs/ffs_balloc.c

340

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_balloc.c

347

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_balloc.c

349

lbn = lblkno(fs, offset);

usr.sbin/makefs/ffs/ffs_balloc.c

350

size = blkoff(fs, offset) + bufsize;

usr.sbin/makefs/ffs/ffs_balloc.c

355

assert(size <= fs->fs_bsize);

usr.sbin/makefs/ffs/ffs_balloc.c

365

lastlbn = lblkno(fs, ip->i_ffs2_size);

usr.sbin/makefs/ffs/ffs_balloc.c

368

osize = blksize(fs, ip, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

369

if (osize < fs->fs_bsize && osize > 0) {

usr.sbin/makefs/ffs/ffs_balloc.c

382

(uint64_t)lblktosize(fs, lbn + 1)) {

usr.sbin/makefs/ffs/ffs_balloc.c

392

error = bread(ip->i_devvp, lbn, fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

407

osize = fragroundup(fs, blkoff(fs, ip->i_ffs2_size));

usr.sbin/makefs/ffs/ffs_balloc.c

408

nsize = fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

437

if (ip->i_ffs2_size < (uint64_t)lblktosize(fs, lbn + 1))

usr.sbin/makefs/ffs/ffs_balloc.c

438

nsize = fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

440

nsize = fs->fs_bsize;

usr.sbin/makefs/ffs/ffs_balloc.c

449

bp->b_blkno = fsbtodb(fs, newb);

usr.sbin/makefs/ffs/ffs_balloc.c

481

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

486

bp = getblk(ip->i_devvp, indirs[1].in_lbn, fs->fs_bsize, 0, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

487

bp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

504

error = bread(ip->i_devvp, indirs[i].in_lbn, fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

521

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

528

nbp = getblk(ip->i_devvp, indirs[i].in_lbn, fs->fs_bsize, 0, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

529

nbp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

551

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

559

nbp = getblk(ip->i_devvp, lbn, fs->fs_bsize, 0, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

560

nbp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

575

error = bread(ip->i_devvp, lbn, (int)fs->fs_bsize, NULL, &nbp);

usr.sbin/makefs/ffs/ffs_balloc.c

88

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_balloc.c

95

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_balloc.c

97

lbn = lblkno(fs, offset);

usr.sbin/makefs/ffs/ffs_balloc.c

98

size = blkoff(fs, offset) + bufsize;

usr.sbin/makefs/ffs/ffs_bswap.c

204

ffs_cg_swap(struct cg *o, struct cg *n, struct fs *fs)

usr.sbin/makefs/ffs/ffs_bswap.c

243

if (fs->fs_magic == FS_UFS2_MAGIC)

usr.sbin/makefs/ffs/ffs_bswap.c

261

for (i = 0; i < fs->fs_old_cpg; i++)

usr.sbin/makefs/ffs/ffs_bswap.c

264

for (i = 0; i < fs->fs_old_cpg * fs->fs_old_nrpos; i++)

usr.sbin/makefs/ffs/ffs_bswap.c

269

for (i = 1; i < fs->fs_contigsumsize + 1; i++)

usr.sbin/makefs/ffs/ffs_bswap.c

68

ffs_sb_swap(struct fs *o, struct fs *n)

usr.sbin/makefs/ffs/ffs_bswap.c

80

for (i = 0; i < offsetof(struct fs, fs_fmod) / sizeof(u_int32_t); i++)

usr.sbin/makefs/ffs/ffs_extern.h

61

void ffs_clusteracct(struct fs *, struct cg *, int32_t, int);

usr.sbin/makefs/ffs/ffs_extern.h

67

void ffs_sb_swap(struct fs*, struct fs *);

usr.sbin/makefs/ffs/ffs_extern.h

73

void ffs_cg_swap(struct cg *, struct cg *, struct fs *);

usr.sbin/makefs/ffs/ffs_extern.h

76

void ffs_fragacct(struct fs *, int, int32_t[], int, int);

usr.sbin/makefs/ffs/ffs_extern.h

77

int ffs_isblock(struct fs *, u_char *, int32_t);

usr.sbin/makefs/ffs/ffs_extern.h

78

int ffs_isfreeblock(struct fs *, u_char *, int32_t);

usr.sbin/makefs/ffs/ffs_extern.h

79

void ffs_clrblock(struct fs *, u_char *, int32_t);

usr.sbin/makefs/ffs/ffs_extern.h

80

void ffs_setblock(struct fs *, u_char *, int32_t);

usr.sbin/makefs/ffs/ffs_subr.c

104

(int)fs->fs_fragshift);

usr.sbin/makefs/ffs/ffs_subr.c

114

ffs_isfreeblock(struct fs *fs, u_char *cp, int32_t h)

usr.sbin/makefs/ffs/ffs_subr.c

117

switch ((int)fs->fs_fragshift) {

usr.sbin/makefs/ffs/ffs_subr.c

128

(int)fs->fs_fragshift);

usr.sbin/makefs/ffs/ffs_subr.c

136

ffs_clrblock(struct fs *fs, u_char *cp, int32_t h)

usr.sbin/makefs/ffs/ffs_subr.c

139

switch ((int)fs->fs_fragshift) {

usr.sbin/makefs/ffs/ffs_subr.c

154

(int)fs->fs_fragshift);

usr.sbin/makefs/ffs/ffs_subr.c

162

ffs_setblock(struct fs *fs, u_char *cp, int32_t h)

usr.sbin/makefs/ffs/ffs_subr.c

165

switch ((int)fs->fs_fragshift) {

usr.sbin/makefs/ffs/ffs_subr.c

180

(int)fs->fs_fragshift);

usr.sbin/makefs/ffs/ffs_subr.c

50

ffs_fragacct_swap(struct fs *fs, int fragmap, uint32_t fraglist[], int cnt, int needswap)

usr.sbin/makefs/ffs/ffs_subr.c

56

inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1;

usr.sbin/makefs/ffs/ffs_subr.c

58

for (siz = 1; siz < fs->fs_frag; siz++) {

usr.sbin/makefs/ffs/ffs_subr.c

59

if ((inblk & (1 << (siz + (fs->fs_frag & (NBBY - 1))))) == 0)

usr.sbin/makefs/ffs/ffs_subr.c

63

for (pos = siz; pos <= fs->fs_frag; pos++) {

usr.sbin/makefs/ffs/ffs_subr.c

86

ffs_isblock(struct fs *fs, u_char *cp, int32_t h)

usr.sbin/makefs/ffs/ffs_subr.c

90

switch ((int)fs->fs_fragshift) {

usr.sbin/makefs/ffs/mkfs.c

117

struct fs *

usr.sbin/makefs/ffs/mkfs.c

486

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

usr.sbin/makefs/ffs/mkfs.c

573

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

usr.sbin/makefs/ffs/mkfs.c

611

ffs_write_superblock(struct fs *fs, const fsinfo_t *fsopts)

usr.sbin/makefs/ffs/mkfs.c

618

saveflag = fs->fs_flags & FS_INTERNAL;

usr.sbin/makefs/ffs/mkfs.c

619

fs->fs_flags &= ~FS_INTERNAL;

usr.sbin/makefs/ffs/mkfs.c

623

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

usr.sbin/makefs/ffs/mkfs.c

625

ffs_wtfs(fs->fs_sblockloc / sectorsize, sbsize, writebuf, fsopts);

usr.sbin/makefs/ffs/mkfs.c

631

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

usr.sbin/makefs/ffs/mkfs.c

632

ffs_wtfs(fsbtodb(fs, cgsblock(fs, cylno)),

usr.sbin/makefs/ffs/mkfs.c

636

size = fs->fs_cssize;

usr.sbin/makefs/ffs/mkfs.c

637

blks = howmany(size, fs->fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

638

space = (void *)fs->fs_csp;

usr.sbin/makefs/ffs/mkfs.c

640

for (i = 0; i < blks; i+= fs->fs_frag) {

usr.sbin/makefs/ffs/mkfs.c

641

size = fs->fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

642

if (i + fs->fs_frag > blks)

usr.sbin/makefs/ffs/mkfs.c

643

size = (blks - i) * fs->fs_fsize;

usr.sbin/makefs/ffs/mkfs.c

649

ffs_wtfs(fsbtodb(fs, fs->fs_csaddr + i), size, wrbuf, fsopts);

usr.sbin/makefs/ffs/mkfs.c

653

fs->fs_flags |= saveflag;

usr.sbin/makefs/ffs/mkfs.c

82

struct fs fs;

usr.sbin/makefs/ffs/mkfs.c

85

#define sblock fsun.fs

usr.sbin/makefs/ffs/newfs_extern.h

33

struct fs *ffs_mkfs(const char *, const fsinfo_t *, time_t);

usr.sbin/makefs/ffs/newfs_extern.h

34

void ffs_write_superblock(struct fs *, const fsinfo_t *);

usr.sbin/makefs/ffs/ufs_bswap.h

45

#define UFS_FSNEEDSWAP(fs) ((fs)->fs_flags & FS_SWAPPED)

usr.sbin/makefs/ffs/ufs_bswap.h

49

#define UFS_FSNEEDSWAP(fs) (0)

usr.sbin/makefs/ffs/ufs_inode.h

53

struct fs *i_fs; /* File system */

usr.sbin/makefs/hammer2.c

342

devvp.fs = fsopts;

usr.sbin/makefs/hammer2/hammer2_ioctl.c

1294

if (ioctl(hmp->devvp->fs->fd, DIOCGPART, &part) == 0) {

usr.sbin/makefs/hammer2/hammer2_ioctl.c

1298

} else if (fstat(hmp->devvp->fs->fd, &st) == 0) {

usr.sbin/makefs/hammer2/hammer2_ondisk.c

257

assert(vol->dev->devvp->fs);

usr.sbin/makefs/hammer2/hammer2_ondisk.c

258

if (ioctl(vol->dev->devvp->fs->fd, DIOCGPART, &part) == 0) {

usr.sbin/makefs/hammer2/hammer2_ondisk.c

268

} else if (fstat(vol->dev->devvp->fs->fd, &st) == 0) {

usr.sbin/makefs/hammer2/hammer2_ondisk.c

479

hammer2_off_t size = check_volume(devvp->fs->fd);

usr.sbin/makefs/makefs.h

181

#define DECLARE_FUN(fs) \

usr.sbin/makefs/makefs.h

182

void fs ## _prep_opts(fsinfo_t *); \

usr.sbin/makefs/makefs.h

183

int fs ## _parse_opts(const char *, fsinfo_t *); \

usr.sbin/makefs/makefs.h

184

void fs ## _cleanup_opts(fsinfo_t *); \

usr.sbin/makefs/makefs.h

185

void fs ## _makefs(const char *, const char *, fsnode *, fsinfo_t *)

usr.sbin/makefs/makefs.h

309

struct fs;

usr.sbin/makefs/makefs.h

310

void ffs_fragacct_swap(struct fs *, int, uint32_t [], int, int);

usr.sbin/makefs/msdos.c

184

vp.fs = fsopts;

usr.sbin/quot/quot.c

100

get_inode(int fd, struct fs *super, ino_t ino)

usr.sbin/quot/quot.c

133

virtualblocks(struct fs *super, struct ufs1_dinode *ip)

usr.sbin/quot/quot.c

332

dofsizes(int fd, struct fs *super, char *name)

usr.sbin/quot/quot.c

403

douser(int fd, struct fs *super, char *name)

usr.sbin/quot/quot.c

443

donames(int fd, struct fs *super, char *name)

usr.sbin/quot/quot.c

512

if (((struct fs *)superblock)->fs_magic != FS_MAGIC) {

usr.sbin/quot/quot.c

521

(*func)(fd,(struct fs *)superblock,name);

usr.sbin/quot/quot.c

530

struct fstab *fs;

usr.sbin/quot/quot.c

584

if ((fs = getfsfile(*argv)) != NULL)

usr.sbin/quot/quot.c

585

quot(fs->fs_spec, 0);

usr.sbin/quot/quot.c

59

static void (*func)(int, struct fs *, char *);

usr.sbin/quot/quot.c

64

static struct ufs1_dinode *get_inode(int, struct fs *, ino_t);

usr.sbin/quot/quot.c

65

static int virtualblocks(struct fs *, struct ufs1_dinode *);

usr.sbin/quot/quot.c

73

static void dofsizes(int, struct fs *, char *);

usr.sbin/quot/quot.c

74

static void douser(int, struct fs *, char *);

usr.sbin/quot/quot.c

75

static void donames(int, struct fs *, char *);

usr.sbin/quot/quot.c

96

#define INOCNT(fs) ((fs)->fs_ipg)

usr.sbin/quot/quot.c

97

#define INOSZ(fs) (sizeof(struct ufs1_dinode) * INOCNT(fs))

usr.sbin/quotaon/quotaon.c

108

while ((fs = getfsent()) != NULL) {

usr.sbin/quotaon/quotaon.c

109

if (strcmp(fs->fs_vfstype, "ufs") ||

usr.sbin/quotaon/quotaon.c

110

strcmp(fs->fs_type, FSTAB_RW))

usr.sbin/quotaon/quotaon.c

113

if (gflag && hasquota(fs, GRPQUOTA, &qfnp))

usr.sbin/quotaon/quotaon.c

114

errs += quotaonoff(fs, offmode, GRPQUOTA, qfnp);

usr.sbin/quotaon/quotaon.c

115

if (uflag && hasquota(fs, USRQUOTA, &qfnp))

usr.sbin/quotaon/quotaon.c

116

errs += quotaonoff(fs, offmode, USRQUOTA, qfnp);

usr.sbin/quotaon/quotaon.c

119

if ((argnum = oneof(fs->fs_file, argv, argc)) >= 0 ||

usr.sbin/quotaon/quotaon.c

120

(argnum = oneof(fs->fs_spec, argv, argc)) >= 0) {

usr.sbin/quotaon/quotaon.c

122

if (gflag && hasquota(fs, GRPQUOTA, &qfnp))

usr.sbin/quotaon/quotaon.c

123

errs += quotaonoff(fs, offmode, GRPQUOTA, qfnp);

usr.sbin/quotaon/quotaon.c

124

if (uflag && hasquota(fs, USRQUOTA, &qfnp))

usr.sbin/quotaon/quotaon.c

125

errs += quotaonoff(fs, offmode, USRQUOTA, qfnp);

usr.sbin/quotaon/quotaon.c

147

quotaonoff(struct fstab *fs, int offmode, int type, char *qfpathname)

usr.sbin/quotaon/quotaon.c

149

if (strcmp(fs->fs_file, "/") && readonly(fs))

usr.sbin/quotaon/quotaon.c

152

if (quotactl(fs->fs_file, QCMD(Q_QUOTAOFF, type), 0, 0) < 0) {

usr.sbin/quotaon/quotaon.c

153

warn("%s", fs->fs_file);

usr.sbin/quotaon/quotaon.c

157

printf("%s: quotas turned off\n", fs->fs_file);

usr.sbin/quotaon/quotaon.c

160

if (quotactl(fs->fs_file, QCMD(Q_QUOTAON, type), 0, qfpathname) < 0) {

usr.sbin/quotaon/quotaon.c

162

warn("%s", fs->fs_file);

usr.sbin/quotaon/quotaon.c

166

printf("%s: %s quotas turned on\n", fs->fs_file,

usr.sbin/quotaon/quotaon.c

189

hasquota(struct fstab *fs, int type, char **qfnamep)

usr.sbin/quotaon/quotaon.c

201

strcpy(buf, fs->fs_mntops);

usr.sbin/quotaon/quotaon.c

216

sprintf(buf, "%s/%s.%s", fs->fs_file, qfname, qfextension[type]);

usr.sbin/quotaon/quotaon.c

225

readonly(struct fstab *fs)

usr.sbin/quotaon/quotaon.c

229

if (statfs(fs->fs_file, &fsbuf) < 0 ||

usr.sbin/quotaon/quotaon.c

230

strcmp(fsbuf.f_mntonname, fs->fs_file) ||

usr.sbin/quotaon/quotaon.c

231

strcmp(fsbuf.f_mntfromname, fs->fs_spec)) {

usr.sbin/quotaon/quotaon.c

232

printf("%s: not mounted\n", fs->fs_file);

usr.sbin/quotaon/quotaon.c

236

printf("%s: mounted read-only\n", fs->fs_file);

usr.sbin/quotaon/quotaon.c

62

int quotaonoff(struct fstab *fs, int, int, char *);

usr.sbin/quotaon/quotaon.c

69

struct fstab *fs;

usr.sbin/repquota/repquota.c

141

while ((fs = getfsent()) != NULL) {

usr.sbin/repquota/repquota.c

142

if (strcmp(fs->fs_vfstype, "ufs"))

usr.sbin/repquota/repquota.c

145

if (gflag && hasquota(fs, GRPQUOTA, &qfnp))

usr.sbin/repquota/repquota.c

146

errs += repquota(fs, GRPQUOTA, qfnp);

usr.sbin/repquota/repquota.c

147

if (uflag && hasquota(fs, USRQUOTA, &qfnp))

usr.sbin/repquota/repquota.c

148

errs += repquota(fs, USRQUOTA, qfnp);

usr.sbin/repquota/repquota.c

151

if ((argnum = oneof(fs->fs_file, argv, argc)) >= 0 ||

usr.sbin/repquota/repquota.c

152

(argnum = oneof(fs->fs_spec, argv, argc)) >= 0) {

usr.sbin/repquota/repquota.c

154

if (gflag && hasquota(fs, GRPQUOTA, &qfnp))

usr.sbin/repquota/repquota.c

155

errs += repquota(fs, GRPQUOTA, qfnp);

usr.sbin/repquota/repquota.c

156

if (uflag && hasquota(fs, USRQUOTA, &qfnp))

usr.sbin/repquota/repquota.c

157

errs += repquota(fs, USRQUOTA, qfnp);

usr.sbin/repquota/repquota.c

177

repquota(struct fstab *fs, int type, char *qfpathname)

usr.sbin/repquota/repquota.c

187

if (quotactl(fs->fs_file, QCMD(Q_SYNC, type), 0, 0) < 0 &&

usr.sbin/repquota/repquota.c

197

qfextension[type], fs->fs_file, fs->fs_spec);

usr.sbin/repquota/repquota.c

270

hasquota(struct fstab *fs, int type, char **qfnamep)

usr.sbin/repquota/repquota.c

282

strcpy(buf, fs->fs_mntops);

usr.sbin/repquota/repquota.c

297

sprintf(buf, "%s/%s.%s", fs->fs_file, qfname, qfextension[type]);

usr.sbin/repquota/repquota.c

94

struct fstab *fs;