bin/cp/utils.c

104

struct stat sb, *fs;

bin/cp/utils.c

110

fs = entp->fts_statp;

bin/cp/utils.c

128

if ((sb.st_mode & S_IFMT) != (fs->st_mode & S_IFMT)) {

bin/cp/utils.c

198

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

bin/cp/utils.c

228

cp_pct(wtotal, fs->st_size));

bin/cp/utils.c

242

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

bin/cp/utils.c

328

setfile(struct stat *fs, int fd, bool beneath)

bin/cp/utils.c

337

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

bin/cp/utils.c

340

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

bin/cp/utils.c

343

tspec[0] = fs->st_atim;

bin/cp/utils.c

344

tspec[1] = fs->st_mtim;

bin/cp/utils.c

364

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

bin/cp/utils.c

365

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

bin/cp/utils.c

366

fchownat(to.dir, to.path, fs->st_uid, fs->st_gid, atflags)) {

bin/cp/utils.c

371

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

bin/cp/utils.c

375

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

bin/cp/utils.c

376

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

bin/cp/utils.c

377

fchmodat(to.dir, to.path, fs->st_mode, atflags)) {

bin/cp/utils.c

383

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

bin/cp/utils.c

384

if (fdval ? fchflags(fd, fs->st_flags) :

bin/cp/utils.c

385

chflagsat(to.dir, to.path, fs->st_flags, atflags)) {

bin/cp/utils.c

393

if (errno != EOPNOTSUPP || fs->st_flags != 0) {

crypto/heimdal/appl/login/login_access.c

100

if (!(perm = strtok_r(line, fs, &foo))

crypto/heimdal/appl/login/login_access.c

101

|| !(users = strtok_r(NULL, fs, &foo))

crypto/heimdal/appl/login/login_access.c

102

|| !(froms = strtok_r(NULL, fs, &foo))

crypto/heimdal/appl/login/login_access.c

103

|| strtok_r(NULL, fs, &foo)) {

crypto/heimdal/appl/login/login_access.c

32

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

crypto/heimdal/appl/rsh/login_access.c

100

if (!(perm = strtok_r(line, fs, &foo))

crypto/heimdal/appl/rsh/login_access.c

101

|| !(users = strtok_r(NULL, fs, &foo))

crypto/heimdal/appl/rsh/login_access.c

102

|| !(froms = strtok_r(NULL, fs, &foo))

crypto/heimdal/appl/rsh/login_access.c

103

|| strtok_r(NULL, fs, &foo)) {

crypto/heimdal/appl/rsh/login_access.c

32

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

crypto/heimdal/lib/asn1/gen_copy.c

102

char *fs;

crypto/heimdal/lib/asn1/gen_copy.c

113

if (asprintf (&fs, "%s(%s)->%s%s",

crypto/heimdal/lib/asn1/gen_copy.c

117

if (fs == NULL)

crypto/heimdal/lib/asn1/gen_copy.c

126

fprintf(codefile, "if(%s) {\n", fs);

crypto/heimdal/lib/asn1/gen_copy.c

131

copy_type (fs, ts, m->type, FALSE);

crypto/heimdal/lib/asn1/gen_copy.c

136

free (fs);

crypto/krb5/src/util/profile/prof_init.c

168

const_profile_filespec_t *fs;

crypto/krb5/src/util/profile/prof_init.c

185

for (fs = files; !PROFILE_LAST_FILESPEC(*fs); fs++) {

crypto/krb5/src/util/profile/prof_init.c

190

retval = profile_open_file(*fs, &new_file, modspec_arg);

crypto/openssh/openbsd-compat/bsd-statvfs.c

61

struct statfs fs;

crypto/openssh/openbsd-compat/bsd-statvfs.c

63

memset(&fs, 0, sizeof(fs));

crypto/openssh/openbsd-compat/bsd-statvfs.c

64

if (statfs(path, &fs) == -1)

crypto/openssh/openbsd-compat/bsd-statvfs.c

66

copy_statfs_to_statvfs(buf, &fs);

crypto/openssh/openbsd-compat/bsd-statvfs.c

79

struct statfs fs;

crypto/openssh/openbsd-compat/bsd-statvfs.c

81

memset(&fs, 0, sizeof(fs));

crypto/openssh/openbsd-compat/bsd-statvfs.c

82

if (fstatfs(fd, &fs) == -1)

crypto/openssh/openbsd-compat/bsd-statvfs.c

84

copy_statfs_to_statvfs(buf, &fs);

lib/geom/journal/geom_journal_ufs.c

43

static struct fs *

lib/geom/journal/geom_journal_ufs.c

47

struct fs *fs;

lib/geom/journal/geom_journal_ufs.c

51

fs = &disk.d_fs;

lib/geom/journal/geom_journal_ufs.c

53

return (fs);

lib/geom/journal/geom_journal_ufs.c

66

struct fs *fs;

lib/geom/journal/geom_journal_ufs.c

69

fs = read_superblock(prov);

lib/geom/journal/geom_journal_ufs.c

70

if (fs == NULL)

lib/geom/journal/geom_journal_ufs.c

75

fssize = fsbtodb(fs, fs->fs_size);

lib/libbe/be.c

396

zfs_handle_t *fs;

lib/libbe/be.c

417

fs = zfs_open(lbh->lzh, path, ZFS_TYPE_FILESYSTEM);

lib/libbe/be.c

418

if (fs == NULL)

lib/libbe/be.c

422

if ((mounted = zfs_is_mounted(fs, NULL)) != 0) {

lib/libbe/be.c

424

zfs_unmount(fs, NULL, 0);

lib/libbe/be.c

452

fs = zfs_open(lbh->lzh, path, ZFS_TYPE_DATASET);

lib/libbe/be.c

453

if (fs == NULL) {

lib/libbe/be.c

464

if ((err = be_promote_dependent_clones(fs, &bdd)) != 0) {

lib/libbe/be.c

484

zfs_prop_get(fs, ZFS_PROP_ORIGIN, origin, sizeof(origin),

lib/libbe/be.c

502

err = be_destroy_cb(fs, &bdd);

lib/libbe/be.c

503

zfs_close(fs);

lib/libpmc/libpmc.c

380

__K8MASK(fs, 4),

lib/libufs/cgroup.c

103

blk = blkmap(fs, blksfree, bbase);

lib/libufs/cgroup.c

104

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

lib/libufs/cgroup.c

108

frags = numfrags(fs, size);

lib/libufs/cgroup.c

112

fs->fs_cstotal.cs_nffree += i;

lib/libufs/cgroup.c

113

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

lib/libufs/cgroup.c

117

blk = blkmap(fs, blksfree, bbase);

lib/libufs/cgroup.c

118

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

lib/libufs/cgroup.c

122

fragno = fragstoblks(fs, bbase);

lib/libufs/cgroup.c

123

if (ffs_isblock(fs, blksfree, fragno)) {

lib/libufs/cgroup.c

124

cgp->cg_cs.cs_nffree -= fs->fs_frag;

lib/libufs/cgroup.c

125

fs->fs_cstotal.cs_nffree -= fs->fs_frag;

lib/libufs/cgroup.c

126

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

lib/libufs/cgroup.c

127

ffs_clusteracct(fs, cgp, fragno, 1);

lib/libufs/cgroup.c

129

fs->fs_cstotal.cs_nbfree++;

lib/libufs/cgroup.c

130

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

lib/libufs/cgroup.c

142

struct fs *fs;

lib/libufs/cgroup.c

146

fs = &disk->d_fs;

lib/libufs/cgroup.c

149

for (ino = 0; ino < fs->fs_ipg; ino++)

lib/libufs/cgroup.c

154

if (fs->fs_magic == FS_UFS2_MAGIC &&

lib/libufs/cgroup.c

155

ino + INOPB(fs) > cgp->cg_initediblk &&

lib/libufs/cgroup.c

158

bzero(block, (int)fs->fs_bsize);

lib/libufs/cgroup.c

160

for (i = 0; i < INOPB(fs); i++) {

lib/libufs/cgroup.c

164

if (bwrite(disk, ino_to_fsba(fs,

lib/libufs/cgroup.c

165

cgp->cg_cgx * fs->fs_ipg + cgp->cg_initediblk),

lib/libufs/cgroup.c

166

block, fs->fs_bsize))

lib/libufs/cgroup.c

168

cgp->cg_initediblk += INOPB(fs);

lib/libufs/cgroup.c

174

fs->fs_cstotal.cs_nifree--;

lib/libufs/cgroup.c

175

fs->fs_cs(fs, cgp->cg_cgx).cs_nifree--;

lib/libufs/cgroup.c

176

fs->fs_fmod = 1;

lib/libufs/cgroup.c

178

return (ino + (cgp->cg_cgx * fs->fs_ipg));

lib/libufs/cgroup.c

221

cgget(int devfd, struct fs *fs, int cg, struct cg *cgp)

lib/libufs/cgroup.c

227

if ((cnt = pread(devfd, cgp, fs->fs_cgsize,

lib/libufs/cgroup.c

228

fsbtodb(fs, cgtod(fs, cg)) * (fs->fs_fsize / fsbtodb(fs,1)))) < 0)

lib/libufs/cgroup.c

235

if (cnt != fs->fs_cgsize) {

lib/libufs/cgroup.c

241

if ((fs->fs_metackhash & CK_CYLGRP) != 0) {

lib/libufs/cgroup.c

244

calchash = calculate_crc32c(~0L, (void *)cgp, fs->fs_cgsize);

lib/libufs/cgroup.c

298

cgput(int devfd, struct fs *fs, struct cg *cgp)

lib/libufs/cgroup.c

302

if ((fs->fs_metackhash & CK_CYLGRP) != 0) {

lib/libufs/cgroup.c

305

calculate_crc32c(~0L, (void *)cgp, fs->fs_cgsize);

lib/libufs/cgroup.c

308

if ((cnt = pwrite(devfd, cgp, fs->fs_cgsize,

lib/libufs/cgroup.c

309

fsbtodb(fs, cgtod(fs, cgp->cg_cgx)) *

lib/libufs/cgroup.c

310

(fs->fs_fsize / fsbtodb(fs,1)))) < 0)

lib/libufs/cgroup.c

312

if (cnt != fs->fs_cgsize) {

lib/libufs/cgroup.c

55

struct fs *fs;

lib/libufs/cgroup.c

58

fs = &disk->d_fs;

lib/libufs/cgroup.c

61

for (bno = 0; bno < fs->fs_fpg / fs->fs_frag; bno++)

lib/libufs/cgroup.c

62

if (ffs_isblock(fs, blksfree, bno))

lib/libufs/cgroup.c

66

fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--;

lib/libufs/cgroup.c

67

ffs_clrblock(fs, blksfree, (long)bno);

lib/libufs/cgroup.c

68

ffs_clusteracct(fs, cgp, bno, -1);

lib/libufs/cgroup.c

70

fs->fs_cstotal.cs_nbfree--;

lib/libufs/cgroup.c

71

fs->fs_fmod = 1;

lib/libufs/cgroup.c

72

return (cgbase(fs, cgp->cg_cgx) + blkstofrags(fs, bno));

lib/libufs/cgroup.c

79

struct fs *fs;

lib/libufs/cgroup.c

84

fs = &disk->d_fs;

lib/libufs/cgroup.c

85

cg = dtog(fs, bno);

lib/libufs/cgroup.c

89

cgbno = dtogd(fs, bno);

lib/libufs/cgroup.c

91

if (size == fs->fs_bsize) {

lib/libufs/cgroup.c

92

fragno = fragstoblks(fs, cgbno);

lib/libufs/cgroup.c

93

ffs_setblock(fs, blksfree, fragno);

lib/libufs/cgroup.c

94

ffs_clusteracct(fs, cgp, fragno, 1);

lib/libufs/cgroup.c

96

fs->fs_cstotal.cs_nbfree++;

lib/libufs/cgroup.c

97

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

lib/libufs/cgroup.c

99

bbase = cgbno - fragnum(fs, cgbno);

lib/libufs/inode.c

110

struct fs *fs;

lib/libufs/inode.c

112

fs = &disk->d_fs;

lib/libufs/inode.c

114

ffs_update_dinode_ckhash(fs, disk->d_dp.dp2);

lib/libufs/inode.c

115

if (bwrite(disk, fsbtodb(fs, ino_to_fsba(&disk->d_fs, disk->d_inomin)),

lib/libufs/inode.c

56

struct fs *fs;

lib/libufs/inode.c

61

fs = &disk->d_fs;

lib/libufs/inode.c

62

if (inum >= (ino_t)fs->fs_ipg * fs->fs_ncg) {

lib/libufs/inode.c

76

bread(disk, fsbtodb(fs, ino_to_fsba(fs, inum)), inoblock,

lib/libufs/inode.c

77

fs->fs_bsize);

lib/libufs/inode.c

78

disk->d_inomin = min = inum - (inum % INOPB(fs));

lib/libufs/inode.c

79

disk->d_inomax = max = min + INOPB(fs);

lib/libufs/inode.c

83

if (ffs_oldfscompat_inode_read(fs, disk->d_dp, now.tv_sec))

lib/libufs/inode.c

92

if (ffs_verify_dinode_ckhash(fs, disk->d_dp.dp2) == 0) {

lib/libufs/inode.c

93

if (ffs_oldfscompat_inode_read(fs, disk->d_dp,

lib/libufs/libufs.h

119

void ffs_clrblock(struct fs *, u_char *, ufs1_daddr_t);

lib/libufs/libufs.h

120

void ffs_clusteracct(struct fs *, struct cg *, ufs1_daddr_t, int);

lib/libufs/libufs.h

121

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

lib/libufs/libufs.h

122

int ffs_isblock(struct fs *, u_char *, ufs1_daddr_t);

lib/libufs/libufs.h

123

int ffs_isfreeblock(struct fs *, u_char *, ufs1_daddr_t);

lib/libufs/libufs.h

124

bool ffs_oldfscompat_inode_read(struct fs *, union dinodep, time_t);

lib/libufs/libufs.h

125

int ffs_sbsearch(void *, struct fs **, int, char *,

lib/libufs/libufs.h

127

void ffs_setblock(struct fs *, u_char *, ufs1_daddr_t);

lib/libufs/libufs.h

128

int ffs_sbget(void *, struct fs **, off_t, int, char *,

lib/libufs/libufs.h

130

int ffs_sbput(void *, struct fs *, off_t,

lib/libufs/libufs.h

132

void ffs_update_dinode_ckhash(struct fs *, struct ufs2_dinode *);

lib/libufs/libufs.h

133

int ffs_verify_dinode_ckhash(struct fs *, struct ufs2_dinode *);

lib/libufs/libufs.h

148

int cgget(int, struct fs *, int, struct cg *);

lib/libufs/libufs.h

149

int cgput(int, struct fs *, struct cg *);

lib/libufs/libufs.h

168

int sbget(int, struct fs **, off_t, int);

lib/libufs/libufs.h

169

int sbsearch(int, struct fs **, int);

lib/libufs/libufs.h

170

int sbput(int, struct fs *, int);

lib/libufs/libufs.h

46

struct fs d_fs; /* filesystem information */

lib/libufs/sblock.c

130

memcpy(&disk->d_fs, fs, fs->fs_sbsize);

lib/libufs/sblock.c

131

free(fs);

lib/libufs/sblock.c

132

fs = &disk->d_fs;

lib/libufs/sblock.c

133

if (fs->fs_magic == FS_UFS1_MAGIC)

lib/libufs/sblock.c

135

if (fs->fs_magic == FS_UFS2_MAGIC)

lib/libufs/sblock.c

137

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

lib/libufs/sblock.c

138

disk->d_sblock = fs->fs_sblockloc / disk->d_bsize;

lib/libufs/sblock.c

139

disk->d_si = fs->fs_si;

lib/libufs/sblock.c

146

struct fs *fs;

lib/libufs/sblock.c

157

fs = &disk->d_fs;

lib/libufs/sblock.c

158

if ((errno = sbput(disk->d_fd, fs, all ? fs->fs_ncg : 0)) != 0) {

lib/libufs/sblock.c

196

sbget(int devfd, struct fs **fsp, off_t sblockloc, int flags)

lib/libufs/sblock.c

212

sbsearch(int devfd, struct fs **fsp, int flags)

lib/libufs/sblock.c

247

sbput(int devfd, struct fs *fs, int numaltwrite)

lib/libufs/sblock.c

253

error = ffs_sbput(&devfd, fs, fs->fs_sblockactualloc, use_pwrite);

lib/libufs/sblock.c

257

savedactualloc = fs->fs_sblockactualloc;

lib/libufs/sblock.c

258

if (fs->fs_si != NULL) {

lib/libufs/sblock.c

259

savedcsp = fs->fs_csp;

lib/libufs/sblock.c

260

fs->fs_csp = NULL;

lib/libufs/sblock.c

263

fs->fs_sblockactualloc = dbtob(fsbtodb(fs, cgsblock(fs, i)));

lib/libufs/sblock.c

264

if ((error = ffs_sbput(&devfd, fs, fs->fs_sblockactualloc,

lib/libufs/sblock.c

267

fs->fs_sblockactualloc = savedactualloc;

lib/libufs/sblock.c

268

fs->fs_csp = savedcsp;

lib/libufs/sblock.c

272

fs->fs_sblockactualloc = savedactualloc;

lib/libufs/sblock.c

273

if (fs->fs_si != NULL)

lib/libufs/sblock.c

274

fs->fs_csp = savedcsp;

lib/libufs/sblock.c

49

static int handle_disk_read(struct uufsd *, struct fs *, int);

lib/libufs/sblock.c

66

struct fs *fs;

lib/libufs/sblock.c

69

error = sbget(disk->d_fd, &fs, disk->d_sblockloc, disk->d_lookupflags);

lib/libufs/sblock.c

70

return (handle_disk_read(disk, fs, error));

lib/libufs/sblock.c

90

struct fs *fs;

lib/libufs/sblock.c

93

error = sbsearch(disk->d_fd, &fs, flags);

lib/libufs/sblock.c

94

return (handle_disk_read(disk, fs, error));

lib/libufs/sblock.c

98

handle_disk_read(struct uufsd *disk, struct fs *fs, int error)

lib/libufs/type.c

121

} else if ((fs = getfsfile(name)) != NULL) {

lib/libufs/type.c

131

name = fs->fs_spec;

lib/libufs/type.c

93

struct fstab *fs;

lib/libutil/quotafile.c

100

strcmp(fs->fs_file, sfb.f_mntonname)) {

lib/libutil/quotafile.c

106

(void)snprintf(qfnamep, qfbufsize, "%s/%s.%s", fs->fs_file,

lib/libutil/quotafile.c

113

quota_open(struct fstab *fs, int quotatype, int openflags)

lib/libutil/quotafile.c

126

strlcpy(qf->fsname, fs->fs_file, sizeof(qf->fsname));

lib/libutil/quotafile.c

131

ufs = strcmp(fs->fs_vfstype, "ufs") == 0;

lib/libutil/quotafile.c

137

serrno = hasquota(fs, quotatype, qf->qfname,

lib/libutil/quotafile.c

66

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

lib/libutil/quotafile.c

85

strcpy(buf, fs->fs_mntops);

lib/libutil/quotafile.c

99

if (statfs(fs->fs_file, &sfb) != 0 ||

libexec/rtld-elf/rtld.c

2933

struct statfs fs;

libexec/rtld-elf/rtld.c

2941

if (dangerous_ld_env && fstatfs(fd, &fs) == 0 &&

libexec/rtld-elf/rtld.c

2942

(fs.f_flags & MNT_NOEXEC) != 0) {

libexec/rtld-elf/rtld.c

2943

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

sbin/dump/dump.h

84

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

sbin/dump/main.c

93

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

sbin/dump/optr.c

281

allocfsent(const struct fstab *fs)

sbin/dump/optr.c

285

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

sbin/dump/optr.c

287

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

sbin/dump/optr.c

288

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

sbin/dump/optr.c

289

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

sbin/dump/optr.c

291

new->fs_passno = fs->fs_passno;

sbin/dump/optr.c

292

new->fs_freq = fs->fs_freq;

sbin/dump/optr.c

306

struct fstab *fs;

sbin/dump/optr.c

314

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

sbin/dump/optr.c

315

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

sbin/dump/optr.c

316

strcmp(fs->fs_type, FSTAB_RO) &&

sbin/dump/optr.c

317

strcmp(fs->fs_type, FSTAB_RQ)) ||

sbin/dump/optr.c

318

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

sbin/dump/optr.c

320

fs = allocfsent(fs);

sbin/dump/optr.c

323

pf->pf_fstab = fs;

sbin/dump/optr.c

339

struct fstab *fs;

sbin/dump/optr.c

343

fs = pf->pf_fstab;

sbin/dump/optr.c

344

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

sbin/dump/optr.c

345

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

sbin/dump/optr.c

346

return (fs);

sbin/dump/optr.c

347

rn = rawname(fs->fs_spec);

sbin/dump/optr.c

349

return (fs);

sbin/dump/optr.c

351

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

sbin/dump/optr.c

352

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

sbin/dump/optr.c

353

return (fs);

sbin/dump/optr.c

354

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

sbin/dump/optr.c

355

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

sbin/dump/optr.c

356

return (fs);

sbin/dumpfs/dumpfs.c

424

struct fs *fs;

sbin/dumpfs/dumpfs.c

426

fs = &disk.d_fs;

sbin/dumpfs/dumpfs.c

430

if (fs->fs_volname[0] != '\0')

sbin/dumpfs/dumpfs.c

431

printf("-L %s ", fs->fs_volname);

sbin/dumpfs/dumpfs.c

433

if (fs->fs_flags & FS_DOSOFTDEP)

sbin/dumpfs/dumpfs.c

435

printf("-a %d ", fs->fs_maxcontig);

sbin/dumpfs/dumpfs.c

436

printf("-b %d ", fs->fs_bsize);

sbin/dumpfs/dumpfs.c

438

printf("-d %d ", fs->fs_maxbsize);

sbin/dumpfs/dumpfs.c

439

printf("-e %d ", fs->fs_maxbpg);

sbin/dumpfs/dumpfs.c

440

printf("-f %d ", fs->fs_fsize);

sbin/dumpfs/dumpfs.c

441

printf("-g %d ", fs->fs_avgfilesize);

sbin/dumpfs/dumpfs.c

442

printf("-h %d ", fs->fs_avgfpdir);

sbin/dumpfs/dumpfs.c

443

printf("-i %jd ", fragroundup(fs, lblktosize(fs, fragstoblks(fs,

sbin/dumpfs/dumpfs.c

444

fs->fs_fpg)) / fs->fs_ipg));

sbin/dumpfs/dumpfs.c

445

if (fs->fs_flags & FS_SUJ)

sbin/dumpfs/dumpfs.c

447

if (fs->fs_flags & FS_GJOURNAL)

sbin/dumpfs/dumpfs.c

449

printf("-k %jd ", fs->fs_metaspace);

sbin/dumpfs/dumpfs.c

450

if (fs->fs_flags & FS_MULTILABEL)

sbin/dumpfs/dumpfs.c

452

printf("-m %d ", fs->fs_minfree);

sbin/dumpfs/dumpfs.c

455

switch (fs->fs_optim) {

sbin/dumpfs/dumpfs.c

467

printf("-s %jd ", (intmax_t)fsbtodb(fs, fs->fs_size));

sbin/dumpfs/dumpfs.c

468

if (fs->fs_flags & FS_TRIM)

sbin/ffsinfo/ffsinfo.c

81

struct fs fs;

sbin/ffsinfo/ffsinfo.c

85

#define osblock fsun.fs

sbin/fsck/fsck.c

210

if ((fs = getfsfile(spec)) == NULL &&

sbin/fsck/fsck.c

211

(fs = getfsspec(spec)) == NULL) {

sbin/fsck/fsck.c

219

spec = fs->fs_spec;

sbin/fsck/fsck.c

220

type = fs->fs_vfstype;

sbin/fsck/fsck.c

221

mntpt = fs->fs_file;

sbin/fsck/fsck.c

222

if (BADTYPE(fs->fs_type))

sbin/fsck/fsck.c

243

isok(struct fstab *fs)

sbin/fsck/fsck.c

247

if (fs->fs_passno == 0)

sbin/fsck/fsck.c

249

if (BADTYPE(fs->fs_type))

sbin/fsck/fsck.c

251

if (!selected(fs->fs_vfstype))

sbin/fsck/fsck.c

254

if (getfsopt(fs, "failok"))

sbin/fsck/fsck.c

266

if (!strcmp(fs->fs_type, FSTAB_RO))

sbin/fsck/fsck.c

268

if (getmntpoint(fs->fs_spec) == NULL)

sbin/fsck/fsck.c

270

if (checkfs(fs->fs_vfstype, fs->fs_spec, fs->fs_file, "-F", 0))

sbin/fsck/fsck.c

283

if ((flags & CHECK_BACKGRD) == 0 || !strcmp(fs->fs_type, FSTAB_RO))

sbin/fsck/fsck.c

285

for (i = strlen(fs->fs_mntops) - 6; i >= 0; i--)

sbin/fsck/fsck.c

286

if (!strncmp(&fs->fs_mntops[i], "noauto", 6))

sbin/fsck/fsck.c

290

if (checkfs(fs->fs_vfstype, fs->fs_spec, fs->fs_file, "-F", NULL) != 0)

sbin/fsck/fsck.c

292

printf("%s: DEFER FOR BACKGROUND CHECKING\n", fs->fs_spec);

sbin/fsck/fsck.c

98

struct fstab *fs;

sbin/fsck/fsutil.c

72

getfsopt(struct fstab *fs, const char *option)

sbin/fsck/fsutil.c

82

optbuf = strdup(fs->fs_mntops);

sbin/fsck/preen.c

103

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

sbin/fsck/preen.c

104

name = fs->fs_spec;

sbin/fsck/preen.c

105

if (fs->fs_passno > passno && fs->fs_passno < nextpass)

sbin/fsck/preen.c

106

nextpass = fs->fs_passno;

sbin/fsck/preen.c

108

if (passno != fs->fs_passno)

sbin/fsck/preen.c

111

if ((*docheck)(fs) == 0)

sbin/fsck/preen.c

125

sumstatus = (*checkit)(fs->fs_vfstype,

sbin/fsck/preen.c

126

name, fs->fs_file, NULL, NULL);

sbin/fsck/preen.c

133

"BAD DISK NAME %s\n", fs->fs_spec);

sbin/fsck/preen.c

137

addpart(fs->fs_vfstype, name, fs->fs_file,

sbin/fsck/preen.c

138

getfsopt(fs, "failok"));

sbin/fsck/preen.c

82

struct fstab *fs;

sbin/fsck_ffs/fsck.h

162

struct fs *b_fs; /* super block */

sbin/fsck_ffs/fsck.h

486

void copyonwrite(struct fs *, struct bufarea *,

sbin/fsck_ffs/fsck.h

542

int snapblkfree(struct fs *, ufs2_daddr_t, long, ino_t,

sbin/fsck_ffs/gjournal.c

110

for (cino = 0; cino < fs->fs_ipg; cino++) {

sbin/fsck_ffs/gjournal.c

111

ino = fs->fs_ipg * cg + cino;

sbin/fsck_ffs/gjournal.c

142

fs->fs_unrefs--;

sbin/fsck_ffs/gjournal.c

156

if (fs->fs_unrefs == 0)

sbin/fsck_ffs/gjournal.c

65

struct fs *fs;

sbin/fsck_ffs/gjournal.c

75

fs = &sblock;

sbin/fsck_ffs/gjournal.c

77

if (fs->fs_unrefs == 0) {

sbin/fsck_ffs/gjournal.c

83

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

sbin/fsck_ffs/gjournal.c

87

cdevname, cg, fs->fs_ncg, cg * 100 / fs->fs_ncg);

sbin/fsck_ffs/gjournal.c

92

cg * 100 / fs->fs_ncg);

sbin/fsck_ffs/inode.c

1014

if (blread(fsreadfd, copybuf, fsbtodb(fs, copyblkno),

sbin/fsck_ffs/inode.c

1015

fs->fs_bsize) != 0) {

sbin/fsck_ffs/inode.c

1026

if ((blkno = allocblk(dtog(fs, copyblkno), fs->fs_frag,

sbin/fsck_ffs/inode.c

1037

blwrite(fswritefd, copybuf, fsbtodb(fs, blkno), fs->fs_bsize);

sbin/fsck_ffs/inode.c

1042

DIP(dp, di_blocks) + btodb(fs->fs_bsize));

sbin/fsck_ffs/inode.c

55

static void chkcopyonwrite(struct fs *, ufs2_daddr_t,

sbin/fsck_ffs/inode.c

830

snapblkfree(struct fs *fs, ufs2_daddr_t bno, long size, ino_t inum,

sbin/fsck_ffs/inode.c

846

relblkno = blknum(fs, bno);

sbin/fsck_ffs/inode.c

847

lbn = fragstoblks(fs, relblkno);

sbin/fsck_ffs/inode.c

898

if (size == fs->fs_bsize) {

sbin/fsck_ffs/inode.c

915

if (blread(fsreadfd, copybuf, fsbtodb(fs, relblkno),

sbin/fsck_ffs/inode.c

916

fs->fs_bsize) != 0) {

sbin/fsck_ffs/inode.c

927

blkno = allocblk(dtog(fs, relblkno), fs->fs_frag,

sbin/fsck_ffs/inode.c

939

blwrite(fswritefd, copybuf, fsbtodb(fs, blkno), fs->fs_bsize);

sbin/fsck_ffs/inode.c

944

DIP(dp, di_blocks) + btodb(fs->fs_bsize));

sbin/fsck_ffs/inode.c

958

copyonwrite(struct fs *fs, struct bufarea *bp,

sbin/fsck_ffs/inode.c

967

numblks = blkroundup(fs, bp->b_size) / fs->fs_bsize;

sbin/fsck_ffs/inode.c

971

copyblkno = blknum(fs, dbtofsb(fs, bp->b_bno));

sbin/fsck_ffs/inode.c

973

chkcopyonwrite(fs, copyblkno, checkblkavail);

sbin/fsck_ffs/inode.c

974

copyblkno += fs->fs_frag;

sbin/fsck_ffs/inode.c

979

chkcopyonwrite(struct fs *fs, ufs2_daddr_t copyblkno,

sbin/fsck_ffs/inode.c

989

lbn = fragstoblks(fs, copyblkno);

sbin/fsck_ffs/pass5.c

102

fs->fs_cgsize =

sbin/fsck_ffs/pass5.c

103

fragroundup(fs, CGSIZE(fs));

sbin/fsck_ffs/pass5.c

122

fs->fs_old_cpg * sizeof(int32_t);

sbin/fsck_ffs/pass5.c

124

fs->fs_old_cpg * fs->fs_old_nrpos * sizeof(u_int16_t);

sbin/fsck_ffs/pass5.c

127

inomapsize = howmany(fs->fs_ipg, CHAR_BIT);

sbin/fsck_ffs/pass5.c

129

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

sbin/fsck_ffs/pass5.c

131

if (fs->fs_contigsumsize > 0) {

sbin/fsck_ffs/pass5.c

137

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

sbin/fsck_ffs/pass5.c

139

howmany(fragstoblks(fs, fs->fs_fpg), CHAR_BIT);

sbin/fsck_ffs/pass5.c

147

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

sbin/fsck_ffs/pass5.c

148

for (d = fs->fs_size; d < dmax; d++)

sbin/fsck_ffs/pass5.c

150

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

sbin/fsck_ffs/pass5.c

170

if ((fs->fs_metackhash & CK_CYLGRP) != 0 &&

sbin/fsck_ffs/pass5.c

176

thishash = calculate_crc32c(~0L, cg, fs->fs_cgsize);

sbin/fsck_ffs/pass5.c

191

dbase = cgbase(fs, c);

sbin/fsck_ffs/pass5.c

192

dmax = dbase + fs->fs_fpg;

sbin/fsck_ffs/pass5.c

193

if (dmax > fs->fs_size)

sbin/fsck_ffs/pass5.c

194

dmax = fs->fs_size;

sbin/fsck_ffs/pass5.c

196

if (fs->fs_magic == FS_UFS1_MAGIC) {

sbin/fsck_ffs/pass5.c

197

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

sbin/fsck_ffs/pass5.c

199

fs->fs_fpg / fs->fs_old_cpg);

sbin/fsck_ffs/pass5.c

201

newcg->cg_old_ncyl = fs->fs_old_cpg;

sbin/fsck_ffs/pass5.c

202

newcg->cg_old_niblk = fs->fs_ipg;

sbin/fsck_ffs/pass5.c

205

if (fs->fs_contigsumsize > 0)

sbin/fsck_ffs/pass5.c

206

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

sbin/fsck_ffs/pass5.c

210

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

sbin/fsck_ffs/pass5.c

219

if (cg->cg_irotor >= 0 && cg->cg_irotor < fs->fs_ipg)

sbin/fsck_ffs/pass5.c

223

if (fs->fs_magic == FS_UFS1_MAGIC) {

sbin/fsck_ffs/pass5.c

226

if ((unsigned)cg->cg_initediblk > fs->fs_ipg)

sbin/fsck_ffs/pass5.c

227

newcg->cg_initediblk = fs->fs_ipg;

sbin/fsck_ffs/pass5.c

233

inum = fs->fs_ipg * c;

sbin/fsck_ffs/pass5.c

269

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

sbin/fsck_ffs/pass5.c

271

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

sbin/fsck_ffs/pass5.c

284

if (frags == fs->fs_frag) {

sbin/fsck_ffs/pass5.c

286

if (fs->fs_contigsumsize > 0)

sbin/fsck_ffs/pass5.c

288

i / fs->fs_frag);

sbin/fsck_ffs/pass5.c

291

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

sbin/fsck_ffs/pass5.c

292

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

sbin/fsck_ffs/pass5.c

297

if (fs->fs_contigsumsize > 0) {

sbin/fsck_ffs/pass5.c

308

if (run > fs->fs_contigsumsize)

sbin/fsck_ffs/pass5.c

309

run = fs->fs_contigsumsize;

sbin/fsck_ffs/pass5.c

321

if (run > fs->fs_contigsumsize)

sbin/fsck_ffs/pass5.c

322

run = fs->fs_contigsumsize;

sbin/fsck_ffs/pass5.c

338

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

sbin/fsck_ffs/pass5.c

346

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

sbin/fsck_ffs/pass5.c

367

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

sbin/fsck_ffs/pass5.c

372

(intmax_t)fs->fs_cstotal.cs_ndir,

sbin/fsck_ffs/pass5.c

373

(intmax_t)fs->fs_cstotal.cs_nbfree,

sbin/fsck_ffs/pass5.c

374

(intmax_t)fs->fs_cstotal.cs_nffree,

sbin/fsck_ffs/pass5.c

375

(intmax_t)fs->fs_cstotal.cs_nifree,

sbin/fsck_ffs/pass5.c

376

(intmax_t)fs->fs_cstotal.cs_numclusters);

sbin/fsck_ffs/pass5.c

385

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

sbin/fsck_ffs/pass5.c

386

fs->fs_ronly = 0;

sbin/fsck_ffs/pass5.c

387

fs->fs_fmod = 0;

sbin/fsck_ffs/pass5.c

399

cmd.value = cstotal.cs_ndir - fs->fs_cstotal.cs_ndir;

sbin/fsck_ffs/pass5.c

409

cmd.value = cstotal.cs_nbfree - fs->fs_cstotal.cs_nbfree;

sbin/fsck_ffs/pass5.c

420

cmd.value = cstotal.cs_nifree - fs->fs_cstotal.cs_nifree;

sbin/fsck_ffs/pass5.c

431

cmd.value = cstotal.cs_nffree - fs->fs_cstotal.cs_nffree;

sbin/fsck_ffs/pass5.c

443

fs->fs_cstotal.cs_numclusters;

sbin/fsck_ffs/pass5.c

469

struct fs *fs = &sblock;

sbin/fsck_ffs/pass5.c

471

inomapsize = howmany(fs->fs_ipg, CHAR_BIT);

sbin/fsck_ffs/pass5.c

479

oldcg->cg_cgx * (ufs2_daddr_t)fs->fs_ipg, "DIR", freedirs,

sbin/fsck_ffs/pass5.c

482

oldcg->cg_cgx * (ufs2_daddr_t)fs->fs_ipg, "FILE", freefiles,

sbin/fsck_ffs/pass5.c

483

excessdirs, fs->fs_ipg, usesysctl);

sbin/fsck_ffs/pass5.c

485

howmany(fs->fs_fpg, CHAR_BIT),

sbin/fsck_ffs/pass5.c

486

oldcg->cg_cgx * (ufs2_daddr_t)fs->fs_fpg, "FRAG",

sbin/fsck_ffs/pass5.c

487

freeblks, 0, fs->fs_fpg, usesysctl);

sbin/fsck_ffs/pass5.c

54

struct fs *fs = &sblock;

sbin/fsck_ffs/pass5.c

66

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

sbin/fsck_ffs/pass5.c

67

newcg->cg_niblk = fs->fs_ipg;

sbin/fsck_ffs/pass5.c

72

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

sbin/fsck_ffs/pass5.c

76

fs->fs_contigsumsize = 0;

sbin/fsck_ffs/pass5.c

81

if (fs->fs_maxcontig > 1) {

sbin/fsck_ffs/pass5.c

84

if (fs->fs_contigsumsize < 1) {

sbin/fsck_ffs/pass5.c

86

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

sbin/fsck_ffs/pass5.c

87

fs->fs_contigsumsize < FS_MAXCONTIG) {

sbin/fsck_ffs/pass5.c

91

i = fs->fs_contigsumsize;

sbin/fsck_ffs/pass5.c

92

fs->fs_contigsumsize =

sbin/fsck_ffs/pass5.c

93

MIN(fs->fs_maxcontig, FS_MAXCONTIG);

sbin/fsck_ffs/pass5.c

94

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

sbin/fsck_ffs/pass5.c

96

fs->fs_contigsumsize = i;

sbin/fsck_ffs/setup.c

274

struct fs *fs;

sbin/fsck_ffs/setup.c

282

fs = &sblock;

sbin/fsck_ffs/setup.c

287

lbn = howmany(fs->fs_size, fs->fs_frag);

sbin/fsck_ffs/setup.c

291

size = fragroundup(fs,

sbin/fsck_ffs/setup.c

292

DIP(snapip->i_dp, di_size) - lblktosize(fs, lbn));

sbin/fsck_ffs/setup.c

310

CHKBLKINLIST(lblkno(fs, fs->fs_sblockloc));

sbin/fsck_ffs/setup.c

320

csblkno = fragstoblks(fs, fs->fs_csaddr);

sbin/fsck_ffs/setup.c

321

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

sbin/fsck_ffs/setup.c

322

if (fragstoblks(fs, cgtod(fs, cg)) > csblkno)

sbin/fsck_ffs/setup.c

324

CHKBLKINLIST(fragstoblks(fs, cgtod(fs, cg)));

sbin/fsck_ffs/setup.c

329

len = howmany(fs->fs_cssize, fs->fs_bsize);

sbin/fsck_ffs/setup.c

336

for (; cg < fs->fs_ncg; cg++) {

sbin/fsck_ffs/setup.c

337

CHKBLKINLIST(fragstoblks(fs, cgtod(fs, cg)));

sbin/fsck_ffs/setup.c

402

struct fs *fs;

sbin/fsck_ffs/setup.c

410

switch (sbget(fsreadfd, &fs, bflag * dev_bsize, 0)) {

sbin/fsck_ffs/setup.c

429

if (sbget(fsreadfd, &fs, UFS_STDSB, UFS_NOMSG) == 0)

sbin/fsck_ffs/setup.c

435

if (sbget(fsreadfd, &fs, UFS_STDSB, UFS_NOMSG | UFS_NOHASHFAIL) == 0) {

sbin/fsck_ffs/setup.c

442

switch (sbsearch(fsreadfd, &fs, 0)) {

sbin/fsck_ffs/setup.c

458

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

sbin/fsck_ffs/setup.c

459

free(fs);

sbin/fsck_ffs/suj.c

1004

size = lfragtosize(fs, frags);

sbin/fsck_ffs/suj.c

1022

diroff = lblktosize(fs, lbn) + dpoff;

sbin/fsck_ffs/suj.c

1054

if (fs->fs_magic == FS_UFS1_MAGIC)

sbin/fsck_ffs/suj.c

112

static struct fs *fs = NULL;

sbin/fsck_ffs/suj.c

1235

lbnadd *= NINDIR(fs);

sbin/fsck_ffs/suj.c

1236

bp = getdatablk(blk, fs->fs_bsize, BT_LEVEL1 + level);

sbin/fsck_ffs/suj.c

1239

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

sbin/fsck_ffs/suj.c

1263

blk_free(ino, nblk, 0, fs->fs_frag);

sbin/fsck_ffs/suj.c

1310

(mode == IFLNK && cursize < fs->fs_maxsymlinklen)) {

sbin/fsck_ffs/suj.c

1325

lastlbn = lblkno(fs, blkroundup(fs, size));

sbin/fsck_ffs/suj.c

1329

blksize = sblksize(fs, cursize, i);

sbin/fsck_ffs/suj.c

1330

blk_free(ino, bn, 0, numfrags(fs, blksize));

sbin/fsck_ffs/suj.c

1336

for (i = 0, tmpval = NINDIR(fs), lbn = UFS_NDADDR; i < UFS_NIADDR; i++,

sbin/fsck_ffs/suj.c

1339

tmpval *= NINDIR(fs);

sbin/fsck_ffs/suj.c

1349

blk_free(ino, bn, 0, fs->fs_frag);

sbin/fsck_ffs/suj.c

1361

if (size > lblktosize(fs, visitlbn + 1))

sbin/fsck_ffs/suj.c

1362

size = lblktosize(fs, visitlbn + 1);

sbin/fsck_ffs/suj.c

1374

oldspace = sblksize(fs, cursize, visitlbn);

sbin/fsck_ffs/suj.c

1375

newspace = sblksize(fs, size, visitlbn);

sbin/fsck_ffs/suj.c

1377

bn += numfrags(fs, newspace);

sbin/fsck_ffs/suj.c

1378

frags = numfrags(fs, oldspace - newspace);

sbin/fsck_ffs/suj.c

1383

DIP_SET(dp, di_blocks, fsbtodb(fs, totalfrags));

sbin/fsck_ffs/suj.c

1391

off = blkoff(fs, size);

sbin/fsck_ffs/suj.c

1399

clrsize = frags * fs->fs_fsize;

sbin/fsck_ffs/suj.c

1652

ino = fs->fs_sujfree;

sbin/fsck_ffs/suj.c

1653

fs->fs_sujfree = 0;

sbin/fsck_ffs/suj.c

178

if (cgx < 0 || cgx >= fs->fs_ncg)

sbin/fsck_ffs/suj.c

1918

blk = blknum(fs, blkrec->jb_blkno);

sbin/fsck_ffs/suj.c

1919

frag = fragnum(fs, blkrec->jb_blkno);

sbin/fsck_ffs/suj.c

1920

if (blkrec->jb_blkno < 0 || blk + fs->fs_frag - frag > fs->fs_size)

sbin/fsck_ffs/suj.c

1930

if (blkrec->jb_oldfrags + blkrec->jb_frags > fs->fs_frag)

sbin/fsck_ffs/suj.c

213

sc = cg_lookup(ino_to_cg(fs, ino));

sbin/fsck_ffs/suj.c

2133

if (DIP(dp, di_modrev) != fs->fs_mtime) {

sbin/fsck_ffs/suj.c

2269

jblocks_add(suj_jblocks, fsbtodb(fs, blk), fsbtodb(fs, frags));

sbin/fsck_ffs/suj.c

2311

if (rec->jsr_time != fs->fs_mtime) {

sbin/fsck_ffs/suj.c

2315

rec->jsr_time, fs->fs_mtime);

sbin/fsck_ffs/suj.c

2334

if (size < fs->fs_bsize &&

sbin/fsck_ffs/suj.c

2336

recsize <= fs->fs_bsize)

sbin/fsck_ffs/suj.c

2389

fs = &sblock;

sbin/fsck_ffs/suj.c

244

sc = cg_lookup(dtog(fs, blk));

sbin/fsck_ffs/suj.c

2465

if (blocks != numfrags(fs, DIP(jip, di_size))) {

sbin/fsck_ffs/suj.c

247

hd = &sc->sc_blkhash[HASH(fragstoblks(fs, blk))];

sbin/fsck_ffs/suj.c

2507

bzero(&fs->fs_cstotal, sizeof(struct csum_total));

sbin/fsck_ffs/suj.c

2508

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

sbin/fsck_ffs/suj.c

2509

cgsum = &fs->fs_cs(fs, i);

sbin/fsck_ffs/suj.c

2510

fs->fs_cstotal.cs_nffree += cgsum->cs_nffree;

sbin/fsck_ffs/suj.c

2511

fs->fs_cstotal.cs_nbfree += cgsum->cs_nbfree;

sbin/fsck_ffs/suj.c

2512

fs->fs_cstotal.cs_nifree += cgsum->cs_nifree;

sbin/fsck_ffs/suj.c

2513

fs->fs_cstotal.cs_ndir += cgsum->cs_ndir;

sbin/fsck_ffs/suj.c

2515

fs->fs_pendinginodes = 0;

sbin/fsck_ffs/suj.c

2516

fs->fs_pendingblocks = 0;

sbin/fsck_ffs/suj.c

2517

fs->fs_clean = 1;

sbin/fsck_ffs/suj.c

2518

fs->fs_time = time(NULL);

sbin/fsck_ffs/suj.c

2519

fs->fs_mtime = time(NULL);

sbin/fsck_ffs/suj.c

2543

fs = NULL;

sbin/fsck_ffs/suj.c

325

sblk = blk_lookup(blknum(fs, blk), 0);

sbin/fsck_ffs/suj.c

372

if (blk_equals(brec, ino, lbn, blk, fs->fs_frag))

sbin/fsck_ffs/suj.c

434

cg = ino_to_cg(fs, ino);

sbin/fsck_ffs/suj.c

435

ino = ino % fs->fs_ipg;

sbin/fsck_ffs/suj.c

479

if (snapblkfree(fs, bno, lfragtosize(fs, frags), ino,

sbin/fsck_ffs/suj.c

482

cg = dtog(fs, bno);

sbin/fsck_ffs/suj.c

485

cgbno = dtogd(fs, bno);

sbin/fsck_ffs/suj.c

493

if (frags == fs->fs_frag && mask == 0) {

sbin/fsck_ffs/suj.c

494

fragno = fragstoblks(fs, cgbno);

sbin/fsck_ffs/suj.c

495

ffs_setblock(fs, blksfree, fragno);

sbin/fsck_ffs/suj.c

520

sc = cg_lookup(dtog(fs, bno));

sbin/fsck_ffs/suj.c

521

return ffs_isblock(fs, cg_blksfree(sc->sc_cgp), dtogd(fs, bno));

sbin/fsck_ffs/suj.c

568

lbn = lblkno(fs, diroff);

sbin/fsck_ffs/suj.c

569

doff = blkoff(fs, diroff);

sbin/fsck_ffs/suj.c

573

blksize = sblksize(fs, DIP(dip, di_size), lbn);

sbin/fsck_ffs/suj.c

629

lbn = lblkno(fs, diroff);

sbin/fsck_ffs/suj.c

630

doff = blkoff(fs, diroff);

sbin/fsck_ffs/suj.c

631

blksize = sblksize(fs, DIP(dip, di_size), lbn);

sbin/fsck_ffs/suj.c

665

if (dpoff > fs->fs_bsize)

sbin/fsck_ffs/suj.c

734

lbnadd *= NINDIR(fs);

sbin/fsck_ffs/suj.c

735

bp = getdatablk(blk, fs->fs_bsize, BT_LEVEL1 + level);

sbin/fsck_ffs/suj.c

738

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

sbin/fsck_ffs/suj.c

743

(*frags) += fs->fs_frag;

sbin/fsck_ffs/suj.c

744

visitor(ino, nlbn, nblk, fs->fs_frag);

sbin/fsck_ffs/suj.c

753

(*frags) += fs->fs_frag;

sbin/fsck_ffs/suj.c

754

visitor(ino, lbn, blk, fs->fs_frag);

sbin/fsck_ffs/suj.c

781

fs->fs_magic == FS_UFS2_MAGIC && dp->dp2.di_extsize) {

sbin/fsck_ffs/suj.c

785

frags = sblksize(fs, dp->dp2.di_extsize, i);

sbin/fsck_ffs/suj.c

786

frags = numfrags(fs, frags);

sbin/fsck_ffs/suj.c

793

(mode == IFLNK && size < fs->fs_maxsymlinklen))

sbin/fsck_ffs/suj.c

798

frags = sblksize(fs, size, i);

sbin/fsck_ffs/suj.c

799

frags = numfrags(fs, frags);

sbin/fsck_ffs/suj.c

808

for (i = 0, tmpval = NINDIR(fs), lbn = UFS_NDADDR; i < UFS_NIADDR; i++,

sbin/fsck_ffs/suj.c

811

tmpval *= NINDIR(fs);

sbin/fsck_ffs/suj.c

865

blocks = fsbtodb(fs, frags);

sbin/fsck_ffs/suj.c

874

size = lblktosize(fs, visitlbn + 1);

sbin/fsck_msdosfs/fat.c

580

checkdirty(int fs, struct bootblock *boot)

sbin/fsck_msdosfs/fat.c

599

if (lseek(fs, off, SEEK_SET) != off) {

sbin/fsck_msdosfs/fat.c

604

if ((size_t)read(fs, buffer, boot->bpbBytesPerSec) !=

sbin/fsck_msdosfs/fat.c

806

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

sbin/fsck_msdosfs/fat.c

821

fat->fd = fs;

sbin/fsdb/fsdbutil.c

51

void prtblknos(struct fs *fs, union dinode *dp);

sbin/fsirand/fsirand.c

107

struct fs *sblock;

sbin/growfs/debug.c

125

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

sbin/growfs/debug.c

459

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

sbin/growfs/debug.c

502

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

sbin/growfs/debug.c

548

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

sbin/growfs/debug.c

593

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

sbin/growfs/debug.c

628

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

sbin/growfs/debug.c

663

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

sbin/growfs/debug.c

730

dbg_dump_ufs2_ino(struct fs *sb, const char *comment, struct ufs2_dinode *ino)

sbin/growfs/debug.c

802

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

sbin/growfs/debug.c

97

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

sbin/growfs/debug.h

54

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

sbin/growfs/debug.h

55

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

sbin/growfs/debug.h

59

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

sbin/growfs/debug.h

60

void dbg_dump_ufs2_ino(struct fs *, const char *, struct ufs2_dinode *);

sbin/growfs/debug.h

61

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

sbin/growfs/debug.h

62

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

sbin/growfs/debug.h

63

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

sbin/growfs/debug.h

64

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

sbin/growfs/debug.h

65

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

sbin/growfs/debug.h

66

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

sbin/growfs/growfs.c

103

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

sbin/growfs/growfs.c

104

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

sbin/growfs/growfs.c

105

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

sbin/growfs/growfs.c

1118

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

sbin/growfs/growfs.c

1125

switch (fs->fs_frag) {

sbin/growfs/growfs.c

1142

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

sbin/growfs/growfs.c

1154

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

sbin/growfs/growfs.c

1160

switch ((fs)->fs_frag) {

sbin/growfs/growfs.c

1174

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

sbin/growfs/growfs.c

1188

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

sbin/growfs/growfs.c

1194

switch (fs->fs_frag) {

sbin/growfs/growfs.c

1208

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

sbin/growfs/growfs.c

1302

struct fs *fs;

sbin/growfs/growfs.c

1380

if ((ret = sbget(fsi, &fs, UFS_STDSB, 0)) != 0) {

sbin/growfs/growfs.c

1391

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

sbin/growfs/growfs.c

1393

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

sbin/growfs/growfs.c

1394

free(fs);

sbin/growfs/growfs.c

83

struct fs fs;

sbin/growfs/growfs.c

86

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

sbin/growfs/growfs.c

87

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

sbin/ipfw/dummynet.c

1285

struct dn_fs *fs = NULL;

sbin/ipfw/dummynet.c

1349

fs = o_next(&buf, sizeof(*fs), DN_FS);

sbin/ipfw/dummynet.c

1361

fs->fs_nr = i + 2*DN_MAX_ID;

sbin/ipfw/dummynet.c

1362

fs->sched_nr = i + DN_MAX_ID;

sbin/ipfw/dummynet.c

1370

fs = o_next(&buf, sizeof(*fs), DN_FS);

sbin/ipfw/dummynet.c

1371

fs->fs_nr = i;

sbin/ipfw/dummynet.c

1372

mask = &fs->flow_mask;

sbin/ipfw/dummynet.c

1373

flags = &fs->flags;

sbin/ipfw/dummynet.c

1374

buckets = &fs->buckets;

sbin/ipfw/dummynet.c

1387

fs = o_next(&buf, sizeof(*fs), DN_FS);

sbin/ipfw/dummynet.c

1393

fs->fs_nr = i + DN_MAX_ID;

sbin/ipfw/dummynet.c

1394

fs->sched_nr = i;

sbin/ipfw/dummynet.c

1404

for (j = 0; j < nitems(fs->par); j++)

sbin/ipfw/dummynet.c

1405

fs->par[j] = -1;

sbin/ipfw/dummynet.c

1413

NEED(fs, "noerror is only for pipes");

sbin/ipfw/dummynet.c

1414

fs->flags |= DN_NOERROR;

sbin/ipfw/dummynet.c

1418

NEED(fs, "plr is only for pipes");

sbin/ipfw/dummynet.c

1423

fs->plr[0] = (int)(d*0x7fffffff);

sbin/ipfw/dummynet.c

1428

fs->plr[1] = (int)(d*0x7fffffff);

sbin/ipfw/dummynet.c

1433

fs->plr[2] = (int)(d*0x7fffffff);

sbin/ipfw/dummynet.c

1438

fs->plr[3] = (int)(d*0x7fffffff);

sbin/ipfw/dummynet.c

1444

NEED(fs, "queue is only for pipes or flowsets");

sbin/ipfw/dummynet.c

1447

fs->qsize = strtoul(av[0], &end, 0);

sbin/ipfw/dummynet.c

1449

fs->flags |= DN_QSIZE_BYTES;

sbin/ipfw/dummynet.c

1450

fs->qsize *= 1024;

sbin/ipfw/dummynet.c

1453

fs->flags |= DN_QSIZE_BYTES;

sbin/ipfw/dummynet.c

1459

NEED(fs, "buckets is only for pipes or flowsets");

sbin/ipfw/dummynet.c

1590

NEED(fs, "codel/pie is only for flowsets");

sbin/ipfw/dummynet.c

1592

fs->flags &= ~(DN_IS_RED|DN_IS_GENTLE_RED);

sbin/ipfw/dummynet.c

1593

fs->flags |= DN_IS_AQM;

sbin/ipfw/dummynet.c

1617

fs->flags |= DN_IS_RED;

sbin/ipfw/dummynet.c

1619

fs->flags |= DN_IS_GENTLE_RED;

sbin/ipfw/dummynet.c

1627

fs->w_q = (int) (w_q * (1 << SCALE_RED));

sbin/ipfw/dummynet.c

1630

fs->min_th = strtoul(end, &end, 0);

sbin/ipfw/dummynet.c

1632

fs->min_th *= 1024;

sbin/ipfw/dummynet.c

1635

fs->max_th = strtoul(end, &end, 0);

sbin/ipfw/dummynet.c

1637

fs->max_th *= 1024;

sbin/ipfw/dummynet.c

1643

fs->max_p = (int)(max_p * (1 << SCALE_RED));

sbin/ipfw/dummynet.c

1649

fs->flags |= DN_IS_ECN;

sbin/ipfw/dummynet.c

1653

NEED(fs, "droptail is only for flowsets");

sbin/ipfw/dummynet.c

1654

fs->flags &= ~(DN_IS_RED|DN_IS_GENTLE_RED);

sbin/ipfw/dummynet.c

1699

NEED(fs, "weight is only for flowsets");

sbin/ipfw/dummynet.c

1701

fs->par[0] = strtol(av[0], &end, 0);

sbin/ipfw/dummynet.c

1706

NEED(fs, "lmax is only for flowsets");

sbin/ipfw/dummynet.c

1708

fs->par[1] = strtol(av[0], &end, 0);

sbin/ipfw/dummynet.c

1713

NEED(fs, "priority is only for flowsets");

sbin/ipfw/dummynet.c

1715

fs->par[2] = strtol(av[0], &end, 0);

sbin/ipfw/dummynet.c

1721

NEED(fs, "pipe/sched");

sbin/ipfw/dummynet.c

1723

fs->sched_nr = strtoul(av[0], &end, 0);

sbin/ipfw/dummynet.c

1764

if (fs) {

sbin/ipfw/dummynet.c

1766

if (fs->flags & DN_QSIZE_BYTES) {

sbin/ipfw/dummynet.c

1774

if (fs->qsize > limit)

sbin/ipfw/dummynet.c

1784

if (fs->qsize > limit)

sbin/ipfw/dummynet.c

1789

if ((fs->flags & DN_IS_ECN) && !((fs->flags & DN_IS_RED)||

sbin/ipfw/dummynet.c

1790

(fs->flags & DN_IS_AQM)))

sbin/ipfw/dummynet.c

1794

if ((fs->flags & DN_IS_ECN) && !(fs->flags & DN_IS_RED))

sbin/ipfw/dummynet.c

1799

if (fs->flags & DN_IS_RED) {

sbin/ipfw/dummynet.c

1803

if (!(fs->flags & DN_IS_ECN) && (fs->min_th >= fs->max_th))

sbin/ipfw/dummynet.c

1805

fs->min_th, fs->max_th);

sbin/ipfw/dummynet.c

1806

else if ((fs->flags & DN_IS_ECN) && (fs->min_th > fs->max_th))

sbin/ipfw/dummynet.c

1808

fs->min_th, fs->max_th);

sbin/ipfw/dummynet.c

1810

if (fs->max_th == 0)

sbin/ipfw/dummynet.c

1850

w_q = ((double)fs->w_q) / (1 << SCALE_RED);

sbin/ipfw/dummynet.c

1852

fs->lookup_step = (int)idle / lookup_depth;

sbin/ipfw/dummynet.c

1853

if (!fs->lookup_step)

sbin/ipfw/dummynet.c

1854

fs->lookup_step = 1;

sbin/ipfw/dummynet.c

1856

for (t = fs->lookup_step; t > 1; --t)

sbin/ipfw/dummynet.c

1858

fs->lookup_weight = (int)(weight * (1 << SCALE_RED));

sbin/ipfw/dummynet.c

470

print_flowset_parms(struct dn_fs *fs, char *prefix)

sbin/ipfw/dummynet.c

477

l = fs->qsize;

sbin/ipfw/dummynet.c

478

if (fs->flags & DN_QSIZE_BYTES) {

sbin/ipfw/dummynet.c

485

if (fs->plr[0] || fs->plr[1]) {

sbin/ipfw/dummynet.c

486

if (fs->plr[1] == 0)

sbin/ipfw/dummynet.c

488

1.0 * fs->plr[0] / (double)(0x7fffffff));

sbin/ipfw/dummynet.c

491

1.0 * fs->plr[0] / (double)(0x7fffffff),

sbin/ipfw/dummynet.c

492

1.0 * fs->plr[1] / (double)(0x7fffffff),

sbin/ipfw/dummynet.c

493

1.0 * fs->plr[2] / (double)(0x7fffffff),

sbin/ipfw/dummynet.c

494

1.0 * fs->plr[3] / (double)(0x7fffffff));

sbin/ipfw/dummynet.c

498

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

sbin/ipfw/dummynet.c

501

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

sbin/ipfw/dummynet.c

502

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

sbin/ipfw/dummynet.c

503

fs->min_th,

sbin/ipfw/dummynet.c

504

fs->max_th,

sbin/ipfw/dummynet.c

505

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

sbin/ipfw/dummynet.c

506

if (fs->flags & DN_IS_ECN)

sbin/ipfw/dummynet.c

510

} else if (fs->flags & DN_IS_AQM) {

sbin/ipfw/dummynet.c

511

get_extra_parms(fs->fs_nr, red, DN_AQM_PARAMS);

sbin/ipfw/dummynet.c

518

prefix, qs, plr, fs->oid.id, fs->buckets, red);

sbin/ipfw/dummynet.c

523

fs->fs_nr, qs, plr, fs->oid.id, fs->buckets,

sbin/ipfw/dummynet.c

524

fs->sched_nr, fs->par[0], fs->par[1], fs->par[2], red);

sbin/ipfw/dummynet.c

525

if (fs->flags & DN_HAVE_MASK)

sbin/ipfw/dummynet.c

526

print_mask(&fs->flow_mask);

sbin/mount/mount.c

120

const char *fs[] = {

sbin/mount/mount.c

129

for (i = 0; fs[i] != NULL; ++i) {

sbin/mount/mount.c

130

if (strcmp(vfstype, fs[i]) == 0)

sbin/mount/mount.c

207

struct fstab *fs;

sbin/mount/mount.c

300

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

sbin/mount/mount.c

301

if (BADTYPE(fs->fs_type))

sbin/mount/mount.c

303

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

sbin/mount/mount.c

305

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

sbin/mount/mount.c

307

if (!hasopt(fs->fs_mntops, "late") && onlylate)

sbin/mount/mount.c

309

if (hasopt(fs->fs_mntops, "late") && !late)

sbin/mount/mount.c

311

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

sbin/mount/mount.c

316

!hasopt(fs->fs_mntops, "update") &&

sbin/mount/mount.c

317

ismounted(fs, mntbuf, mntsize))

sbin/mount/mount.c

319

options = update_options(options, fs->fs_mntops,

sbin/mount/mount.c

321

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

sbin/mount/mount.c

322

fs->fs_file, init_flags, options,

sbin/mount/mount.c

323

fs->fs_mntops) && !failok)

sbin/mount/mount.c

369

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

sbin/mount/mount.c

370

if (strcmp(fs->fs_spec,

sbin/mount/mount.c

372

strcmp(fs->fs_file,

sbin/mount/mount.c

378

strcmp(fs->fs_vfstype,

sbin/mount/mount.c

380

fs = getfsfile("/");

sbin/mount/mount.c

382

mntfromname = fs->fs_spec;

sbin/mount/mount.c

386

options = update_options(options, fs->fs_mntops,

sbin/mount/mount.c

397

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

sbin/mount/mount.c

398

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

sbin/mount/mount.c

401

if (BADTYPE(fs->fs_type))

sbin/mount/mount.c

404

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

sbin/mount/mount.c

405

init_flags, options, fs->fs_mntops);

sbin/mount/mount.c

452

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

sbin/mount/mount.c

457

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

sbin/mount/mount.c

462

if (realpath(fs->fs_file, realfsfile) == NULL) {

sbin/mount/mount.c

464

strlcpy(realfsfile, fs->fs_file, sizeof(realfsfile));

sbin/mount/mount.c

476

strcmp(fs->fs_vfstype, mntbuf[i].f_fstypename) == 0 &&

sbin/mount/mount.c

477

(!isremountable(fs->fs_vfstype) ||

sbin/mount/mount.c

478

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

sbin/newfs/mkfs.c

100

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

sbin/newfs/mkfs.c

104

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

sbin/newfs/mkfs.c

107

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

sbin/newfs/mkfs.c

1109

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

sbin/newfs/mkfs.c

1113

switch (fs->fs_frag) {

sbin/newfs/mkfs.c

1126

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

sbin/newfs/mkfs.c

1135

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

sbin/newfs/mkfs.c

1137

switch ((fs)->fs_frag) {

sbin/newfs/mkfs.c

1151

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

sbin/newfs/mkfs.c

1160

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

sbin/newfs/mkfs.c

1162

switch (fs->fs_frag) {

sbin/newfs/mkfs.c

1176

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

sbin/newfs/mkfs.c

126

struct fs fdummy;

sbin/newfs/mkfs.c

452

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

sbin/quotacheck/preen.c

101

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

sbin/quotacheck/preen.c

102

if (fs->fs_passno > passno && fs->fs_passno < nextpass)

sbin/quotacheck/preen.c

103

nextpass = fs->fs_passno;

sbin/quotacheck/preen.c

105

if (passno != fs->fs_passno)

sbin/quotacheck/preen.c

110

qfu = quota_open(fs, USRQUOTA, O_CREAT|O_RDWR);

sbin/quotacheck/preen.c

113

qfg = quota_open(fs, GRPQUOTA, O_CREAT|O_RDWR);

sbin/quotacheck/preen.c

118

sumstatus = chkquota(fs->fs_spec, qfu, qfg);

sbin/quotacheck/preen.c

127

addpart(fs, qfu, qfg);

sbin/quotacheck/preen.c

245

addpart(struct fstab *fs, struct quotafile *qfu, struct quotafile *qfg)

sbin/quotacheck/preen.c

247

struct diskentry *d = finddisk(fs->fs_spec);

sbin/quotacheck/preen.c

251

if (strcmp(p->p_devname, fs->fs_spec) == 0) {

sbin/quotacheck/preen.c

252

warnx("%s in fstab more than once!\n", fs->fs_spec);

sbin/quotacheck/preen.c

257

p->p_devname = estrdup(blockcheck(fs->fs_spec));

sbin/quotacheck/preen.c

83

struct fstab *fs;

sbin/quotacheck/quotacheck.c

124

struct fstab *fs;

sbin/quotacheck/quotacheck.c

192

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

sbin/quotacheck/quotacheck.c

193

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

sbin/quotacheck/quotacheck.c

194

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

sbin/quotacheck/quotacheck.c

195

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

sbin/quotacheck/quotacheck.c

199

qfu = quota_open(fs, USRQUOTA, O_CREAT|O_RDWR);

sbin/quotacheck/quotacheck.c

202

qfg = quota_open(fs, GRPQUOTA, O_CREAT|O_RDWR);

sbin/quotacheck/quotacheck.c

237

struct fs *fs;

sbin/quotacheck/quotacheck.c

306

if ((ret = sbget(fi, &fs, UFS_STDSB, UFS_NOCSUM)) != 0) {

sbin/quotacheck/quotacheck.c

316

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

sbin/quotacheck/quotacheck.c

317

free(fs);

sbin/quotacheck/quotacheck.c

68

struct fs sblk;

sbin/umount/umount.c

206

struct fstab *fs;

sbin/umount/umount.c

211

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

sbin/umount/umount.c

219

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

sbin/umount/umount.c

225

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

sbin/umount/umount.c

226

strcmp(fs->fs_type, FSTAB_RO) &&

sbin/umount/umount.c

227

strcmp(fs->fs_type, FSTAB_RQ))

sbin/umount/umount.c

230

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

sbin/umount/umount.c

232

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

sbin/umount/umount.c

240

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

sbin/umount/umount.c

242

(void)strcpy(cp, fs->fs_file);

sbin/umount/umount.c

247

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

stand/i386/btx/lib/btxv86.h

42

uint32_t fs; /* V86 FS register */

stand/libsa/cd9660.c

682

char *fs;

stand/libsa/cd9660.c

690

if (asprintf(&fs, "%s%s", dev, path) < 0)

stand/libsa/cd9660.c

693

mnt->cd_fd = open(fs, O_RDONLY);

stand/libsa/cd9660.c

694

free(fs);

stand/libsa/dosfs.c

1002

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

stand/libsa/dosfs.c

1008

err = ioget(fs, bytsec(fs, offset), fs->secbuf, secsiz);

stand/libsa/dosfs.c

1011

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

stand/libsa/dosfs.c

1021

ioget(DOS_FS *fs, daddr_t lsec, void *buf, size_t size)

stand/libsa/dosfs.c

1025

struct open_file *fd = fs->fd;

stand/libsa/dosfs.c

1030

lsec = secbyt(fs, lsec) >> 9;

stand/libsa/dosfs.c

147

#define bytsec(fs, n) ((n) >> (fs)->sshift)

stand/libsa/dosfs.c

148

#define secbyt(fs, s) ((s) << (fs)->sshift)

stand/libsa/dosfs.c

149

#define depsec(fs) (1 << (fs)->dshift)

stand/libsa/dosfs.c

150

#define entsec(fs, e) ((e) >> (fs)->dshift)

stand/libsa/dosfs.c

151

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

stand/libsa/dosfs.c

152

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

stand/libsa/dosfs.c

153

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

stand/libsa/dosfs.c

154

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

stand/libsa/dosfs.c

157

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

stand/libsa/dosfs.c

158

blkbyt(fs, (b) - LOCLUS))

stand/libsa/dosfs.c

161

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

stand/libsa/dosfs.c

169

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

stand/libsa/dosfs.c

189

dos_read_fatblk(DOS_FS *fs, u_int blknum)

stand/libsa/dosfs.c

196

max_offset_in_fat = secbyt(fs, (daddr_t)fs->spf);

stand/libsa/dosfs.c

204

err = ioget(fs, fs->lsnfat + bytsec(fs, offset_in_fat),

stand/libsa/dosfs.c

205

fs->fatbuf, io_size);

stand/libsa/dosfs.c

207

fs->fatbuf_blknum = ((u_int)(-1));

stand/libsa/dosfs.c

212

memset(fs->fatbuf + io_size, 0, FATBLKSZ - io_size);

stand/libsa/dosfs.c

214

fs->fatbuf_blknum = blknum;

stand/libsa/dosfs.c

222

dos_mount_impl(DOS_FS *fs, struct open_file *fd)

stand/libsa/dosfs.c

228

fs->fd = fd;

stand/libsa/dosfs.c

239

if ((err = ioget(fs, 0, buf, secsz)) ||

stand/libsa/dosfs.c

240

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

stand/libsa/dosfs.c

244

fs->secbuf = buf;

stand/libsa/dosfs.c

246

if ((fs->fatbuf = malloc(FATBLKSZ)) == NULL) {

stand/libsa/dosfs.c

250

err = dos_read_fatblk(fs, 0);

stand/libsa/dosfs.c

253

free(fs->fatbuf);

stand/libsa/dosfs.c

257

fs->root = dot[0];

stand/libsa/dosfs.c

258

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

stand/libsa/dosfs.c

259

if (fs->fatsz == 32) {

stand/libsa/dosfs.c

260

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

stand/libsa/dosfs.c

261

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

stand/libsa/dosfs.c

262

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

stand/libsa/dosfs.c

263

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

stand/libsa/dosfs.c

271

char *fs;

stand/libsa/dosfs.c

285

if (asprintf(&fs, "%s%s", dev, path) < 0)

stand/libsa/dosfs.c

288

mnt->dos_fd = open(fs, O_RDONLY);

stand/libsa/dosfs.c

289

free(fs);

stand/libsa/dosfs.c

296

mnt->dos_fs = df->fs;

stand/libsa/dosfs.c

331

dos_unmount_impl(DOS_FS *fs)

stand/libsa/dosfs.c

333

if (fs->links)

stand/libsa/dosfs.c

335

free(fs->secbuf);

stand/libsa/dosfs.c

336

free(fs->fatbuf);

stand/libsa/dosfs.c

337

free(fs);

stand/libsa/dosfs.c

349

DOS_FS *fs = NULL;

stand/libsa/dosfs.c

363

if ((fs = calloc(1, sizeof(DOS_FS))) == NULL)

stand/libsa/dosfs.c

365

if ((err = dos_mount_impl(fs, fd))) {

stand/libsa/dosfs.c

366

free(fs);

stand/libsa/dosfs.c

370

fs = mnt->dos_fs;

stand/libsa/dosfs.c

373

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

stand/libsa/dosfs.c

375

dos_unmount_impl(fs);

stand/libsa/dosfs.c

379

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

stand/libsa/dosfs.c

384

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

stand/libsa/dosfs.c

386

dos_unmount_impl(fs);

stand/libsa/dosfs.c

392

dos_unmount_impl(fs);

stand/libsa/dosfs.c

395

f->fs = fs;

stand/libsa/dosfs.c

396

fs->links++;

stand/libsa/dosfs.c

423

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

stand/libsa/dosfs.c

428

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

stand/libsa/dosfs.c

429

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

stand/libsa/dosfs.c

436

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

stand/libsa/dosfs.c

440

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

stand/libsa/dosfs.c

442

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

stand/libsa/dosfs.c

447

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

stand/libsa/dosfs.c

450

off += blkoff(f->fs, (uint64_t)c);

stand/libsa/dosfs.c

452

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

stand/libsa/dosfs.c

453

err = ioread(f->fs, off, buf, n);

stand/libsa/dosfs.c

510

DOS_FS *fs = f->fs;

stand/libsa/dosfs.c

512

f->fs->links--;

stand/libsa/dosfs.c

514

dos_unmount_impl(fs);

stand/libsa/dosfs.c

531

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

stand/libsa/dosfs.c

630

parsebs(DOS_FS *fs, DOS_BS *bs)

stand/libsa/dosfs.c

643

fs->sshift = ffs(cv2(bs->bpb.secsiz)) - 1;

stand/libsa/dosfs.c

650

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

stand/libsa/dosfs.c

652

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

stand/libsa/dosfs.c

653

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

stand/libsa/dosfs.c

654

fs->dshift = ffs(secbyt(fs, 1) / sizeof (DOS_DE)) - 1;

stand/libsa/dosfs.c

655

fs->dirents = cv2(bs->bpb.dirents);

stand/libsa/dosfs.c

656

fs->spf = cv2(bs->bpb.spf);

stand/libsa/dosfs.c

657

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

stand/libsa/dosfs.c

659

if (fs->spf != 0) {

stand/libsa/dosfs.c

662

if (fs->dirents == 0)

stand/libsa/dosfs.c

665

fs->spf = cv4(bs->bpb.fstype.f32.lspf);

stand/libsa/dosfs.c

666

if (fs->spf == 0)

stand/libsa/dosfs.c

670

fs->rdcl = cv4(bs->bpb.fstype.f32.rdcl);

stand/libsa/dosfs.c

671

if (fs->rdcl < LOCLUS)

stand/libsa/dosfs.c

675

RootDirSectors = ((fs->dirents * sizeof (DOS_DE)) +

stand/libsa/dosfs.c

676

(secbyt(fs, 1) - 1)) / secbyt(fs, 1);

stand/libsa/dosfs.c

678

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

stand/libsa/dosfs.c

679

fs->lsndta = fs->lsndir + RootDirSectors;

stand/libsa/dosfs.c

682

if (fs->lsndta > sc)

stand/libsa/dosfs.c

684

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

stand/libsa/dosfs.c

686

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

stand/libsa/dosfs.c

687

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

stand/libsa/dosfs.c

688

if (fs->xclus > sc)

stand/libsa/dosfs.c

689

fs->xclus = sc;

stand/libsa/dosfs.c

697

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

stand/libsa/dosfs.c

706

de = &fs->root;

stand/libsa/dosfs.c

721

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

stand/libsa/dosfs.c

732

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

stand/libsa/dosfs.c

746

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

stand/libsa/dosfs.c

747

clus = fs->rdcl;

stand/libsa/dosfs.c

748

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

stand/libsa/dosfs.c

751

dir = (DOS_DIR *)fs->secbuf;

stand/libsa/dosfs.c

754

lsec = fs->lsndir;

stand/libsa/dosfs.c

755

else if (okclus(fs, clus))

stand/libsa/dosfs.c

756

lsec = blklsn(fs, clus);

stand/libsa/dosfs.c

760

if ((err = ioget(fs, lsec + sec, dir,

stand/libsa/dosfs.c

761

secbyt(fs, 1))))

stand/libsa/dosfs.c

763

for (ent = 0; ent < depsec(fs); ent++) {

stand/libsa/dosfs.c

809

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

stand/libsa/dosfs.c

811

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

stand/libsa/dosfs.c

879

fsize(DOS_FS *fs, DOS_DE *de)

stand/libsa/dosfs.c

886

if (!(c = stclus(fs->fatsz, de))) {

stand/libsa/dosfs.c

887

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

stand/libsa/dosfs.c

889

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

stand/libsa/dosfs.c

891

size = blkbyt(fs, n);

stand/libsa/dosfs.c

901

fatcnt(DOS_FS *fs, u_int c)

stand/libsa/dosfs.c

905

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

stand/libsa/dosfs.c

906

if (fatget(fs, &c))

stand/libsa/dosfs.c

908

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

stand/libsa/dosfs.c

916

fatget(DOS_FS *fs, u_int *c)

stand/libsa/dosfs.c

928

offset = fatoff(fs->fatsz, val_in);

stand/libsa/dosfs.c

929

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

stand/libsa/dosfs.c

930

if (offset + nbyte > secbyt(fs, fs->spf))

stand/libsa/dosfs.c

936

if (blknum != fs->fatbuf_blknum) {

stand/libsa/dosfs.c

937

err = dos_read_fatblk(fs, blknum);

stand/libsa/dosfs.c

941

p_entry = fs->fatbuf + offset;

stand/libsa/dosfs.c

944

switch (fs->fatsz) {

stand/libsa/dosfs.c

979

ioread(DOS_FS *fs, uint64_t offset, void *buf, size_t nbyte)

stand/libsa/dosfs.c

986

secsiz = secbyt(fs, 1);

stand/libsa/dosfs.c

992

err = ioget(fs, bytsec(fs, offset), fs->secbuf, secsiz);

stand/libsa/dosfs.c

995

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

stand/libsa/dosfs.h

118

DOS_FS *fs; /* associated filesystem */

stand/libsa/ext2fs.c

137

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

stand/libsa/ext2fs.c

145

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

stand/libsa/ext2fs.c

146

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

stand/libsa/ext2fs.c

147

#define ino_to_db(fs, bg, ino) \

stand/libsa/ext2fs.c

148

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

stand/libsa/ext2fs.c

149

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

stand/libsa/ext2fs.c

150

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

stand/libsa/ext2fs.c

152

#define nindir(fs) \

stand/libsa/ext2fs.c

153

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

stand/libsa/ext2fs.c

154

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

stand/libsa/ext2fs.c

155

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

stand/libsa/ext2fs.c

156

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

stand/libsa/ext2fs.c

157

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

stand/libsa/ext2fs.c

158

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

stand/libsa/ext2fs.c

159

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

stand/libsa/ext2fs.c

160

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

stand/libsa/ext2fs.c

161

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

stand/libsa/ext2fs.c

162

#define dblksize(fs, dip, lbn) \

stand/libsa/ext2fs.c

163

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

stand/libsa/ext2fs.c

164

? (fs)->fs_bsize \

stand/libsa/ext2fs.c

165

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

stand/libsa/ext2fs.c

334

struct ext2fs *fs;

stand/libsa/ext2fs.c

352

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

stand/libsa/ext2fs.c

353

fp->f_fs = fs;

stand/libsa/ext2fs.c

356

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

stand/libsa/ext2fs.c

360

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

stand/libsa/ext2fs.c

368

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

stand/libsa/ext2fs.c

369

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

stand/libsa/ext2fs.c

370

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

stand/libsa/ext2fs.c

372

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

stand/libsa/ext2fs.c

373

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

stand/libsa/ext2fs.c

374

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

stand/libsa/ext2fs.c

376

if (fs->fs_revision == EXT2_REV0) {

stand/libsa/ext2fs.c

377

fs->fs_isize = EXT2_R0_ISIZE;

stand/libsa/ext2fs.c

378

fs->fs_firstino = EXT2_R0_FIRSTINO;

stand/libsa/ext2fs.c

380

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

stand/libsa/ext2fs.c

381

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

stand/libsa/ext2fs.c

383

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

stand/libsa/ext2fs.c

384

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

stand/libsa/ext2fs.c

385

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

stand/libsa/ext2fs.c

390

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

stand/libsa/ext2fs.c

391

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

stand/libsa/ext2fs.c

393

len = blkgrps * fs->fs_bsize;

stand/libsa/ext2fs.c

413

mult *= nindir(fs);

stand/libsa/ext2fs.c

498

struct ext2fs *fs = fp->f_fs;

stand/libsa/ext2fs.c

503

buf = malloc(fs->fs_bsize);

stand/libsa/ext2fs.c

510

F_READ, fsb_to_db(fs, disk_block),

stand/libsa/ext2fs.c

511

fs->fs_bsize, buf, &buf_size);

stand/libsa/ext2fs.c

559

struct ext2fs *fs = fp->f_fs;

stand/libsa/ext2fs.c

568

buf = malloc(fs->fs_bsize);

stand/libsa/ext2fs.c

571

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

stand/libsa/ext2fs.c

574

if (rsize != fs->fs_bsize) {

stand/libsa/ext2fs.c

580

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

stand/libsa/ext2fs.c

601

struct ext2fs *fs = fp->f_fs;

stand/libsa/ext2fs.c

665

malloc(fs->fs_bsize);

stand/libsa/ext2fs.c

668

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

stand/libsa/ext2fs.c

672

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

stand/libsa/ext2fs.c

701

struct ext2fs *fs = fp->f_fs;

stand/libsa/ext2fs.c

708

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

stand/libsa/ext2fs.c

709

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

stand/libsa/ext2fs.c

710

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

stand/libsa/ext2fs.c

718

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

stand/libsa/ext2fs.c

726

fsb_to_db(fs, disk_block), block_size,

stand/libsa/mount.c

105

struct fs_ops *fs;

stand/libsa/mount.c

107

fs = file_system[i];

stand/libsa/mount.c

108

if (fs->fo_mount == NULL)

stand/libsa/mount.c

111

__func__, fs->fs_name, path));

stand/libsa/mount.c

114

if (fs->fo_mount(dev, path, &data) != 0)

stand/libsa/mount.c

117

rc = add_mnt_info(fs, dev, path, data);

stand/libsa/mount.c

60

add_mnt_info(struct fs_ops *fs, const char *dev, const char *path, void *data)

stand/libsa/mount.c

68

mnt->mnt_fs = fs;

stand/libsa/open.c

138

struct fs_ops *fs;

stand/libsa/open.c

178

fs = exclusive_file_system;

stand/libsa/open.c

179

error = (fs->fo_open)(file, f);

stand/libsa/open.c

190

fs = file_system[i];

stand/libsa/open.c

195

error = (fs->fo_open)(file, f);

stand/libsa/open.c

215

f->f_ops = fs;

stand/libsa/ufs.c

113

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

stand/libsa/ufs.c

149

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

stand/libsa/ufs.c

152

int ffs_sbsearch(void *, struct fs **, int, char *,

stand/libsa/ufs.c

162

struct fs *fs = fp->f_fs;

stand/libsa/ufs.c

167

if (fs == NULL)

stand/libsa/ufs.c

173

buf = malloc(fs->fs_bsize);

stand/libsa/ufs.c

176

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

stand/libsa/ufs.c

180

if (rsize != fs->fs_bsize) {

stand/libsa/ufs.c

187

[ino_to_fsbo(fs, inumber)];

stand/libsa/ufs.c

190

[ino_to_fsbo(fs, inumber)];

stand/libsa/ufs.c

218

struct fs *fs = fp->f_fs;

stand/libsa/ufs.c

282

malloc(fs->fs_bsize);

stand/libsa/ufs.c

286

fs->fs_bsize,

stand/libsa/ufs.c

291

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

stand/libsa/ufs.c

320

struct fs *fs = fp->f_fs;

stand/libsa/ufs.c

330

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

stand/libsa/ufs.c

331

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

stand/libsa/ufs.c

332

block_size = sblksize(fs, DIP(fp, di_size), file_block);

stand/libsa/ufs.c

359

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

stand/libsa/ufs.c

363

fsbtodb(fs, disk_block),

stand/libsa/ufs.c

382

fsbtodb(fs, disk_block),

stand/libsa/ufs.c

395

struct fs *fs = fp->f_fs;

stand/libsa/ufs.c

402

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

stand/libsa/ufs.c

403

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

stand/libsa/ufs.c

404

block_size = sblksize(fs, DIP(fp, di_size), file_block);

stand/libsa/ufs.c

408

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

stand/libsa/ufs.c

420

fsbtodb(fs, disk_block),

stand/libsa/ufs.c

504

struct fs *fs;

stand/libsa/ufs.c

530

if ((rc = ffs_sbget(f, &fs, UFS_STDSB, UFS_NOHASHFAIL, "stand",

stand/libsa/ufs.c

541

fs = sfp->f_fs;

stand/libsa/ufs.c

543

fp->f_fs = fs;

stand/libsa/ufs.c

554

mult *= NINDIR(fs);

stand/libsa/ufs.c

637

if (link_len < fs->fs_maxsymlinklen) {

stand/libsa/ufs.c

646

struct fs *fs = fp->f_fs;

stand/libsa/ufs.c

649

buf = malloc(fs->fs_bsize);

stand/libsa/ufs.c

656

F_READ, fsbtodb(fs, disk_block),

stand/libsa/ufs.c

657

fs->fs_bsize, buf, &buf_size);

stand/libsa/ufs.c

911

char *fs;

stand/libsa/ufs.c

924

if (asprintf(&fs, "%s%s", dev, path) < 0)

stand/libsa/ufs.c

927

mnt->um_fd = open(fs, O_RDONLY);

stand/libsa/ufs.c

928

free(fs);

stand/libsa/ufsread.c

168

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

stand/libsa/ufsread.c

181

static struct fs fs;

stand/libsa/ufsread.c

211

memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));

stand/libsa/ufsread.c

214

fs.fs_magic == FS_UFS1_MAGIC

stand/libsa/ufsread.c

216

(fs.fs_magic == FS_UFS2_MAGIC &&

stand/libsa/ufsread.c

217

fs.fs_sblockloc == sblock_try[n])

stand/libsa/ufsread.c

219

fs.fs_magic == FS_UFS1_MAGIC ||

stand/libsa/ufsread.c

220

(fs.fs_magic == FS_UFS2_MAGIC &&

stand/libsa/ufsread.c

221

fs.fs_sblockloc == sblock_try[n])

stand/libsa/ufsread.c

224

fs.fs_bsize <= MAXBSIZE &&

stand/libsa/ufsread.c

225

fs.fs_bsize >= (int32_t)sizeof(struct fs))

stand/libsa/ufsread.c

233

memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));

stand/libsa/ufsread.c

237

n = IPERVBLK(&fs);

stand/libsa/ufsread.c

238

if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK))

stand/libsa/ufsread.c

248

if (fs.fs_magic == FS_UFS1_MAGIC)

stand/libsa/ufsread.c

266

lbn = lblkno(&fs, fs_off);

stand/libsa/ufsread.c

267

off = blkoff(&fs, fs_off);

stand/libsa/ufsread.c

270

} else if (lbn < UFS_NDADDR + NINDIR(&fs)) {

stand/libsa/ufsread.c

271

n = INDIRPERVBLK(&fs);

stand/libsa/ufsread.c

274

vbaddr = fsbtodb(&fs, addr2) + u;

stand/libsa/ufsread.c

289

if (fs.fs_magic == FS_UFS1_MAGIC) {

stand/libsa/ufsread.c

299

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

stand/libsa/ufsread.c

301

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

stand/libsa/ufsread.c

55

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

stand/libsa/ufsread.c

68

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

stand/libsa/ufsread.c

69

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

stand/libsa/ufsread.c

70

#define INO_TO_VBA(fs, ipervblk, x) \

stand/libsa/ufsread.c

71

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

stand/libsa/ufsread.c

72

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

stand/libsa/ufsread.c

74

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

stand/libsa/ufsread.c

76

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

stand/powerpc/boot1.chrp/boot1.c

48

static struct fs fs;

sys/amd64/include/asmacros.h

95

movw %fs,TF_FS(%rsp)

sys/amd64/linux/linux.h

234

l_ulong fs;

sys/amd64/linux/linux_machdep.c

249

l_regset->fs = b_reg->r_fs;

sys/amd64/linux/linux_machdep.c

280

b_reg->r_fs = l_regset->fs;

sys/amd64/linux/linux_machdep.c

373

.reg = offsetof(struct linux_pt_regset, fs),

sys/amd64/linux32/linux.h

409

l_uint fs;

sys/amd64/linux32/linux32_machdep.c

543

l_regset->fs = b_reg->r_fs;

sys/amd64/vmm/amd/vmcb.c

82

seg = &state->fs;

sys/amd64/vmm/amd/vmcb.h

306

struct vmcb_segment fs;

sys/amd64/vmm/vmm_util.c

105

DUMP_SEG(fs);

sys/compat/linprocfs/linprocfs.c

2380

struct pfs_node *dir, *fs, *root, *sys;

sys/compat/linprocfs/linprocfs.c

2531

pfs_create_dir(sys, &fs, "fs", NULL, NULL, NULL, 0);

sys/compat/linprocfs/linprocfs.c

2533

pfs_create_dir(fs, &dir, "inotify", NULL, NULL, NULL, 0);

sys/compat/linprocfs/linprocfs.c

2542

pfs_create_dir(fs, &dir, "mqueue", NULL, NULL, NULL, 0);

sys/dev/cxgbe/t4_filter.c

1001

if (tp->matchtype_shift >= 0 && fs->mask.matchtype) {

sys/dev/cxgbe/t4_filter.c

1002

*ftuple |= SFF(fs->val.matchtype, tp->matchtype_shift);

sys/dev/cxgbe/t4_filter.c

1005

if (tp->frag_shift >= 0 && fs->mask.frag) {

sys/dev/cxgbe/t4_filter.c

1006

*ftuple |= SFF(fs->val.frag, tp->frag_shift);

sys/dev/cxgbe/t4_filter.c

1009

if (tp->roce_shift >= 0 && fs->mask.roce) {

sys/dev/cxgbe/t4_filter.c

1010

*ftuple |= SFF(fs->val.roce, tp->roce_shift);

sys/dev/cxgbe/t4_filter.c

1013

if (tp->synonly_shift >= 0 && fs->mask.synonly) {

sys/dev/cxgbe/t4_filter.c

1014

*ftuple |= SFF(fs->val.synonly, tp->synonly_shift);

sys/dev/cxgbe/t4_filter.c

1017

if (tp->tcpflags_shift >= 0 && fs->mask.tcpflags) {

sys/dev/cxgbe/t4_filter.c

1018

*ftuple |= SFF(fs->val.tcpflags, tp->synonly_shift);

sys/dev/cxgbe/t4_filter.c

1022

if (fs->mask.ipsecidx || fs->mask.roce || fs->mask.synonly ||

sys/dev/cxgbe/t4_filter.c

1023

fs->mask.tcpflags) {

sys/dev/cxgbe/t4_filter.c

1030

if (tp->fcoe_shift >= 0 && fs->mask.fcoe) {

sys/dev/cxgbe/t4_filter.c

1031

*ftuple |= SFF(fs->val.fcoe, tp->fcoe_shift);

sys/dev/cxgbe/t4_filter.c

1034

if (tp->port_shift >= 0 && fs->mask.iport) {

sys/dev/cxgbe/t4_filter.c

1035

*ftuple |= (uint64_t)fs->val.iport << tp->port_shift;

sys/dev/cxgbe/t4_filter.c

1038

if (tp->vnic_shift >= 0 && fs->mask.vnic) {

sys/dev/cxgbe/t4_filter.c

1041

MPASS(fs->mask.pfvf_vld);

sys/dev/cxgbe/t4_filter.c

1043

MPASS(fs->mask.ovlan_vld);

sys/dev/cxgbe/t4_filter.c

1046

MPASS(fs->mask.encap_vld);

sys/dev/cxgbe/t4_filter.c

1048

*ftuple |= SFF(F_FT_VNID_ID_VLD | fs->val.vnic, tp->vnic_shift);

sys/dev/cxgbe/t4_filter.c

1051

if (tp->vlan_shift >= 0 && fs->mask.vlan) {

sys/dev/cxgbe/t4_filter.c

1052

*ftuple |= SFF(F_FT_VLAN_VLD | fs->val.vlan, tp->vlan_shift);

sys/dev/cxgbe/t4_filter.c

1055

if (tp->tos_shift >= 0 && fs->mask.tos) {

sys/dev/cxgbe/t4_filter.c

1056

*ftuple |= SFF(fs->val.tos, tp->tos_shift);

sys/dev/cxgbe/t4_filter.c

1059

if (tp->protocol_shift >= 0 && fs->mask.proto) {

sys/dev/cxgbe/t4_filter.c

1060

*ftuple |= SFF(fs->val.proto, tp->protocol_shift);

sys/dev/cxgbe/t4_filter.c

1063

if (tp->ethertype_shift >= 0 && fs->mask.ethtype) {

sys/dev/cxgbe/t4_filter.c

1064

*ftuple |= SFF(fs->val.ethtype, tp->ethertype_shift);

sys/dev/cxgbe/t4_filter.c

1067

if (tp->macmatch_shift >= 0 && fs->mask.macidx) {

sys/dev/cxgbe/t4_filter.c

1068

*ftuple |= SFF(fs->val.macidx, tp->macmatch_shift);

sys/dev/cxgbe/t4_filter.c

1071

if (tp->matchtype_shift >= 0 && fs->mask.matchtype) {

sys/dev/cxgbe/t4_filter.c

1072

*ftuple |= SFF(fs->val.matchtype, tp->matchtype_shift);

sys/dev/cxgbe/t4_filter.c

1075

if (tp->frag_shift >= 0 && fs->mask.frag) {

sys/dev/cxgbe/t4_filter.c

1076

*ftuple |= SFF(fs->val.frag, tp->frag_shift);

sys/dev/cxgbe/t4_filter.c

1090

is_4tuple_specified(struct t4_filter_specification *fs)

sys/dev/cxgbe/t4_filter.c

1093

const int n = fs->type ? 16 : 4;

sys/dev/cxgbe/t4_filter.c

1095

if (fs->mask.sport != 0xffff || fs->mask.dport != 0xffff)

sys/dev/cxgbe/t4_filter.c

1099

if (fs->mask.sip[i] != 0xff)

sys/dev/cxgbe/t4_filter.c

1101

if (fs->mask.dip[i] != 0xff)

sys/dev/cxgbe/t4_filter.c

1121

if (t->fs.hash) {

sys/dev/cxgbe/t4_filter.c

1128

if (is_t5(sc) && t->fs.hitcnts)

sys/dev/cxgbe/t4_filter.c

1130

if (!is_4tuple_specified(&t->fs))

sys/dev/cxgbe/t4_filter.c

1132

rc = hashfilter_ntuple(sc, &t->fs, &ftuple);

sys/dev/cxgbe/t4_filter.c

1136

if (separate_hpfilter_region(sc) && t->fs.prio) {

sys/dev/cxgbe/t4_filter.c

1148

if (t->fs.type == 1 &&

sys/dev/cxgbe/t4_filter.c

1154

if (is_t4(sc) && t->fs.action == FILTER_SWITCH &&

sys/dev/cxgbe/t4_filter.c

1155

(t->fs.newvlan == VLAN_REMOVE || t->fs.newvlan == VLAN_REWRITE ||

sys/dev/cxgbe/t4_filter.c

1156

t->fs.swapmac || t->fs.nat_mode))

sys/dev/cxgbe/t4_filter.c

1159

if (t->fs.action == FILTER_SWITCH && t->fs.eport >= sc->params.nports)

sys/dev/cxgbe/t4_filter.c

1161

if (t->fs.val.iport >= sc->params.nports)

sys/dev/cxgbe/t4_filter.c

1165

if (!t->fs.dirsteer && !t->fs.dirsteerhash && !t->fs.maskhash && t->fs.iq)

sys/dev/cxgbe/t4_filter.c

1169

rc = check_fspec_against_fconf_iconf(sc, &t->fs);

sys/dev/cxgbe/t4_filter.c

1189

if (t->fs.hash) {

sys/dev/cxgbe/t4_filter.c

1195

} else if (separate_hpfilter_region(sc) && t->fs.prio &&

sys/dev/cxgbe/t4_filter.c

1236

if (t->fs.newdmac || t->fs.newvlan) {

sys/dev/cxgbe/t4_filter.c

1238

l2te = t4_l2t_alloc_switching(sc, t->fs.vlan, t->fs.eport,

sys/dev/cxgbe/t4_filter.c

1239

t->fs.dmac);

sys/dev/cxgbe/t4_filter.c

1246

if (t->fs.newsmac) {

sys/dev/cxgbe/t4_filter.c

1248

smt = t4_smt_alloc_switching(sc->smt, t->fs.smac);

sys/dev/cxgbe/t4_filter.c

1253

rc = t4_smt_set_switching(sc, smt, 0x0, t->fs.smac);

sys/dev/cxgbe/t4_filter.c

1258

if (t->fs.hash)

sys/dev/cxgbe/t4_filter.c

1285

if (separate_hpfilter_region(sc) && t->fs.prio) {

sys/dev/cxgbe/t4_filter.c

1328

t->fs = f->fs; /* extra info for the caller */

sys/dev/cxgbe/t4_filter.c

1357

if (t->fs.hash) {

sys/dev/cxgbe/t4_filter.c

1360

} else if (separate_hpfilter_region(sc) && t->fs.prio) {

sys/dev/cxgbe/t4_filter.c

1463

if (f->fs.newsmac) {

sys/dev/cxgbe/t4_filter.c

1481

if (separate_hpfilter_region(sc) && f->fs.prio)

sys/dev/cxgbe/t4_filter.c

161

n += f->fs.type ? 2 : 1;

sys/dev/cxgbe/t4_filter.c

1629

MPASS(!t->fs.hash);

sys/dev/cxgbe/t4_filter.c

1631

if (separate_hpfilter_region(sc) && t->fs.prio) {

sys/dev/cxgbe/t4_filter.c

1660

if (f->fs.hitcnts)

sys/dev/cxgbe/t4_filter.c

1664

t->fs = f->fs;

sys/dev/cxgbe/t4_filter.c

1683

MPASS(t->fs.hash);

sys/dev/cxgbe/t4_filter.c

1700

if (f->fs.hitcnts)

sys/dev/cxgbe/t4_filter.c

1704

t->fs = f->fs;

sys/dev/cxgbe/t4_filter.c

1737

cpl->local_port = htobe16(f->fs.val.dport);

sys/dev/cxgbe/t4_filter.c

1738

cpl->peer_port = htobe16(f->fs.val.sport);

sys/dev/cxgbe/t4_filter.c

1739

cpl->local_ip_hi = *(uint64_t *)(&f->fs.val.dip);

sys/dev/cxgbe/t4_filter.c

1740

cpl->local_ip_lo = *(((uint64_t *)&f->fs.val.dip) + 1);

sys/dev/cxgbe/t4_filter.c

1741

cpl->peer_ip_hi = *(uint64_t *)(&f->fs.val.sip);

sys/dev/cxgbe/t4_filter.c

1742

cpl->peer_ip_lo = *(((uint64_t *)&f->fs.val.sip) + 1);

sys/dev/cxgbe/t4_filter.c

1743

cpl->opt0 = htobe64(V_NAGLE(f->fs.newvlan == VLAN_REMOVE ||

sys/dev/cxgbe/t4_filter.c

1744

f->fs.newvlan == VLAN_REWRITE) | V_DELACK(f->fs.hitcnts) |

sys/dev/cxgbe/t4_filter.c

1745

V_L2T_IDX(f->l2te ? f->l2te->idx : 0) | V_TX_CHAN(f->fs.eport) |

sys/dev/cxgbe/t4_filter.c

1746

V_NO_CONG(f->fs.rpttid) |

sys/dev/cxgbe/t4_filter.c

1747

V_ULP_MODE(f->fs.nat_mode ? ULP_MODE_TCPDDP : ULP_MODE_NONE) |

sys/dev/cxgbe/t4_filter.c

1751

cpl6->opt2 = htobe32(F_RSS_QUEUE_VALID | V_RSS_QUEUE(f->fs.iq) |

sys/dev/cxgbe/t4_filter.c

1752

V_TX_QUEUE(f->fs.nat_mode) | V_WND_SCALE_EN(f->fs.nat_flag_chk) |

sys/dev/cxgbe/t4_filter.c

1753

V_RX_FC_DISABLE(f->fs.nat_seq_chk ? 1 : 0) | F_T5_OPT_2_VALID |

sys/dev/cxgbe/t4_filter.c

1754

F_RX_CHANNEL | V_SACK_EN(f->fs.swapmac) |

sys/dev/cxgbe/t4_filter.c

1755

V_CONG_CNTRL((f->fs.action == FILTER_DROP) | (f->fs.dirsteer << 1)) |

sys/dev/cxgbe/t4_filter.c

1756

V_PACE(f->fs.maskhash | (f->fs.dirsteerhash << 1)));

sys/dev/cxgbe/t4_filter.c

1781

cpl->local_port = htobe16(f->fs.val.dport);

sys/dev/cxgbe/t4_filter.c

1782

cpl->peer_port = htobe16(f->fs.val.sport);

sys/dev/cxgbe/t4_filter.c

1783

cpl->local_ip = f->fs.val.dip[0] | f->fs.val.dip[1] << 8 |

sys/dev/cxgbe/t4_filter.c

1784

f->fs.val.dip[2] << 16 | f->fs.val.dip[3] << 24;

sys/dev/cxgbe/t4_filter.c

1785

cpl->peer_ip = f->fs.val.sip[0] | f->fs.val.sip[1] << 8 |

sys/dev/cxgbe/t4_filter.c

1786

f->fs.val.sip[2] << 16 | f->fs.val.sip[3] << 24;

sys/dev/cxgbe/t4_filter.c

1787

cpl->opt0 = htobe64(V_NAGLE(f->fs.newvlan == VLAN_REMOVE ||

sys/dev/cxgbe/t4_filter.c

1788

f->fs.newvlan == VLAN_REWRITE) | V_DELACK(f->fs.hitcnts) |

sys/dev/cxgbe/t4_filter.c

1789

V_L2T_IDX(f->l2te ? f->l2te->idx : 0) | V_TX_CHAN(f->fs.eport) |

sys/dev/cxgbe/t4_filter.c

1790

V_NO_CONG(f->fs.rpttid) |

sys/dev/cxgbe/t4_filter.c

1791

V_ULP_MODE(f->fs.nat_mode ? ULP_MODE_TCPDDP : ULP_MODE_NONE) |

sys/dev/cxgbe/t4_filter.c

1795

cpl6->opt2 = htobe32(F_RSS_QUEUE_VALID | V_RSS_QUEUE(f->fs.iq) |

sys/dev/cxgbe/t4_filter.c

1796

V_TX_QUEUE(f->fs.nat_mode) | V_WND_SCALE_EN(f->fs.nat_flag_chk) |

sys/dev/cxgbe/t4_filter.c

1797

V_RX_FC_DISABLE(f->fs.nat_seq_chk ? 1 : 0) | F_T5_OPT_2_VALID |

sys/dev/cxgbe/t4_filter.c

1798

F_RX_CHANNEL | V_SACK_EN(f->fs.swapmac) |

sys/dev/cxgbe/t4_filter.c

1799

V_CONG_CNTRL((f->fs.action == FILTER_DROP) | (f->fs.dirsteer << 1)) |

sys/dev/cxgbe/t4_filter.c

1800

V_PACE(f->fs.maskhash | (f->fs.dirsteerhash << 1)));

sys/dev/cxgbe/t4_filter.c

1842

MPASS(t->fs.hash);

sys/dev/cxgbe/t4_filter.c

1844

MPASS((t->fs.val.pfvf_vld & t->fs.val.ovlan_vld) == 0);

sys/dev/cxgbe/t4_filter.c

1845

MPASS((t->fs.mask.pfvf_vld & t->fs.mask.ovlan_vld) == 0);

sys/dev/cxgbe/t4_filter.c

1847

hash = hf_hashfn_4t(&t->fs);

sys/dev/cxgbe/t4_filter.c

1850

if (lookup_hf(sc, &t->fs, hash) != NULL) {

sys/dev/cxgbe/t4_filter.c

1860

f->fs = t->fs;

sys/dev/cxgbe/t4_filter.c

1872

wr = start_wrq_wr(&sc->sge.ctrlq[0], act_open_cpl_len16(sc, f->fs.type),

sys/dev/cxgbe/t4_filter.c

1880

if (f->fs.type)

sys/dev/cxgbe/t4_filter.c

193

hash = hf_hashfn_4t(&f->fs);

sys/dev/cxgbe/t4_filter.c

195

atomic_add_int(&t->tids_in_use, f->fs.type ? 2 : 1);

sys/dev/cxgbe/t4_filter.c

2045

t->fs = f->fs; /* extra info for the caller */

sys/dev/cxgbe/t4_filter.c

2077

if (f->fs.type) {

sys/dev/cxgbe/t4_filter.c

2079

f->fs.nat_dip[15] | f->fs.nat_dip[14] << 8 |

sys/dev/cxgbe/t4_filter.c

2080

f->fs.nat_dip[13] << 16 | f->fs.nat_dip[12] << 24, 1);

sys/dev/cxgbe/t4_filter.c

2084

f->fs.nat_dip[11] | f->fs.nat_dip[10] << 8 |

sys/dev/cxgbe/t4_filter.c

2085

f->fs.nat_dip[9] << 16 | f->fs.nat_dip[8] << 24, 1);

sys/dev/cxgbe/t4_filter.c

2089

f->fs.nat_dip[7] | f->fs.nat_dip[6] << 8 |

sys/dev/cxgbe/t4_filter.c

2090

f->fs.nat_dip[5] << 16 | f->fs.nat_dip[4] << 24, 1);

sys/dev/cxgbe/t4_filter.c

2094

f->fs.nat_dip[3] | f->fs.nat_dip[2] << 8 |

sys/dev/cxgbe/t4_filter.c

2095

f->fs.nat_dip[1] << 16 | f->fs.nat_dip[0] << 24, 1);

sys/dev/cxgbe/t4_filter.c

2099

f->fs.nat_dip[3] | f->fs.nat_dip[2] << 8 |

sys/dev/cxgbe/t4_filter.c

2100

f->fs.nat_dip[1] << 16 | f->fs.nat_dip[0] << 24, 1);

sys/dev/cxgbe/t4_filter.c

2105

if (f->fs.type) {

sys/dev/cxgbe/t4_filter.c

2108

f->fs.nat_sip[15] | f->fs.nat_sip[14] << 8 |

sys/dev/cxgbe/t4_filter.c

2109

f->fs.nat_sip[13] << 16 | f->fs.nat_sip[12] << 24, 1);

sys/dev/cxgbe/t4_filter.c

2113

f->fs.nat_sip[11] | f->fs.nat_sip[10] << 8 |

sys/dev/cxgbe/t4_filter.c

2114

f->fs.nat_sip[9] << 16 | f->fs.nat_sip[8] << 24, 1);

sys/dev/cxgbe/t4_filter.c

2118

f->fs.nat_sip[7] | f->fs.nat_sip[6] << 8 |

sys/dev/cxgbe/t4_filter.c

2119

f->fs.nat_sip[5] << 16 | f->fs.nat_sip[4] << 24, 1);

sys/dev/cxgbe/t4_filter.c

2123

f->fs.nat_sip[3] | f->fs.nat_sip[2] << 8 |

sys/dev/cxgbe/t4_filter.c

2124

f->fs.nat_sip[1] << 16 | f->fs.nat_sip[0] << 24, 1);

sys/dev/cxgbe/t4_filter.c

2129

f->fs.nat_sip[3] | f->fs.nat_sip[2] << 8 |

sys/dev/cxgbe/t4_filter.c

2130

f->fs.nat_sip[1] << 16 | f->fs.nat_sip[0] << 24, 1);

sys/dev/cxgbe/t4_filter.c

2135

(dp ? f->fs.nat_dport : 0) | (sp ? f->fs.nat_sport << 16 : 0), 1);

sys/dev/cxgbe/t4_filter.c

2149

MPASS(f->fs.hash);

sys/dev/cxgbe/t4_filter.c

2153

if (f->fs.newdmac) {

sys/dev/cxgbe/t4_filter.c

2158

if (f->fs.newvlan == VLAN_INSERT || f->fs.newvlan == VLAN_REWRITE) {

sys/dev/cxgbe/t4_filter.c

2163

if (f->fs.newsmac) {

sys/dev/cxgbe/t4_filter.c

2172

switch(f->fs.nat_mode) {

sys/dev/cxgbe/t4_filter.c

2209

if (f->fs.nat_seq_chk) {

sys/dev/cxgbe/t4_filter.c

2212

V_TCB_RCV_NXT(f->fs.nat_seq_chk), 1);

sys/dev/cxgbe/t4_filter.c

2216

if (is_t5(sc) && f->fs.action == FILTER_DROP) {

sys/dev/cxgbe/t4_filter.c

2230

if (f->fs.action == FILTER_SWITCH) {

sys/dev/cxgbe/t4_filter.c

2235

if (f->fs.hitcnts || updated > 0) {

sys/dev/cxgbe/t4_filter.c

262

lookup_hf(struct adapter *sc, struct t4_filter_specification *fs, uint32_t hash)

sys/dev/cxgbe/t4_filter.c

272

hash = hf_hashfn_4t(fs);

sys/dev/cxgbe/t4_filter.c

275

if (filter_eq(&f->fs, fs))

sys/dev/cxgbe/t4_filter.c

310

atomic_subtract_int(&t->tids_in_use, f->fs.type ? 2 : 1);

sys/dev/cxgbe/t4_filter.c

424

struct t4_filter_specification *fs)

sys/dev/cxgbe/t4_filter.c

430

if (fs->val.tcpflags || fs->mask.tcpflags)

sys/dev/cxgbe/t4_filter.c

432

if (fs->val.synonly || fs->mask.synonly)

sys/dev/cxgbe/t4_filter.c

434

if (fs->val.roce || fs->mask.roce)

sys/dev/cxgbe/t4_filter.c

436

if (fs->val.frag || fs->mask.frag)

sys/dev/cxgbe/t4_filter.c

438

if (fs->val.matchtype || fs->mask.matchtype)

sys/dev/cxgbe/t4_filter.c

440

if (fs->val.macidx || fs->mask.macidx)

sys/dev/cxgbe/t4_filter.c

442

if (fs->val.ethtype || fs->mask.ethtype)

sys/dev/cxgbe/t4_filter.c

444

if (fs->val.proto || fs->mask.proto)

sys/dev/cxgbe/t4_filter.c

446

if (fs->val.tos || fs->mask.tos)

sys/dev/cxgbe/t4_filter.c

448

if (fs->val.vlan_vld || fs->mask.vlan_vld)

sys/dev/cxgbe/t4_filter.c

450

if (fs->val.ovlan_vld || fs->mask.ovlan_vld) {

sys/dev/cxgbe/t4_filter.c

455

if (fs->val.pfvf_vld || fs->mask.pfvf_vld) {

sys/dev/cxgbe/t4_filter.c

461

if (fs->val.encap_vld || fs->mask.encap_vld) {

sys/dev/cxgbe/t4_filter.c

467

if (fs->val.iport || fs->mask.iport)

sys/dev/cxgbe/t4_filter.c

469

if (fs->val.fcoe || fs->mask.fcoe)

sys/dev/cxgbe/t4_filter.c

471

if (fs->val.ipsecidx || fs->mask.ipsecidx)

sys/dev/cxgbe/t4_filter.c

474

if (fs->val.tcpflags || fs->mask.tcpflags ||

sys/dev/cxgbe/t4_filter.c

475

fs->val.synonly || fs->mask.synonly ||

sys/dev/cxgbe/t4_filter.c

476

fs->val.roce || fs->mask.roce ||

sys/dev/cxgbe/t4_filter.c

477

fs->val.ipsecidx || fs->mask.ipsecidx)

sys/dev/cxgbe/t4_filter.c

479

if (fs->val.frag || fs->mask.frag)

sys/dev/cxgbe/t4_filter.c

481

if (fs->val.matchtype || fs->mask.matchtype)

sys/dev/cxgbe/t4_filter.c

483

if (fs->val.macidx || fs->mask.macidx)

sys/dev/cxgbe/t4_filter.c

485

if (fs->val.ethtype || fs->mask.ethtype)

sys/dev/cxgbe/t4_filter.c

487

if (fs->val.proto || fs->mask.proto)

sys/dev/cxgbe/t4_filter.c

489

if (fs->val.tos || fs->mask.tos)

sys/dev/cxgbe/t4_filter.c

491

if (fs->val.vlan_vld || fs->mask.vlan_vld)

sys/dev/cxgbe/t4_filter.c

493

if (fs->val.ovlan_vld || fs->mask.ovlan_vld) {

sys/dev/cxgbe/t4_filter.c

498

if (fs->val.pfvf_vld || fs->mask.pfvf_vld) {

sys/dev/cxgbe/t4_filter.c

504

if (fs->val.encap_vld || fs->mask.encap_vld) {

sys/dev/cxgbe/t4_filter.c

510

if (fs->val.iport || fs->mask.iport)

sys/dev/cxgbe/t4_filter.c

512

if (fs->val.fcoe || fs->mask.fcoe)

sys/dev/cxgbe/t4_filter.c

65

struct t4_filter_specification fs;

sys/dev/cxgbe/t4_filter.c

761

if (t->fs.hash)

sys/dev/cxgbe/t4_filter.c

777

const int ntids = t->fs.type ? 4 : 1;

sys/dev/cxgbe/t4_filter.c

779

MPASS(!t->fs.hash);

sys/dev/cxgbe/t4_filter.c

781

MPASS((t->fs.val.pfvf_vld & t->fs.val.ovlan_vld) == 0);

sys/dev/cxgbe/t4_filter.c

782

MPASS((t->fs.mask.pfvf_vld & t->fs.mask.ovlan_vld) == 0);

sys/dev/cxgbe/t4_filter.c

784

if (separate_hpfilter_region(sc) && t->fs.prio) {

sys/dev/cxgbe/t4_filter.c

815

if (separate_hpfilter_region(sc) && t->fs.prio)

sys/dev/cxgbe/t4_filter.c

830

f->fs = t->fs;

sys/dev/cxgbe/t4_filter.c

834

if (t->fs.val.pfvf_vld || t->fs.val.ovlan_vld)

sys/dev/cxgbe/t4_filter.c

838

if (t->fs.mask.pfvf_vld || t->fs.mask.ovlan_vld)

sys/dev/cxgbe/t4_filter.c

84

hf_hashfn_4t(struct t4_filter_specification *fs)

sys/dev/cxgbe/t4_filter.c

851

V_FW_FILTER_WR_RQTYPE(f->fs.type) |

sys/dev/cxgbe/t4_filter.c

853

V_FW_FILTER_WR_IQ(f->fs.iq));

sys/dev/cxgbe/t4_filter.c

855

htobe32(V_FW_FILTER_WR_RPTTID(f->fs.rpttid) |

sys/dev/cxgbe/t4_filter.c

856

V_FW_FILTER_WR_DROP(f->fs.action == FILTER_DROP) |

sys/dev/cxgbe/t4_filter.c

857

V_FW_FILTER_WR_DIRSTEER(f->fs.dirsteer) |

sys/dev/cxgbe/t4_filter.c

858

V_FW_FILTER_WR_MASKHASH(f->fs.maskhash) |

sys/dev/cxgbe/t4_filter.c

859

V_FW_FILTER_WR_DIRSTEERHASH(f->fs.dirsteerhash) |

sys/dev/cxgbe/t4_filter.c

86

struct t4_filter_tuple *ft = &fs->val;

sys/dev/cxgbe/t4_filter.c

860

V_FW_FILTER_WR_LPBK(f->fs.action == FILTER_SWITCH) |

sys/dev/cxgbe/t4_filter.c

861

V_FW_FILTER_WR_DMAC(f->fs.newdmac) |

sys/dev/cxgbe/t4_filter.c

862

V_FW_FILTER_WR_SMAC(f->fs.newsmac) |

sys/dev/cxgbe/t4_filter.c

863

V_FW_FILTER_WR_INSVLAN(f->fs.newvlan == VLAN_INSERT ||

sys/dev/cxgbe/t4_filter.c

864

f->fs.newvlan == VLAN_REWRITE) |

sys/dev/cxgbe/t4_filter.c

865

V_FW_FILTER_WR_RMVLAN(f->fs.newvlan == VLAN_REMOVE ||

sys/dev/cxgbe/t4_filter.c

866

f->fs.newvlan == VLAN_REWRITE) |

sys/dev/cxgbe/t4_filter.c

867

V_FW_FILTER_WR_HITCNTS(f->fs.hitcnts) |

sys/dev/cxgbe/t4_filter.c

868

V_FW_FILTER_WR_TXCHAN(f->fs.eport) |

sys/dev/cxgbe/t4_filter.c

869

V_FW_FILTER_WR_PRIO(f->fs.prio) |

sys/dev/cxgbe/t4_filter.c

871

fwr->ethtype = htobe16(f->fs.val.ethtype);

sys/dev/cxgbe/t4_filter.c

872

fwr->ethtypem = htobe16(f->fs.mask.ethtype);

sys/dev/cxgbe/t4_filter.c

874

(V_FW_FILTER_WR_FRAG(f->fs.val.frag) |

sys/dev/cxgbe/t4_filter.c

875

V_FW_FILTER_WR_FRAGM(f->fs.mask.frag) |

sys/dev/cxgbe/t4_filter.c

876

V_FW_FILTER_WR_IVLAN_VLD(f->fs.val.vlan_vld) |

sys/dev/cxgbe/t4_filter.c

878

V_FW_FILTER_WR_IVLAN_VLDM(f->fs.mask.vlan_vld) |

sys/dev/cxgbe/t4_filter.c

884

htobe32(V_FW_FILTER_WR_MACI(f->fs.val.macidx) |

sys/dev/cxgbe/t4_filter.c

885

V_FW_FILTER_WR_MACIM(f->fs.mask.macidx) |

sys/dev/cxgbe/t4_filter.c

886

V_FW_FILTER_WR_FCOE(f->fs.val.fcoe) |

sys/dev/cxgbe/t4_filter.c

887

V_FW_FILTER_WR_FCOEM(f->fs.mask.fcoe) |

sys/dev/cxgbe/t4_filter.c

888

V_FW_FILTER_WR_PORT(f->fs.val.iport) |

sys/dev/cxgbe/t4_filter.c

889

V_FW_FILTER_WR_PORTM(f->fs.mask.iport) |

sys/dev/cxgbe/t4_filter.c

89

if (fs->type) {

sys/dev/cxgbe/t4_filter.c

890

V_FW_FILTER_WR_MATCHTYPE(f->fs.val.matchtype) |

sys/dev/cxgbe/t4_filter.c

891

V_FW_FILTER_WR_MATCHTYPEM(f->fs.mask.matchtype));

sys/dev/cxgbe/t4_filter.c

892

fwr->ptcl = f->fs.val.proto;

sys/dev/cxgbe/t4_filter.c

893

fwr->ptclm = f->fs.mask.proto;

sys/dev/cxgbe/t4_filter.c

894

fwr->ttyp = f->fs.val.tos;

sys/dev/cxgbe/t4_filter.c

895

fwr->ttypm = f->fs.mask.tos;

sys/dev/cxgbe/t4_filter.c

896

fwr->ivlan = htobe16(f->fs.val.vlan);

sys/dev/cxgbe/t4_filter.c

897

fwr->ivlanm = htobe16(f->fs.mask.vlan);

sys/dev/cxgbe/t4_filter.c

898

fwr->ovlan = htobe16(f->fs.val.vnic);

sys/dev/cxgbe/t4_filter.c

899

fwr->ovlanm = htobe16(f->fs.mask.vnic);

sys/dev/cxgbe/t4_filter.c

900

bcopy(f->fs.val.dip, fwr->lip, sizeof (fwr->lip));

sys/dev/cxgbe/t4_filter.c

901

bcopy(f->fs.mask.dip, fwr->lipm, sizeof (fwr->lipm));

sys/dev/cxgbe/t4_filter.c

902

bcopy(f->fs.val.sip, fwr->fip, sizeof (fwr->fip));

sys/dev/cxgbe/t4_filter.c

903

bcopy(f->fs.mask.sip, fwr->fipm, sizeof (fwr->fipm));

sys/dev/cxgbe/t4_filter.c

904

fwr->lp = htobe16(f->fs.val.dport);

sys/dev/cxgbe/t4_filter.c

905

fwr->lpm = htobe16(f->fs.mask.dport);

sys/dev/cxgbe/t4_filter.c

906

fwr->fp = htobe16(f->fs.val.sport);

sys/dev/cxgbe/t4_filter.c

907

fwr->fpm = htobe16(f->fs.mask.sport);

sys/dev/cxgbe/t4_filter.c

912

V_FW_FILTER2_WR_SWAPMAC(f->fs.swapmac);

sys/dev/cxgbe/t4_filter.c

914

V_FW_FILTER2_WR_ULP_TYPE(f->fs.nat_mode ?

sys/dev/cxgbe/t4_filter.c

916

V_FW_FILTER2_WR_NATFLAGCHECK(f->fs.nat_flag_chk) |

sys/dev/cxgbe/t4_filter.c

917

V_FW_FILTER2_WR_NATMODE(f->fs.nat_mode);

sys/dev/cxgbe/t4_filter.c

918

memcpy(fwr->newlip, f->fs.nat_dip, sizeof(fwr->newlip));

sys/dev/cxgbe/t4_filter.c

919

memcpy(fwr->newfip, f->fs.nat_sip, sizeof(fwr->newfip));

sys/dev/cxgbe/t4_filter.c

920

fwr->newlport = htobe16(f->fs.nat_dport);

sys/dev/cxgbe/t4_filter.c

921

fwr->newfport = htobe16(f->fs.nat_sport);

sys/dev/cxgbe/t4_filter.c

922

fwr->natseqcheck = htobe32(f->fs.nat_seq_chk);

sys/dev/cxgbe/t4_filter.c

943

hashfilter_ntuple(struct adapter *sc, const struct t4_filter_specification *fs,

sys/dev/cxgbe/t4_filter.c

956

if (tp->ipsecidx_shift >= 0 && fs->mask.ipsecidx) {

sys/dev/cxgbe/t4_filter.c

957

*ftuple |= SFF(fs->val.ipsecidx, tp->ipsecidx_shift);

sys/dev/cxgbe/t4_filter.c

960

if (tp->fcoe_shift >= 0 && fs->mask.fcoe) {

sys/dev/cxgbe/t4_filter.c

961

*ftuple |= SFF(fs->val.fcoe, tp->fcoe_shift);

sys/dev/cxgbe/t4_filter.c

964

if (tp->port_shift >= 0 && fs->mask.iport) {

sys/dev/cxgbe/t4_filter.c

965

*ftuple |= (uint64_t)fs->val.iport << tp->port_shift;

sys/dev/cxgbe/t4_filter.c

968

if (tp->vnic_shift >= 0 && fs->mask.vnic) {

sys/dev/cxgbe/t4_filter.c

971

MPASS(fs->mask.pfvf_vld);

sys/dev/cxgbe/t4_filter.c

973

MPASS(fs->mask.ovlan_vld);

sys/dev/cxgbe/t4_filter.c

976

MPASS(fs->mask.encap_vld);

sys/dev/cxgbe/t4_filter.c

978

*ftuple |= SFF(F_FT_VNID_ID_VLD | fs->val.vnic, tp->vnic_shift);

sys/dev/cxgbe/t4_filter.c

981

if (tp->vlan_shift >= 0 && fs->mask.vlan) {

sys/dev/cxgbe/t4_filter.c

982

*ftuple |= SFF(F_FT_VLAN_VLD | fs->val.vlan, tp->vlan_shift);

sys/dev/cxgbe/t4_filter.c

985

if (tp->tos_shift >= 0 && fs->mask.tos) {

sys/dev/cxgbe/t4_filter.c

986

*ftuple |= SFF(fs->val.tos, tp->tos_shift);

sys/dev/cxgbe/t4_filter.c

989

if (tp->protocol_shift >= 0 && fs->mask.proto) {

sys/dev/cxgbe/t4_filter.c

990

*ftuple |= SFF(fs->val.proto, tp->protocol_shift);

sys/dev/cxgbe/t4_filter.c

993

if (tp->ethertype_shift >= 0 && fs->mask.ethtype) {

sys/dev/cxgbe/t4_filter.c

994

*ftuple |= SFF(fs->val.ethtype, tp->ethertype_shift);

sys/dev/cxgbe/t4_filter.c

997

if (tp->macmatch_shift >= 0 && fs->mask.macidx) {

sys/dev/cxgbe/t4_filter.c

998

*ftuple |= SFF(fs->val.macidx, tp->macmatch_shift);

sys/dev/cxgbe/t4_ioctl.h

260

struct t4_filter_specification fs;

sys/dev/dpaa2/dpaa2_ni.c

763

sc->attr.entries.qos, sc->attr.entries.fs);

sys/dev/dpaa2/dpaa2_ni.c

765

sc->attr.key_size.qos, sc->attr.key_size.fs);

sys/dev/dpaa2/dpaa2_ni.h

204

uint16_t fs;

sys/dev/dpaa2/dpaa2_ni.h

217

uint8_t fs;

sys/dev/dpaa2/dpaa2_rc.c

1193

attr->entries.fs = resp->fs_entries;

sys/dev/dpaa2/dpaa2_rc.c

1204

attr->key_size.fs = resp->fs_key_size;

sys/dev/firewire/iec68113.h

82

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

sys/dev/firewire/iec68113.h

89

fs:1; /* 50/60 field system

sys/fs/ext2fs/ext2_alloc.c

1002

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

1009

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

1011

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

sys/fs/ext2fs/ext2_alloc.c

1015

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

sys/fs/ext2fs/ext2_alloc.c

1016

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

sys/fs/ext2fs/ext2_alloc.c

1017

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

sys/fs/ext2fs/ext2_alloc.c

1021

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||

sys/fs/ext2fs/ext2_alloc.c

1022

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/fs/ext2fs/ext2_alloc.c

1023

error = ext2_cg_block_bitmap_init(fs, cg, bp);

sys/fs/ext2fs/ext2_alloc.c

1027

ext2_gd_b_bitmap_csum_set(fs, cg, bp);

sys/fs/ext2fs/ext2_alloc.c

1029

error = ext2_gd_b_bitmap_csum_verify(fs, cg, bp);

sys/fs/ext2fs/ext2_alloc.c

103

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

1033

error = ext2_b_bitmap_validate(fs,bp, cg);

sys/fs/ext2fs/ext2_alloc.c

1041

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

sys/fs/ext2fs/ext2_alloc.c

1046

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

sys/fs/ext2fs/ext2_alloc.c

1049

bpref = dtogd(fs, bpref);

sys/fs/ext2fs/ext2_alloc.c

1065

start = dtogd(fs, bpref) / NBBY;

sys/fs/ext2fs/ext2_alloc.c

1068

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

sys/fs/ext2fs/ext2_alloc.c

109

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

1115

bno = ext2_mapsearch(fs, bbp, bpref);

sys/fs/ext2fs/ext2_alloc.c

1123

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

sys/fs/ext2fs/ext2_alloc.c

1129

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

sys/fs/ext2fs/ext2_alloc.c

113

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

sys/fs/ext2fs/ext2_alloc.c

1130

fs->e2fs_fbcount--;

sys/fs/ext2fs/ext2_alloc.c

1131

e2fs_gd_set_nbfree(&fs->e2fs_gd[cg],

sys/fs/ext2fs/ext2_alloc.c

1132

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

sys/fs/ext2fs/ext2_alloc.c

1133

fs->e2fs_fmod = 1;

sys/fs/ext2fs/ext2_alloc.c

1135

ext2_gd_b_bitmap_csum_set(fs, cg, bp);

sys/fs/ext2fs/ext2_alloc.c

1137

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

sys/fs/ext2fs/ext2_alloc.c

1138

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

sys/fs/ext2fs/ext2_alloc.c

115

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

sys/fs/ext2fs/ext2_alloc.c

1152

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

1160

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

1163

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

sys/fs/ext2fs/ext2_alloc.c

1168

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

sys/fs/ext2fs/ext2_alloc.c

1169

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

sys/fs/ext2fs/ext2_alloc.c

1179

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

sys/fs/ext2fs/ext2_alloc.c

1180

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

sys/fs/ext2fs/ext2_alloc.c

1183

if (i > fs->e2fs_contigsumsize) {

sys/fs/ext2fs/ext2_alloc.c

1190

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

sys/fs/ext2fs/ext2_alloc.c

1194

fs->e2fs_maxcluster[cg] = i;

sys/fs/ext2fs/ext2_alloc.c

1200

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

sys/fs/ext2fs/ext2_alloc.c

1203

bpref = dtogd(fs, bpref);

sys/fs/ext2fs/ext2_alloc.c

1206

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

sys/fs/ext2fs/ext2_alloc.c

121

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

sys/fs/ext2fs/ext2_alloc.c

1222

if (got >= fs->e2fs_fpg)

sys/fs/ext2fs/ext2_alloc.c

1231

if (bno >= fs->e2fs_fpg)

sys/fs/ext2fs/ext2_alloc.c

1235

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

sys/fs/ext2fs/ext2_alloc.c

1237

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

sys/fs/ext2fs/ext2_alloc.c

1238

fs->e2fs_fbcount--;

sys/fs/ext2fs/ext2_alloc.c

1239

e2fs_gd_set_nbfree(&fs->e2fs_gd[cg],

sys/fs/ext2fs/ext2_alloc.c

124

fs->e2fs_fbcount < fs->e2fs_rbcount)

sys/fs/ext2fs/ext2_alloc.c

1240

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

sys/fs/ext2fs/ext2_alloc.c

1242

fs->e2fs_fmod = 1;

sys/fs/ext2fs/ext2_alloc.c

1246

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

sys/fs/ext2fs/ext2_alloc.c

1259

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

126

if (bpref >= fs->e2fs_bcount)

sys/fs/ext2fs/ext2_alloc.c

1263

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

1265

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

sys/fs/ext2fs/ext2_alloc.c

1268

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

sys/fs/ext2fs/ext2_alloc.c

1269

fs->e2fs_bsize;

sys/fs/ext2fs/ext2_alloc.c

1271

used_blks = howmany(fs->e2fs_ipg -

sys/fs/ext2fs/ext2_alloc.c

1272

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

sys/fs/ext2fs/ext2_alloc.c

1273

fs->e2fs_bsize / EXT2_INODE_SIZE(fs));

sys/fs/ext2fs/ext2_alloc.c

1276

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

sys/fs/ext2fs/ext2_alloc.c

1277

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

sys/fs/ext2fs/ext2_alloc.c

1278

fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_alloc.c

1282

vfs_bio_bzero_buf(bp, 0, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_alloc.c

1286

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

sys/fs/ext2fs/ext2_alloc.c

1287

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

sys/fs/ext2fs/ext2_alloc.c

129

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

sys/fs/ext2fs/ext2_alloc.c

131

cg = dtog(fs, bpref);

sys/fs/ext2fs/ext2_alloc.c

1310

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

1319

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

132

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

sys/fs/ext2fs/ext2_alloc.c

1321

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

sys/fs/ext2fs/ext2_alloc.c

1324

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

sys/fs/ext2fs/ext2_alloc.c

1325

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

sys/fs/ext2fs/ext2_alloc.c

1326

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

sys/fs/ext2fs/ext2_alloc.c

1331

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||

sys/fs/ext2fs/ext2_alloc.c

1332

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/fs/ext2fs/ext2_alloc.c

1333

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

sys/fs/ext2fs/ext2_alloc.c

1335

ibytes = fs->e2fs_ipg / 8;

sys/fs/ext2fs/ext2_alloc.c

1338

fs->e2fs_bsize - 1);

sys/fs/ext2fs/ext2_alloc.c

1339

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

sys/fs/ext2fs/ext2_alloc.c

1340

fs->e2fs_gd[cg].ext4bgd_flags) &

sys/fs/ext2fs/ext2_alloc.c

1343

ext2_gd_i_bitmap_csum_set(fs, cg, bp);

sys/fs/ext2fs/ext2_alloc.c

1351

error = ext2_gd_i_bitmap_csum_verify(fs, cg, bp);

sys/fs/ext2fs/ext2_alloc.c

1357

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

sys/fs/ext2fs/ext2_alloc.c

1368

ipref %= fs->e2fs_ipg;

sys/fs/ext2fs/ext2_alloc.c

1373

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

sys/fs/ext2fs/ext2_alloc.c

1382

fs->e2fs_fsmnt);

sys/fs/ext2fs/ext2_alloc.c

139

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

sys/fs/ext2fs/ext2_alloc.c

1392

e2fs_gd_set_nifree(&fs->e2fs_gd[cg],

sys/fs/ext2fs/ext2_alloc.c

1393

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

sys/fs/ext2fs/ext2_alloc.c

1394

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||

sys/fs/ext2fs/ext2_alloc.c

1395

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/fs/ext2fs/ext2_alloc.c

1396

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

sys/fs/ext2fs/ext2_alloc.c

1398

e2fs_gd_set_i_unused(&fs->e2fs_gd[cg],

sys/fs/ext2fs/ext2_alloc.c

1399

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

sys/fs/ext2fs/ext2_alloc.c

1401

fs->e2fs_ficount--;

sys/fs/ext2fs/ext2_alloc.c

1402

fs->e2fs_fmod = 1;

sys/fs/ext2fs/ext2_alloc.c

1404

e2fs_gd_set_ndirs(&fs->e2fs_gd[cg],

sys/fs/ext2fs/ext2_alloc.c

1405

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

sys/fs/ext2fs/ext2_alloc.c

1406

fs->e2fs_total_dir++;

sys/fs/ext2fs/ext2_alloc.c

1409

ext2_gd_i_bitmap_csum_set(fs, cg, bp);

sys/fs/ext2fs/ext2_alloc.c

1411

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

sys/fs/ext2fs/ext2_alloc.c

1421

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

1427

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

1429

cg = dtog(fs, bno);

sys/fs/ext2fs/ext2_alloc.c

1430

if (bno >= fs->e2fs_bcount) {

sys/fs/ext2fs/ext2_alloc.c

1436

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

sys/fs/ext2fs/ext2_alloc.c

1437

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

sys/fs/ext2fs/ext2_alloc.c

1442

bno = dtogd(fs, bno);

sys/fs/ext2fs/ext2_alloc.c

1445

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

sys/fs/ext2fs/ext2_alloc.c

1449

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

sys/fs/ext2fs/ext2_alloc.c

1450

fs->e2fs_fbcount++;

sys/fs/ext2fs/ext2_alloc.c

1451

e2fs_gd_set_nbfree(&fs->e2fs_gd[cg],

sys/fs/ext2fs/ext2_alloc.c

1452

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

sys/fs/ext2fs/ext2_alloc.c

1453

fs->e2fs_fmod = 1;

sys/fs/ext2fs/ext2_alloc.c

1455

ext2_gd_b_bitmap_csum_set(fs, cg, bp);

sys/fs/ext2fs/ext2_alloc.c

1466

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

1474

fs = pip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

1476

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

sys/fs/ext2fs/ext2_alloc.c

1478

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

sys/fs/ext2fs/ext2_alloc.c

1480

cg = ino_to_cg(fs, ino);

sys/fs/ext2fs/ext2_alloc.c

1482

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

sys/fs/ext2fs/ext2_alloc.c

1483

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

sys/fs/ext2fs/ext2_alloc.c

1488

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

sys/fs/ext2fs/ext2_alloc.c

1491

fs->e2fs_fsmnt, ino);

sys/fs/ext2fs/ext2_alloc.c

1492

if (fs->e2fs_ronly == 0)

sys/fs/ext2fs/ext2_alloc.c

1497

fs->e2fs_ficount++;

sys/fs/ext2fs/ext2_alloc.c

1498

e2fs_gd_set_nifree(&fs->e2fs_gd[cg],

sys/fs/ext2fs/ext2_alloc.c

1499

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

sys/fs/ext2fs/ext2_alloc.c

1501

e2fs_gd_set_ndirs(&fs->e2fs_gd[cg],

sys/fs/ext2fs/ext2_alloc.c

1502

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

sys/fs/ext2fs/ext2_alloc.c

1503

fs->e2fs_total_dir--;

sys/fs/ext2fs/ext2_alloc.c

1505

fs->e2fs_fmod = 1;

sys/fs/ext2fs/ext2_alloc.c

1507

ext2_gd_i_bitmap_csum_set(fs, cg, bp);

sys/fs/ext2fs/ext2_alloc.c

1519

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

sys/fs/ext2fs/ext2_alloc.c

1529

start = dtogd(fs, bpref) / NBBY;

sys/fs/ext2fs/ext2_alloc.c

1532

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

sys/fs/ext2fs/ext2_alloc.c

1540

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

sys/fs/ext2fs/ext2_alloc.c

1548

ext2_cg_has_sb(struct m_ext2fs *fs, int cg)

sys/fs/ext2fs/ext2_alloc.c

1555

if (EXT2_HAS_COMPAT_FEATURE(fs, EXT2F_COMPAT_SPARSESUPER2)) {

sys/fs/ext2fs/ext2_alloc.c

1556

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

sys/fs/ext2fs/ext2_alloc.c

1557

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

sys/fs/ext2fs/ext2_alloc.c

156

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

1563

!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_SPARSESUPER))

sys/fs/ext2fs/ext2_alloc.c

159

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

162

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

sys/fs/ext2fs/ext2_alloc.c

202

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

220

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

223

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

sys/fs/ext2fs/ext2_alloc.c

252

if (dtog(fs, dbtofsb(fs, buflist->bs_children[0]->b_blkno)) !=

sys/fs/ext2fs/ext2_alloc.c

253

dtog(fs, dbtofsb(fs, buflist->bs_children[len - 1]->b_blkno)))

sys/fs/ext2fs/ext2_alloc.c

266

if (bread(vp, idp->in_lbn, (int)fs->e2fs_bsize, NOCRED, &sbp)) {

sys/fs/ext2fs/ext2_alloc.c

285

if (bread(vp, idp->in_lbn, (int)fs->e2fs_bsize, NOCRED, &ebp))

sys/fs/ext2fs/ext2_alloc.c

297

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

sys/fs/ext2fs/ext2_alloc.c

312

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

sys/fs/ext2fs/ext2_alloc.c

318

if (buflist->bs_children[i]->b_blkno != fsbtodb(fs, *bap))

sys/fs/ext2fs/ext2_alloc.c

357

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

sys/fs/ext2fs/ext2_alloc.c

358

ext2_blkfree(ip, dbtofsb(fs, buflist->bs_children[i]->b_blkno),

sys/fs/ext2fs/ext2_alloc.c

359

fs->e2fs_bsize);

sys/fs/ext2fs/ext2_alloc.c

360

buflist->bs_children[i]->b_blkno = fsbtodb(fs, blkno);

sys/fs/ext2fs/ext2_alloc.c

382

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

393

fs = pip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

397

if (fs->e2fs_ficount == 0)

sys/fs/ext2fs/ext2_alloc.c

406

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

sys/fs/ext2fs/ext2_alloc.c

407

fs->e2fs_contigdirs[cg]++;

sys/fs/ext2fs/ext2_alloc.c

409

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

sys/fs/ext2fs/ext2_alloc.c

410

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

sys/fs/ext2fs/ext2_alloc.c

411

fs->e2fs_contigdirs[cg]--;

sys/fs/ext2fs/ext2_alloc.c

413

ipref = cg * fs->e2fs_ipg + 1;

sys/fs/ext2fs/ext2_alloc.c

435

ip->i_e2fs = fs = ump->um_e2fs;

sys/fs/ext2fs/ext2_alloc.c

438

ip->i_block_group = ino_to_cg(fs, ino);

sys/fs/ext2fs/ext2_alloc.c

462

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_EXTENTS)

sys/fs/ext2fs/ext2_alloc.c

598

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

607

fs = pip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

609

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

sys/fs/ext2fs/ext2_alloc.c

610

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

sys/fs/ext2fs/ext2_alloc.c

611

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

sys/fs/ext2fs/ext2_alloc.c

618

prefcg = arc4random() % fs->e2fs_gcount;

sys/fs/ext2fs/ext2_alloc.c

620

minndir = fs->e2fs_ipg;

sys/fs/ext2fs/ext2_alloc.c

621

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

sys/fs/ext2fs/ext2_alloc.c

622

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

sys/fs/ext2fs/ext2_alloc.c

623

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

sys/fs/ext2fs/ext2_alloc.c

624

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

sys/fs/ext2fs/ext2_alloc.c

626

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

sys/fs/ext2fs/ext2_alloc.c

629

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

sys/fs/ext2fs/ext2_alloc.c

630

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

sys/fs/ext2fs/ext2_alloc.c

631

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

sys/fs/ext2fs/ext2_alloc.c

633

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

sys/fs/ext2fs/ext2_alloc.c

641

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

sys/fs/ext2fs/ext2_alloc.c

648

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

sys/fs/ext2fs/ext2_alloc.c

651

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

sys/fs/ext2fs/ext2_alloc.c

654

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

sys/fs/ext2fs/ext2_alloc.c

655

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

sys/fs/ext2fs/ext2_alloc.c

664

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

sys/fs/ext2fs/ext2_alloc.c

665

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

sys/fs/ext2fs/ext2_alloc.c

666

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

sys/fs/ext2fs/ext2_alloc.c

667

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

sys/fs/ext2fs/ext2_alloc.c

668

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

sys/fs/ext2fs/ext2_alloc.c

669

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

sys/fs/ext2fs/ext2_alloc.c

673

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

sys/fs/ext2fs/ext2_alloc.c

674

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

sys/fs/ext2fs/ext2_alloc.c

675

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

sys/fs/ext2fs/ext2_alloc.c

676

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

sys/fs/ext2fs/ext2_alloc.c

682

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

sys/fs/ext2fs/ext2_alloc.c

683

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

sys/fs/ext2fs/ext2_alloc.c

686

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

sys/fs/ext2fs/ext2_alloc.c

708

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

711

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

737

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

sys/fs/ext2fs/ext2_alloc.c

752

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_alloc.c

757

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_alloc.c

767

for (i = 1; i < fs->e2fs_gcount; i *= 2) {

sys/fs/ext2fs/ext2_alloc.c

769

if (cg >= fs->e2fs_gcount)

sys/fs/ext2fs/ext2_alloc.c

770

cg -= fs->e2fs_gcount;

sys/fs/ext2fs/ext2_alloc.c

780

cg = (icg + 2) % fs->e2fs_gcount;

sys/fs/ext2fs/ext2_alloc.c

781

for (i = 2; i < fs->e2fs_gcount; i++) {

sys/fs/ext2fs/ext2_alloc.c

786

if (cg == fs->e2fs_gcount)

sys/fs/ext2fs/ext2_alloc.c

793

ext2_cg_number_gdb_nometa(struct m_ext2fs *fs, int cg)

sys/fs/ext2fs/ext2_alloc.c

796

if (!ext2_cg_has_sb(fs, cg))

sys/fs/ext2fs/ext2_alloc.c

799

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG))

sys/fs/ext2fs/ext2_alloc.c

800

return (le32toh(fs->e2fs->e3fs_first_meta_bg));

sys/fs/ext2fs/ext2_alloc.c

802

return ((fs->e2fs_gcount + EXT2_DESCS_PER_BLOCK(fs) - 1) /

sys/fs/ext2fs/ext2_alloc.c

803

EXT2_DESCS_PER_BLOCK(fs));

sys/fs/ext2fs/ext2_alloc.c

807

ext2_cg_number_gdb_meta(struct m_ext2fs *fs, int cg)

sys/fs/ext2fs/ext2_alloc.c

812

metagroup = cg / EXT2_DESCS_PER_BLOCK(fs);

sys/fs/ext2fs/ext2_alloc.c

813

first = metagroup * EXT2_DESCS_PER_BLOCK(fs);

sys/fs/ext2fs/ext2_alloc.c

814

last = first + EXT2_DESCS_PER_BLOCK(fs) - 1;

sys/fs/ext2fs/ext2_alloc.c

823

ext2_cg_number_gdb(struct m_ext2fs *fs, int cg)

sys/fs/ext2fs/ext2_alloc.c

827

first_meta_bg = le32toh(fs->e2fs->e3fs_first_meta_bg);

sys/fs/ext2fs/ext2_alloc.c

828

metagroup = cg / EXT2_DESCS_PER_BLOCK(fs);

sys/fs/ext2fs/ext2_alloc.c

830

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) ||

sys/fs/ext2fs/ext2_alloc.c

832

return (ext2_cg_number_gdb_nometa(fs, cg));

sys/fs/ext2fs/ext2_alloc.c

834

return ext2_cg_number_gdb_meta(fs, cg);

sys/fs/ext2fs/ext2_alloc.c

838

ext2_number_base_meta_blocks(struct m_ext2fs *fs, int cg)

sys/fs/ext2fs/ext2_alloc.c

842

number = ext2_cg_has_sb(fs, cg);

sys/fs/ext2fs/ext2_alloc.c

844

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) ||

sys/fs/ext2fs/ext2_alloc.c

845

cg < le32toh(fs->e2fs->e3fs_first_meta_bg) *

sys/fs/ext2fs/ext2_alloc.c

846

EXT2_DESCS_PER_BLOCK(fs)) {

sys/fs/ext2fs/ext2_alloc.c

848

number += ext2_cg_number_gdb(fs, cg);

sys/fs/ext2fs/ext2_alloc.c

849

number += le16toh(fs->e2fs->e2fs_reserved_ngdb);

sys/fs/ext2fs/ext2_alloc.c

852

number += ext2_cg_number_gdb(fs, cg);

sys/fs/ext2fs/ext2_alloc.c

873

ext2_get_group_number(struct m_ext2fs *fs, e4fs_daddr_t block)

sys/fs/ext2fs/ext2_alloc.c

876

return ((block - le32toh(fs->e2fs->e2fs_first_dblock)) /

sys/fs/ext2fs/ext2_alloc.c

877

fs->e2fs_bsize);

sys/fs/ext2fs/ext2_alloc.c

881

ext2_block_in_group(struct m_ext2fs *fs, e4fs_daddr_t block, int cg)

sys/fs/ext2fs/ext2_alloc.c

884

return ((ext2_get_group_number(fs, block) == cg) ? 1 : 0);

sys/fs/ext2fs/ext2_alloc.c

888

ext2_cg_block_bitmap_init(struct m_ext2fs *fs, int cg, struct buf *bp)

sys/fs/ext2fs/ext2_alloc.c

893

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

sys/fs/ext2fs/ext2_alloc.c

896

memset(bp->b_data, 0, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_alloc.c

898

bit_max = ext2_number_base_meta_blocks(fs, cg);

sys/fs/ext2fs/ext2_alloc.c

899

if ((bit_max >> 3) >= fs->e2fs_bsize)

sys/fs/ext2fs/ext2_alloc.c

905

start = (uint64_t)cg * fs->e2fs_bpg +

sys/fs/ext2fs/ext2_alloc.c

906

le32toh(fs->e2fs->e2fs_first_dblock);

sys/fs/ext2fs/ext2_alloc.c

909

tmp = e2fs_gd_get_b_bitmap(&fs->e2fs_gd[cg]);

sys/fs/ext2fs/ext2_alloc.c

910

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) ||

sys/fs/ext2fs/ext2_alloc.c

911

ext2_block_in_group(fs, tmp, cg))

sys/fs/ext2fs/ext2_alloc.c

914

tmp = e2fs_gd_get_i_bitmap(&fs->e2fs_gd[cg]);

sys/fs/ext2fs/ext2_alloc.c

915

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) ||

sys/fs/ext2fs/ext2_alloc.c

916

ext2_block_in_group(fs, tmp, cg))

sys/fs/ext2fs/ext2_alloc.c

919

tmp = e2fs_gd_get_i_tables(&fs->e2fs_gd[cg]);

sys/fs/ext2fs/ext2_alloc.c

920

inodes_per_block = fs->e2fs_bsize/EXT2_INODE_SIZE(fs);

sys/fs/ext2fs/ext2_alloc.c

921

while( tmp < e2fs_gd_get_i_tables(&fs->e2fs_gd[cg]) +

sys/fs/ext2fs/ext2_alloc.c

922

fs->e2fs_ipg / inodes_per_block ) {

sys/fs/ext2fs/ext2_alloc.c

923

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) ||

sys/fs/ext2fs/ext2_alloc.c

924

ext2_block_in_group(fs, tmp, cg))

sys/fs/ext2fs/ext2_alloc.c

934

ext2_mark_bitmap_end(fs->e2fs_bpg, fs->e2fs_bsize * 8,

sys/fs/ext2fs/ext2_alloc.c

938

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

sys/fs/ext2fs/ext2_alloc.c

939

fs->e2fs_gd[cg].ext4bgd_flags) & ~EXT2_BG_BLOCK_UNINIT);

sys/fs/ext2fs/ext2_alloc.c

945

ext2_b_bitmap_validate(struct m_ext2fs *fs, struct buf *bp, int cg)

sys/fs/ext2fs/ext2_alloc.c

951

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG)) {

sys/fs/ext2fs/ext2_alloc.c

961

gd = &fs->e2fs_gd[cg];

sys/fs/ext2fs/ext2_alloc.c

962

max_bit = fs->e2fs_fpg;

sys/fs/ext2fs/ext2_alloc.c

963

group_first_block = ((uint64_t)cg) * fs->e2fs_fpg +

sys/fs/ext2fs/ext2_alloc.c

964

le32toh(fs->e2fs->e2fs_first_dblock);

sys/fs/ext2fs/ext2_alloc.c

984

if (offset >= max_bit || offset + fs->e2fs_itpg >= max_bit) {

sys/fs/ext2fs/ext2_balloc.c

101

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_balloc.c

113

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_balloc.c

139

error = bread(vp, lbn, fs->e2fs_bsize, NOCRED, &bp);

sys/fs/ext2fs/ext2_balloc.c

143

bp->b_blkno = fsbtodb(fs, nb);

sys/fs/ext2fs/ext2_balloc.c

144

if (ip->i_size >= (lbn + 1) * fs->e2fs_bsize) {

sys/fs/ext2fs/ext2_balloc.c

152

fs->e2fs_bsize, cred, &newb);

sys/fs/ext2fs/ext2_balloc.c

161

bp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_balloc.c

162

bp->b_blkno = fsbtodb(fs, newb);

sys/fs/ext2fs/ext2_balloc.c

166

ip->i_db[lbn] = dbtofsb(fs, bp->b_blkno);

sys/fs/ext2fs/ext2_balloc.c

190

if ((error = ext2_alloc(ip, lbn, pref, fs->e2fs_bsize, cred,

sys/fs/ext2fs/ext2_balloc.c

196

bp = getblk(vp, indirs[1].in_lbn, fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_balloc.c

197

bp->b_blkno = fsbtodb(fs, newb);

sys/fs/ext2fs/ext2_balloc.c

204

ext2_blkfree(ip, nb, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_balloc.c

215

indirs[i].in_lbn, (int)fs->e2fs_bsize, NOCRED, &bp);

sys/fs/ext2fs/ext2_balloc.c

232

error = ext2_alloc(ip, lbn, pref, (int)fs->e2fs_bsize, cred, &newb);

sys/fs/ext2fs/ext2_balloc.c

240

nbp = getblk(vp, indirs[i].in_lbn, fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_balloc.c

241

nbp->b_blkno = fsbtodb(fs, nb);

sys/fs/ext2fs/ext2_balloc.c

248

ext2_blkfree(ip, nb, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_balloc.c

260

if (bp->b_bufsize == fs->e2fs_bsize)

sys/fs/ext2fs/ext2_balloc.c

273

lbn, pref, (int)fs->e2fs_bsize, cred, &newb)) != 0) {

sys/fs/ext2fs/ext2_balloc.c

280

nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_balloc.c

281

nbp->b_blkno = fsbtodb(fs, nb);

sys/fs/ext2fs/ext2_balloc.c

292

if (bp->b_bufsize == fs->e2fs_bsize)

sys/fs/ext2fs/ext2_balloc.c

305

(int)fs->e2fs_bsize, NOCRED,

sys/fs/ext2fs/ext2_balloc.c

308

error = bread(vp, lbn, (int)fs->e2fs_bsize, NOCRED, &nbp);

sys/fs/ext2fs/ext2_balloc.c

315

nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_balloc.c

316

nbp->b_blkno = fsbtodb(fs, nb);

sys/fs/ext2fs/ext2_balloc.c

59

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_balloc.c

65

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_balloc.c

66

blks = howmany(size, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_balloc.c

73

bp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_balloc.c

77

error = bread(vp, lbn, fs->e2fs_bsize, NOCRED, &bp);

sys/fs/ext2fs/ext2_balloc.c

83

bp->b_blkno = fsbtodb(fs, newblk);

sys/fs/ext2fs/ext2_bmap.c

104

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_bmap.c

132

*bnp = fsbtodb(fs, lbn - le32toh(ep->e_blk) +

sys/fs/ext2fs/ext2_bmap.c

94

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

102

fs->e2fs_fsmnt, le32toh(fs->e2fs->e4fs_sbchksum),

sys/fs/ext2fs/ext2_csum.c

103

calculate_crc32c(~0, (const char *)fs->e2fs,

sys/fs/ext2fs/ext2_csum.c

112

ext2_sb_csum_set(struct m_ext2fs *fs)

sys/fs/ext2fs/ext2_csum.c

115

fs->e2fs->e4fs_sbchksum =

sys/fs/ext2fs/ext2_csum.c

116

htole32(calculate_crc32c(~0, (const char *)fs->e2fs,

sys/fs/ext2fs/ext2_csum.c

124

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

129

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

131

crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&facl_bn,

sys/fs/ext2fs/ext2_csum.c

138

fs->e2fs_bsize - offset);

sys/fs/ext2fs/ext2_csum.c

182

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

185

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

187

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

230

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

234

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

240

crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum));

sys/fs/ext2fs/ext2_csum.c

297

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

302

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

312

crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum));

sys/fs/ext2fs/ext2_csum.c

351

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

355

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

357

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

376

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

379

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

381

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

395

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

400

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

402

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

422

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

426

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

433

crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum));

sys/fs/ext2fs/ext2_csum.c

443

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

448

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

450

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

471

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

475

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

477

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

489

ext2_gd_i_bitmap_csum_verify(struct m_ext2fs *fs, int cg, struct buf *bp)

sys/fs/ext2fs/ext2_csum.c

493

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

496

provided = le16toh(fs->e2fs_gd[cg].ext4bgd_i_bmap_csum);

sys/fs/ext2fs/ext2_csum.c

497

calculated = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data,

sys/fs/ext2fs/ext2_csum.c

498

fs->e2fs_ipg / 8);

sys/fs/ext2fs/ext2_csum.c

499

if (le16toh(fs->e2fs->e3fs_desc_size) >=

sys/fs/ext2fs/ext2_csum.c

501

hi = le16toh(fs->e2fs_gd[cg].ext4bgd_i_bmap_csum_hi);

sys/fs/ext2fs/ext2_csum.c

515

ext2_gd_i_bitmap_csum_set(struct m_ext2fs *fs, int cg, struct buf *bp)

sys/fs/ext2fs/ext2_csum.c

519

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

522

csum = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data,

sys/fs/ext2fs/ext2_csum.c

523

fs->e2fs_ipg / 8);

sys/fs/ext2fs/ext2_csum.c

524

fs->e2fs_gd[cg].ext4bgd_i_bmap_csum = htole16(csum & 0xFFFF);

sys/fs/ext2fs/ext2_csum.c

525

if (le16toh(fs->e2fs->e3fs_desc_size) >= EXT2_BG_INODE_BITMAP_CSUM_HI_END)

sys/fs/ext2fs/ext2_csum.c

526

fs->e2fs_gd[cg].ext4bgd_i_bmap_csum_hi = htole16(csum >> 16);

sys/fs/ext2fs/ext2_csum.c

530

ext2_gd_b_bitmap_csum_verify(struct m_ext2fs *fs, int cg, struct buf *bp)

sys/fs/ext2fs/ext2_csum.c

534

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

537

size = fs->e2fs_fpg / 8;

sys/fs/ext2fs/ext2_csum.c

538

provided = le16toh(fs->e2fs_gd[cg].ext4bgd_b_bmap_csum);

sys/fs/ext2fs/ext2_csum.c

539

calculated = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data, size);

sys/fs/ext2fs/ext2_csum.c

540

if (le16toh(fs->e2fs->e3fs_desc_size) >=

sys/fs/ext2fs/ext2_csum.c

542

hi = le16toh(fs->e2fs_gd[cg].ext4bgd_b_bmap_csum_hi);

sys/fs/ext2fs/ext2_csum.c

556

ext2_gd_b_bitmap_csum_set(struct m_ext2fs *fs, int cg, struct buf *bp)

sys/fs/ext2fs/ext2_csum.c

560

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

563

size = fs->e2fs_fpg / 8;

sys/fs/ext2fs/ext2_csum.c

564

csum = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data, size);

sys/fs/ext2fs/ext2_csum.c

565

fs->e2fs_gd[cg].ext4bgd_b_bmap_csum = htole16(csum & 0xFFFF);

sys/fs/ext2fs/ext2_csum.c

566

if (le16toh(fs->e2fs->e3fs_desc_size) >= EXT2_BG_BLOCK_BITMAP_CSUM_HI_LOCATION)

sys/fs/ext2fs/ext2_csum.c

567

fs->e2fs_gd[cg].ext4bgd_b_bmap_csum_hi = htole16(csum >> 16);

sys/fs/ext2fs/ext2_csum.c

573

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

578

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

582

crc = calculate_crc32c(fs->e2fs_csum_seed,

sys/fs/ext2fs/ext2_csum.c

594

if (EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE) {

sys/fs/ext2fs/ext2_csum.c

608

EXT2_INODE_SIZE(fs) - offset);

sys/fs/ext2fs/ext2_csum.c

617

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

621

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

623

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

629

if ((EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE &&

sys/fs/ext2fs/ext2_csum.c

656

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_csum.c

659

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_csum.c

661

if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_csum.c

667

if ((EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE &&

sys/fs/ext2fs/ext2_csum.c

673

ext2_gd_csum(struct m_ext2fs *fs, uint32_t block_group, struct ext2_gd *gd)

sys/fs/ext2fs/ext2_csum.c

683

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/fs/ext2fs/ext2_csum.c

684

csum32 = calculate_crc32c(fs->e2fs_csum_seed,

sys/fs/ext2fs/ext2_csum.c

691

if (offset < le16toh(fs->e2fs->e3fs_desc_size))

sys/fs/ext2fs/ext2_csum.c

693

le16toh(fs->e2fs->e3fs_desc_size) - offset);

sys/fs/ext2fs/ext2_csum.c

697

} else if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM)) {

sys/fs/ext2fs/ext2_csum.c

698

crc = crc16(~0, fs->e2fs->e2fs_uuid,

sys/fs/ext2fs/ext2_csum.c

699

sizeof(fs->e2fs->e2fs_uuid));

sys/fs/ext2fs/ext2_csum.c

704

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT) &&

sys/fs/ext2fs/ext2_csum.c

705

offset < le16toh(fs->e2fs->e3fs_desc_size))

sys/fs/ext2fs/ext2_csum.c

707

le16toh(fs->e2fs->e3fs_desc_size) - offset);

sys/fs/ext2fs/ext2_csum.c

715

ext2_gd_csum_verify(struct m_ext2fs *fs, struct cdev *dev)

sys/fs/ext2fs/ext2_csum.c

720

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

sys/fs/ext2fs/ext2_csum.c

721

if (fs->e2fs_gd[i].ext4bgd_csum !=

sys/fs/ext2fs/ext2_csum.c

722

ext2_gd_csum(fs, i, &fs->e2fs_gd[i])) {

sys/fs/ext2fs/ext2_csum.c

725

devtoname(dev), i, fs->e2fs_gd[i].ext4bgd_csum,

sys/fs/ext2fs/ext2_csum.c

726

ext2_gd_csum(fs, i, &fs->e2fs_gd[i]));

sys/fs/ext2fs/ext2_csum.c

736

ext2_gd_csum_set(struct m_ext2fs *fs)

sys/fs/ext2fs/ext2_csum.c

740

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

sys/fs/ext2fs/ext2_csum.c

741

fs->e2fs_gd[i].ext4bgd_csum = ext2_gd_csum(fs, i, &fs->e2fs_gd[i]);

sys/fs/ext2fs/ext2_csum.c

75

ext2_sb_csum_set_seed(struct m_ext2fs *fs)

sys/fs/ext2fs/ext2_csum.c

78

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_CSUM_SEED))

sys/fs/ext2fs/ext2_csum.c

79

fs->e2fs_csum_seed = le32toh(fs->e2fs->e4fs_chksum_seed);

sys/fs/ext2fs/ext2_csum.c

80

else if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/fs/ext2fs/ext2_csum.c

81

fs->e2fs_csum_seed = calculate_crc32c(~0, fs->e2fs->e2fs_uuid,

sys/fs/ext2fs/ext2_csum.c

82

sizeof(fs->e2fs->e2fs_uuid));

sys/fs/ext2fs/ext2_csum.c

85

fs->e2fs_csum_seed = 0;

sys/fs/ext2fs/ext2_csum.c

89

ext2_sb_csum_verify(struct m_ext2fs *fs)

sys/fs/ext2fs/ext2_csum.c

92

if (fs->e2fs->e4fs_chksum_type != EXT4_CRC32C_CHKSUM) {

sys/fs/ext2fs/ext2_csum.c

94

"WARNING: mount of %s denied due bad sb csum type\n", fs->e2fs_fsmnt);

sys/fs/ext2fs/ext2_csum.c

97

if (le32toh(fs->e2fs->e4fs_sbchksum) !=

sys/fs/ext2fs/ext2_csum.c

98

calculate_crc32c(~0, (const char *)fs->e2fs,

sys/fs/ext2fs/ext2_extattr.c

1066

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extattr.c

1075

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extattr.c

1078

error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl),

sys/fs/ext2fs/ext2_extattr.c

1079

fs->e2fs_bsize, NOCRED, &bp);

sys/fs/ext2fs/ext2_extattr.c

1168

if (size > fs->e2fs_bsize)

sys/fs/ext2fs/ext2_extattr.c

1176

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

sys/fs/ext2fs/ext2_extattr.c

1179

bp = getblk(ip->i_devvp, fsbtodb(fs, ip->i_facl), fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_extattr.c

1181

ext2_blkfree(ip, ip->i_facl, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_extattr.c

1182

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

sys/fs/ext2fs/ext2_extattr.c

1215

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extattr.c

1220

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extattr.c

1225

error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl),

sys/fs/ext2fs/ext2_extattr.c

1226

fs->e2fs_bsize, NOCRED, &bp);

sys/fs/ext2fs/ext2_extattr.c

194

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extattr.c

202

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extattr.c

205

fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),

sys/fs/ext2fs/ext2_extattr.c

206

(int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {

sys/fs/ext2fs/ext2_extattr.c

213

EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number));

sys/fs/ext2fs/ext2_extattr.c

225

(char *)dinode + EXT2_INODE_SIZE(fs));

sys/fs/ext2fs/ext2_extattr.c

268

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extattr.c

276

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extattr.c

278

error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl),

sys/fs/ext2fs/ext2_extattr.c

279

fs->e2fs_bsize, NOCRED, &bp);

sys/fs/ext2fs/ext2_extattr.c

335

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extattr.c

343

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extattr.c

346

fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),

sys/fs/ext2fs/ext2_extattr.c

347

(int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {

sys/fs/ext2fs/ext2_extattr.c

354

EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number));

sys/fs/ext2fs/ext2_extattr.c

366

(char *)dinode + EXT2_INODE_SIZE(fs));

sys/fs/ext2fs/ext2_extattr.c

410

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extattr.c

418

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extattr.c

420

error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl),

sys/fs/ext2fs/ext2_extattr.c

421

fs->e2fs_bsize, NOCRED, &bp);

sys/fs/ext2fs/ext2_extattr.c

540

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extattr.c

548

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extattr.c

551

fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),

sys/fs/ext2fs/ext2_extattr.c

552

(int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {

sys/fs/ext2fs/ext2_extattr.c

559

EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number));

sys/fs/ext2fs/ext2_extattr.c

571

(char *)dinode + EXT2_INODE_SIZE(fs));

sys/fs/ext2fs/ext2_extattr.c

616

(char *)dinode + EXT2_INODE_SIZE(fs));

sys/fs/ext2fs/ext2_extattr.c

630

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extattr.c

636

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extattr.c

648

cbp = getblk(ip->i_devvp, fsbtodb(fs, facl), fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_extattr.c

650

ext2_blkfree(ip, facl, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_extattr.c

654

memcpy(cbp->b_data, sbp->b_data, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_extattr.c

672

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extattr.c

680

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extattr.c

682

error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl),

sys/fs/ext2fs/ext2_extattr.c

683

fs->e2fs_bsize, NOCRED, &bp);

sys/fs/ext2fs/ext2_extattr.c

725

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

sys/fs/ext2fs/ext2_extattr.c

726

ext2_blkfree(ip, ip->i_facl, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_extattr.c

905

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extattr.c

914

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extattr.c

917

fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),

sys/fs/ext2fs/ext2_extattr.c

918

(int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {

sys/fs/ext2fs/ext2_extattr.c

925

EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number));

sys/fs/ext2fs/ext2_extattr.c

937

EXT2_INODE_SIZE(fs));

sys/fs/ext2fs/ext2_extattr.c

963

max_size = EXT2_INODE_SIZE(fs) - E2FS_REV0_INODE_SIZE -

sys/fs/ext2fs/ext2_extents.c

1017

error = bread(ip->i_devvp, fsbtodb(fs, newblk),

sys/fs/ext2fs/ext2_extents.c

1018

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

sys/fs/ext2fs/ext2_extents.c

108

fsbtodb(fs, blk), (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {

sys/fs/ext2fs/ext2_extents.c

1081

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

1088

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

1095

bp = getblk(ip->i_devvp, fsbtodb(fs, newblk), fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_extents.c

1366

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

1375

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

1377

*perror = ext2_alloc(ip, lbn, pref, (int)fs->e2fs_bsize, cred, &newblk);

sys/fs/ext2fs/ext2_extents.c

1394

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

1479

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

1480

error = bread(ip->i_devvp, fsbtodb(fs, newblk),

sys/fs/ext2fs/ext2_extents.c

1481

fs->e2fs_bsize, cred, &bp);

sys/fs/ext2fs/ext2_extents.c

1638

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

1643

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

1644

error = bread(ip->i_devvp, fsbtodb(fs, pblk),

sys/fs/ext2fs/ext2_extents.c

1645

fs->e2fs_bsize, NOCRED, &bp);

sys/fs/ext2fs/ext2_extents.c

302

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

305

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

307

size = (fs->e2fs_bsize - sizeof(struct ext4_extent_header)) /

sys/fs/ext2fs/ext2_extents.c

328

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

331

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

333

size = (fs->e2fs_bsize - sizeof(struct ext4_extent_header)) /

sys/fs/ext2fs/ext2_extents.c

369

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

371

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

373

if ((start_blk <= le32toh(fs->e2fs->e2fs_first_dblock)) ||

sys/fs/ext2fs/ext2_extents.c

375

(start_blk + count > fs->e2fs_bcount))

sys/fs/ext2fs/ext2_extents.c

692

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

695

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

697

size = (fs->e2fs_bsize - sizeof(struct ext4_extent_header)) /

sys/fs/ext2fs/ext2_extents.c

72

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

736

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

74

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

741

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

76

if (blk < fs->e2fs->e2fs_first_dblock || blk >= fs->e2fs_bcount)

sys/fs/ext2fs/ext2_extents.c

763

le32toh(fs->e2fs->e2fs_first_dblock);

sys/fs/ext2fs/ext2_extents.c

812

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

817

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

824

bp = getblk(ip->i_devvp, fsbtodb(fs, blk),

sys/fs/ext2fs/ext2_extents.c

825

fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_extents.c

86

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

901

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

904

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

908

ext2_blkfree(ip, blk + i, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_extents.c

91

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

911

ip->i_blocks -= (btodb(fs->e2fs_bsize)*blocksreleased);

sys/fs/ext2fs/ext2_extents.c

923

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_extents.c

935

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_extents.c

963

bp = getblk(ip->i_devvp, fsbtodb(fs, newblk), fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_extern.h

90

int ext2_cg_has_sb(struct m_ext2fs *fs, int cg);

sys/fs/ext2fs/ext2_extern.h

91

uint64_t ext2_cg_number_gdb(struct m_ext2fs *fs, int cg);

sys/fs/ext2fs/ext2_htree.c

219

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_htree.c

222

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_htree.c

226

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_htree.c

235

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_htree.c

238

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_htree.c

239

space = fs->e2fs_bsize - EXT2_DIR_REC_LEN(0);

sys/fs/ext2fs/ext2_htree.c

241

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_htree.c

261

struct ext2fs *fs;

sys/fs/ext2fs/ext2_htree.c

276

fs = ip->i_e2fs->e2fs;

sys/fs/ext2fs/ext2_htree.c

295

ext2_get_hash_seed(fs, hash_seed);

sys/fs/ext2fs/ext2_htree.c

539

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_htree.c

550

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_htree.c

556

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_htree.c

671

struct ext2fs *fs;

sys/fs/ext2fs/ext2_htree.c

684

fs = dp->i_e2fs->e2fs;

sys/fs/ext2fs/ext2_htree.c

713

root->h_info.h_hash_version = fs->e3fs_def_hash_version;

sys/fs/ext2fs/ext2_htree.c

728

ext2_get_hash_seed(fs, hash_seed);

sys/fs/ext2fs/ext2_htree.c

783

struct ext2fs *fs;

sys/fs/ext2fs/ext2_htree.c

802

fs = m_fs->e2fs;

sys/fs/ext2fs/ext2_htree.c

919

ext2_get_hash_seed(fs, hash_seed);

sys/fs/ext2fs/ext2_inode.c

124

struct m_ext2fs *fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_inode.c

138

factor *= NINDIR(fs);

sys/fs/ext2fs/ext2_inode.c

142

nblocks = btodb(fs->e2fs_bsize);

sys/fs/ext2fs/ext2_inode.c

152

bp = getblk(vp, lbn, (int)fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_inode.c

169

copy = malloc(fs->e2fs_bsize, M_TEMP, M_WAITOK);

sys/fs/ext2fs/ext2_inode.c

170

bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->e2fs_bsize);

sys/fs/ext2fs/ext2_inode.c

172

(NINDIR(fs) - (last + 1)) * sizeof(e2fs_daddr_t));

sys/fs/ext2fs/ext2_inode.c

187

for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;

sys/fs/ext2fs/ext2_inode.c

194

fsbtodb(fs, nb), (int32_t)-1, level - 1, &blkcount)) != 0)

sys/fs/ext2fs/ext2_inode.c

198

ext2_blkfree(ip, nb, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_inode.c

209

if ((error = ext2_indirtrunc(ip, nlbn, fsbtodb(fs, nb),

sys/fs/ext2fs/ext2_inode.c

236

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_inode.c

251

fs = oip->i_e2fs;

sys/fs/ext2fs/ext2_inode.c

262

offset = blkoff(fs, length - 1);

sys/fs/ext2fs/ext2_inode.c

263

lbn = lblkno(fs, length - 1);

sys/fs/ext2fs/ext2_inode.c

271

if (bp->b_bufsize == fs->e2fs_bsize)

sys/fs/ext2fs/ext2_inode.c

290

offset = blkoff(fs, length);

sys/fs/ext2fs/ext2_inode.c

294

lbn = lblkno(fs, length);

sys/fs/ext2fs/ext2_inode.c

300

size = blksize(fs, oip, lbn);

sys/fs/ext2fs/ext2_inode.c

303

if (bp->b_bufsize == fs->e2fs_bsize)

sys/fs/ext2fs/ext2_inode.c

318

lastblock = lblkno(fs, length + fs->e2fs_bsize - 1) - 1;

sys/fs/ext2fs/ext2_inode.c

320

lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);

sys/fs/ext2fs/ext2_inode.c

321

lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);

sys/fs/ext2fs/ext2_inode.c

322

nblocks = btodb(fs->e2fs_bsize);

sys/fs/ext2fs/ext2_inode.c

363

error = vtruncbuf(ovp, length, (int)fs->e2fs_bsize);

sys/fs/ext2fs/ext2_inode.c

372

indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;

sys/fs/ext2fs/ext2_inode.c

373

indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;

sys/fs/ext2fs/ext2_inode.c

378

fsbtodb(fs, bn), lastiblock[level], level, &count);

sys/fs/ext2fs/ext2_inode.c

384

ext2_blkfree(oip, bn, fs->e2fs_fsize);

sys/fs/ext2fs/ext2_inode.c

402

bsize = blksize(fs, oip, i);

sys/fs/ext2fs/ext2_inode.c

421

oldspace = blksize(fs, oip, lastblock);

sys/fs/ext2fs/ext2_inode.c

423

newspace = blksize(fs, oip, lastblock);

sys/fs/ext2fs/ext2_inode.c

432

bn += numfrags(fs, newspace);

sys/fs/ext2fs/ext2_inode.c

470

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_inode.c

478

fs = oip->i_e2fs;

sys/fs/ext2fs/ext2_inode.c

486

offset = blkoff(fs, length - 1);

sys/fs/ext2fs/ext2_inode.c

487

lbn = lblkno(fs, length - 1);

sys/fs/ext2fs/ext2_inode.c

495

if (bp->b_bufsize == fs->e2fs_bsize)

sys/fs/ext2fs/ext2_inode.c

507

lastblock = (length + fs->e2fs_bsize - 1) / fs->e2fs_bsize;

sys/fs/ext2fs/ext2_inode.c

512

offset = blkoff(fs, length);

sys/fs/ext2fs/ext2_inode.c

516

lbn = lblkno(fs, length);

sys/fs/ext2fs/ext2_inode.c

523

size = blksize(fs, oip, lbn);

sys/fs/ext2fs/ext2_inode.c

526

if (bp->b_bufsize == fs->e2fs_bsize)

sys/fs/ext2fs/ext2_inode.c

537

error = vtruncbuf(ovp, length, (int)fs->e2fs_bsize);

sys/fs/ext2fs/ext2_inode.c

72

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_inode.c

83

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_inode.c

84

if (fs->e2fs_ronly)

sys/fs/ext2fs/ext2_inode.c

87

fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),

sys/fs/ext2fs/ext2_inode.c

88

(int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {

sys/fs/ext2fs/ext2_inode.c

93

EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)));

sys/fs/ext2fs/ext2_inode_cnv.c

147

struct m_ext2fs *fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_inode_cnv.c

152

if ((ip->i_number < EXT2_FIRST_INO(fs) && ip->i_number != EXT2_ROOTINO) ||

sys/fs/ext2fs/ext2_inode_cnv.c

154

(ip->i_number > le32toh(fs->e2fs->e2fs_icount))) {

sys/fs/ext2fs/ext2_inode_cnv.c

175

if (EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE) {

sys/fs/ext2fs/ext2_inode_cnv.c

177

EXT2_INODE_SIZE(fs) || (ei_extra_isize_le & 3)) {

sys/fs/ext2fs/ext2_inode_cnv.c

256

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_inode_cnv.c

259

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_inode_cnv.c

293

!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE)) {

sys/fs/ext2fs/ext2_inode_cnv.c

302

ei->e2di_nblock = htole32(dbtofsb(fs, ip->i_blocks));

sys/fs/ext2fs/ext2_inode_cnv.c

303

ei->e2di_nblock_high = htole16(dbtofsb(fs, ip->i_blocks) >> 32 & 0xffff);

sys/fs/ext2fs/ext2_lookup.c

818

struct m_ext2fs *fs = VTOI(dp)->i_e2fs;

sys/fs/ext2fs/ext2_lookup.c

827

else if (entryoffsetinblock + le16toh(de->e2d_reclen)> fs->e2fs_bsize)

sys/fs/ext2fs/ext2_lookup.c

829

else if (le32toh(de->e2d_ino) > fs->e2fs->e2fs_icount)

sys/fs/ext2fs/ext2_subr.c

100

ext2_clusteracct(struct m_ext2fs *fs, char *bbp, int cg, e4fs_daddr_t bno, int cnt)

sys/fs/ext2fs/ext2_subr.c

102

int32_t *sump = fs->e2fs_clustersum[cg].cs_sum;

sys/fs/ext2fs/ext2_subr.c

108

if (fs->e2fs_clustersum[cg].cs_init == 0) {

sys/fs/ext2fs/ext2_subr.c

114

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

sys/fs/ext2fs/ext2_subr.c

118

if (run > fs->e2fs_contigsumsize)

sys/fs/ext2fs/ext2_subr.c

119

run = fs->e2fs_contigsumsize;

sys/fs/ext2fs/ext2_subr.c

131

if (run > fs->e2fs_contigsumsize)

sys/fs/ext2fs/ext2_subr.c

132

run = fs->e2fs_contigsumsize;

sys/fs/ext2fs/ext2_subr.c

135

fs->e2fs_clustersum[cg].cs_init = 1;

sys/fs/ext2fs/ext2_subr.c

138

if (fs->e2fs_contigsumsize <= 0)

sys/fs/ext2fs/ext2_subr.c

143

end = start + fs->e2fs_contigsumsize;

sys/fs/ext2fs/ext2_subr.c

144

if (end > fs->e2fs_fpg)

sys/fs/ext2fs/ext2_subr.c

145

end = fs->e2fs_fpg;

sys/fs/ext2fs/ext2_subr.c

162

end = start - fs->e2fs_contigsumsize;

sys/fs/ext2fs/ext2_subr.c

184

if (i > fs->e2fs_contigsumsize)

sys/fs/ext2fs/ext2_subr.c

185

i = fs->e2fs_contigsumsize;

sys/fs/ext2fs/ext2_subr.c

193

lp = &sump[fs->e2fs_contigsumsize];

sys/fs/ext2fs/ext2_subr.c

194

for (i = fs->e2fs_contigsumsize; i > 0; i--)

sys/fs/ext2fs/ext2_subr.c

197

fs->e2fs_maxcluster[cg] = i;

sys/fs/ext2fs/ext2_subr.c

67

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_subr.c

73

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_subr.c

74

lbn = lblkno(fs, offset);

sys/fs/ext2fs/ext2_subr.c

75

bsize = blksize(fs, ip, lbn);

sys/fs/ext2fs/ext2_subr.c

87

*res = (char *)bp->b_data + blkoff(fs, offset);

sys/fs/ext2fs/ext2_vfsops.c

1010

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vfsops.c

1023

fs = ump->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

1024

ronly = fs->e2fs_ronly;

sys/fs/ext2fs/ext2_vfsops.c

1026

if (fs->e2fs_wasvalid)

sys/fs/ext2fs/ext2_vfsops.c

1027

fs->e2fs->e2fs_state =

sys/fs/ext2fs/ext2_vfsops.c

1028

htole16(le16toh(fs->e2fs->e2fs_state) | E2FS_ISCLEAN);

sys/fs/ext2fs/ext2_vfsops.c

1036

sump = fs->e2fs_clustersum;

sys/fs/ext2fs/ext2_vfsops.c

1037

for (i = 0; i < fs->e2fs_gcount; i++, sump++)

sys/fs/ext2fs/ext2_vfsops.c

1039

free(fs->e2fs_clustersum, M_EXT2MNT);

sys/fs/ext2fs/ext2_vfsops.c

1040

free(fs->e2fs_maxcluster, M_EXT2MNT);

sys/fs/ext2fs/ext2_vfsops.c

1041

free(fs->e2fs_gd, M_EXT2MNT);

sys/fs/ext2fs/ext2_vfsops.c

1042

free(fs->e2fs_contigdirs, M_EXT2MNT);

sys/fs/ext2fs/ext2_vfsops.c

1043

free(fs->e2fs, M_EXT2MNT);

sys/fs/ext2fs/ext2_vfsops.c

1044

free(fs, M_EXT2MNT);

sys/fs/ext2fs/ext2_vfsops.c

1069

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vfsops.c

1074

fs = ump->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

1075

if (le16toh(fs->e2fs->e2fs_magic) != E2FS_MAGIC)

sys/fs/ext2fs/ext2_vfsops.c

1084

fs->e2fs_itpg;

sys/fs/ext2fs/ext2_vfsops.c

1085

overhead = le32toh(fs->e2fs->e2fs_first_dblock) +

sys/fs/ext2fs/ext2_vfsops.c

1086

fs->e2fs_gcount * overhead_per_group;

sys/fs/ext2fs/ext2_vfsops.c

1087

if (le32toh(fs->e2fs->e2fs_rev) > E2FS_REV0 &&

sys/fs/ext2fs/ext2_vfsops.c

1088

le32toh(fs->e2fs->e2fs_features_rocompat) & EXT2F_ROCOMPAT_SPARSESUPER) {

sys/fs/ext2fs/ext2_vfsops.c

1089

for (i = 0, ngroups = 0; i < fs->e2fs_gcount; i++) {

sys/fs/ext2fs/ext2_vfsops.c

109

struct ext2fs * es, struct m_ext2fs * fs);

sys/fs/ext2fs/ext2_vfsops.c

1090

if (ext2_cg_has_sb(fs, i))

sys/fs/ext2fs/ext2_vfsops.c

1094

ngroups = fs->e2fs_gcount;

sys/fs/ext2fs/ext2_vfsops.c

1096

ngdb = fs->e2fs_gdbcount;

sys/fs/ext2fs/ext2_vfsops.c

1097

if (le32toh(fs->e2fs->e2fs_rev) > E2FS_REV0 &&

sys/fs/ext2fs/ext2_vfsops.c

1098

le32toh(fs->e2fs->e2fs_features_compat) & EXT2F_COMPAT_RESIZE)

sys/fs/ext2fs/ext2_vfsops.c

1099

ngdb += le16toh(fs->e2fs->e2fs_reserved_ngdb);

sys/fs/ext2fs/ext2_vfsops.c

1102

sbp->f_bsize = EXT2_FRAG_SIZE(fs);

sys/fs/ext2fs/ext2_vfsops.c

1103

sbp->f_iosize = EXT2_BLOCK_SIZE(fs);

sys/fs/ext2fs/ext2_vfsops.c

1104

sbp->f_blocks = fs->e2fs_bcount - overhead;

sys/fs/ext2fs/ext2_vfsops.c

1105

sbp->f_bfree = fs->e2fs_fbcount;

sys/fs/ext2fs/ext2_vfsops.c

1106

sbp->f_bavail = sbp->f_bfree - fs->e2fs_rbcount;

sys/fs/ext2fs/ext2_vfsops.c

1107

sbp->f_files = le32toh(fs->e2fs->e2fs_icount);

sys/fs/ext2fs/ext2_vfsops.c

1108

sbp->f_ffree = fs->e2fs_ficount;

sys/fs/ext2fs/ext2_vfsops.c

1126

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vfsops.c

1130

fs = ump->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

1131

if (fs->e2fs_fmod != 0 && fs->e2fs_ronly != 0) { /* XXX */

sys/fs/ext2fs/ext2_vfsops.c

1132

panic("ext2_sync: rofs mod fs=%s", fs->e2fs_fsmnt);

sys/fs/ext2fs/ext2_vfsops.c

1178

if (fs->e2fs_fmod != 0) {

sys/fs/ext2fs/ext2_vfsops.c

1179

fs->e2fs_fmod = 0;

sys/fs/ext2fs/ext2_vfsops.c

1180

fs->e2fs->e2fs_wtime = htole32(time_second);

sys/fs/ext2fs/ext2_vfsops.c

1196

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vfsops.c

1221

ip->i_e2fs = fs = ump->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

1238

if ((error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),

sys/fs/ext2fs/ext2_vfsops.c

1239

(int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {

sys/fs/ext2fs/ext2_vfsops.c

1253

EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ino)), ip);

sys/fs/ext2fs/ext2_vfsops.c

1260

ip->i_block_group = ino_to_cg(fs, ino);

sys/fs/ext2fs/ext2_vfsops.c

127

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vfsops.c

1274

used_blocks = howmany(ip->i_size, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_vfsops.c

1326

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vfsops.c

1330

fs = VFSTOEXT2(mp)->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

1332

ufhp->ufid_ino > fs->e2fs_gcount * fs->e2fs_ipg)

sys/fs/ext2fs/ext2_vfsops.c

1358

struct m_ext2fs *fs = mp->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

1359

struct ext2fs *es = fs->e2fs;

sys/fs/ext2fs/ext2_vfsops.c

1363

es->e2fs_bcount = htole32(fs->e2fs_bcount & 0xffffffff);

sys/fs/ext2fs/ext2_vfsops.c

1364

es->e2fs_rbcount = htole32(fs->e2fs_rbcount & 0xffffffff);

sys/fs/ext2fs/ext2_vfsops.c

1365

es->e2fs_fbcount = htole32(fs->e2fs_fbcount & 0xffffffff);

sys/fs/ext2fs/ext2_vfsops.c

1366

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {

sys/fs/ext2fs/ext2_vfsops.c

1367

es->e4fs_bcount_hi = htole32(fs->e2fs_bcount >> 32);

sys/fs/ext2fs/ext2_vfsops.c

1368

es->e4fs_rbcount_hi = htole32(fs->e2fs_rbcount >> 32);

sys/fs/ext2fs/ext2_vfsops.c

1369

es->e4fs_fbcount_hi = htole32(fs->e2fs_fbcount >> 32);

sys/fs/ext2fs/ext2_vfsops.c

1372

es->e2fs_ficount = htole32(fs->e2fs_ficount);

sys/fs/ext2fs/ext2_vfsops.c

1374

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_vfsops.c

1375

ext2_sb_csum_set(fs);

sys/fs/ext2fs/ext2_vfsops.c

1398

struct m_ext2fs *fs = mp->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

1405

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||

sys/fs/ext2fs/ext2_vfsops.c

1406

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_vfsops.c

1407

ext2_gd_csum_set(fs);

sys/fs/ext2fs/ext2_vfsops.c

1409

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

sys/fs/ext2fs/ext2_vfsops.c

1410

bp = getblk(mp->um_devvp, fsbtodb(fs,

sys/fs/ext2fs/ext2_vfsops.c

1411

ext2_cg_location(fs, i)),

sys/fs/ext2fs/ext2_vfsops.c

1412

fs->e2fs_bsize, 0, 0, 0);

sys/fs/ext2fs/ext2_vfsops.c

1413

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {

sys/fs/ext2fs/ext2_vfsops.c

1414

memcpy(bp->b_data, &fs->e2fs_gd[

sys/fs/ext2fs/ext2_vfsops.c

1415

i * fs->e2fs_bsize / sizeof(struct ext2_gd)],

sys/fs/ext2fs/ext2_vfsops.c

1416

fs->e2fs_bsize);

sys/fs/ext2fs/ext2_vfsops.c

1418

for (j = 0; j < fs->e2fs_bsize / E2FS_REV0_GD_SIZE &&

sys/fs/ext2fs/ext2_vfsops.c

1419

g_count < fs->e2fs_gcount; j++, g_count++)

sys/fs/ext2fs/ext2_vfsops.c

1421

&fs->e2fs_gd[g_count], E2FS_REV0_GD_SIZE);

sys/fs/ext2fs/ext2_vfsops.c

155

fs = ump->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

157

if (fs->e2fs_ronly == 0 &&

sys/fs/ext2fs/ext2_vfsops.c

166

if (error == 0 && fs->e2fs_wasvalid &&

sys/fs/ext2fs/ext2_vfsops.c

168

fs->e2fs->e2fs_state =

sys/fs/ext2fs/ext2_vfsops.c

169

htole16((le16toh(fs->e2fs->e2fs_state) |

sys/fs/ext2fs/ext2_vfsops.c

173

fs->e2fs_ronly = 1;

sys/fs/ext2fs/ext2_vfsops.c

184

if (fs->e2fs_ronly && !vfs_flagopt(opts, "ro", NULL, 0)) {

sys/fs/ext2fs/ext2_vfsops.c

185

if (ext2_check_sb_compat(fs->e2fs, devvp->v_rdev, 0))

sys/fs/ext2fs/ext2_vfsops.c

208

if ((le16toh(fs->e2fs->e2fs_state) & E2FS_ISCLEAN) == 0 ||

sys/fs/ext2fs/ext2_vfsops.c

209

(le16toh(fs->e2fs->e2fs_state) & E2FS_ERRORS)) {

sys/fs/ext2fs/ext2_vfsops.c

212

"WARNING: %s was not properly dismounted\n", fs->e2fs_fsmnt);

sys/fs/ext2fs/ext2_vfsops.c

216

fs->e2fs_fsmnt);

sys/fs/ext2fs/ext2_vfsops.c

220

fs->e2fs->e2fs_state =

sys/fs/ext2fs/ext2_vfsops.c

221

htole16(le16toh(fs->e2fs->e2fs_state) & ~E2FS_ISCLEAN);

sys/fs/ext2fs/ext2_vfsops.c

223

fs->e2fs_ronly = 0;

sys/fs/ext2fs/ext2_vfsops.c

282

fs = ump->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

288

strncpy(fs->e2fs_fsmnt, path, MAXMNTLEN);

sys/fs/ext2fs/ext2_vfsops.c

289

fs->e2fs_fsmnt[MAXMNTLEN - 1] = '\0';

sys/fs/ext2fs/ext2_vfsops.c

334

ext2_cg_location(struct m_ext2fs *fs, int number)

sys/fs/ext2fs/ext2_vfsops.c

343

logical_sb = fs->e2fs_bsize > SBLOCKSIZE ? 0 : 1;

sys/fs/ext2fs/ext2_vfsops.c

345

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) ||

sys/fs/ext2fs/ext2_vfsops.c

346

number < le32toh(fs->e2fs->e3fs_first_meta_bg))

sys/fs/ext2fs/ext2_vfsops.c

349

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT))

sys/fs/ext2fs/ext2_vfsops.c

350

descpb = fs->e2fs_bsize / sizeof(struct ext2_gd);

sys/fs/ext2fs/ext2_vfsops.c

352

descpb = fs->e2fs_bsize / E2FS_REV0_GD_SIZE;

sys/fs/ext2fs/ext2_vfsops.c

356

if (ext2_cg_has_sb(fs, cg))

sys/fs/ext2fs/ext2_vfsops.c

359

return (has_super + cg * (e4fs_daddr_t)EXT2_BLOCKS_PER_GROUP(fs) +

sys/fs/ext2fs/ext2_vfsops.c

360

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

sys/fs/ext2fs/ext2_vfsops.c

364

ext2_cg_validate(struct m_ext2fs *fs)

sys/fs/ext2fs/ext2_vfsops.c

373

first_block = le32toh(fs->e2fs->e2fs_first_dblock);

sys/fs/ext2fs/ext2_vfsops.c

374

last_cg_block = ext2_cg_number_gdb(fs, 0);

sys/fs/ext2fs/ext2_vfsops.c

375

cg_count = fs->e2fs_gcount;

sys/fs/ext2fs/ext2_vfsops.c

377

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

sys/fs/ext2fs/ext2_vfsops.c

378

gd = &fs->e2fs_gd[i];

sys/fs/ext2fs/ext2_vfsops.c

380

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) ||

sys/fs/ext2fs/ext2_vfsops.c

381

i == fs->e2fs_gcount - 1) {

sys/fs/ext2fs/ext2_vfsops.c

382

last_block = fs->e2fs_bcount - 1;

sys/fs/ext2fs/ext2_vfsops.c

385

(EXT2_BLOCKS_PER_GROUP(fs) - 1);

sys/fs/ext2fs/ext2_vfsops.c

388

if ((cg_count == fs->e2fs_gcount) &&

sys/fs/ext2fs/ext2_vfsops.c

438

i_tables + fs->e2fs_itpg - 1 > last_block) {

sys/fs/ext2fs/ext2_vfsops.c

444

if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG))

sys/fs/ext2fs/ext2_vfsops.c

445

first_block += EXT2_BLOCKS_PER_GROUP(fs);

sys/fs/ext2fs/ext2_vfsops.c

457

struct m_ext2fs *fs)

sys/fs/ext2fs/ext2_vfsops.c

466

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) &&

sys/fs/ext2fs/ext2_vfsops.c

467

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/fs/ext2fs/ext2_vfsops.c

474

ext2_sb_csum_set_seed(fs);

sys/fs/ext2fs/ext2_vfsops.c

477

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/fs/ext2fs/ext2_vfsops.c

478

error = ext2_sb_csum_verify(fs);

sys/fs/ext2fs/ext2_vfsops.c

491

fs->e2fs_bshift = EXT2_MIN_BLOCK_LOG_SIZE + le32toh(es->e2fs_log_bsize);

sys/fs/ext2fs/ext2_vfsops.c

492

fs->e2fs_bsize = 1U << fs->e2fs_bshift;

sys/fs/ext2fs/ext2_vfsops.c

493

fs->e2fs_fsbtodb = le32toh(es->e2fs_log_bsize) + 1;

sys/fs/ext2fs/ext2_vfsops.c

494

fs->e2fs_qbmask = fs->e2fs_bsize - 1;

sys/fs/ext2fs/ext2_vfsops.c

504

fs->e2fs_fsize = EXT2_MIN_FRAG_SIZE << le32toh(es->e2fs_log_fsize);

sys/fs/ext2fs/ext2_vfsops.c

505

if (fs->e2fs_fsize != fs->e2fs_bsize) {

sys/fs/ext2fs/ext2_vfsops.c

511

fs->e2fs_fpb = fs->e2fs_bsize / fs->e2fs_fsize;

sys/fs/ext2fs/ext2_vfsops.c

514

if (le16toh(es->e2fs_reserved_ngdb) > (fs->e2fs_bsize / 4)) {

sys/fs/ext2fs/ext2_vfsops.c

521

fs->e2fs_isize = E2FS_REV0_INODE_SIZE;

sys/fs/ext2fs/ext2_vfsops.c

523

fs->e2fs_isize = le16toh(es->e2fs_inode_size);

sys/fs/ext2fs/ext2_vfsops.c

537

if (EXT2_INODE_SIZE(fs) < E2FS_REV0_INODE_SIZE ||

sys/fs/ext2fs/ext2_vfsops.c

538

EXT2_INODE_SIZE(fs) > fs->e2fs_bsize ||

sys/fs/ext2fs/ext2_vfsops.c

539

(fs->e2fs_isize & (fs->e2fs_isize - 1)) != 0) {

sys/fs/ext2fs/ext2_vfsops.c

547

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT) &&

sys/fs/ext2fs/ext2_vfsops.c

554

fs->e2fs_bpg = le32toh(es->e2fs_bpg);

sys/fs/ext2fs/ext2_vfsops.c

555

fs->e2fs_fpg = le32toh(es->e2fs_fpg);

sys/fs/ext2fs/ext2_vfsops.c

556

if (fs->e2fs_bpg == 0 || fs->e2fs_fpg == 0) {

sys/fs/ext2fs/ext2_vfsops.c

560

} else if (fs->e2fs_bpg != fs->e2fs_fpg) {

sys/fs/ext2fs/ext2_vfsops.c

566

if (fs->e2fs_bpg != fs->e2fs_bsize * 8) {

sys/fs/ext2fs/ext2_vfsops.c

572

fs->e2fs_ipb = fs->e2fs_bsize / EXT2_INODE_SIZE(fs);

sys/fs/ext2fs/ext2_vfsops.c

573

if (fs->e2fs_ipb == 0 ||

sys/fs/ext2fs/ext2_vfsops.c

574

fs->e2fs_ipb > fs->e2fs_bsize / E2FS_REV0_INODE_SIZE) {

sys/fs/ext2fs/ext2_vfsops.c

580

fs->e2fs_ipg = le32toh(es->e2fs_ipg);

sys/fs/ext2fs/ext2_vfsops.c

581

if (fs->e2fs_ipg < fs->e2fs_ipb || fs->e2fs_ipg > fs->e2fs_bsize * 8) {

sys/fs/ext2fs/ext2_vfsops.c

587

fs->e2fs_itpg = fs->e2fs_ipg / fs->e2fs_ipb;

sys/fs/ext2fs/ext2_vfsops.c

589

fs->e2fs_bcount = le32toh(es->e2fs_bcount);

sys/fs/ext2fs/ext2_vfsops.c

590

fs->e2fs_rbcount = le32toh(es->e2fs_rbcount);

sys/fs/ext2fs/ext2_vfsops.c

591

fs->e2fs_fbcount = le32toh(es->e2fs_fbcount);

sys/fs/ext2fs/ext2_vfsops.c

592

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {

sys/fs/ext2fs/ext2_vfsops.c

593

fs->e2fs_bcount |= (uint64_t)(le32toh(es->e4fs_bcount_hi)) << 32;

sys/fs/ext2fs/ext2_vfsops.c

594

fs->e2fs_rbcount |= (uint64_t)(le32toh(es->e4fs_rbcount_hi)) << 32;

sys/fs/ext2fs/ext2_vfsops.c

595

fs->e2fs_fbcount |= (uint64_t)(le32toh(es->e4fs_fbcount_hi)) << 32;

sys/fs/ext2fs/ext2_vfsops.c

597

if (fs->e2fs_rbcount > fs->e2fs_bcount ||

sys/fs/ext2fs/ext2_vfsops.c

598

fs->e2fs_fbcount > fs->e2fs_bcount) {

sys/fs/ext2fs/ext2_vfsops.c

604

fs->e2fs_ficount = le32toh(es->e2fs_ficount);

sys/fs/ext2fs/ext2_vfsops.c

605

if (fs->e2fs_ficount > le32toh(es->e2fs_icount)) {

sys/fs/ext2fs/ext2_vfsops.c

611

if (le32toh(es->e2fs_first_dblock) != (fs->e2fs_bsize > 1024 ? 0 : 1) ||

sys/fs/ext2fs/ext2_vfsops.c

612

le32toh(es->e2fs_first_dblock) >= fs->e2fs_bcount) {

sys/fs/ext2fs/ext2_vfsops.c

618

fs->e2fs_gcount = howmany(fs->e2fs_bcount -

sys/fs/ext2fs/ext2_vfsops.c

619

le32toh(es->e2fs_first_dblock), EXT2_BLOCKS_PER_GROUP(fs));

sys/fs/ext2fs/ext2_vfsops.c

620

if (fs->e2fs_gcount > ((uint64_t)1 << 32) - EXT2_DESCS_PER_BLOCK(fs)) {

sys/fs/ext2fs/ext2_vfsops.c

627

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_EXTRA_ISIZE) &&

sys/fs/ext2fs/ext2_vfsops.c

628

EXT2_INODE_SIZE(fs) < sizeof(struct ext2fs_dinode)) {

sys/fs/ext2fs/ext2_vfsops.c

636

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {

sys/fs/ext2fs/ext2_vfsops.c

637

e2fs_descpb = fs->e2fs_bsize / E2FS_64BIT_GD_SIZE;

sys/fs/ext2fs/ext2_vfsops.c

638

e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount, e2fs_descpb);

sys/fs/ext2fs/ext2_vfsops.c

640

e2fs_descpb = fs->e2fs_bsize / E2FS_REV0_GD_SIZE;

sys/fs/ext2fs/ext2_vfsops.c

641

e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount,

sys/fs/ext2fs/ext2_vfsops.c

642

fs->e2fs_bsize / sizeof(struct ext2_gd));

sys/fs/ext2fs/ext2_vfsops.c

644

fs->e2fs_gdbcount = howmany(fs->e2fs_gcount, e2fs_descpb);

sys/fs/ext2fs/ext2_vfsops.c

645

fs->e2fs_gd = malloc(e2fs_gdbcount_alloc * fs->e2fs_bsize,

sys/fs/ext2fs/ext2_vfsops.c

647

fs->e2fs_contigdirs = malloc(fs->e2fs_gcount *

sys/fs/ext2fs/ext2_vfsops.c

648

sizeof(*fs->e2fs_contigdirs), M_EXT2MNT, M_WAITOK | M_ZERO);

sys/fs/ext2fs/ext2_vfsops.c

650

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

sys/fs/ext2fs/ext2_vfsops.c

652

fsbtodb(fs, ext2_cg_location(fs, i)),

sys/fs/ext2fs/ext2_vfsops.c

653

fs->e2fs_bsize, NOCRED, &bp);

sys/fs/ext2fs/ext2_vfsops.c

663

if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {

sys/fs/ext2fs/ext2_vfsops.c

664

memcpy(&fs->e2fs_gd[

sys/fs/ext2fs/ext2_vfsops.c

665

i * fs->e2fs_bsize / sizeof(struct ext2_gd)],

sys/fs/ext2fs/ext2_vfsops.c

666

bp->b_data, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_vfsops.c

669

g_count < fs->e2fs_gcount; j++, g_count++)

sys/fs/ext2fs/ext2_vfsops.c

670

memcpy(&fs->e2fs_gd[g_count],

sys/fs/ext2fs/ext2_vfsops.c

679

error = ext2_cg_validate(fs);

sys/fs/ext2fs/ext2_vfsops.c

684

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||

sys/fs/ext2fs/ext2_vfsops.c

685

EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/fs/ext2fs/ext2_vfsops.c

686

error = ext2_gd_csum_verify(fs, devvp->v_rdev);

sys/fs/ext2fs/ext2_vfsops.c

691

fs->e2fs_total_dir = 0;

sys/fs/ext2fs/ext2_vfsops.c

692

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

sys/fs/ext2fs/ext2_vfsops.c

693

fs->e2fs_total_dir += e2fs_gd_get_ndirs(&fs->e2fs_gd[i]);

sys/fs/ext2fs/ext2_vfsops.c

696

!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_LARGEFILE))

sys/fs/ext2fs/ext2_vfsops.c

697

fs->e2fs_maxfilesize = 0x7fffffff;

sys/fs/ext2fs/ext2_vfsops.c

699

fs->e2fs_maxfilesize = 0xffffffffffff;

sys/fs/ext2fs/ext2_vfsops.c

700

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE))

sys/fs/ext2fs/ext2_vfsops.c

701

fs->e2fs_maxfilesize = 0x7fffffffffffffff;

sys/fs/ext2fs/ext2_vfsops.c

704

fs->e2fs_uhash = 3;

sys/fs/ext2fs/ext2_vfsops.c

708

fs->e2fs_uhash = 3;

sys/fs/ext2fs/ext2_vfsops.c

713

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))

sys/fs/ext2fs/ext2_vfsops.c

714

error = ext2_sb_csum_verify(fs);

sys/fs/ext2fs/ext2_vfsops.c

740

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vfsops.c

767

fs = VFSTOEXT2(mp)->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

768

bcopy(bp->b_data, fs->e2fs, sizeof(struct ext2fs));

sys/fs/ext2fs/ext2_vfsops.c

770

if ((error = ext2_compute_sb_data(devvp, es, fs)) != 0) {

sys/fs/ext2fs/ext2_vfsops.c

780

if (fs->e2fs_contigsumsize > 0) {

sys/fs/ext2fs/ext2_vfsops.c

781

lp = fs->e2fs_maxcluster;

sys/fs/ext2fs/ext2_vfsops.c

782

sump = fs->e2fs_clustersum;

sys/fs/ext2fs/ext2_vfsops.c

783

for (i = 0; i < fs->e2fs_gcount; i++, sump++) {

sys/fs/ext2fs/ext2_vfsops.c

784

*lp++ = fs->e2fs_contigsumsize;

sys/fs/ext2fs/ext2_vfsops.c

786

bzero(sump->cs_sum, fs->e2fs_contigsumsize + 1);

sys/fs/ext2fs/ext2_vfsops.c

806

error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),

sys/fs/ext2fs/ext2_vfsops.c

807

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

sys/fs/ext2fs/ext2_vfsops.c

815

EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)), ip);

sys/fs/ext2fs/ext2_vfsops.c

836

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vfsops.c

941

fs = ump->um_e2fs;

sys/fs/ext2fs/ext2_vfsops.c

942

fs->e2fs_ronly = ronly; /* ronly is set according to mnt_flags */

sys/fs/ext2fs/ext2_vfsops.c

948

fs->e2fs_wasvalid = le16toh(fs->e2fs->e2fs_state) & E2FS_ISCLEAN ? 1 : 0;

sys/fs/ext2fs/ext2_vfsops.c

950

fs->e2fs_fmod = 1; /* mark it modified and set fs invalid */

sys/fs/ext2fs/ext2_vfsops.c

951

fs->e2fs->e2fs_state =

sys/fs/ext2fs/ext2_vfsops.c

952

htole16(le16toh(fs->e2fs->e2fs_state) & ~E2FS_ISCLEAN);

sys/fs/ext2fs/ext2_vfsops.c

970

ump->um_nindir = EXT2_ADDR_PER_BLOCK(fs);

sys/fs/ext2fs/ext2_vfsops.c

971

ump->um_bptrtodb = le32toh(fs->e2fs->e2fs_log_bsize) + 1;

sys/fs/ext2fs/ext2_vfsops.c

972

ump->um_seqinc = EXT2_FRAGS_PER_BLOCK(fs);

sys/fs/ext2fs/ext2_vnops.c

1304

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vnops.c

1331

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_vnops.c

1391

if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/fs/ext2fs/ext2_vnops.c

1727

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vnops.c

1731

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_vnops.c

1746

if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {

sys/fs/ext2fs/ext2_vnops.c

1765

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vnops.c

1769

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_vnops.c

1787

if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {

sys/fs/ext2fs/ext2_vnops.c

1808

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vnops.c

1812

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_vnops.c

1828

if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {

sys/fs/ext2fs/ext2_vnops.c

1849

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vnops.c

1853

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_vnops.c

1870

if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {

sys/fs/ext2fs/ext2_vnops.c

2030

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vnops.c

2061

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_vnops.c

2063

uio->uio_offset >= fs->e2fs_maxfilesize)

sys/fs/ext2fs/ext2_vnops.c

2069

lbn = lblkno(fs, uio->uio_offset);

sys/fs/ext2fs/ext2_vnops.c

2071

size = blksize(fs, ip, lbn);

sys/fs/ext2fs/ext2_vnops.c

2072

blkoffset = blkoff(fs, uio->uio_offset);

sys/fs/ext2fs/ext2_vnops.c

2074

xfersize = fs->e2fs_fsize - blkoffset;

sys/fs/ext2fs/ext2_vnops.c

2080

if (lblktosize(fs, nextlbn) >= ip->i_size)

sys/fs/ext2fs/ext2_vnops.c

2087

u_int nextsize = blksize(fs, ip, nextlbn);

sys/fs/ext2fs/ext2_vnops.c

2170

struct m_ext2fs *fs;

sys/fs/ext2fs/ext2_vnops.c

2210

fs = ip->i_e2fs;

sys/fs/ext2fs/ext2_vnops.c

2211

if ((uoff_t)uio->uio_offset + uio->uio_resid > fs->e2fs_maxfilesize)

sys/fs/ext2fs/ext2_vnops.c

2231

lbn = lblkno(fs, uio->uio_offset);

sys/fs/ext2fs/ext2_vnops.c

2232

blkoffset = blkoff(fs, uio->uio_offset);

sys/fs/ext2fs/ext2_vnops.c

2233

xfersize = fs->e2fs_fsize - blkoffset;

sys/fs/ext2fs/ext2_vnops.c

2243

if (fs->e2fs_bsize > xfersize)

sys/fs/ext2fs/ext2_vnops.c

2256

size = blksize(fs, ip, lbn) - bp->b_resid;

sys/fs/ext2fs/ext2_vnops.c

2280

fs->e2fs_bsize == xfersize)

sys/fs/ext2fs/ext2_vnops.c

2299

} else if (xfersize + blkoffset == fs->e2fs_fsize) {

sys/fs/ext2fs/fs.h

102

#define fsbtodb(fs, b) ((daddr_t)(b) << (fs)->e2fs_fsbtodb)

sys/fs/ext2fs/fs.h

103

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

sys/fs/ext2fs/fs.h

106

#define ino_to_cg(fs, x) (((x) - 1) / (fs->e2fs_ipg))

sys/fs/ext2fs/fs.h

109

#define ino_to_fsba(fs, x) \

sys/fs/ext2fs/fs.h

110

(e2fs_gd_get_i_tables(&(fs)->e2fs_gd[ino_to_cg((fs), (x))]) + \

sys/fs/ext2fs/fs.h

111

(((x) - 1) % (fs)->e2fs_ipg) / (fs)->e2fs_ipb)

sys/fs/ext2fs/fs.h

114

#define ino_to_fsbo(fs, x) ((x-1) % (fs->e2fs_ipb))

sys/fs/ext2fs/fs.h

120

#define dtog(fs, d) (((d) - le32toh(fs->e2fs->e2fs_first_dblock)) / \

sys/fs/ext2fs/fs.h

121

EXT2_BLOCKS_PER_GROUP(fs))

sys/fs/ext2fs/fs.h

122

#define dtogd(fs, d) (((d) - le32toh(fs->e2fs->e2fs_first_dblock)) % \

sys/fs/ext2fs/fs.h

123

EXT2_BLOCKS_PER_GROUP(fs))

sys/fs/ext2fs/fs.h

130

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

sys/fs/ext2fs/fs.h

131

((loc) & (fs)->e2fs_qbmask)

sys/fs/ext2fs/fs.h

133

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

sys/fs/ext2fs/fs.h

134

((blk) << (fs->e2fs_bshift))

sys/fs/ext2fs/fs.h

136

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

sys/fs/ext2fs/fs.h

137

((loc) >> (fs->e2fs_bshift))

sys/fs/ext2fs/fs.h

140

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

sys/fs/ext2fs/fs.h

141

((loc) >> (fs->e2fs_bshift))

sys/fs/ext2fs/fs.h

143

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

sys/fs/ext2fs/fs.h

144

roundup(size, fs->e2fs_fsize)

sys/fs/ext2fs/fs.h

151

#define blksize(fs, ip, lbn) ((fs)->e2fs_fsize)

sys/fs/ext2fs/fs.h

156

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

sys/fs/ext2fs/fs.h

161

#define NINDIR(fs) (EXT2_ADDR_PER_BLOCK(fs))

sys/fs/nfs/nfs_commonsubs.c

2848

struct statfs *fs;

sys/fs/nfs/nfs_commonsubs.c

2891

fs = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);

sys/fs/nfs/nfs_commonsubs.c

2893

error = VFS_STATFS(mp, fs);

sys/fs/nfs/nfs_commonsubs.c

2897

free(fs, M_STATFS);

sys/fs/nfs/nfs_commonsubs.c

2909

if (fs->f_bavail < 0)

sys/fs/nfs/nfs_commonsubs.c

2910

fs->f_bavail = 0;

sys/fs/nfs/nfs_commonsubs.c

2911

if (fs->f_ffree < 0)

sys/fs/nfs/nfs_commonsubs.c

2912

fs->f_ffree = 0;

sys/fs/nfs/nfs_commonsubs.c

2939

free(fs, M_STATFS);

sys/fs/nfs/nfs_commonsubs.c

2964

free(fs, M_STATFS);

sys/fs/nfs/nfs_commonsubs.c

3160

freenum = nfsv4_filesavail(fs, mp);

sys/fs/nfs/nfs_commonsubs.c

3169

*tl = txdr_unsigned(fs->f_ffree);

sys/fs/nfs/nfs_commonsubs.c

3175

*tl = txdr_unsigned(fs->f_files);

sys/fs/nfs/nfs_commonsubs.c

3259

freenum = fs->f_bfree;

sys/fs/nfs/nfs_commonsubs.c

3261

freenum = fs->f_bavail;

sys/fs/nfs/nfs_commonsubs.c

3277

NFSQUOTABLKTOBYTE(uquad, fs->f_bsize);

sys/fs/nfs/nfs_commonsubs.c

3283

freenum = fs->f_bfree;

sys/fs/nfs/nfs_commonsubs.c

3285

freenum = fs->f_bavail;

sys/fs/nfs/nfs_commonsubs.c

3301

NFSQUOTABLKTOBYTE(uquad, fs->f_bsize);

sys/fs/nfs/nfs_commonsubs.c

3322

NFSQUOTABLKTOBYTE(uquad, fs->f_bsize);

sys/fs/nfs/nfs_commonsubs.c

3338

uquad = (u_int64_t)fs->f_bfree;

sys/fs/nfs/nfs_commonsubs.c

3343

uquad = (u_int64_t)fs->f_bavail;

sys/fs/nfs/nfs_commonsubs.c

3348

uquad *= fs->f_bsize;

sys/fs/nfs/nfs_commonsubs.c

3358

uquad = (u_int64_t)fs->f_bfree;

sys/fs/nfs/nfs_commonsubs.c

3359

uquad *= fs->f_bsize;

sys/fs/nfs/nfs_commonsubs.c

3370

uquad = (u_int64_t)fs->f_blocks;

sys/fs/nfs/nfs_commonsubs.c

3371

uquad *= fs->f_bsize;

sys/fs/nfs/nfs_commonsubs.c

3551

free(fs, M_STATFS);

sys/fs/nfs/nfs_commonsubs.c

3560

nfsv4_filesavail(struct statfs *fs, struct mount *mp)

sys/fs/nfs/nfs_commonsubs.c

3572

freenum = fs->f_ffree;

sys/fs/nfsclient/nfs_clrpcops.c

10004

error = nfsrpc_statfs(vp, &sb, &fs, &lease, &clone_blksize, cred, td,

sys/fs/nfsclient/nfs_clrpcops.c

10014

nfscl_loadfsinfo(nmp, &fs, clone_blksize);

sys/fs/nfsclient/nfs_clrpcops.c

9995

struct nfsfsinfo fs;

sys/fs/nfsclient/nfs_clvfsops.c

290

struct nfsfsinfo fs;

sys/fs/nfsclient/nfs_clvfsops.c

335

error = nfsrpc_fsinfo(vp, &fs, td->td_ucred, td, &nfsva,

sys/fs/nfsclient/nfs_clvfsops.c

342

error = nfsrpc_statfs(vp, &sb, &fs, NULL, &clone_blksize,

sys/fs/nfsclient/nfs_clvfsops.c

380

nfscl_loadfsinfo(nmp, &fs, clone_blksize);

sys/fs/nfsclient/nfs_clvfsops.c

404

struct nfsfsinfo fs;

sys/fs/nfsclient/nfs_clvfsops.c

408

error = nfsrpc_fsinfo(vp, &fs, cred, td, &nfsva, &attrflag);

sys/fs/nfsclient/nfs_clvfsops.c

413

nfscl_loadfsinfo(nmp, &fs, 0);

sys/fs/nfsserver/nfs_nfsdserv.c

2443

struct nfsfsinfo fs;

sys/fs/nfsserver/nfs_nfsdserv.c

2453

nfsvno_getfs(&fs, isdgram);

sys/fs/nfsserver/nfs_nfsdserv.c

2457

*tl++ = txdr_unsigned(fs.fs_rtmax);

sys/fs/nfsserver/nfs_nfsdserv.c

2458

*tl++ = txdr_unsigned(fs.fs_rtpref);

sys/fs/nfsserver/nfs_nfsdserv.c

2459

*tl++ = txdr_unsigned(fs.fs_rtmult);

sys/fs/nfsserver/nfs_nfsdserv.c

2460

*tl++ = txdr_unsigned(fs.fs_wtmax);

sys/fs/nfsserver/nfs_nfsdserv.c

2461

*tl++ = txdr_unsigned(fs.fs_wtpref);

sys/fs/nfsserver/nfs_nfsdserv.c

2462

*tl++ = txdr_unsigned(fs.fs_wtmult);

sys/fs/nfsserver/nfs_nfsdserv.c

2463

*tl++ = txdr_unsigned(fs.fs_dtpref);

sys/fs/nfsserver/nfs_nfsdserv.c

2464

txdr_hyper(fs.fs_maxfilesize, tl);

sys/fs/nfsserver/nfs_nfsdserv.c

2466

txdr_nfsv3time(&fs.fs_timedelta, tl);

sys/fs/nfsserver/nfs_nfsdserv.c

2468

*tl = txdr_unsigned(fs.fs_properties);

sys/fs/nfsserver/nfs_nfsdserv.c

4434

struct nfsfsinfo fs;

sys/fs/nfsserver/nfs_nfsdserv.c

4445

nfsvno_getfs(&fs, isdgram);

sys/fs/nfsserver/nfs_nfsdserv.c

4447

sf, NULL, &fs, NULL, 1, &ret, NULL, NULL, NULL, NULL, NULL,

sys/fs/nfsserver/nfs_nfsdstate.c

220

static void nfsrv_freelayouts(nfsquad_t *clid, fsid_t *fs, int laytype,

sys/fs/nfsserver/nfs_nfsdstate.c

238

fhandle_t *fhp, fhandle_t *dsfhp, char *devid, fsid_t fs);

sys/fs/nfsserver/nfs_nfsdstate.c

240

int mirrorcnt, fhandle_t *fhp, fhandle_t *dsfhp, char *devid, fsid_t fs);

sys/fs/nfsserver/nfs_nfsdstate.c

6965

fhandle_t *dsfhp, char *devid, fsid_t fs)

sys/fs/nfsserver/nfs_nfsdstate.c

6980

lyp->lay_fsid = fs;

sys/fs/nfsserver/nfs_nfsdstate.c

7013

fhandle_t *fhp, fhandle_t *dsfhp, char *devid, fsid_t fs)

sys/fs/nfsserver/nfs_nfsdstate.c

7029

lyp->lay_fsid = fs;

sys/fs/nfsserver/nfs_nfsdstate.c

7658

nfsrv_freelayouts(nfsquad_t *clid, fsid_t *fs, int laytype, int iomode)

sys/fs/nfsserver/nfs_nfsdstate.c

7670

if (fs != NULL && fsidcmp(fs, &lyp->lay_fsid) != 0)

sys/geom/journal/g_journal_ufs.c

51

struct fs *fs;

sys/geom/journal/g_journal_ufs.c

55

fs = ump->um_fs;

sys/geom/journal/g_journal_ufs.c

57

flags = fs->fs_flags;

sys/geom/journal/g_journal_ufs.c

58

fs->fs_flags &= ~(FS_UNCLEAN | FS_NEEDSFSCK);

sys/geom/journal/g_journal_ufs.c

60

fs->fs_flags = flags;

sys/geom/journal/g_journal_ufs.c

68

struct fs *fs;

sys/geom/journal/g_journal_ufs.c

71

fs = NULL;

sys/geom/journal/g_journal_ufs.c

73

ffs_sbget(cp, &fs, UFS_STDSB, UFS_NOCSUM, M_GEOM, g_use_g_read_data)

sys/geom/journal/g_journal_ufs.c

77

KASSERT(fs == NULL,

sys/geom/journal/g_journal_ufs.c

78

("g_journal_ufs_dirty: non-NULL fs %p\n", fs));

sys/geom/journal/g_journal_ufs.c

85

g_free(fs->fs_csp);

sys/geom/journal/g_journal_ufs.c

86

g_free(fs->fs_si);

sys/geom/journal/g_journal_ufs.c

87

fs->fs_si = NULL;

sys/geom/journal/g_journal_ufs.c

89

GJ_DEBUG(0, "clean=%d flags=0x%x", fs->fs_clean, fs->fs_flags);

sys/geom/journal/g_journal_ufs.c

90

fs->fs_clean = 0;

sys/geom/journal/g_journal_ufs.c

91

fs->fs_flags |= FS_NEEDSFSCK | FS_UNCLEAN;

sys/geom/journal/g_journal_ufs.c

92

error = ffs_sbput(cp, fs, fs->fs_sblockloc, g_use_g_write_data);

sys/geom/journal/g_journal_ufs.c

93

g_free(fs);

sys/geom/label/g_label_ext2fs.c

55

e2sb_t *fs;

sys/geom/label/g_label_ext2fs.c

63

if (pp->sectorsize < sizeof(*fs))

sys/geom/label/g_label_ext2fs.c

68

fs = g_read_data(cp, EXT2FS_SB_OFFSET, pp->sectorsize, NULL);

sys/geom/label/g_label_ext2fs.c

69

if (fs == NULL)

sys/geom/label/g_label_ext2fs.c

73

if (fs->s_magic == EXT2_SUPER_MAGIC &&

sys/geom/label/g_label_ext2fs.c

74

fs->s_rev_level == EXT2_DYNAMIC_REV) {

sys/geom/label/g_label_ext2fs.c

81

s_volume_name = fs->s_volume_name;

sys/geom/label/g_label_ext2fs.c

83

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

sys/geom/label/g_label_ext2fs.c

95

g_free(fs);

sys/geom/label/g_label_ufs.c

101

if (fs->fs_sblockloc < pp->sectorsize * 2)

sys/geom/label/g_label_ufs.c

132

struct fs *fs;

sys/geom/label/g_label_ufs.c

138

fs = NULL;

sys/geom/label/g_label_ufs.c

140

if (SBLOCKSIZE % pp->sectorsize != 0 || ffs_sbget(cp, &fs, UFS_STDSB,

sys/geom/label/g_label_ufs.c

143

KASSERT(fs == NULL,

sys/geom/label/g_label_ufs.c

144

("g_label_ufs_taste_common: non-NULL fs %p\n", fs));

sys/geom/label/g_label_ufs.c

149

if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_fsize > 0) {

sys/geom/label/g_label_ufs.c

151

} else if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_fsize > 0) {

sys/geom/label/g_label_ufs.c

157

if (g_label_ufs_ignore_bsdlabel_slice(cp, fs))

sys/geom/label/g_label_ufs.c

160

fs->fs_magic == FS_UFS1_MAGIC ? "UFS1" : "UFS2", pp->name);

sys/geom/label/g_label_ufs.c

164

if (fs->fs_volname[0] != '\0')

sys/geom/label/g_label_ufs.c

165

strlcpy(label, fs->fs_volname, size);

sys/geom/label/g_label_ufs.c

168

if (fs->fs_id[0] != 0 || fs->fs_id[1] != 0)

sys/geom/label/g_label_ufs.c

169

snprintf(label, size, "%08x%08x", fs->fs_id[0],

sys/geom/label/g_label_ufs.c

170

fs->fs_id[1]);

sys/geom/label/g_label_ufs.c

174

g_free(fs);

sys/geom/label/g_label_ufs.c

70

struct fs *fs)

sys/geom/label/g_label_ufs.c

83

if (G_LABEL_UFS_CMP(pp, fs, fs_providersize))

sys/geom/label/g_label_ufs.c

90

if (fs->fs_magic == FS_UFS1_MAGIC ?

sys/geom/label/g_label_ufs.c

91

G_LABEL_UFS_CMP(pp, fs, fs_old_size) :

sys/geom/label/g_label_ufs.c

92

G_LABEL_UFS_CMP(pp, fs, fs_size))

sys/i386/include/asmacros.h

106

movl %eax, %fs

sys/i386/include/asmacros.h

79

movw %fs,(%esp)

sys/i386/include/asmacros.h

92

#define PCPU(member) %fs:PC_ ## member

sys/i386/include/asmacros.h

95

movl %fs:PC_PRVSPACE, reg ; \

sys/i386/include/vm86.h

72

reg86_t fs;

sys/i386/linux/linux.h

374

l_uint fs;

sys/i386/linux/linux_machdep.c

609

l_regset->fs = b_reg->r_fs;

sys/kern/subr_vmem.c

1839

size_t fs[VMEM_MAXORDER], us[VMEM_MAXORDER];

sys/kern/subr_vmem.c

1857

memset(&fs, 0, sizeof(fs));

sys/kern/subr_vmem.c

1866

fs[ord] += bt->bt_size;

sys/kern/subr_vmem.c

1875

ut[ord], us[ord], ft[ord], fs[ord]);

sys/kern/vfs_mountroot.c

1012

vfs_mountroot_wait_if_neccessary(const char *fs, const char *dev)

sys/kern/vfs_mountroot.c

1021

if (strcmp(fs, "zfs") == 0 || strstr(fs, "nfs") != NULL ||

sys/kern/vfs_mountroot.c

1022

strcmp(fs, "p9fs") == 0 ||

sys/kern/vfs_mountroot.c

738

char *dev, *fs, *opts, *tok;

sys/kern/vfs_mountroot.c

744

fs = tok;

sys/kern/vfs_mountroot.c

747

free(fs, M_TEMP);

sys/kern/vfs_mountroot.c

765

printf("Trying to mount root from %s:%s [%s]...\n", fs, dev,

sys/kern/vfs_mountroot.c

770

if (vfs_byname(fs) == NULL) {

sys/kern/vfs_mountroot.c

776

error = vfs_mountroot_wait_if_neccessary(fs, dev);

sys/kern/vfs_mountroot.c

785

ma = mount_arg(ma, "fstype", fs, -1);

sys/kern/vfs_mountroot.c

799

"retrying for %d more second%s\n", fs, dev, error,

sys/kern/vfs_mountroot.c

808

fs, dev, error);

sys/kern/vfs_mountroot.c

813

free(fs, M_TEMP);

sys/kern/vfs_mountroot.c

92

static int vfs_mountroot_wait_if_neccessary(const char *fs, const char *dev);

sys/netinet/tcp_subr.c

1187

struct tcp_function_set fs;

sys/netinet/tcp_subr.c

1235

(void)strlcpy(fs.function_set_name, names[i],

sys/netinet/tcp_subr.c

1236

sizeof(fs.function_set_name));

sys/netinet/tcp_subr.c

1237

if (find_tcp_functions_locked(&fs) != NULL) {

sys/netinet/tcp_subr.c

392

find_tcp_functions_locked(struct tcp_function_set *fs)

sys/netinet/tcp_subr.c

399

if (strcmp(f->tf_name, fs->function_set_name) == 0) {

sys/netinet/tcp_subr.c

427

find_and_ref_tcp_functions(struct tcp_function_set *fs)

sys/netinet/tcp_subr.c

432

blk = find_tcp_functions_locked(fs);

sys/netinet/tcp_subr.c

455

struct tcp_function_set *fs)

sys/netinet/tcp_subr.c

467

strncpy(fs->function_set_name, f->tf_name,

sys/netinet/tcp_subr.c

475

fs->function_set_name[TCP_FUNCTION_NAME_LEN_MAX - 1] = '\0';

sys/netinet/tcp_subr.c

477

fs->function_set_name[0] = '\0';

sys/netinet/tcp_subr.c

662

struct tcp_function_set fs;

sys/netinet/tcp_subr.c

666

memset(&fs, 0, sizeof(struct tcp_function_set));

sys/netinet/tcp_subr.c

671

strcpy(fs.function_set_name, blk->tfb_tcp_block_name);

sys/netinet/tcp_subr.c

672

fs.pcbcnt = blk->tfb_refcnt;

sys/netinet/tcp_subr.c

675

error = sysctl_handle_string(oidp, fs.function_set_name,

sys/netinet/tcp_subr.c

676

sizeof(fs.function_set_name), req);

sys/netinet/tcp_subr.c

683

blk = find_tcp_functions_locked(&fs);

sys/netinet/tcp_var.h

1440

struct tcp_function_block *find_and_ref_tcp_functions(struct tcp_function_set *fs);

sys/netinet/tcp_var.h

1441

int find_tcp_function_alias(struct tcp_function_block *blk, struct tcp_function_set *fs);

sys/netinet/tcp_var.h

1445

find_and_ref_tcp_fb(struct tcp_function_block *fs);

sys/netpfil/ipfw/dn_aqm_codel.c

235

f = &(q->fs->fs);

sys/netpfil/ipfw/dn_aqm_codel.c

295

if (!q->fs->aqmcfg) {

sys/netpfil/ipfw/dn_aqm_codel.c

345

aqm_codel_config(struct dn_fsk* fs, struct dn_extra_parms *ep, int len)

sys/netpfil/ipfw/dn_aqm_codel.c

357

if (fs->aqmcfg) {

sys/netpfil/ipfw/dn_aqm_codel.c

358

free(fs->aqmcfg, M_DUMMYNET);

sys/netpfil/ipfw/dn_aqm_codel.c

359

fs->aqmcfg = NULL;

sys/netpfil/ipfw/dn_aqm_codel.c

362

fs->aqmcfg = malloc(sizeof(struct dn_aqm_codel_parms),

sys/netpfil/ipfw/dn_aqm_codel.c

364

if (fs->aqmcfg== NULL) {

sys/netpfil/ipfw/dn_aqm_codel.c

370

ccfg = fs->aqmcfg;

sys/netpfil/ipfw/dn_aqm_codel.c

400

aqm_codel_deconfig(struct dn_fsk* fs)

sys/netpfil/ipfw/dn_aqm_codel.c

403

if (fs && fs->aqmcfg) {

sys/netpfil/ipfw/dn_aqm_codel.c

404

free(fs->aqmcfg, M_DUMMYNET);

sys/netpfil/ipfw/dn_aqm_codel.c

405

fs->aqmcfg = NULL;

sys/netpfil/ipfw/dn_aqm_codel.c

406

fs->aqmfp = NULL;

sys/netpfil/ipfw/dn_aqm_codel.c

418

aqm_codel_getconfig(struct dn_fsk *fs, struct dn_extra_parms * ep)

sys/netpfil/ipfw/dn_aqm_codel.c

422

if (fs->aqmcfg) {

sys/netpfil/ipfw/dn_aqm_codel.c

424

ccfg = fs->aqmcfg;

sys/netpfil/ipfw/dn_aqm_codel.h

141

cprms = q->fs->aqmcfg;

sys/netpfil/ipfw/dn_aqm_codel.h

97

cprms = q->fs->aqmcfg;

sys/netpfil/ipfw/dn_aqm_pie.c

498

f = &(q->fs->fs);

sys/netpfil/ipfw/dn_aqm_pie.c

580

pprms = q->fs->aqmcfg;

sys/netpfil/ipfw/dn_aqm_pie.c

608

pst->one_third_q_size = q->fs->fs.qsize/3;

sys/netpfil/ipfw/dn_aqm_pie.c

657

if(!q->fs || !q->fs->aqmcfg) {

sys/netpfil/ipfw/dn_aqm_pie.c

661

if (q->fs->aqmfp && q->fs->aqmfp->type !=DN_AQM_PIE) {

sys/netpfil/ipfw/dn_aqm_pie.c

662

D("Not PIE fs (%d)", q->fs->fs.fs_nr);

sys/netpfil/ipfw/dn_aqm_pie.c

687

aqm_pie_config(struct dn_fsk* fs, struct dn_extra_parms *ep, int len)

sys/netpfil/ipfw/dn_aqm_pie.c

699

if (fs->aqmcfg) {

sys/netpfil/ipfw/dn_aqm_pie.c

700

free(fs->aqmcfg, M_DUMMYNET);

sys/netpfil/ipfw/dn_aqm_pie.c

701

fs->aqmcfg = NULL;

sys/netpfil/ipfw/dn_aqm_pie.c

704

fs->aqmcfg = malloc(sizeof(struct dn_aqm_pie_parms),

sys/netpfil/ipfw/dn_aqm_pie.c

706

if (fs->aqmcfg== NULL) {

sys/netpfil/ipfw/dn_aqm_pie.c

717

pcfg = fs->aqmcfg;

sys/netpfil/ipfw/dn_aqm_pie.c

765

aqm_pie_deconfig(struct dn_fsk* fs)

sys/netpfil/ipfw/dn_aqm_pie.c

767

if (fs && fs->aqmcfg) {

sys/netpfil/ipfw/dn_aqm_pie.c

768

free(fs->aqmcfg, M_DUMMYNET);

sys/netpfil/ipfw/dn_aqm_pie.c

769

fs->aqmcfg = NULL;

sys/netpfil/ipfw/dn_aqm_pie.c

779

aqm_pie_getconfig (struct dn_fsk *fs, struct dn_extra_parms * ep)

sys/netpfil/ipfw/dn_aqm_pie.c

782

if (fs->aqmcfg) {

sys/netpfil/ipfw/dn_aqm_pie.c

784

pcfg = fs->aqmcfg;

sys/netpfil/ipfw/dn_sched.h

179

if (q->fs->aqmfp && q->fs->aqmfp->dequeue )

sys/netpfil/ipfw/dn_sched.h

180

return q->fs->aqmfp->dequeue(q);

sys/netpfil/ipfw/dn_sched_fifo.c

89

q->fs = si->sched->fs;

sys/netpfil/ipfw/dn_sched_fq_codel.c

453

q->fs = _si->sched->fs;

sys/netpfil/ipfw/dn_sched_fq_pie.c

1030

q->fs = _si->sched->fs;

sys/netpfil/ipfw/dn_sched_prio.c

154

prio_new_fsk(struct dn_fsk *fs)

sys/netpfil/ipfw/dn_sched_prio.c

157

ipdn_bound_var(&fs->fs.par[0], 0, 0, MAXPRIO - 1, "PRIO priority");

sys/netpfil/ipfw/dn_sched_prio.c

165

int prio = q->fs->fs.par[0];

sys/netpfil/ipfw/dn_sched_prio.c

199

int prio = q->fs->fs.par[0];

sys/netpfil/ipfw/dn_sched_prio.c

89

int prio = q->fs->fs.par[0];

sys/netpfil/ipfw/dn_sched_qfq.c

312

w = _q->fs->fs.par[0];

sys/netpfil/ipfw/dn_sched_qfq.c

313

cl->lmax = _q->fs->fs.par[1];

sys/netpfil/ipfw/dn_sched_qfq.c

797

ipdn_bound_var(&f->fs.par[0], 1, 1, QFQ_MAX_WEIGHT, "qfq weight");

sys/netpfil/ipfw/dn_sched_qfq.c

798

ipdn_bound_var(&f->fs.par[1], 1500, 1, 2000, "qfq maxlen");

sys/netpfil/ipfw/dn_sched_qfq.c

799

ND("weight %d len %d\n", f->fs.par[0], f->fs.par[1]);

sys/netpfil/ipfw/dn_sched_rr.c

243

rr_new_fsk(struct dn_fsk *fs)

sys/netpfil/ipfw/dn_sched_rr.c

245

struct rr_schk *schk = (struct rr_schk *)(fs->sched + 1);

sys/netpfil/ipfw/dn_sched_rr.c

248

ipdn_bound_var(&fs->fs.par[0], 1,

sys/netpfil/ipfw/dn_sched_rr.c

250

ipdn_bound_var(&fs->fs.par[1], schk->q_bytes,

sys/netpfil/ipfw/dn_sched_rr.c

263

quantum = (uint64_t)_q->fs->fs.par[0] * _q->fs->fs.par[1];

sys/netpfil/ipfw/dn_sched_wf2q.c

129

si->wsum -= q->fs->fs.par[0]; /* adjust sum of weights */

sys/netpfil/ipfw/dn_sched_wf2q.c

138

struct dn_fsk *fs = q->fs;

sys/netpfil/ipfw/dn_sched_wf2q.c

156

si->wsum += fs->fs.par[0]; /* add weight of new queue. */

sys/netpfil/ipfw/dn_sched_wf2q.c

298

wf2qp_new_fsk(struct dn_fsk *fs)

sys/netpfil/ipfw/dn_sched_wf2q.c

300

ipdn_bound_var(&fs->fs.par[0], 1,

sys/netpfil/ipfw/dn_sched_wf2q.c

313

q->inv_w = ONE_FP / _q->fs->fs.par[0];

sys/netpfil/ipfw/dn_sched_wf2q.c

334

si->wsum -= q->fs->fs.par[0];

sys/netpfil/ipfw/ip_dn_io.c

1014

return (fs && (fs->fs.flags & DN_NOERROR)) ? 0 : ENOBUFS;

sys/netpfil/ipfw/ip_dn_io.c

331

struct dn_fsk *fs = q->fs;

sys/netpfil/ipfw/ip_dn_io.c

335

uint32_t q_size = (fs->fs.flags & DN_QSIZE_BYTES) ?

sys/netpfil/ipfw/ip_dn_io.c

342

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

sys/netpfil/ipfw/ip_dn_io.c

354

u_int t = div64((V_dn_cfg.curr_time - q->q_time), fs->lookup_step);

sys/netpfil/ipfw/ip_dn_io.c

356

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

sys/netpfil/ipfw/ip_dn_io.c

357

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

sys/netpfil/ipfw/ip_dn_io.c

362

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

sys/netpfil/ipfw/ip_dn_io.c

366

if (q->avg >= fs->max_th) { /* average queue >= max threshold */

sys/netpfil/ipfw/ip_dn_io.c

367

if (fs->fs.flags & DN_IS_ECN)

sys/netpfil/ipfw/ip_dn_io.c

369

if (fs->fs.flags & DN_IS_GENTLE_RED) {

sys/netpfil/ipfw/ip_dn_io.c

377

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

sys/netpfil/ipfw/ip_dn_io.c

378

fs->c_4;

sys/netpfil/ipfw/ip_dn_io.c

383

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

sys/netpfil/ipfw/ip_dn_io.c

384

if (fs->fs.flags & DN_IS_ECN)

sys/netpfil/ipfw/ip_dn_io.c

392

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

sys/netpfil/ipfw/ip_dn_io.c

395

if (fs->fs.flags & DN_QSIZE_BYTES)

sys/netpfil/ipfw/ip_dn_io.c

396

p_b = div64((p_b * len) , fs->max_pkt_size);

sys/netpfil/ipfw/ip_dn_io.c

488

if (q->fs == NULL || q->_si == NULL) {

sys/netpfil/ipfw/ip_dn_io.c

490

__FUNCTION__, q->fs, q->_si);

sys/netpfil/ipfw/ip_dn_io.c

494

f = &(q->fs->fs);

sys/netpfil/ipfw/ip_dn_io.c

530

if (q->fs->aqmfp)

sys/netpfil/ipfw/ip_dn_io.c

531

return q->fs->aqmfp->enqueue(q ,m);

sys/netpfil/ipfw/ip_dn_io.c

909

struct dn_fsk *fs = NULL;

sys/netpfil/ipfw/ip_dn_io.c

931

fs = dn_ht_find(V_dn_cfg.fshash, fs_id, 0, NULL);

sys/netpfil/ipfw/ip_dn_io.c

932

if (fs == NULL)

sys/netpfil/ipfw/ip_dn_io.c

934

if (fs->sched == NULL) /* should not happen */

sys/netpfil/ipfw/ip_dn_io.c

937

si = ipdn_si_find(fs->sched, &(fwa->f_id));

sys/netpfil/ipfw/ip_dn_io.c

944

if (fs->sched->fp->flags & DN_MULTIQUEUE) {

sys/netpfil/ipfw/ip_dn_io.c

945

q = ipdn_q_find(fs, si, &(fwa->f_id));

sys/netpfil/ipfw/ip_dn_io.c

949

if (fs->sched->fp->enqueue(si, q, m)) {

sys/netpfil/ipfw/ip_dn_io.c

967

struct dn_link *p = &fs->sched->link;

sys/netpfil/ipfw/ip_dn_private.h

203

struct dn_fs fs;

sys/netpfil/ipfw/ip_dn_private.h

255

struct dn_fsk *fs; /* parent flowset. */

sys/netpfil/ipfw/ip_dn_private.h

286

struct dn_fsk *fs; /* Flowset for !MULTIQUEUE */

sys/netpfil/ipfw/ip_dummynet.c

1027

copy_q(struct copy_args *a, struct dn_fsk *fs, int flags)

sys/netpfil/ipfw/ip_dummynet.c

1029

if (!fs->qht)

sys/netpfil/ipfw/ip_dummynet.c

1031

if (fs->fs.flags & DN_QHT_HASH)

sys/netpfil/ipfw/ip_dummynet.c

1032

dn_ht_scan(fs->qht, copy_q_cb, a);

sys/netpfil/ipfw/ip_dummynet.c

1034

copy_q_cb(fs->qht, a);

sys/netpfil/ipfw/ip_dummynet.c

1062

copy_flowset(struct copy_args *a, struct dn_fsk *fs, int flags)

sys/netpfil/ipfw/ip_dummynet.c

1065

if (!fs)

sys/netpfil/ipfw/ip_dummynet.c

1067

ND("flowset %d", fs->fs.fs_nr);

sys/netpfil/ipfw/ip_dummynet.c

1068

if (copy_obj(a->start, a->end, &fs->fs, "flowset", fs->fs.fs_nr))

sys/netpfil/ipfw/ip_dummynet.c

1070

ufs->oid.id = (fs->fs.flags & DN_QHT_HASH) ?

sys/netpfil/ipfw/ip_dummynet.c

1071

dn_ht_entries(fs->qht) : (fs->qht ? 1 : 0);

sys/netpfil/ipfw/ip_dummynet.c

1073

copy_q(a, fs, 0);

sys/netpfil/ipfw/ip_dummynet.c

1108

struct dn_fsk *fs;

sys/netpfil/ipfw/ip_dummynet.c

1113

SLIST_FOREACH(fs, &s->fsk_list, sch_chain) {

sys/netpfil/ipfw/ip_dummynet.c

1114

if (fs->fs.fs_nr < DN_MAX_ID)

sys/netpfil/ipfw/ip_dummynet.c

1126

SLIST_FOREACH(fs, &s->fsk_list, sch_chain)

sys/netpfil/ipfw/ip_dummynet.c

1127

if (fs->fs.fs_nr < DN_MAX_ID)

sys/netpfil/ipfw/ip_dummynet.c

1128

*p++ = fs->fs.fs_nr;

sys/netpfil/ipfw/ip_dummynet.c

1163

if (copy_flowset(a, s->fs, 0))

sys/netpfil/ipfw/ip_dummynet.c

1180

struct dn_fsk *fs = _o;

sys/netpfil/ipfw/ip_dummynet.c

1182

n = fs->fs.fs_nr;

sys/netpfil/ipfw/ip_dummynet.c

1189

if (copy_flowset(a, fs, 0))

sys/netpfil/ipfw/ip_dummynet.c

1191

copy_q(a, fs, 0);

sys/netpfil/ipfw/ip_dummynet.c

1208

config_red(struct dn_fsk *fs)

sys/netpfil/ipfw/ip_dummynet.c

1213

fs->w_q = fs->fs.w_q;

sys/netpfil/ipfw/ip_dummynet.c

1214

fs->max_p = fs->fs.max_p;

sys/netpfil/ipfw/ip_dummynet.c

1217

i = fs->sched->link.bandwidth;

sys/netpfil/ipfw/ip_dummynet.c

1221

idle = div64((s * 3) , fs->w_q); /* s, fs->w_q scaled; idle not scaled */

sys/netpfil/ipfw/ip_dummynet.c

1222

fs->lookup_step = div64(idle , V_dn_cfg.red_lookup_depth);

sys/netpfil/ipfw/ip_dummynet.c

1224

if (!fs->lookup_step)

sys/netpfil/ipfw/ip_dummynet.c

1225

fs->lookup_step = 1;

sys/netpfil/ipfw/ip_dummynet.c

1226

w0 = weight = SCALE(1) - fs->w_q; //fs->w_q scaled

sys/netpfil/ipfw/ip_dummynet.c

1228

for (t = fs->lookup_step; t > 1; --t)

sys/netpfil/ipfw/ip_dummynet.c

1230

fs->lookup_weight = (int)(weight); // scaled

sys/netpfil/ipfw/ip_dummynet.c

1233

fs->min_th = SCALE(fs->fs.min_th);

sys/netpfil/ipfw/ip_dummynet.c

1234

fs->max_th = SCALE(fs->fs.max_th);

sys/netpfil/ipfw/ip_dummynet.c

1236

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

sys/netpfil/ipfw/ip_dummynet.c

1237

fs->c_1 = fs->max_p;

sys/netpfil/ipfw/ip_dummynet.c

1239

fs->c_1 = SCALE((int64_t)(fs->max_p)) / (fs->fs.max_th - fs->fs.min_th);

sys/netpfil/ipfw/ip_dummynet.c

1240

fs->c_2 = SCALE_MUL(fs->c_1, SCALE(fs->fs.min_th));

sys/netpfil/ipfw/ip_dummynet.c

1242

if (fs->fs.flags & DN_IS_GENTLE_RED) {

sys/netpfil/ipfw/ip_dummynet.c

1243

fs->c_3 = (SCALE(1) - fs->max_p) / fs->fs.max_th;

sys/netpfil/ipfw/ip_dummynet.c

1244

fs->c_4 = SCALE(1) - 2 * fs->max_p;

sys/netpfil/ipfw/ip_dummynet.c

1248

free(fs->w_q_lookup, M_DUMMYNET);

sys/netpfil/ipfw/ip_dummynet.c

1249

fs->w_q_lookup = NULL;

sys/netpfil/ipfw/ip_dummynet.c

1253

fs->fs.flags &= ~DN_IS_RED;

sys/netpfil/ipfw/ip_dummynet.c

1254

fs->fs.flags &= ~DN_IS_GENTLE_RED;

sys/netpfil/ipfw/ip_dummynet.c

1257

fs->lookup_depth = V_dn_cfg.red_lookup_depth;

sys/netpfil/ipfw/ip_dummynet.c

1258

fs->w_q_lookup = (u_int *)malloc(fs->lookup_depth * sizeof(int),

sys/netpfil/ipfw/ip_dummynet.c

1260

if (fs->w_q_lookup == NULL) {

sys/netpfil/ipfw/ip_dummynet.c

1262

fs->fs.flags &= ~DN_IS_RED;

sys/netpfil/ipfw/ip_dummynet.c

1263

fs->fs.flags &= ~DN_IS_GENTLE_RED;

sys/netpfil/ipfw/ip_dummynet.c

1268

fs->w_q_lookup[0] = SCALE(1) - fs->w_q;

sys/netpfil/ipfw/ip_dummynet.c

1270

for (i = 1; i < fs->lookup_depth; i++)

sys/netpfil/ipfw/ip_dummynet.c

1271

fs->w_q_lookup[i] =

sys/netpfil/ipfw/ip_dummynet.c

1272

SCALE_MUL(fs->w_q_lookup[i - 1], fs->lookup_weight);

sys/netpfil/ipfw/ip_dummynet.c

1276

fs->avg_pkt_size = V_dn_cfg.red_avg_pkt_size;

sys/netpfil/ipfw/ip_dummynet.c

1279

fs->max_pkt_size = V_dn_cfg.red_max_pkt_size;

sys/netpfil/ipfw/ip_dummynet.c

1288

struct dn_fsk *fs;

sys/netpfil/ipfw/ip_dummynet.c

1289

SLIST_FOREACH(fs, &s->fsk_list, sch_chain) {

sys/netpfil/ipfw/ip_dummynet.c

1290

if (fs && (fs->fs.flags & DN_IS_RED))

sys/netpfil/ipfw/ip_dummynet.c

1291

config_red(fs);

sys/netpfil/ipfw/ip_dummynet.c

1297

fsk_attach(struct dn_fsk *fs, struct dn_schk *s)

sys/netpfil/ipfw/ip_dummynet.c

1300

fs->fs.fs_nr, s->sch.sched_nr);

sys/netpfil/ipfw/ip_dummynet.c

1301

SLIST_REMOVE(&V_dn_cfg.fsu, fs, dn_fsk, sch_chain);

sys/netpfil/ipfw/ip_dummynet.c

1302

fs->sched = s;

sys/netpfil/ipfw/ip_dummynet.c

1303

SLIST_INSERT_HEAD(&s->fsk_list, fs, sch_chain);

sys/netpfil/ipfw/ip_dummynet.c

1305

s->fp->new_fsk(fs);

sys/netpfil/ipfw/ip_dummynet.c

1307

fs->fsk_mask = fs->fs.flow_mask;

sys/netpfil/ipfw/ip_dummynet.c

1308

if (fs->sched->sch.flags & DN_HAVE_MASK)

sys/netpfil/ipfw/ip_dummynet.c

1309

flow_id_or(&fs->sched->sch.sched_mask, &fs->fsk_mask);

sys/netpfil/ipfw/ip_dummynet.c

1310

if (fs->qht) {

sys/netpfil/ipfw/ip_dummynet.c

1320

fs->fs.fs_nr, s->sch.sched_nr);

sys/netpfil/ipfw/ip_dummynet.c

1321

fs->qht = NULL;

sys/netpfil/ipfw/ip_dummynet.c

1324

if (nonzero_mask(&fs->fsk_mask))

sys/netpfil/ipfw/ip_dummynet.c

1325

fs->fs.flags |= DN_QHT_HASH;

sys/netpfil/ipfw/ip_dummynet.c

1327

fs->fs.flags &= ~DN_QHT_HASH;

sys/netpfil/ipfw/ip_dummynet.c

1330

if (fs->fs.flags & DN_IS_RED)

sys/netpfil/ipfw/ip_dummynet.c

1331

config_red(fs);

sys/netpfil/ipfw/ip_dummynet.c

1338

struct dn_fsk *fs, *tmp;

sys/netpfil/ipfw/ip_dummynet.c

1340

SLIST_FOREACH_SAFE(fs, &V_dn_cfg.fsu, sch_chain, tmp) {

sys/netpfil/ipfw/ip_dummynet.c

1341

if (s->sch.sched_nr != fs->fs.sched_nr) {

sys/netpfil/ipfw/ip_dummynet.c

1343

fs->fs.fs_nr, fs->fs.sched_nr,

sys/netpfil/ipfw/ip_dummynet.c

1347

fsk_attach(fs, s);

sys/netpfil/ipfw/ip_dummynet.c

1358

struct dn_fsk *fs;

sys/netpfil/ipfw/ip_dummynet.c

1385

fs = dn_ht_find(V_dn_cfg.fshash, ep->nr, 0, NULL);

sys/netpfil/ipfw/ip_dummynet.c

1386

if (!fs) {

sys/netpfil/ipfw/ip_dummynet.c

1392

if (fs->aqmfp && fs->aqmfp->getconfig) {

sys/netpfil/ipfw/ip_dummynet.c

1393

if(fs->aqmfp->getconfig(fs, ep)) {

sys/netpfil/ipfw/ip_dummynet.c

1466

config_aqm(struct dn_fsk *fs, struct dn_extra_parms *ep, int busy)

sys/netpfil/ipfw/ip_dummynet.c

1497

if (fs->aqmcfg && fs->aqmfp && fs->aqmfp->deconfig) {

sys/netpfil/ipfw/ip_dummynet.c

1498

aqm_cleanup_deconfig_fs(fs);

sys/netpfil/ipfw/ip_dummynet.c

1501

if (!(fs->aqmfp = find_aqm_type(0, ep->name))) {

sys/netpfil/ipfw/ip_dummynet.c

1503

fs->fs.flags &= ~DN_IS_AQM;

sys/netpfil/ipfw/ip_dummynet.c

1507

fs->fs.flags |= DN_IS_AQM;

sys/netpfil/ipfw/ip_dummynet.c

1515

if (fs->aqmfp->config) {

sys/netpfil/ipfw/ip_dummynet.c

1516

err = fs->aqmfp->config(fs, ep, ep->oid.len);

sys/netpfil/ipfw/ip_dummynet.c

1518

D("Unable to configure AQM for FS %d", fs->fs.fs_nr );

sys/netpfil/ipfw/ip_dummynet.c

1519

fs->fs.flags &= ~DN_IS_AQM;

sys/netpfil/ipfw/ip_dummynet.c

1520

fs->aqmfp = NULL;

sys/netpfil/ipfw/ip_dummynet.c

1615

struct dn_fsk *fs;

sys/netpfil/ipfw/ip_dummynet.c

1659

fs = dn_ht_find(V_dn_cfg.fshash, i, flags, NULL);

sys/netpfil/ipfw/ip_dummynet.c

1660

if (fs == NULL) {

sys/netpfil/ipfw/ip_dummynet.c

1666

nfs->sched_nr = fs->fs.sched_nr;

sys/netpfil/ipfw/ip_dummynet.c

1669

nfs->par[j] = fs->fs.par[j];

sys/netpfil/ipfw/ip_dummynet.c

1671

if (bcmp(&fs->fs, nfs, sizeof(*nfs)) == 0) {

sys/netpfil/ipfw/ip_dummynet.c

1681

config_aqm(fs, ep, s != NULL && s->siht != NULL);

sys/netpfil/ipfw/ip_dummynet.c

1694

fs->fs.fs_nr,

sys/netpfil/ipfw/ip_dummynet.c

1695

fs->fs.sched_nr, fs->sched, nfs->sched_nr, s);

sys/netpfil/ipfw/ip_dummynet.c

1696

if (fs->sched) {

sys/netpfil/ipfw/ip_dummynet.c

1699

fsk_detach(fs, flags);

sys/netpfil/ipfw/ip_dummynet.c

1701

fs->fs = *nfs; /* copy configuration */

sys/netpfil/ipfw/ip_dummynet.c

1703

fs->aqmfp = NULL;

sys/netpfil/ipfw/ip_dummynet.c

1705

config_aqm(fs, ep, s != NULL &&

sys/netpfil/ipfw/ip_dummynet.c

1709

fsk_attach(fs, s);

sys/netpfil/ipfw/ip_dummynet.c

1716

return fs;

sys/netpfil/ipfw/ip_dummynet.c

1869

if (!(s->fp->flags & DN_MULTIQUEUE) && !s->fs) {

sys/netpfil/ipfw/ip_dummynet.c

1870

s->fs = dn_ht_find(V_dn_cfg.fshash, i, 0, NULL);

sys/netpfil/ipfw/ip_dummynet.c

1871

if (!s->fs) {

sys/netpfil/ipfw/ip_dummynet.c

1872

struct dn_fs fs;

sys/netpfil/ipfw/ip_dummynet.c

1873

bzero(&fs, sizeof(fs));

sys/netpfil/ipfw/ip_dummynet.c

1874

set_oid(&fs.oid, DN_FS, sizeof(fs));

sys/netpfil/ipfw/ip_dummynet.c

1875

fs.fs_nr = i + DN_MAX_ID;

sys/netpfil/ipfw/ip_dummynet.c

1876

fs.sched_nr = i;

sys/netpfil/ipfw/ip_dummynet.c

1877

s->fs = config_fs(&fs, NULL, 1 /* locked */);

sys/netpfil/ipfw/ip_dummynet.c

1879

if (!s->fs) {

sys/netpfil/ipfw/ip_dummynet.c

2009

struct dn_fs fs;

sys/netpfil/ipfw/ip_dummynet.c

2135

memcpy(&dn->fs, (char *)p + off, sizeof(dn->fs));

sys/netpfil/ipfw/ip_dummynet.c

2136

err = (NULL == config_fs(&dn->fs, arg, 0));

sys/netpfil/ipfw/ip_dummynet.c

2429

struct dn_fsk *fs = _fs;

sys/netpfil/ipfw/ip_dummynet.c

2431

if (fs->fs.flags & DN_QHT_HASH) {

sys/netpfil/ipfw/ip_dummynet.c

2433

dn_ht_scan_bucket(fs->qht, &fs->drain_bucket,

sys/netpfil/ipfw/ip_dummynet.c

2435

fs->drain_bucket++;

sys/netpfil/ipfw/ip_dummynet.c

2440

if (fs->qht) {

sys/netpfil/ipfw/ip_dummynet.c

2441

if (drain_queue_cb(fs->qht, NULL) == DNHT_SCAN_DEL)

sys/netpfil/ipfw/ip_dummynet.c

2442

fs->qht = NULL;

sys/netpfil/ipfw/ip_dummynet.c

2769

struct dn_fsk *fs = _fs;

sys/netpfil/ipfw/ip_dummynet.c

2772

if (fs->aqmfp && fs->aqmfp->type == type)

sys/netpfil/ipfw/ip_dummynet.c

2773

aqm_cleanup_deconfig_fs(fs);

sys/netpfil/ipfw/ip_dummynet.c

356

struct dn_fsk *fs = template->fs;

sys/netpfil/ipfw/ip_dummynet.c

357

int size = sizeof(*q) + fs->sched->fp->q_datalen;

sys/netpfil/ipfw/ip_dummynet.c

366

if (fs->fs.flags & DN_QHT_HASH)

sys/netpfil/ipfw/ip_dummynet.c

368

q->fs = fs;

sys/netpfil/ipfw/ip_dummynet.c

372

if (fs->sched->fp->new_queue)

sys/netpfil/ipfw/ip_dummynet.c

373

fs->sched->fp->new_queue(q);

sys/netpfil/ipfw/ip_dummynet.c

377

if (fs->aqmfp && fs->aqmfp->init)

sys/netpfil/ipfw/ip_dummynet.c

378

if(fs->aqmfp->init(q))

sys/netpfil/ipfw/ip_dummynet.c

379

D("unable to init AQM for fs %d", fs->fs.fs_nr);

sys/netpfil/ipfw/ip_dummynet.c

394

struct dn_fsk *fs = q->fs;

sys/netpfil/ipfw/ip_dummynet.c

400

if (fs && fs->aqmfp && fs->aqmfp->cleanup)

sys/netpfil/ipfw/ip_dummynet.c

401

fs->aqmfp->cleanup(q);

sys/netpfil/ipfw/ip_dummynet.c

405

if (fs && fs->sched->fp->free_queue)

sys/netpfil/ipfw/ip_dummynet.c

406

fs->sched->fp->free_queue(q);

sys/netpfil/ipfw/ip_dummynet.c

432

qht_delete(struct dn_fsk *fs, int flags)

sys/netpfil/ipfw/ip_dummynet.c

435

fs->fs.fs_nr, flags, fs->qht);

sys/netpfil/ipfw/ip_dummynet.c

436

if (!fs->qht)

sys/netpfil/ipfw/ip_dummynet.c

438

if (fs->fs.flags & DN_QHT_HASH) {

sys/netpfil/ipfw/ip_dummynet.c

439

dn_ht_scan(fs->qht, q_delete_cb, (void *)(uintptr_t)flags);

sys/netpfil/ipfw/ip_dummynet.c

441

dn_ht_free(fs->qht, 0);

sys/netpfil/ipfw/ip_dummynet.c

442

fs->qht = NULL;

sys/netpfil/ipfw/ip_dummynet.c

445

dn_delete_queue((struct dn_queue *)(fs->qht), flags);

sys/netpfil/ipfw/ip_dummynet.c

447

fs->qht = NULL;

sys/netpfil/ipfw/ip_dummynet.c

456

ipdn_q_find(struct dn_fsk *fs, struct dn_sch_inst *si,

sys/netpfil/ipfw/ip_dummynet.c

462

template.fs = fs;

sys/netpfil/ipfw/ip_dummynet.c

464

if (fs->fs.flags & DN_QHT_HASH) {

sys/netpfil/ipfw/ip_dummynet.c

466

if (fs->qht == NULL) {

sys/netpfil/ipfw/ip_dummynet.c

467

fs->qht = dn_ht_init(NULL, fs->fs.buckets,

sys/netpfil/ipfw/ip_dummynet.c

470

if (fs->qht == NULL)

sys/netpfil/ipfw/ip_dummynet.c

474

flow_id_mask(&fs->fsk_mask, &masked_id);

sys/netpfil/ipfw/ip_dummynet.c

475

return dn_ht_find(fs->qht, (uintptr_t)&masked_id,

sys/netpfil/ipfw/ip_dummynet.c

478

if (fs->qht == NULL)

sys/netpfil/ipfw/ip_dummynet.c

479

fs->qht = q_new(0, 0, &template);

sys/netpfil/ipfw/ip_dummynet.c

480

return (struct dn_queue *)fs->qht;

sys/netpfil/ipfw/ip_dummynet.c

547

if (s->fs->aqmfp && s->fs->aqmfp->init)

sys/netpfil/ipfw/ip_dummynet.c

548

if(s->fs->aqmfp->init((struct dn_queue *)(si + 1))) {

sys/netpfil/ipfw/ip_dummynet.c

549

D("unable to init AQM for fs %d", s->fs->fs.fs_nr);

sys/netpfil/ipfw/ip_dummynet.c

592

if (q->aqm_status && q->fs->aqmfp)

sys/netpfil/ipfw/ip_dummynet.c

593

if (q->fs->aqmfp->cleanup)

sys/netpfil/ipfw/ip_dummynet.c

594

q->fs->aqmfp->cleanup(q);

sys/netpfil/ipfw/ip_dummynet.c

655

((struct dn_fsk *)key)->fs.fs_nr;

sys/netpfil/ipfw/ip_dummynet.c

663

struct dn_fsk *fs = obj;

sys/netpfil/ipfw/ip_dummynet.c

665

((struct dn_fsk *)key)->fs.fs_nr;

sys/netpfil/ipfw/ip_dummynet.c

667

return (fs->fs.fs_nr == i);

sys/netpfil/ipfw/ip_dummynet.c

673

struct dn_fsk *fs;

sys/netpfil/ipfw/ip_dummynet.c

675

fs = malloc(sizeof(*fs), M_DUMMYNET, M_NOWAIT | M_ZERO);

sys/netpfil/ipfw/ip_dummynet.c

676

if (fs) {

sys/netpfil/ipfw/ip_dummynet.c

677

set_oid(&fs->fs.oid, DN_FS, sizeof(fs->fs));

sys/netpfil/ipfw/ip_dummynet.c

679

fs->drain_bucket = 0;

sys/netpfil/ipfw/ip_dummynet.c

680

SLIST_INSERT_HEAD(&V_dn_cfg.fsu, fs, sch_chain);

sys/netpfil/ipfw/ip_dummynet.c

682

return fs;

sys/netpfil/ipfw/ip_dummynet.c

695

if (si->sched->fs->aqmfp && si->sched->fs->aqmfp->cleanup)

sys/netpfil/ipfw/ip_dummynet.c

696

si->sched->fs->aqmfp->cleanup((struct dn_queue *) (si+1));

sys/netpfil/ipfw/ip_dummynet.c

706

q->fs->aqmfp->cleanup(q);

sys/netpfil/ipfw/ip_dummynet.c

714

aqm_cleanup_deconfig_fs(struct dn_fsk *fs)

sys/netpfil/ipfw/ip_dummynet.c

719

if (fs->fs.fs_nr > DN_MAX_ID) {

sys/netpfil/ipfw/ip_dummynet.c

720

if (fs->sched && !(fs->sched->fp->flags & DN_MULTIQUEUE)) {

sys/netpfil/ipfw/ip_dummynet.c

721

if (fs->sched->sch.flags & DN_HAVE_MASK)

sys/netpfil/ipfw/ip_dummynet.c

722

dn_ht_scan(fs->sched->siht, si_cleanup_q, NULL);

sys/netpfil/ipfw/ip_dummynet.c

725

si = (struct dn_sch_inst *) fs->sched->siht;

sys/netpfil/ipfw/ip_dummynet.c

726

if (si && fs->aqmfp && fs->aqmfp->cleanup)

sys/netpfil/ipfw/ip_dummynet.c

727

fs->aqmfp->cleanup((struct dn_queue *) (si+1));

sys/netpfil/ipfw/ip_dummynet.c

733

if (fs->sched && fs->sched->fp->flags & DN_MULTIQUEUE && fs->qht) {

sys/netpfil/ipfw/ip_dummynet.c

734

if (fs->fs.flags & DN_QHT_HASH)

sys/netpfil/ipfw/ip_dummynet.c

735

dn_ht_scan(fs->qht, q_cleanup_q, NULL);

sys/netpfil/ipfw/ip_dummynet.c

737

fs->aqmfp->cleanup((struct dn_queue *)(fs->qht));

sys/netpfil/ipfw/ip_dummynet.c

741

if(fs->aqmcfg && fs->aqmfp && fs->aqmfp->deconfig)

sys/netpfil/ipfw/ip_dummynet.c

742

fs->aqmfp->deconfig(fs);

sys/netpfil/ipfw/ip_dummynet.c

753

fsk_detach(struct dn_fsk *fs, int flags)

sys/netpfil/ipfw/ip_dummynet.c

758

fs->fs.fs_nr, fs->fs.sched_nr,

sys/netpfil/ipfw/ip_dummynet.c

764

h = fs->sched ? &fs->sched->fsk_list : &V_dn_cfg.fsu;

sys/netpfil/ipfw/ip_dummynet.c

765

SLIST_REMOVE(h, fs, dn_fsk, sch_chain);

sys/netpfil/ipfw/ip_dummynet.c

770

free(fs->w_q_lookup, M_DUMMYNET);

sys/netpfil/ipfw/ip_dummynet.c

771

fs->w_q_lookup = NULL;

sys/netpfil/ipfw/ip_dummynet.c

772

qht_delete(fs, flags);

sys/netpfil/ipfw/ip_dummynet.c

774

aqm_cleanup_deconfig_fs(fs);

sys/netpfil/ipfw/ip_dummynet.c

777

if (fs->sched && fs->sched->fp->free_fsk)

sys/netpfil/ipfw/ip_dummynet.c

778

fs->sched->fp->free_fsk(fs);

sys/netpfil/ipfw/ip_dummynet.c

779

fs->sched = NULL;

sys/netpfil/ipfw/ip_dummynet.c

781

bzero(fs, sizeof(*fs)); /* safety */

sys/netpfil/ipfw/ip_dummynet.c

782

free(fs, M_DUMMYNET);

sys/netpfil/ipfw/ip_dummynet.c

785

SLIST_INSERT_HEAD(&V_dn_cfg.fsu, fs, sch_chain);

sys/netpfil/ipfw/ip_dummynet.c

799

struct dn_fsk *fs;

sys/netpfil/ipfw/ip_dummynet.c

803

while ((fs = SLIST_FIRST(h))) {

sys/netpfil/ipfw/ip_dummynet.c

806

fsk_detach(fs, flags);

sys/netpfil/ipfw/ip_dummynet.c

818

struct dn_fsk *fs;

sys/netpfil/ipfw/ip_dummynet.c

823

fs = dn_ht_find(V_dn_cfg.fshash, i, DNHT_REMOVE, NULL);

sys/netpfil/ipfw/ip_dummynet.c

824

ND("fs %d found %p", i, fs);

sys/netpfil/ipfw/ip_dummynet.c

825

if (fs) {

sys/netpfil/ipfw/ip_dummynet.c

826

fsk_detach(fs, DN_DETACH | DN_DELETE_FS);

sys/netpfil/ipfw/test/main.c

192

double weight = (double)_q->fs->fs.par[0] / c->wsum;

sys/netpfil/ipfw/test/main.c

317

parse_flowsets(struct cfg_s *c, const char *fs)

sys/netpfil/ipfw/test/main.c

323

int pass = (fs == NULL);

sys/netpfil/ipfw/test/main.c

326

if (fs != NULL) { /* first pass */

sys/netpfil/ipfw/test/main.c

329

c->fs_config, fs);

sys/netpfil/ipfw/test/main.c

330

c->fs_config = fs;

sys/netpfil/ipfw/test/main.c

368

struct dn_fs *fs = &c->fs[n_fs].fs; // tentative

sys/netpfil/ipfw/test/main.c

377

if (c->fs == NULL || c->flowsets <= n_fs) {

sys/netpfil/ipfw/test/main.c

382

fs->par[0] = wi;

sys/netpfil/ipfw/test/main.c

383

fs->par[1] = li;

sys/netpfil/ipfw/test/main.c

384

fs->index = n_fs;

sys/netpfil/ipfw/test/main.c

385

fs->n_flows = flows;

sys/netpfil/ipfw/test/main.c

386

fs->cur = fs->first_flow = prev==NULL ? 0 : prev->next_flow;

sys/netpfil/ipfw/test/main.c

387

fs->next_flow = fs->first_flow + fs->n_flows;

sys/netpfil/ipfw/test/main.c

388

fs->y = x * flows;

sys/netpfil/ipfw/test/main.c

389

fs->base_y = (prev == NULL) ? 0 : prev->next_y;

sys/netpfil/ipfw/test/main.c

390

fs->next_y = fs->base_y + fs->y;

sys/netpfil/ipfw/test/main.c

391

prev = fs;

sys/netpfil/ipfw/test/main.c

408

struct dn_fs *fs = &c->fs[i].fs;

sys/netpfil/ipfw/test/main.c

410

i, fs->par[0], fs->par[1],

sys/netpfil/ipfw/test/main.c

411

fs->first_flow, fs->next_flow,

sys/netpfil/ipfw/test/main.c

412

fs->base_y, fs->next_y);

sys/netpfil/ipfw/test/main.c

413

for (j = fs->first_flow; j < fs->next_flow; j++) {

sys/netpfil/ipfw/test/main.c

415

q->fs = &c->fs[i];

sys/netpfil/ipfw/test/main.c

550

c->fs = calloc(c->flowsets, sizeof(struct dn_fsk));

sys/netpfil/ipfw/test/main.c

553

if (!c->sched || !c->si || !c->fs || !c->q || !c->q_wfi) {

sys/netpfil/ipfw/test/main.c

569

struct dn_fsk *fsk = &c->fs[i];

sys/netpfil/ipfw/test/main.c

570

if (fsk->fs.par[1] == 0)

sys/netpfil/ipfw/test/main.c

571

fsk->fs.par[1] = 1000; /* default pkt len */

sys/netpfil/ipfw/test/main.c

587

if (q->fs == NULL)

sys/netpfil/ipfw/test/main.c

588

q->fs = &c->fs[0]; /* XXX */

sys/netpfil/ipfw/test/main.c

648

struct dn_fs *fs;

sys/netpfil/ipfw/test/main.c

695

fs = &q->fs->fs;

sys/netpfil/ipfw/test/main.c

696

fs->cur = flow_id;

sys/netpfil/ipfw/test/main.c

698

c->cur_fs = q->fs - c->fs;

sys/netpfil/ipfw/test/main.c

707

fs = &c->fs[c->cur_fs].fs;

sys/netpfil/ipfw/test/main.c

708

flow_id = fs->cur++;

sys/netpfil/ipfw/test/main.c

709

if (fs->cur >= fs->next_flow)

sys/netpfil/ipfw/test/main.c

710

fs->cur = fs->first_flow;

sys/netpfil/ipfw/test/main.c

712

if (c->cur_y >= fs->next_y)

sys/netpfil/ipfw/test/main.c

729

m->m_pkthdr.len = fs->par[1]; // XXX maxlen

sys/netpfil/ipfw/test/main.c

73

struct dn_fsk *fs; /* array of flowsets */

sys/netpfil/ipfw/test/main.c

734

fs->par[0], m->m_pkthdr.len);

sys/powerpc/fpu/fpu_emu.c

267

struct fpu *fs;

sys/powerpc/fpu/fpu_emu.c

271

fs = fe->fe_fpstate;

sys/powerpc/fpu/fpu_emu.c

272

fe->fe_fpscr = ((int *)&fs->fpscr)[1];

sys/powerpc/fpu/fpu_emu.c

326

a = (int *)&fs->fpr[rt].fpr;

sys/powerpc/fpu/fpu_emu.c

393

if (copyout(&fs->fpr[rt].fpr, (void *)addr,

sys/powerpc/fpu/fpu_emu.c

402

if (copyin((const void *)addr, &fs->fpr[rt].fpr,

sys/powerpc/fpu/fpu_emu.c

408

(u_int *)&fs->fpr[rt].fpr);

sys/powerpc/fpu/fpu_emu.c

458

(u_int *)&fs->fpr[rt].fpr);

sys/powerpc/fpu/fpu_emu.c

491

memcpy(&fs->fpr[rt].fpr, &fs->fpr[rb].fpr,

sys/powerpc/fpu/fpu_emu.c

493

a = (int *)&fs->fpr[rt].fpr;

sys/powerpc/fpu/fpu_emu.c

521

memcpy(&fs->fpr[rt].fpr, &fs->fpr[rb].fpr,

sys/powerpc/fpu/fpu_emu.c

538

memcpy(&fs->fpr[rt].fpr, &fs->fpr[rb].fpr,

sys/powerpc/fpu/fpu_emu.c

540

a = (int *)&fs->fpr[rt].fpr;

sys/powerpc/fpu/fpu_emu.c

546

memcpy(&fs->fpr[rt].fpr, &fs->fpr[rb].fpr,

sys/powerpc/fpu/fpu_emu.c

548

a = (int *)&fs->fpr[rt].fpr;

sys/powerpc/fpu/fpu_emu.c

554

memcpy(&fs->fpr[rt].fpr, &fs->fpscr,

sys/powerpc/fpu/fpu_emu.c

555

sizeof(fs->fpscr));

sys/powerpc/fpu/fpu_emu.c

569

a = (int *)&fs->fpr[rt].fpr;

sys/powerpc/fpu/fpu_emu.c

641

memcpy(&fs->fpr[rt].fpr, &fs->fpr[rc].fpr,

sys/powerpc/fpu/fpu_emu.c

725

(u_int *)&fs->fpr[rt].fpr);

sys/powerpc/fpu/fpu_emu.c

740

fpu_implode(fe, fp, type, (u_int *)&fs->fpr[rt].fpr);

sys/powerpc/fpu/fpu_emu.c

782

((int *)&fs->fpscr)[1] = fsr;

sys/ufs/ffs/ffs_alloc.c

1000

blkno, *bap, fs->fs_bsize, fs->fs_bsize,

sys/ufs/ffs/ffs_alloc.c

1046

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

sys/ufs/ffs/ffs_alloc.c

1063

ffs_blkfree(ump, fs, ump->um_devvp,

sys/ufs/ffs/ffs_alloc.c

1064

dbtofsb(fs, bp->b_blkno),

sys/ufs/ffs/ffs_alloc.c

1065

fs->fs_bsize, ip->i_number, vp->v_type, NULL,

sys/ufs/ffs/ffs_alloc.c

1068

bp->b_blkno = fsbtodb(fs, blkno);

sys/ufs/ffs/ffs_alloc.c

1070

if (!ffs_checkfreeblk(ip, dbtofsb(fs, bp->b_blkno),

sys/ufs/ffs/ffs_alloc.c

1071

fs->fs_bsize))

sys/ufs/ffs/ffs_alloc.c

109

static void ffs_blkfree_cg(struct ufsmount *, struct fs *,

sys/ufs/ffs/ffs_alloc.c

1117

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

1128

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

1133

if (fs->fs_cstotal.cs_nifree == 0)

sys/ufs/ffs/ffs_alloc.c

1140

if (ipref >= fs->fs_ncg * fs->fs_ipg)

sys/ufs/ffs/ffs_alloc.c

1142

cg = ino_to_cg(fs, ipref);

sys/ufs/ffs/ffs_alloc.c

1148

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

sys/ufs/ffs/ffs_alloc.c

1149

fs->fs_contigdirs[cg]++;

sys/ufs/ffs/ffs_alloc.c

115

static void ffs_checkcgintegrity(struct fs *, uint64_t, int);

sys/ufs/ffs/ffs_alloc.c

1151

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

sys/ufs/ffs/ffs_alloc.c

1152

fs->fs_contigdirs[cg]--;

sys/ufs/ffs/ffs_alloc.c

1174

ip->i_mode, (uintmax_t)ip->i_number, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

1177

if (DIP(ip, i_blocks) && (fs->fs_flags & FS_UNCLEAN) == 0) { /* XXX */

sys/ufs/ffs/ffs_alloc.c

1179

fs->fs_fsmnt, (intmax_t)ino, (long)DIP(ip, i_blocks));

sys/ufs/ffs/ffs_alloc.c

1192

if (fs->fs_magic == FS_UFS2_MAGIC) {

sys/ufs/ffs/ffs_alloc.c

1200

if (fs->fs_magic == FS_UFS2_MAGIC) {

sys/ufs/ffs/ffs_alloc.c

1210

softdep_request_cleanup(fs, pvp, cred, FLUSH_INODES_WAIT);

sys/ufs/ffs/ffs_alloc.c

1219

ffs_fserr(fs, pip->i_number, "out of inodes");

sys/ufs/ffs/ffs_alloc.c

1221

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

1244

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

125

static ufs1_daddr_t ffs_mapsearch(struct fs *, struct cg *, ufs2_daddr_t, int);

sys/ufs/ffs/ffs_alloc.c

1252

fs = ITOFS(pip);

sys/ufs/ffs/ffs_alloc.c

1254

avgifree = fs->fs_cstotal.cs_nifree / fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1255

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1256

avgndir = fs->fs_cstotal.cs_ndir / fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1277

range = fs->fs_ncg / (1 << depth);

sys/ufs/ffs/ffs_alloc.c

1278

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

sys/ufs/ffs/ffs_alloc.c

1281

start += fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1283

if (end >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

1284

end -= fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1291

prefcg += fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1292

if (prefcg >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

1293

prefcg -= fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1305

maxndir = min(avgndir + (1 << depth), fs->fs_ipg);

sys/ufs/ffs/ffs_alloc.c

1312

cgsize = fs->fs_fsize * fs->fs_fpg;

sys/ufs/ffs/ffs_alloc.c

1313

dirsize = fs->fs_avgfilesize * fs->fs_avgfpdir;

sys/ufs/ffs/ffs_alloc.c

1314

curdirsize = avgndir ? (cgsize - avgbfree * fs->fs_bsize) / avgndir : 0;

sys/ufs/ffs/ffs_alloc.c

1320

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

sys/ufs/ffs/ffs_alloc.c

1321

if (fs->fs_avgfpdir > 0)

sys/ufs/ffs/ffs_alloc.c

1323

fs->fs_ipg / fs->fs_avgfpdir);

sys/ufs/ffs/ffs_alloc.c

1349

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

sys/ufs/ffs/ffs_alloc.c

1350

if (fs->fs_cs(fs, cg).cs_ndir < maxndir &&

sys/ufs/ffs/ffs_alloc.c

1351

fs->fs_cs(fs, cg).cs_nifree >= minifree &&

sys/ufs/ffs/ffs_alloc.c

1352

fs->fs_cs(fs, cg).cs_nbfree >= minbfree) {

sys/ufs/ffs/ffs_alloc.c

1353

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

sys/ufs/ffs/ffs_alloc.c

1354

return ((ino_t)(fs->fs_ipg * cg));

sys/ufs/ffs/ffs_alloc.c

1357

if (fs->fs_cs(fs, cg).cs_ndir < maxndir &&

sys/ufs/ffs/ffs_alloc.c

1358

fs->fs_cs(fs, cg).cs_nifree >= minifree &&

sys/ufs/ffs/ffs_alloc.c

1359

fs->fs_cs(fs, cg).cs_nbfree >= minbfree) {

sys/ufs/ffs/ffs_alloc.c

1360

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

sys/ufs/ffs/ffs_alloc.c

1361

return ((ino_t)(fs->fs_ipg * cg));

sys/ufs/ffs/ffs_alloc.c

1366

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

sys/ufs/ffs/ffs_alloc.c

1367

if (fs->fs_cs(fs, cg).cs_nifree >= avgifree)

sys/ufs/ffs/ffs_alloc.c

1368

return ((ino_t)(fs->fs_ipg * cg));

sys/ufs/ffs/ffs_alloc.c

1370

if (fs->fs_cs(fs, cg).cs_nifree >= avgifree)

sys/ufs/ffs/ffs_alloc.c

1372

return ((ino_t)(fs->fs_ipg * cg));

sys/ufs/ffs/ffs_alloc.c

1410

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

1417

fs = ITOFS(ip);

sys/ufs/ffs/ffs_alloc.c

1429

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

sys/ufs/ffs/ffs_alloc.c

1436

pref = cgmeta(fs, inocg);

sys/ufs/ffs/ffs_alloc.c

1441

if (indx == -1 && lbn < UFS_NDADDR + NINDIR(fs) &&

sys/ufs/ffs/ffs_alloc.c

1443

pref = ip->i_din1->di_db[UFS_NDADDR - 1] + fs->fs_frag;

sys/ufs/ffs/ffs_alloc.c

1444

if (dtog(fs, pref) >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

1456

if (pref != 0 && pref >= cgdata(fs, inocg) &&

sys/ufs/ffs/ffs_alloc.c

1457

pref < cgbase(fs, inocg + 1)) {

sys/ufs/ffs/ffs_alloc.c

1458

if (dtog(fs, pref + fs->fs_frag) >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

1460

return (pref + fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

1474

fs->fs_bsize) != 0)

sys/ufs/ffs/ffs_alloc.c

1477

if (indx % fs->fs_maxbpg == 0 || prevbn == 0) {

sys/ufs/ffs/ffs_alloc.c

1483

return (cgmeta(fs, inocg));

sys/ufs/ffs/ffs_alloc.c

1489

if (lbn < UFS_NDADDR + NINDIR(fs))

sys/ufs/ffs/ffs_alloc.c

1490

return (cgdata(fs, inocg));

sys/ufs/ffs/ffs_alloc.c

1496

startcg = inocg + lbn / fs->fs_maxbpg;

sys/ufs/ffs/ffs_alloc.c

1498

startcg = dtog(fs, prevbn) + 1;

sys/ufs/ffs/ffs_alloc.c

1499

startcg %= fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1500

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1501

for (cg = startcg; cg < fs->fs_ncg; cg++)

sys/ufs/ffs/ffs_alloc.c

1502

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/ufs/ffs/ffs_alloc.c

1503

fs->fs_cgrotor = cg;

sys/ufs/ffs/ffs_alloc.c

1504

return (cgdata(fs, cg));

sys/ufs/ffs/ffs_alloc.c

1507

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/ufs/ffs/ffs_alloc.c

1508

fs->fs_cgrotor = cg;

sys/ufs/ffs/ffs_alloc.c

1509

return (cgdata(fs, cg));

sys/ufs/ffs/ffs_alloc.c

1516

if (dtog(fs, prevbn + fs->fs_frag) >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

1518

return (prevbn + fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

1530

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

1537

fs = ITOFS(ip);

sys/ufs/ffs/ffs_alloc.c

1549

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

sys/ufs/ffs/ffs_alloc.c

1556

pref = cgmeta(fs, inocg);

sys/ufs/ffs/ffs_alloc.c

1561

if (indx == -1 && lbn < UFS_NDADDR + NINDIR(fs) &&

sys/ufs/ffs/ffs_alloc.c

1563

pref = ip->i_din2->di_db[UFS_NDADDR - 1] + fs->fs_frag;

sys/ufs/ffs/ffs_alloc.c

1564

if (dtog(fs, pref) >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

1576

if (pref != 0 && pref >= cgdata(fs, inocg) &&

sys/ufs/ffs/ffs_alloc.c

1577

pref < cgbase(fs, inocg + 1)) {

sys/ufs/ffs/ffs_alloc.c

1578

if (dtog(fs, pref + fs->fs_frag) >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

158

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

1580

return (pref + fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

1594

fs->fs_bsize) != 0)

sys/ufs/ffs/ffs_alloc.c

1597

if (indx % fs->fs_maxbpg == 0 || prevbn == 0) {

sys/ufs/ffs/ffs_alloc.c

1603

return (cgmeta(fs, inocg));

sys/ufs/ffs/ffs_alloc.c

1609

if (lbn < UFS_NDADDR + NINDIR(fs))

sys/ufs/ffs/ffs_alloc.c

1610

return (cgdata(fs, inocg));

sys/ufs/ffs/ffs_alloc.c

1616

startcg = inocg + lbn / fs->fs_maxbpg;

sys/ufs/ffs/ffs_alloc.c

1618

startcg = dtog(fs, prevbn) + 1;

sys/ufs/ffs/ffs_alloc.c

1619

startcg %= fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1620

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1621

for (cg = startcg; cg < fs->fs_ncg; cg++)

sys/ufs/ffs/ffs_alloc.c

1622

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/ufs/ffs/ffs_alloc.c

1623

fs->fs_cgrotor = cg;

sys/ufs/ffs/ffs_alloc.c

1624

return (cgdata(fs, cg));

sys/ufs/ffs/ffs_alloc.c

1627

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/ufs/ffs/ffs_alloc.c

1628

fs->fs_cgrotor = cg;

sys/ufs/ffs/ffs_alloc.c

1629

return (cgdata(fs, cg));

sys/ufs/ffs/ffs_alloc.c

1636

if (dtog(fs, prevbn + fs->fs_frag) >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

1638

return (prevbn + fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

1661

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

1670

fs = ITOFS(ip);

sys/ufs/ffs/ffs_alloc.c

1680

for (i = 1; i < fs->fs_ncg; i *= 2) {

sys/ufs/ffs/ffs_alloc.c

1682

if (cg >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

1683

cg -= fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

169

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

1693

cg = (icg + 2) % fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

1694

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

sys/ufs/ffs/ffs_alloc.c

1699

if (cg == fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

1718

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

172

if ((uint64_t)size > fs->fs_bsize || fragoff(fs, size) != 0) {

sys/ufs/ffs/ffs_alloc.c

1729

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

1730

if (fs->fs_cs(fs, cg).cs_nffree < numfrags(fs, nsize - osize))

sys/ufs/ffs/ffs_alloc.c

1732

frags = numfrags(fs, nsize);

sys/ufs/ffs/ffs_alloc.c

1733

bbase = fragnum(fs, bprev);

sys/ufs/ffs/ffs_alloc.c

1734

if (bbase > fragnum(fs, (bprev + frags - 1))) {

sys/ufs/ffs/ffs_alloc.c

1739

if ((error = ffs_getcg(fs, ump->um_devvp, cg, 0, &bp, &cgp)) != 0) {

sys/ufs/ffs/ffs_alloc.c

174

devtoname(ump->um_dev), (long)fs->fs_bsize, size,

sys/ufs/ffs/ffs_alloc.c

1740

ffs_checkcgintegrity(fs, cg, error);

sys/ufs/ffs/ffs_alloc.c

1743

bno = dtogd(fs, bprev);

sys/ufs/ffs/ffs_alloc.c

1745

for (i = numfrags(fs, osize); i < frags; i++)

sys/ufs/ffs/ffs_alloc.c

175

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

1754

for (i = frags; i < fs->fs_frag - bbase; i++)

sys/ufs/ffs/ffs_alloc.c

1757

cgp->cg_frsum[i - numfrags(fs, osize)]--;

sys/ufs/ffs/ffs_alloc.c

1760

for (i = numfrags(fs, osize), nffree = 0; i < frags; i++) {

sys/ufs/ffs/ffs_alloc.c

1766

fs->fs_cstotal.cs_nffree -= nffree;

sys/ufs/ffs/ffs_alloc.c

1767

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

sys/ufs/ffs/ffs_alloc.c

1768

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

1769

ACTIVECLEAR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

1773

frags, numfrags(fs, osize));

sys/ufs/ffs/ffs_alloc.c

1797

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

1807

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

1808

if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)

sys/ufs/ffs/ffs_alloc.c

1811

if ((error = ffs_getcg(fs, ump->um_devvp, cg, 0, &bp, &cgp)) != 0 ||

sys/ufs/ffs/ffs_alloc.c

1812

(cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize)) {

sys/ufs/ffs/ffs_alloc.c

1813

ffs_checkcgintegrity(fs, cg, error);

sys/ufs/ffs/ffs_alloc.c

1816

if (size == fs->fs_bsize) {

sys/ufs/ffs/ffs_alloc.c

1819

ACTIVECLEAR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

1830

frags = numfrags(fs, size);

sys/ufs/ffs/ffs_alloc.c

1831

for (allocsiz = frags; allocsiz < fs->fs_frag; allocsiz++)

sys/ufs/ffs/ffs_alloc.c

1834

if (allocsiz == fs->fs_frag) {

sys/ufs/ffs/ffs_alloc.c

1843

ACTIVECLEAR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

1850

bno = ffs_mapsearch(fs, cgp, bpref, allocsiz);

sys/ufs/ffs/ffs_alloc.c

1860

fs->fs_cstotal.cs_nffree -= frags;

sys/ufs/ffs/ffs_alloc.c

1861

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

sys/ufs/ffs/ffs_alloc.c

1862

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

1863

blkno = cgbase(fs, cg) + bno;

sys/ufs/ffs/ffs_alloc.c

1864

ACTIVECLEAR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

1894

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

190

if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)

sys/ufs/ffs/ffs_alloc.c

1903

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

1908

bpref = cgbase(fs, cgp->cg_cgx) + cgp->cg_rotor + fs->fs_frag;

sys/ufs/ffs/ffs_alloc.c

1909

} else if ((cgbpref = dtog(fs, bpref)) != cgp->cg_cgx) {

sys/ufs/ffs/ffs_alloc.c

1911

if (bpref < cgdata(fs, cgbpref))

sys/ufs/ffs/ffs_alloc.c

1912

bpref = cgmeta(fs, cgp->cg_cgx);

sys/ufs/ffs/ffs_alloc.c

1914

bpref = cgdata(fs, cgp->cg_cgx);

sys/ufs/ffs/ffs_alloc.c

1919

bno = dtogd(fs, blknum(fs, bpref));

sys/ufs/ffs/ffs_alloc.c

1920

if (ffs_isblock(fs, blksfree, fragstoblks(fs, bno)))

sys/ufs/ffs/ffs_alloc.c

1925

bno = ffs_mapsearch(fs, cgp, bpref, (int)fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

1929

if (bno >= dtogd(fs, cgdata(fs, cgp->cg_cgx)))

sys/ufs/ffs/ffs_alloc.c

193

freespace(fs, fs->fs_minfree) - numfrags(fs, size) < 0)

sys/ufs/ffs/ffs_alloc.c

1932

blkno = fragstoblks(fs, bno);

sys/ufs/ffs/ffs_alloc.c

1933

ffs_clrblock(fs, blksfree, (long)blkno);

sys/ufs/ffs/ffs_alloc.c

1934

ffs_clusteracct(fs, cgp, blkno, -1);

sys/ufs/ffs/ffs_alloc.c

1936

fs->fs_cstotal.cs_nbfree--;

sys/ufs/ffs/ffs_alloc.c

1937

fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--;

sys/ufs/ffs/ffs_alloc.c

1938

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

1939

blkno = cgbase(fs, cgp->cg_cgx) + bno;

sys/ufs/ffs/ffs_alloc.c

1943

size = numfrags(fs, size);

sys/ufs/ffs/ffs_alloc.c

1944

if (size != fs->fs_frag) {

sys/ufs/ffs/ffs_alloc.c

1945

bno = dtogd(fs, blkno);

sys/ufs/ffs/ffs_alloc.c

1946

for (i = size; i < fs->fs_frag; i++)

sys/ufs/ffs/ffs_alloc.c

1948

i = fs->fs_frag - size;

sys/ufs/ffs/ffs_alloc.c

195

if (bpref >= fs->fs_size)

sys/ufs/ffs/ffs_alloc.c

1950

fs->fs_cstotal.cs_nffree += i;

sys/ufs/ffs/ffs_alloc.c

1951

fs->fs_cs(fs, cgp->cg_cgx).cs_nffree += i;

sys/ufs/ffs/ffs_alloc.c

1952

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

1976

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

198

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

sys/ufs/ffs/ffs_alloc.c

1987

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

1988

MPASS(cg < fs->fs_ncg);

sys/ufs/ffs/ffs_alloc.c

1989

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

sys/ufs/ffs/ffs_alloc.c

1992

if ((error = ffs_getcg(fs, ump->um_devvp, cg, 0, &bp, &cgp)) != 0) {

sys/ufs/ffs/ffs_alloc.c

1993

ffs_checkcgintegrity(fs, cg, error);

sys/ufs/ffs/ffs_alloc.c

200

cg = dtog(fs, bpref);

sys/ufs/ffs/ffs_alloc.c

2002

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

sys/ufs/ffs/ffs_alloc.c

2005

if (i > fs->fs_contigsumsize) {

sys/ufs/ffs/ffs_alloc.c

2018

fs->fs_maxcluster[cg] = i;

sys/ufs/ffs/ffs_alloc.c

2033

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

sys/ufs/ffs/ffs_alloc.c

2034

bpref = cgdata(fs, cg);

sys/ufs/ffs/ffs_alloc.c

2036

bpref = blknum(fs, bpref);

sys/ufs/ffs/ffs_alloc.c

2037

bpref = fragstoblks(fs, dtogd(fs, bpref));

sys/ufs/ffs/ffs_alloc.c

2066

if (!ffs_isblock(fs, blksfree, got - run + i))

sys/ufs/ffs/ffs_alloc.c

2068

bno = cgbase(fs, cg) + blkstofrags(fs, got - run + 1);

sys/ufs/ffs/ffs_alloc.c

2069

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

sys/ufs/ffs/ffs_alloc.c

2071

len = blkstofrags(fs, len);

sys/ufs/ffs/ffs_alloc.c

2073

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

sys/ufs/ffs/ffs_alloc.c

2074

if (ffs_alloccgblk(ip, bp, bno + i, fs->fs_bsize) != bno + i)

sys/ufs/ffs/ffs_alloc.c

2076

ACTIVECLEAR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

2088

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

2090

fs = ITOFS(ip);

sys/ufs/ffs/ffs_alloc.c

2091

return (getblk(ITODEVVP(ip), fsbtodb(fs, ino_to_fsba(fs,

sys/ufs/ffs/ffs_alloc.c

2092

cg * fs->fs_ipg + cginoblk)), (int)fs->fs_bsize, 0, 0,

sys/ufs/ffs/ffs_alloc.c

2122

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

2132

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

2134

if (fs->fs_cs(fs, cg).cs_nifree == 0)

sys/ufs/ffs/ffs_alloc.c

2137

if ((error = ffs_getcg(fs, ump->um_devvp, cg, 0, &bp, &cgp)) != 0) {

sys/ufs/ffs/ffs_alloc.c

2138

ffs_checkcgintegrity(fs, cg, error);

sys/ufs/ffs/ffs_alloc.c

2150

ipref %= fs->fs_ipg;

sys/ufs/ffs/ffs_alloc.c

2155

len = howmany(fs->fs_ipg - cgp->cg_irotor, NBBY);

sys/ufs/ffs/ffs_alloc.c

2163

(intmax_t)cg, (long)cgp->cg_irotor, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2173

if (fs->fs_magic == FS_UFS2_MAGIC &&

sys/ufs/ffs/ffs_alloc.c

2174

ipref + INOPB(fs) > cgp->cg_initediblk &&

sys/ufs/ffs/ffs_alloc.c

2207

bzero(ibp->b_data, (int)fs->fs_bsize);

sys/ufs/ffs/ffs_alloc.c

2209

for (i = 0; i < INOPB(fs); i++) {

sys/ufs/ffs/ffs_alloc.c

223

softdep_request_cleanup(fs, ITOV(ip), cred, FLUSH_BLOCKS_WAIT);

sys/ufs/ffs/ffs_alloc.c

2235

error = ffs_getcg(fs, ump->um_devvp, cg, 0, &bp, &cgp);

sys/ufs/ffs/ffs_alloc.c

2237

ACTIVECLEAR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

2242

cgp->cg_initediblk += INOPB(fs);

sys/ufs/ffs/ffs_alloc.c

2247

ACTIVECLEAR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

2250

fs->fs_cstotal.cs_nifree--;

sys/ufs/ffs/ffs_alloc.c

2251

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

sys/ufs/ffs/ffs_alloc.c

2252

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

2255

fs->fs_cstotal.cs_ndir++;

sys/ufs/ffs/ffs_alloc.c

2256

fs->fs_cs(fs, cg).cs_ndir++;

sys/ufs/ffs/ffs_alloc.c

2260

softdep_setup_inomapdep(bp, ip, cg * fs->fs_ipg + ipref, mode);

sys/ufs/ffs/ffs_alloc.c

2262

return ((ino_t)(cg * fs->fs_ipg + ipref));

sys/ufs/ffs/ffs_alloc.c

2274

struct fs *fs,

sys/ufs/ffs/ffs_alloc.c

2291

cg = dtog(fs, bno);

sys/ufs/ffs/ffs_alloc.c

2306

if ((uint64_t)size > fs->fs_bsize || fragoff(fs, size) != 0 ||

sys/ufs/ffs/ffs_alloc.c

2307

fragnum(fs, bno) + numfrags(fs, size) > fs->fs_frag) {

sys/ufs/ffs/ffs_alloc.c

2309

devtoname(dev), (intmax_t)bno, (long)fs->fs_bsize,

sys/ufs/ffs/ffs_alloc.c

2310

size, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2314

if ((uint64_t)bno >= fs->fs_size) {

sys/ufs/ffs/ffs_alloc.c

2317

ffs_fserr(fs, inum, "bad block");

sys/ufs/ffs/ffs_alloc.c

2320

if ((error = ffs_getcg(fs, devvp, cg, GB_CVTENXIO, &bp, &cgp)) != 0) {

sys/ufs/ffs/ffs_alloc.c

2328

fs->fs_flags |= FS_NEEDSFSCK;

sys/ufs/ffs/ffs_alloc.c

233

ffs_fserr(fs, ip->i_number, "filesystem full");

sys/ufs/ffs/ffs_alloc.c

2330

dbn = fragstoblks(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

2332

dbn = fsbtodb(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

2333

error = getblkx(devvp, dbn, dbn, fs->fs_cgsize, 0, 0, 0, &bp);

sys/ufs/ffs/ffs_alloc.c

2336

numfrags(fs, size), dephd, true);

sys/ufs/ffs/ffs_alloc.c

2342

cgbno = dtogd(fs, bno);

sys/ufs/ffs/ffs_alloc.c

2345

if (size == fs->fs_bsize) {

sys/ufs/ffs/ffs_alloc.c

2346

fragno = fragstoblks(fs, cgbno);

sys/ufs/ffs/ffs_alloc.c

2347

if (!ffs_isfreeblock(fs, blksfree, fragno)) {

sys/ufs/ffs/ffs_alloc.c

235

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2355

devtoname(dev), (intmax_t)bno, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2358

ffs_setblock(fs, blksfree, fragno);

sys/ufs/ffs/ffs_alloc.c

2359

ffs_clusteracct(fs, cgp, fragno, 1);

sys/ufs/ffs/ffs_alloc.c

2361

fs->fs_cstotal.cs_nbfree++;

sys/ufs/ffs/ffs_alloc.c

2362

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

sys/ufs/ffs/ffs_alloc.c

2364

bbase = cgbno - fragnum(fs, cgbno);

sys/ufs/ffs/ffs_alloc.c

2368

blk = blkmap(fs, blksfree, bbase);

sys/ufs/ffs/ffs_alloc.c

2369

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

sys/ufs/ffs/ffs_alloc.c

2373

frags = numfrags(fs, size);

sys/ufs/ffs/ffs_alloc.c

2378

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2384

fs->fs_cstotal.cs_nffree += i;

sys/ufs/ffs/ffs_alloc.c

2385

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

sys/ufs/ffs/ffs_alloc.c

2389

blk = blkmap(fs, blksfree, bbase);

sys/ufs/ffs/ffs_alloc.c

2390

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

sys/ufs/ffs/ffs_alloc.c

2394

fragno = fragstoblks(fs, bbase);

sys/ufs/ffs/ffs_alloc.c

2395

if (ffs_isblock(fs, blksfree, fragno)) {

sys/ufs/ffs/ffs_alloc.c

2396

cgp->cg_cs.cs_nffree -= fs->fs_frag;

sys/ufs/ffs/ffs_alloc.c

2397

fs->fs_cstotal.cs_nffree -= fs->fs_frag;

sys/ufs/ffs/ffs_alloc.c

2398

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

sys/ufs/ffs/ffs_alloc.c

2399

ffs_clusteracct(fs, cgp, fragno, 1);

sys/ufs/ffs/ffs_alloc.c

2401

fs->fs_cstotal.cs_nbfree++;

sys/ufs/ffs/ffs_alloc.c

2402

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

sys/ufs/ffs/ffs_alloc.c

2405

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

2406

ACTIVECLEAR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

2411

numfrags(fs, size), dephd, false);

sys/ufs/ffs/ffs_alloc.c

262

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

2672

struct fs *fs,

sys/ufs/ffs/ffs_alloc.c

2692

ffs_snapblkfree(fs, devvp, bno, size, inum, vtype, dephd)) {

sys/ufs/ffs/ffs_alloc.c

2701

ffs_blkfree_cg(ump, fs, devvp, bno, size, inum, dephd);

sys/ufs/ffs/ffs_alloc.c

272

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

2757

if (bno + numfrags(fs, size) == tp->bno) {

sys/ufs/ffs/ffs_alloc.c

2762

} else if (bno == tp->bno + numfrags(fs, tp->size)) {

sys/ufs/ffs/ffs_alloc.c

2782

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

2789

fs = ITOFS(ip);

sys/ufs/ffs/ffs_alloc.c

2790

if ((uint64_t)size > fs->fs_bsize || fragoff(fs, size) != 0) {

sys/ufs/ffs/ffs_alloc.c

2792

(long)fs->fs_bsize, size, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2795

if ((uint64_t)bno >= fs->fs_size)

sys/ufs/ffs/ffs_alloc.c

2797

if (ffs_getcg(fs, ITODEVVP(ip), dtog(fs, bno), 0, &bp, &cgp) != 0)

sys/ufs/ffs/ffs_alloc.c

2800

cgbno = dtogd(fs, bno);

sys/ufs/ffs/ffs_alloc.c

2801

if (size == fs->fs_bsize) {

sys/ufs/ffs/ffs_alloc.c

2802

blkalloced = ffs_isblock(fs, blksfree, fragstoblks(fs, cgbno));

sys/ufs/ffs/ffs_alloc.c

2804

frags = numfrags(fs, size);

sys/ufs/ffs/ffs_alloc.c

283

if ((uint64_t)osize > fs->fs_bsize || fragoff(fs, osize) != 0 ||

sys/ufs/ffs/ffs_alloc.c

284

(uint64_t)nsize > fs->fs_bsize || fragoff(fs, nsize) != 0) {

sys/ufs/ffs/ffs_alloc.c

2840

struct fs *fs,

sys/ufs/ffs/ffs_alloc.c

2855

cg = ino_to_cg(fs, ino);

sys/ufs/ffs/ffs_alloc.c

2867

if (ino >= fs->fs_ipg * fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

2869

devtoname(dev), (uintmax_t)ino, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

287

devtoname(ump->um_dev), (long)fs->fs_bsize, osize,

sys/ufs/ffs/ffs_alloc.c

2870

if ((error = ffs_getcg(fs, devvp, cg, GB_CVTENXIO, &bp, &cgp)) != 0) {

sys/ufs/ffs/ffs_alloc.c

2878

fs->fs_flags |= FS_NEEDSFSCK;

sys/ufs/ffs/ffs_alloc.c

288

nsize, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2880

dbn = fragstoblks(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

2882

dbn = fsbtodb(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

2883

error = getblkx(devvp, dbn, dbn, fs->fs_cgsize, 0, 0, 0, &bp);

sys/ufs/ffs/ffs_alloc.c

2892

cgino = ino % fs->fs_ipg;

sys/ufs/ffs/ffs_alloc.c

2895

(uintmax_t)ino, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2896

if (fs->fs_ronly == 0)

sys/ufs/ffs/ffs_alloc.c

2904

fs->fs_cstotal.cs_nifree++;

sys/ufs/ffs/ffs_alloc.c

2905

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

sys/ufs/ffs/ffs_alloc.c

2908

fs->fs_cstotal.cs_ndir--;

sys/ufs/ffs/ffs_alloc.c

2909

fs->fs_cs(fs, cg).cs_ndir--;

sys/ufs/ffs/ffs_alloc.c

2911

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

2912

ACTIVECLEAR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

2926

ffs_checkfreefile(struct fs *fs,

sys/ufs/ffs/ffs_alloc.c

2936

cg = ino_to_cg(fs, ino);

sys/ufs/ffs/ffs_alloc.c

2939

if (ino >= fs->fs_ipg * fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

2941

if ((error = ffs_getcg(fs, devvp, cg, 0, &bp, &cgp)) != 0)

sys/ufs/ffs/ffs_alloc.c

2944

ino %= fs->fs_ipg;

sys/ufs/ffs/ffs_alloc.c

2957

ffs_mapsearch(struct fs *fs,

sys/ufs/ffs/ffs_alloc.c

297

freespace(fs, fs->fs_minfree) - numfrags(fs, nsize - osize) < 0) {

sys/ufs/ffs/ffs_alloc.c

2972

start = dtogd(fs, bpref) / NBBY;

sys/ufs/ffs/ffs_alloc.c

2976

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

sys/ufs/ffs/ffs_alloc.c

2978

fragtbl[fs->fs_frag],

sys/ufs/ffs/ffs_alloc.c

2979

(uint8_t)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

sys/ufs/ffs/ffs_alloc.c

2984

fragtbl[fs->fs_frag],

sys/ufs/ffs/ffs_alloc.c

2985

(uint8_t)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

sys/ufs/ffs/ffs_alloc.c

2988

start, len, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2999

for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {

sys/ufs/ffs/ffs_alloc.c

3000

blk = blkmap(fs, blksfree, bno);

sys/ufs/ffs/ffs_alloc.c

3004

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

sys/ufs/ffs/ffs_alloc.c

3011

printf("bno = %ju, fs = %s\n", (intmax_t)bno, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

302

devtoname(ump->um_dev), (long)fs->fs_bsize, (intmax_t)bprev,

sys/ufs/ffs/ffs_alloc.c

3020

ffs_getcg(struct fs *fs,

sys/ufs/ffs/ffs_alloc.c

303

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

3036

if ((fs->fs_metackhash & CK_CYLGRP) != 0)

sys/ufs/ffs/ffs_alloc.c

3039

blkno = fsbtodb(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

3042

blkno = fragstoblks(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

3045

error = breadn_flags(devvp, blkno, blkno, (int)fs->fs_cgsize, NULL,

sys/ufs/ffs/ffs_alloc.c

3050

if ((fs->fs_metackhash & CK_CYLGRP) != 0 &&

sys/ufs/ffs/ffs_alloc.c

3097

if ((fs->fs_metackhash & CK_CYLGRP) != 0)

sys/ufs/ffs/ffs_alloc.c

3133

ffs_checkcgintegrity(struct fs *fs,

sys/ufs/ffs/ffs_alloc.c

3140

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

sys/ufs/ffs/ffs_alloc.c

3141

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

sys/ufs/ffs/ffs_alloc.c

3142

fs->fs_cstotal.cs_nbfree -= fs->fs_cs(fs, cg).cs_nbfree;

sys/ufs/ffs/ffs_alloc.c

3143

fs->fs_cs(fs, cg).cs_nbfree = 0;

sys/ufs/ffs/ffs_alloc.c

3144

fs->fs_cstotal.cs_nifree -= fs->fs_cs(fs, cg).cs_nifree;

sys/ufs/ffs/ffs_alloc.c

3145

fs->fs_cs(fs, cg).cs_nifree = 0;

sys/ufs/ffs/ffs_alloc.c

3146

fs->fs_maxcluster[cg] = 0;

sys/ufs/ffs/ffs_alloc.c

3147

fs->fs_flags |= FS_NEEDSFSCK;

sys/ufs/ffs/ffs_alloc.c

3148

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

3158

ffs_fserr(struct fs *fs,

sys/ufs/ffs/ffs_alloc.c

3167

fs->fs_fsmnt, cp);

sys/ufs/ffs/ffs_alloc.c

318

bp->b_blkno = fsbtodb(fs, bprev);

sys/ufs/ffs/ffs_alloc.c

3287

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

332

cg = dtog(fs, bprev);

sys/ufs/ffs/ffs_alloc.c

3323

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

3334

fs->fs_flags |= (long)cmd.value;

sys/ufs/ffs/ffs_alloc.c

3336

fs->fs_flags &= ~(long)cmd.value;

sys/ufs/ffs/ffs_alloc.c

336

if (bp->b_blkno != fsbtodb(fs, bno))

sys/ufs/ffs/ffs_alloc.c

3437

if ((error = ffs_freefile(ump, fs, ump->um_devvp,

sys/ufs/ffs/ffs_alloc.c

3461

blksize = fs->fs_frag - (blkno % fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

3466

ffs_blkfree(ump, fs, ump->um_devvp, blkno,

sys/ufs/ffs/ffs_alloc.c

3467

blksize * fs->fs_fsize, UFS_ROOTINO,

sys/ufs/ffs/ffs_alloc.c

3471

blksize = fs->fs_frag;

sys/ufs/ffs/ffs_alloc.c

3487

fs->fs_cstotal.cs_ndir += cmd.value;

sys/ufs/ffs/ffs_alloc.c

3497

fs->fs_cstotal.cs_nbfree += cmd.value;

sys/ufs/ffs/ffs_alloc.c

3507

fs->fs_cstotal.cs_nifree += cmd.value;

sys/ufs/ffs/ffs_alloc.c

3517

fs->fs_cstotal.cs_nffree += cmd.value;

sys/ufs/ffs/ffs_alloc.c

3527

fs->fs_cstotal.cs_numclusters += cmd.value;

sys/ufs/ffs/ffs_alloc.c

355

if (bpref >= fs->fs_size)

sys/ufs/ffs/ffs_alloc.c

357

switch ((int)fs->fs_optim) {

sys/ufs/ffs/ffs_alloc.c

367

if (fs->fs_minfree <= 5 ||

sys/ufs/ffs/ffs_alloc.c

368

fs->fs_cstotal.cs_nffree >

sys/ufs/ffs/ffs_alloc.c

369

(off_t)fs->fs_dsize * fs->fs_minfree / (2 * 100))

sys/ufs/ffs/ffs_alloc.c

372

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

373

fs->fs_optim = FS_OPTTIME;

sys/ufs/ffs/ffs_alloc.c

386

request = fs->fs_bsize;

sys/ufs/ffs/ffs_alloc.c

387

if (fs->fs_cstotal.cs_nffree <

sys/ufs/ffs/ffs_alloc.c

388

(off_t)fs->fs_dsize * (fs->fs_minfree - 2) / 100)

sys/ufs/ffs/ffs_alloc.c

391

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

392

fs->fs_optim = FS_OPTSPACE;

sys/ufs/ffs/ffs_alloc.c

396

devtoname(ump->um_dev), (long)fs->fs_optim, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

402

bp->b_blkno = fsbtodb(fs, bno);

sys/ufs/ffs/ffs_alloc.c

418

ffs_blkfree(ump, fs, ump->um_devvp, bprev, (long)osize,

sys/ufs/ffs/ffs_alloc.c

456

softdep_request_cleanup(fs, vp, cred, FLUSH_BLOCKS_WAIT);

sys/ufs/ffs/ffs_alloc.c

468

ffs_fserr(fs, ip->i_number, "filesystem full");

sys/ufs/ffs/ffs_alloc.c

470

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

568

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

584

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

591

if (fs->fs_contigsumsize <= 0 || freespace(fs, 4) < 0)

sys/ufs/ffs/ffs_alloc.c

600

dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))

sys/ufs/ffs/ffs_alloc.c

606

ssize = fsbtodb(fs, fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

628

if (dtog(fs, dbtofsb(fs, buflist->bs_children[0]->b_blkno)) !=

sys/ufs/ffs/ffs_alloc.c

629

dtog(fs, dbtofsb(fs, buflist->bs_children[len - 1]->b_blkno)))

sys/ufs/ffs/ffs_alloc.c

642

if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &sbp)) {

sys/ufs/ffs/ffs_alloc.c

662

if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &ebp))

sys/ufs/ffs/ffs_alloc.c

676

pref = cgdata(fs, ip->i_nextclustercg);

sys/ufs/ffs/ffs_alloc.c

682

cg = dtog(fs, pref);

sys/ufs/ffs/ffs_alloc.c

683

MPASS(cg < fs->fs_ncg);

sys/ufs/ffs/ffs_alloc.c

684

for (i = min(maxclustersearch, fs->fs_ncg); i > 0; i--) {

sys/ufs/ffs/ffs_alloc.c

688

if (cg >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

715

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

sys/ufs/ffs/ffs_alloc.c

722

dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))

sys/ufs/ffs/ffs_alloc.c

724

if (dbtofsb(fs, buflist->bs_children[i]->b_blkno) != *bap)

sys/ufs/ffs/ffs_alloc.c

734

blkno, *bap, fs->fs_bsize, fs->fs_bsize,

sys/ufs/ffs/ffs_alloc.c

780

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

sys/ufs/ffs/ffs_alloc.c

797

ffs_blkfree(ump, fs, ump->um_devvp,

sys/ufs/ffs/ffs_alloc.c

798

dbtofsb(fs, bp->b_blkno),

sys/ufs/ffs/ffs_alloc.c

799

fs->fs_bsize, ip->i_number, vp->v_type, NULL,

sys/ufs/ffs/ffs_alloc.c

802

bp->b_blkno = fsbtodb(fs, blkno);

sys/ufs/ffs/ffs_alloc.c

804

if (!ffs_checkfreeblk(ip, dbtofsb(fs, bp->b_blkno),

sys/ufs/ffs/ffs_alloc.c

805

fs->fs_bsize))

sys/ufs/ffs/ffs_alloc.c

836

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

851

fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

858

if (fs->fs_contigsumsize <= 0 || freespace(fs, 4) < 0)

sys/ufs/ffs/ffs_alloc.c

867

dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))

sys/ufs/ffs/ffs_alloc.c

873

ssize = fsbtodb(fs, fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

895

if (dtog(fs, dbtofsb(fs, buflist->bs_children[0]->b_blkno)) !=

sys/ufs/ffs/ffs_alloc.c

896

dtog(fs, dbtofsb(fs, buflist->bs_children[len - 1]->b_blkno)))

sys/ufs/ffs/ffs_alloc.c

909

if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &sbp)) {

sys/ufs/ffs/ffs_alloc.c

929

if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &ebp))

sys/ufs/ffs/ffs_alloc.c

943

pref = cgdata(fs, ip->i_nextclustercg);

sys/ufs/ffs/ffs_alloc.c

949

cg = dtog(fs, pref);

sys/ufs/ffs/ffs_alloc.c

950

MPASS(cg < fs->fs_ncg);

sys/ufs/ffs/ffs_alloc.c

951

for (i = min(maxclustersearch, fs->fs_ncg); i > 0; i--) {

sys/ufs/ffs/ffs_alloc.c

955

if (cg >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

981

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

sys/ufs/ffs/ffs_alloc.c

988

dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))

sys/ufs/ffs/ffs_alloc.c

990

if (dbtofsb(fs, buflist->bs_children[i]->b_blkno) != *bap)

sys/ufs/ffs/ffs_balloc.c

1002

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

1028

if (pref == 0 || (lbn > UFS_NDADDR && fs->fs_metaspace != 0))

sys/ufs/ffs/ffs_balloc.c

1031

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

1037

softdep_request_cleanup(fs, vp, cred,

sys/ufs/ffs/ffs_balloc.c

1046

ffs_fserr(fs, ip->i_number, "filesystem full");

sys/ufs/ffs/ffs_balloc.c

1048

"is full\n", fs->fs_fsmnt);

sys/ufs/ffs/ffs_balloc.c

1059

nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0, gbflags);

sys/ufs/ffs/ffs_balloc.c

1060

nbp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

1074

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

1096

(int)fs->fs_bsize, NOCRED,

sys/ufs/ffs/ffs_balloc.c

1099

error = bread_gb(vp, lbn, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

1107

nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0, gbflags);

sys/ufs/ffs/ffs_balloc.c

1108

nbp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

112

fs = ITOFS(ip);

sys/ufs/ffs/ffs_balloc.c

1142

bp = getblk(vp, *lbns_remfree, fs->fs_bsize, 0, 0,

sys/ufs/ffs/ffs_balloc.c

1145

KASSERT(bp->b_blkno == fsbtodb(fs, *blkp),

sys/ufs/ffs/ffs_balloc.c

1149

(uintmax_t)fsbtodb(fs, *blkp)));

sys/ufs/ffs/ffs_balloc.c

115

lbn = lblkno(fs, startoffset);

sys/ufs/ffs/ffs_balloc.c

1154

deallocated += fs->fs_bsize;

sys/ufs/ffs/ffs_balloc.c

116

size = blkoff(fs, startoffset) + size;

sys/ufs/ffs/ffs_balloc.c

1162

(int)fs->fs_bsize, NOCRED, gbwflag, &bp);

sys/ufs/ffs/ffs_balloc.c

1172

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

118

if (size > fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

1197

bp = getblk(vp, *lbns_remfree, fs->fs_bsize, 0, 0,

sys/ufs/ffs/ffs_balloc.c

1202

(uintmax_t)fsbtodb(fs, *blkp));

sys/ufs/ffs/ffs_balloc.c

1206

ffs_blkfree(ump, fs, ump->um_devvp, *blkp, fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

134

lastlbn = lblkno(fs, ip->i_size);

sys/ufs/ffs/ffs_balloc.c

137

osize = blksize(fs, ip, nb);

sys/ufs/ffs/ffs_balloc.c

138

if (osize < fs->fs_bsize && osize > 0) {

sys/ufs/ffs/ffs_balloc.c

142

&dp->di_db[0]), osize, (int)fs->fs_bsize, flags,

sys/ufs/ffs/ffs_balloc.c

148

dbtofsb(fs, bp->b_blkno), dp->di_db[nb],

sys/ufs/ffs/ffs_balloc.c

149

fs->fs_bsize, osize, bp);

sys/ufs/ffs/ffs_balloc.c

150

ip->i_size = smalllblktosize(fs, nb + 1);

sys/ufs/ffs/ffs_balloc.c

152

dp->di_db[nb] = dbtofsb(fs, bp->b_blkno);

sys/ufs/ffs/ffs_balloc.c

170

if (nb != 0 && ip->i_size >= smalllblktosize(fs, lbn + 1)) {

sys/ufs/ffs/ffs_balloc.c

172

error = bread(vp, lbn, fs->fs_bsize, NOCRED,

sys/ufs/ffs/ffs_balloc.c

177

bp = getblk(vp, lbn, fs->fs_bsize, 0, 0,

sys/ufs/ffs/ffs_balloc.c

185

bp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

194

osize = fragroundup(fs, blkoff(fs, ip->i_size));

sys/ufs/ffs/ffs_balloc.c

195

nsize = fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

200

bp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

211

dbtofsb(fs, bp->b_blkno), nb,

sys/ufs/ffs/ffs_balloc.c

215

if (ip->i_size < smalllblktosize(fs, lbn + 1))

sys/ufs/ffs/ffs_balloc.c

216

nsize = fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

218

nsize = fs->fs_bsize;

sys/ufs/ffs/ffs_balloc.c

226

bp->b_blkno = fsbtodb(fs, newb);

sys/ufs/ffs/ffs_balloc.c

233

dp->di_db[lbn] = dbtofsb(fs, bp->b_blkno);

sys/ufs/ffs/ffs_balloc.c

262

if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

267

pref = newb + fs->fs_frag;

sys/ufs/ffs/ffs_balloc.c

273

bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0, gbflags);

sys/ufs/ffs/ffs_balloc.c

274

bp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

279

fs->fs_bsize, 0, bp);

sys/ufs/ffs/ffs_balloc.c

282

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

299

indirs[i].in_lbn, (int)fs->fs_bsize, NOCRED, &bp);

sys/ufs/ffs/ffs_balloc.c

306

fs->fs_bsize)) != 0) {

sys/ufs/ffs/ffs_balloc.c

325

if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

330

softdep_request_cleanup(fs, vp, cred,

sys/ufs/ffs/ffs_balloc.c

339

ffs_fserr(fs, ip->i_number, "filesystem full");

sys/ufs/ffs/ffs_balloc.c

341

"is full\n", fs->fs_fsmnt);

sys/ufs/ffs/ffs_balloc.c

347

pref = newb + fs->fs_frag;

sys/ufs/ffs/ffs_balloc.c

353

nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0, 0);

sys/ufs/ffs/ffs_balloc.c

354

nbp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

361

if (nbp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

380

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

406

if (pref == 0 || (lbn > UFS_NDADDR && fs->fs_metaspace != 0))

sys/ufs/ffs/ffs_balloc.c

409

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

415

softdep_request_cleanup(fs, vp, cred,

sys/ufs/ffs/ffs_balloc.c

424

ffs_fserr(fs, ip->i_number, "filesystem full");

sys/ufs/ffs/ffs_balloc.c

426

"is full\n", fs->fs_fsmnt);

sys/ufs/ffs/ffs_balloc.c

437

nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0, gbflags);

sys/ufs/ffs/ffs_balloc.c

438

nbp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

452

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

468

(int)fs->fs_bsize, NOCRED,

sys/ufs/ffs/ffs_balloc.c

471

error = bread_gb(vp, lbn, (int)fs->fs_bsize, NOCRED,

sys/ufs/ffs/ffs_balloc.c

479

nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0, gbflags);

sys/ufs/ffs/ffs_balloc.c

480

nbp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

514

bp = getblk(vp, *lbns_remfree, fs->fs_bsize, 0, 0,

sys/ufs/ffs/ffs_balloc.c

517

KASSERT(bp->b_blkno == fsbtodb(fs, *blkp),

sys/ufs/ffs/ffs_balloc.c

521

(uintmax_t)fsbtodb(fs, *blkp)));

sys/ufs/ffs/ffs_balloc.c

526

deallocated += fs->fs_bsize;

sys/ufs/ffs/ffs_balloc.c

534

(int)fs->fs_bsize, NOCRED, &bp);

sys/ufs/ffs/ffs_balloc.c

544

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

569

bp = getblk(vp, *lbns_remfree, fs->fs_bsize, 0, 0,

sys/ufs/ffs/ffs_balloc.c

574

(uintmax_t)fsbtodb(fs, *blkp));

sys/ufs/ffs/ffs_balloc.c

578

ffs_blkfree(ump, fs, ump->um_devvp, *blkp, fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

600

struct fs *fs;

sys/ufs/ffs/ffs_balloc.c

615

fs = ITOFS(ip);

sys/ufs/ffs/ffs_balloc.c

618

lbn = lblkno(fs, startoffset);

sys/ufs/ffs/ffs_balloc.c

619

size = blkoff(fs, startoffset) + size;

sys/ufs/ffs/ffs_balloc.c

621

if (size > fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

650

lastlbn = lblkno(fs, dp->di_extsize);

sys/ufs/ffs/ffs_balloc.c

653

osize = sblksize(fs, dp->di_extsize, nb);

sys/ufs/ffs/ffs_balloc.c

654

if (osize < fs->fs_bsize && osize > 0) {

sys/ufs/ffs/ffs_balloc.c

660

(int)fs->fs_bsize, flags, cred, &bp);

sys/ufs/ffs/ffs_balloc.c

665

dbtofsb(fs, bp->b_blkno),

sys/ufs/ffs/ffs_balloc.c

667

fs->fs_bsize, osize, bp);

sys/ufs/ffs/ffs_balloc.c

668

dp->di_extsize = smalllblktosize(fs, nb + 1);

sys/ufs/ffs/ffs_balloc.c

669

dp->di_extb[nb] = dbtofsb(fs, bp->b_blkno);

sys/ufs/ffs/ffs_balloc.c

685

if (nb != 0 && dp->di_extsize >= smalllblktosize(fs, lbn + 1)) {

sys/ufs/ffs/ffs_balloc.c

686

error = bread_gb(vp, -1 - lbn, fs->fs_bsize, NOCRED,

sys/ufs/ffs/ffs_balloc.c

690

bp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

699

osize = fragroundup(fs, blkoff(fs, dp->di_extsize));

sys/ufs/ffs/ffs_balloc.c

700

nsize = fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

706

bp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

720

dbtofsb(fs, bp->b_blkno), nb,

sys/ufs/ffs/ffs_balloc.c

724

if (dp->di_extsize < smalllblktosize(fs, lbn + 1))

sys/ufs/ffs/ffs_balloc.c

725

nsize = fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

727

nsize = fs->fs_bsize;

sys/ufs/ffs/ffs_balloc.c

735

bp->b_blkno = fsbtodb(fs, newb);

sys/ufs/ffs/ffs_balloc.c

743

dp->di_extb[lbn] = dbtofsb(fs, bp->b_blkno);

sys/ufs/ffs/ffs_balloc.c

754

lastlbn = lblkno(fs, ip->i_size);

sys/ufs/ffs/ffs_balloc.c

757

osize = blksize(fs, ip, nb);

sys/ufs/ffs/ffs_balloc.c

758

if (osize < fs->fs_bsize && osize > 0) {

sys/ufs/ffs/ffs_balloc.c

762

&dp->di_db[0]), osize, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

768

dbtofsb(fs, bp->b_blkno),

sys/ufs/ffs/ffs_balloc.c

770

fs->fs_bsize, osize, bp);

sys/ufs/ffs/ffs_balloc.c

771

ip->i_size = smalllblktosize(fs, nb + 1);

sys/ufs/ffs/ffs_balloc.c

773

dp->di_db[nb] = dbtofsb(fs, bp->b_blkno);

sys/ufs/ffs/ffs_balloc.c

789

if (nb != 0 && ip->i_size >= smalllblktosize(fs, lbn + 1)) {

sys/ufs/ffs/ffs_balloc.c

791

error = bread_gb(vp, lbn, fs->fs_bsize, NOCRED,

sys/ufs/ffs/ffs_balloc.c

796

bp = getblk(vp, lbn, fs->fs_bsize, 0, 0,

sys/ufs/ffs/ffs_balloc.c

804

bp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

813

osize = fragroundup(fs, blkoff(fs, ip->i_size));

sys/ufs/ffs/ffs_balloc.c

814

nsize = fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

820

bp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

831

dbtofsb(fs, bp->b_blkno), nb,

sys/ufs/ffs/ffs_balloc.c

835

if (ip->i_size < smalllblktosize(fs, lbn + 1))

sys/ufs/ffs/ffs_balloc.c

836

nsize = fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

838

nsize = fs->fs_bsize;

sys/ufs/ffs/ffs_balloc.c

846

bp->b_blkno = fsbtodb(fs, newb);

sys/ufs/ffs/ffs_balloc.c

853

dp->di_db[lbn] = dbtofsb(fs, bp->b_blkno);

sys/ufs/ffs/ffs_balloc.c

882

if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

887

pref = newb + fs->fs_frag;

sys/ufs/ffs/ffs_balloc.c

893

bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0,

sys/ufs/ffs/ffs_balloc.c

895

bp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

900

fs->fs_bsize, 0, bp);

sys/ufs/ffs/ffs_balloc.c

903

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

919

error = bread_gb(vp, indirs[i].in_lbn, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

927

fs->fs_bsize)) != 0) {

sys/ufs/ffs/ffs_balloc.c

946

if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

95

struct fs *fs;

sys/ufs/ffs/ffs_balloc.c

951

softdep_request_cleanup(fs, vp, cred,

sys/ufs/ffs/ffs_balloc.c

960

ffs_fserr(fs, ip->i_number, "filesystem full");

sys/ufs/ffs/ffs_balloc.c

962

"is full\n", fs->fs_fsmnt);

sys/ufs/ffs/ffs_balloc.c

968

pref = newb + fs->fs_frag;

sys/ufs/ffs/ffs_balloc.c

974

nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0,

sys/ufs/ffs/ffs_balloc.c

976

nbp->b_blkno = fsbtodb(fs, nb);

sys/ufs/ffs/ffs_balloc.c

983

if (nbp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_extern.h

100

int ffs_snapblkfree(struct fs *, struct vnode *, ufs2_daddr_t, long, ino_t,

sys/ufs/ffs/ffs_extern.h

112

void ffs_update_dinode_ckhash(struct fs *, struct ufs2_dinode *);

sys/ufs/ffs/ffs_extern.h

113

int ffs_verify_dinode_ckhash(struct fs *, struct ufs2_dinode *);

sys/ufs/ffs/ffs_extern.h

166

int softdep_mount(struct vnode *, struct mount *, struct fs *,

sys/ufs/ffs/ffs_extern.h

176

int softdep_request_cleanup(struct fs *, struct vnode *,

sys/ufs/ffs/ffs_extern.h

198

void softdep_setup_sbupdate(struct ufsmount *, struct fs *, struct buf *);

sys/ufs/ffs/ffs_extern.h

42

struct fs;

sys/ufs/ffs/ffs_extern.h

61

void ffs_blkfree(struct ufsmount *, struct fs *, struct vnode *,

sys/ufs/ffs/ffs_extern.h

68

uint32_t ffs_calc_sbhash(struct fs *);

sys/ufs/ffs/ffs_extern.h

69

int ffs_checkfreefile(struct fs *, struct vnode *, ino_t);

sys/ufs/ffs/ffs_extern.h

70

void ffs_clrblock(struct fs *, uint8_t *, ufs1_daddr_t);

sys/ufs/ffs/ffs_extern.h

71

void ffs_clusteracct(struct fs *, struct cg *, ufs1_daddr_t, int);

sys/ufs/ffs/ffs_extern.h

75

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

sys/ufs/ffs/ffs_extern.h

76

int ffs_freefile(struct ufsmount *, struct fs *, struct vnode *, ino_t,

sys/ufs/ffs/ffs_extern.h

78

void ffs_fserr(struct fs *, ino_t, char *);

sys/ufs/ffs/ffs_extern.h

79

int ffs_getcg(struct fs *, struct vnode *, uint64_t, int, struct buf **,

sys/ufs/ffs/ffs_extern.h

83

int ffs_isblock(struct fs *, uint8_t *, ufs1_daddr_t);

sys/ufs/ffs/ffs_extern.h

84

int ffs_isfreeblock(struct fs *, uint8_t *, ufs1_daddr_t);

sys/ufs/ffs/ffs_extern.h

85

void ffs_oldfscompat_write(struct fs *);

sys/ufs/ffs/ffs_extern.h

86

bool ffs_oldfscompat_inode_read(struct fs *, union dinodep, time_t);

sys/ufs/ffs/ffs_extern.h

88

int ffs_sbsearch(void *, struct fs **, int, struct malloc_type *,

sys/ufs/ffs/ffs_extern.h

94

int ffs_sbget(void *, struct fs **, off_t, int, struct malloc_type *,

sys/ufs/ffs/ffs_extern.h

96

int ffs_sbput(void *, struct fs *, off_t, int (*)(void *, off_t, void *,

sys/ufs/ffs/ffs_extern.h

99

void ffs_setblock(struct fs *, uint8_t *, ufs1_daddr_t);

sys/ufs/ffs/ffs_inode.c

128

fs = ITOFS(ip);

sys/ufs/ffs/ffs_inode.c

129

if (fs->fs_ronly)

sys/ufs/ffs/ffs_inode.c

146

bn = fsbtodb(fs, ino_to_fsba(fs, ip->i_number));

sys/ufs/ffs/ffs_inode.c

148

(int) fs->fs_bsize, NULL, NULL, 0, NOCRED, flags, NULL, &bp);

sys/ufs/ffs/ffs_inode.c

191

ino_to_fsbo(fs, ip->i_number)) = *ip->i_din1;

sys/ufs/ffs/ffs_inode.c

198

ffs_update_dinode_ckhash(fs, ip->i_din2);

sys/ufs/ffs/ffs_inode.c

200

ino_to_fsbo(fs, ip->i_number)) = *ip->i_din2;

sys/ufs/ffs/ffs_inode.c

215

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_inode.c

244

struct fs *fs;

sys/ufs/ffs/ffs_inode.c

256

fs = ump->um_fs;

sys/ufs/ffs/ffs_inode.c

263

if (length > fs->fs_maxfilesize)

sys/ufs/ffs/ffs_inode.c

295

if (fs->fs_magic == FS_UFS2_MAGIC && ip->i_din2->di_extsize > 0) {

sys/ufs/ffs/ffs_inode.c

296

extblocks = btodb(fragroundup(fs, ip->i_din2->di_extsize));

sys/ufs/ffs/ffs_inode.c

313

OFF_TO_IDX(lblktosize(fs, -extblocks)), 0);

sys/ufs/ffs/ffs_inode.c

327

ffs_blkfree(ump, fs, ITODEVVP(ip), oldblks[i],

sys/ufs/ffs/ffs_inode.c

328

sblksize(fs, osize, i), ip->i_number,

sys/ufs/ffs/ffs_inode.c

354

if (fs->fs_ronly)

sys/ufs/ffs/ffs_inode.c

375

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_inode.c

385

lbn = lblkno(fs, length - 1);

sys/ufs/ffs/ffs_inode.c

391

error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn), fs->fs_bsize,

sys/ufs/ffs/ffs_inode.c

395

indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);

sys/ufs/ffs/ffs_inode.c

460

offset = blkoff(fs, length);

sys/ufs/ffs/ffs_inode.c

470

lbn = lblkno(fs, length);

sys/ufs/ffs/ffs_inode.c

486

fragroundup(fs, blkoff(fs, length)) < fs->fs_bsize &&

sys/ufs/ffs/ffs_inode.c

499

size = blksize(fs, ip, lbn);

sys/ufs/ffs/ffs_inode.c

505

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_inode.c

516

lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;

sys/ufs/ffs/ffs_inode.c

518

lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);

sys/ufs/ffs/ffs_inode.c

519

lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);

sys/ufs/ffs/ffs_inode.c

520

nblocks = btodb(fs->fs_bsize);

sys/ufs/ffs/ffs_inode.c

564

error = vtruncbuf(vp, length, fs->fs_bsize);

sys/ufs/ffs/ffs_inode.c

572

indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;

sys/ufs/ffs/ffs_inode.c

573

indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;

sys/ufs/ffs/ffs_inode.c

578

fsbtodb(fs, bn), lastiblock[level], level, &count);

sys/ufs/ffs/ffs_inode.c

584

ffs_blkfree(ump, fs, ump->um_devvp, bn,

sys/ufs/ffs/ffs_inode.c

585

fs->fs_bsize, ip->i_number,

sys/ufs/ffs/ffs_inode.c

605

bsize = blksize(fs, ip, i);

sys/ufs/ffs/ffs_inode.c

606

ffs_blkfree(ump, fs, ump->um_devvp, bn, bsize, ip->i_number,

sys/ufs/ffs/ffs_inode.c

626

oldspace = blksize(fs, ip, lastblock);

sys/ufs/ffs/ffs_inode.c

630

newspace = blksize(fs, ip, lastblock);

sys/ufs/ffs/ffs_inode.c

639

bn += numfrags(fs, newspace);

sys/ufs/ffs/ffs_inode.c

640

ffs_blkfree(ump, fs, ump->um_devvp, bn,

sys/ufs/ffs/ffs_inode.c

660

(fs->fs_magic != FS_UFS2_MAGIC || ip->i_din2->di_extsize == 0) &&

sys/ufs/ffs/ffs_inode.c

705

struct fs *fs;

sys/ufs/ffs/ffs_inode.c

717

fs = ITOFS(ip);

sys/ufs/ffs/ffs_inode.c

725

factor = lbn_offset(fs, level);

sys/ufs/ffs/ffs_inode.c

729

nblocks = btodb(fs->fs_bsize);

sys/ufs/ffs/ffs_inode.c

739

error = ffs_breadz(ump, vp, lbn, dbn, (int)fs->fs_bsize, NULL, NULL, 0,

sys/ufs/ffs/ffs_inode.c

751

copy = malloc(fs->fs_bsize, M_TEMP, M_WAITOK);

sys/ufs/ffs/ffs_inode.c

752

bcopy((caddr_t)bp->b_data, copy, (uint64_t)fs->fs_bsize);

sys/ufs/ffs/ffs_inode.c

753

for (i = last + 1; i < NINDIR(fs); i++)

sys/ufs/ffs/ffs_inode.c

775

for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;

sys/ufs/ffs/ffs_inode.c

781

if ((error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),

sys/ufs/ffs/ffs_inode.c

786

ffs_blkfree(ump, fs, ITODEVVP(ip), nb, fs->fs_bsize,

sys/ufs/ffs/ffs_inode.c

799

error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),

sys/ufs/ffs/ffs_inode.c

96

struct fs *fs;

sys/ufs/ffs/ffs_snapshot.c

1019

if ((fs->fs_metackhash & CK_CYLGRP) != 0) {

sys/ufs/ffs/ffs_snapshot.c

1022

calculate_crc32c(~0L, nbp->b_data, fs->fs_cgsize);

sys/ufs/ffs/ffs_snapshot.c

1038

struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

1040

struct fs *, ufs_lbn_t, int),

sys/ufs/ffs/ffs_snapshot.c

1055

lbn = fragstoblks(fs, ino_to_fsba(fs, cancelip->i_number));

sys/ufs/ffs/ffs_snapshot.c

1063

error = ffs_balloc_ufs1(snapvp, lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1064

fs->fs_bsize, KERNCRED, BA_METAONLY, &bp);

sys/ufs/ffs/ffs_snapshot.c

1068

indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1073

if ((error = bread(snapvp, lbn, fs->fs_bsize, KERNCRED, &bp)))

sys/ufs/ffs/ffs_snapshot.c

1076

error = ffs_balloc_ufs1(snapvp, lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1077

fs->fs_bsize, KERNCRED, 0, &bp);

sys/ufs/ffs/ffs_snapshot.c

1088

ino_to_fsbo(fs, cancelip->i_number);

sys/ufs/ffs/ffs_snapshot.c

1101

numblks = howmany(cancelip->i_size, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1103

&cancelip->i_din1->di_db[UFS_NDADDR], fs, 0, expungetype)))

sys/ufs/ffs/ffs_snapshot.c

1106

&cancelip->i_din1->di_ib[UFS_NIADDR], fs, -1, expungetype)))

sys/ufs/ffs/ffs_snapshot.c

1115

blksperindir, fs, acctfunc, expungetype);

sys/ufs/ffs/ffs_snapshot.c

1118

blksperindir *= NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1139

struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

1141

struct fs *, ufs_lbn_t, int),

sys/ufs/ffs/ffs_snapshot.c

1163

bp = getblk(cancelvp, lbn, fs->fs_bsize, 0, 0, 0);

sys/ufs/ffs/ffs_snapshot.c

1164

bp->b_blkno = fsbtodb(fs, blkno);

sys/ufs/ffs/ffs_snapshot.c

1166

(error = readblock(cancelvp, bp, fragstoblks(fs, blkno)))) {

sys/ufs/ffs/ffs_snapshot.c

1174

if (last > NINDIR(fs))

sys/ufs/ffs/ffs_snapshot.c

1175

last = NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1176

bap = malloc(fs->fs_bsize, M_DEVBUF, M_WAITOK);

sys/ufs/ffs/ffs_snapshot.c

1177

bcopy(bp->b_data, (caddr_t)bap, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1179

error = (*acctfunc)(snapvp, &bap[0], &bap[last], fs,

sys/ufs/ffs/ffs_snapshot.c

1187

subblksperindir = blksperindir / NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1190

rlbn, remblks, subblksperindir, fs, acctfunc, expungetype);

sys/ufs/ffs/ffs_snapshot.c

1209

struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

1215

if ((error = snapacct_ufs1(vp, oldblkp, lastblkp, fs, lblkno, exptype)))

sys/ufs/ffs/ffs_snapshot.c

1217

return (mapacct_ufs1(vp, oldblkp, lastblkp, fs, lblkno, exptype));

sys/ufs/ffs/ffs_snapshot.c

1227

struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

1241

lbn = fragstoblks(fs, blkno);

sys/ufs/ffs/ffs_snapshot.c

1246

error = ffs_balloc_ufs1(vp, lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1247

fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

1251

[(lbn - UFS_NDADDR) % NINDIR(fs)];

sys/ufs/ffs/ffs_snapshot.c

1280

struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

1302

blkno = blkstofrags(fs, lblkno);

sys/ufs/ffs/ffs_snapshot.c

1303

ffs_blkfree(ITOUMP(ip), fs, vp, blkno, fs->fs_bsize, inum,

sys/ufs/ffs/ffs_snapshot.c

1320

struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

1322

struct fs *, ufs_lbn_t, int),

sys/ufs/ffs/ffs_snapshot.c

1337

lbn = fragstoblks(fs, ino_to_fsba(fs, cancelip->i_number));

sys/ufs/ffs/ffs_snapshot.c

1345

error = ffs_balloc_ufs2(snapvp, lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1346

fs->fs_bsize, KERNCRED, BA_METAONLY, &bp);

sys/ufs/ffs/ffs_snapshot.c

135

static int expunge_ufs1(struct vnode *, struct inode *, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1350

indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1355

if ((error = bread(snapvp, lbn, fs->fs_bsize, KERNCRED, &bp)))

sys/ufs/ffs/ffs_snapshot.c

1358

error = ffs_balloc_ufs2(snapvp, lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1359

fs->fs_bsize, KERNCRED, 0, &bp);

sys/ufs/ffs/ffs_snapshot.c

136

int (*)(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1370

ino_to_fsbo(fs, cancelip->i_number);

sys/ufs/ffs/ffs_snapshot.c

1379

ffs_update_dinode_ckhash(fs, dip);

sys/ufs/ffs/ffs_snapshot.c

1385

numblks = howmany(cancelip->i_size, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1387

&cancelip->i_din2->di_db[UFS_NDADDR], fs, 0, expungetype)))

sys/ufs/ffs/ffs_snapshot.c

139

ufs1_daddr_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1390

&cancelip->i_din2->di_ib[UFS_NIADDR], fs, -1, expungetype)))

sys/ufs/ffs/ffs_snapshot.c

1399

blksperindir, fs, acctfunc, expungetype);

sys/ufs/ffs/ffs_snapshot.c

140

int (*)(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1402

blksperindir *= NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1423

struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

1425

struct fs *, ufs_lbn_t, int),

sys/ufs/ffs/ffs_snapshot.c

143

struct fs *, ufs_lbn_t, int);

sys/ufs/ffs/ffs_snapshot.c

1447

bp = getblk(cancelvp, lbn, fs->fs_bsize, 0, 0, 0);

sys/ufs/ffs/ffs_snapshot.c

1448

bp->b_blkno = fsbtodb(fs, blkno);

sys/ufs/ffs/ffs_snapshot.c

145

struct fs *, ufs_lbn_t, int);

sys/ufs/ffs/ffs_snapshot.c

1450

(error = readblock(cancelvp, bp, fragstoblks(fs, blkno)))) {

sys/ufs/ffs/ffs_snapshot.c

1458

if (last > NINDIR(fs))

sys/ufs/ffs/ffs_snapshot.c

1459

last = NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1460

bap = malloc(fs->fs_bsize, M_DEVBUF, M_WAITOK);

sys/ufs/ffs/ffs_snapshot.c

1461

bcopy(bp->b_data, (caddr_t)bap, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1463

error = (*acctfunc)(snapvp, &bap[0], &bap[last], fs,

sys/ufs/ffs/ffs_snapshot.c

147

struct fs *, ufs_lbn_t, int);

sys/ufs/ffs/ffs_snapshot.c

1471

subblksperindir = blksperindir / NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1474

rlbn, remblks, subblksperindir, fs, acctfunc, expungetype);

sys/ufs/ffs/ffs_snapshot.c

148

static int expunge_ufs2(struct vnode *, struct inode *, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

149

int (*)(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1493

struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

1499

if ((error = snapacct_ufs2(vp, oldblkp, lastblkp, fs, lblkno, exptype)))

sys/ufs/ffs/ffs_snapshot.c

1501

return (mapacct_ufs2(vp, oldblkp, lastblkp, fs, lblkno, exptype));

sys/ufs/ffs/ffs_snapshot.c

1511

struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

152

ufs2_daddr_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1525

lbn = fragstoblks(fs, blkno);

sys/ufs/ffs/ffs_snapshot.c

153

int (*)(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1530

error = ffs_balloc_ufs2(vp, lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1531

fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

1535

[(lbn - UFS_NDADDR) % NINDIR(fs)];

sys/ufs/ffs/ffs_snapshot.c

156

struct fs *, ufs_lbn_t, int);

sys/ufs/ffs/ffs_snapshot.c

1564

struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

158

struct fs *, ufs_lbn_t, int);

sys/ufs/ffs/ffs_snapshot.c

1587

blkno = blkstofrags(fs, lblkno);

sys/ufs/ffs/ffs_snapshot.c

1588

ffs_blkfree(ITOUMP(ip), fs, vp, blkno, fs->fs_bsize, inum,

sys/ufs/ffs/ffs_snapshot.c

160

struct fs *, ufs_lbn_t, int);

sys/ufs/ffs/ffs_snapshot.c

1602

struct fs *fs;

sys/ufs/ffs/ffs_snapshot.c

1627

fs = ump->um_fs;

sys/ufs/ffs/ffs_snapshot.c

1630

if (fs->fs_snapinum[snaploc] == ip->i_number)

sys/ufs/ffs/ffs_snapshot.c

1634

if (fs->fs_snapinum[snaploc] == 0)

sys/ufs/ffs/ffs_snapshot.c

1636

fs->fs_snapinum[snaploc - 1] = fs->fs_snapinum[snaploc];

sys/ufs/ffs/ffs_snapshot.c

1638

fs->fs_snapinum[snaploc - 1] = 0;

sys/ufs/ffs/ffs_snapshot.c

1652

struct fs *fs;

sys/ufs/ffs/ffs_snapshot.c

1658

fs = ITOFS(ip);

sys/ufs/ffs/ffs_snapshot.c

1686

else if ((dblk == blkstofrags(fs, blkno) &&

sys/ufs/ffs/ffs_snapshot.c

1687

ffs_snapblkfree(fs, ITODEVVP(ip), dblk, fs->fs_bsize,

sys/ufs/ffs/ffs_snapshot.c

1690

btodb(fs->fs_bsize));

sys/ufs/ffs/ffs_snapshot.c

1694

numblks = howmany(ip->i_size, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1695

for (blkno = UFS_NDADDR; blkno < numblks; blkno += NINDIR(fs)) {

sys/ufs/ffs/ffs_snapshot.c

1696

error = UFS_BALLOC(vp, lblktosize(fs, (off_t)blkno),

sys/ufs/ffs/ffs_snapshot.c

1697

fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

1700

if (fs->fs_size - blkno > NINDIR(fs))

sys/ufs/ffs/ffs_snapshot.c

1701

last = NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1703

last = fs->fs_size - blkno;

sys/ufs/ffs/ffs_snapshot.c

1711

else if ((dblk == blkstofrags(fs, blkno) &&

sys/ufs/ffs/ffs_snapshot.c

1712

ffs_snapblkfree(fs, ITODEVVP(ip), dblk,

sys/ufs/ffs/ffs_snapshot.c

1713

fs->fs_bsize, ip->i_number, vp->v_type,

sys/ufs/ffs/ffs_snapshot.c

1716

btodb(fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1726

else if ((dblk == blkstofrags(fs, blkno) &&

sys/ufs/ffs/ffs_snapshot.c

1727

ffs_snapblkfree(fs, ITODEVVP(ip), dblk,

sys/ufs/ffs/ffs_snapshot.c

1728

fs->fs_bsize, ip->i_number, vp->v_type, NULL))) {

sys/ufs/ffs/ffs_snapshot.c

1729

ip->i_din2->di_blocks -= btodb(fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1776

ffs_snapblkfree(struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

1793

lbn = fragstoblks(fs, bno);

sys/ufs/ffs/ffs_snapshot.c

1821

error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1822

fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

1826

indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1879

if (size == fs->fs_bsize) {

sys/ufs/ffs/ffs_snapshot.c

1920

error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1921

fs->fs_bsize, KERNCRED, 0, &cbp);

sys/ufs/ffs/ffs_snapshot.c

1943

bcopy(savedcbp->b_data, cbp->b_data, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1954

bzero(cbp->b_data, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1998

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_snapshot.c

2015

mp->mnt_stat.f_iosize = fs->fs_bsize;

sys/ufs/ffs/ffs_snapshot.c

2023

if (fs->fs_snapinum[snaploc] == 0)

sys/ufs/ffs/ffs_snapshot.c

2025

if ((error = ffs_vget(mp, fs->fs_snapinum[snaploc],

sys/ufs/ffs/ffs_snapshot.c

2036

lblktosize(fs, howmany(fs->fs_size, fs->fs_frag))) {

sys/ufs/ffs/ffs_snapshot.c

2045

reason, fs->fs_snapinum[snaploc]);

sys/ufs/ffs/ffs_snapshot.c

2049

if (fs->fs_snapinum[loc] == 0)

sys/ufs/ffs/ffs_snapshot.c

2051

fs->fs_snapinum[loc - 1] = fs->fs_snapinum[loc];

sys/ufs/ffs/ffs_snapshot.c

2053

fs->fs_snapinum[loc - 1] = 0;

sys/ufs/ffs/ffs_snapshot.c

206

struct fs *copy_fs = NULL, *fs, *bpfs;

sys/ufs/ffs/ffs_snapshot.c

2098

lblktosize(fs, howmany(fs->fs_size, fs->fs_frag));

sys/ufs/ffs/ffs_snapshot.c

2171

struct fs *fs;

sys/ufs/ffs/ffs_snapshot.c

2180

fs = ITOFS(TAILQ_FIRST(&sn->sn_head));

sys/ufs/ffs/ffs_snapshot.c

2181

lbn = fragstoblks(fs, dbtofsb(fs, bp->b_blkno));

sys/ufs/ffs/ffs_snapshot.c

223

fs = ump->um_fs;

sys/ufs/ffs/ffs_snapshot.c

2279

struct fs *fs;

sys/ufs/ffs/ffs_snapshot.c

2303

fs = ITOFS(ip);

sys/ufs/ffs/ffs_snapshot.c

2304

lbn = fragstoblks(fs, dbtofsb(fs, bp->b_blkno));

sys/ufs/ffs/ffs_snapshot.c

231

"using gjournal", fs->fs_fsmnt);

sys/ufs/ffs/ffs_snapshot.c

2374

error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

2375

fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

2379

indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

2403

error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

2404

fs->fs_bsize, KERNCRED, 0, &cbp);

sys/ufs/ffs/ffs_snapshot.c

2432

bcopy(savedcbp->b_data, cbp->b_data, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

2445

bzero(cbp->b_data, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

245

if (fs->fs_snapinum[snaploc] == 0)

sys/ufs/ffs/ffs_snapshot.c

2530

struct fs *fs;

sys/ufs/ffs/ffs_snapshot.c

2533

fs = ITOFS(ip);

sys/ufs/ffs/ffs_snapshot.c

2536

bp->b_iooffset = dbtob(fsbtodb(fs, blkstofrags(fs, lbn)));

sys/ufs/ffs/ffs_snapshot.c

305

vnode_create_vobject(nd.ni_vp, fs->fs_size, td);

sys/ufs/ffs/ffs_snapshot.c

315

numblks = howmany(fs->fs_size, fs->fs_frag);

sys/ufs/ffs/ffs_snapshot.c

316

error = UFS_BALLOC(vp, lblktosize(fs, (off_t)numblks),

sys/ufs/ffs/ffs_snapshot.c

317

fs->fs_bsize, KERNCRED, BA_CLRBUF, &bp);

sys/ufs/ffs/ffs_snapshot.c

321

ip->i_size = lblktosize(fs, (off_t)(numblks + 1));

sys/ufs/ffs/ffs_snapshot.c

336

for (blkno = UFS_NDADDR; blkno < numblks; blkno += NINDIR(fs)) {

sys/ufs/ffs/ffs_snapshot.c

337

error = UFS_BALLOC(vp, lblktosize(fs, (off_t)blkno),

sys/ufs/ffs/ffs_snapshot.c

338

fs->fs_bsize, td->td_ucred, BA_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

346

error = UFS_BALLOC(vp, fs->fs_sblockloc, fs->fs_sbsize, KERNCRED,

sys/ufs/ffs/ffs_snapshot.c

351

blkno = fragstoblks(fs, fs->fs_csaddr);

sys/ufs/ffs/ffs_snapshot.c

352

len = howmany(fs->fs_cssize, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

354

error = UFS_BALLOC(vp, lblktosize(fs, (off_t)(blkno + loc)),

sys/ufs/ffs/ffs_snapshot.c

355

fs->fs_bsize, KERNCRED, 0, &nbp);

sys/ufs/ffs/ffs_snapshot.c

363

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

sys/ufs/ffs/ffs_snapshot.c

364

error = UFS_BALLOC(vp, lfragtosize(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_snapshot.c

365

fs->fs_bsize, KERNCRED, 0, &nbp);

sys/ufs/ffs/ffs_snapshot.c

393

len = roundup2(howmany(fs->fs_ncg, NBBY), sizeof(uint64_t));

sys/ufs/ffs/ffs_snapshot.c

396

fs->fs_active = space;

sys/ufs/ffs/ffs_snapshot.c

398

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

sys/ufs/ffs/ffs_snapshot.c

399

error = UFS_BALLOC(vp, lfragtosize(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_snapshot.c

400

fs->fs_bsize, KERNCRED, 0, &nbp);

sys/ufs/ffs/ffs_snapshot.c

459

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

sys/ufs/ffs/ffs_snapshot.c

460

if ((ACTIVECGNUM(fs, cg) & ACTIVECGOFF(cg)) != 0)

sys/ufs/ffs/ffs_snapshot.c

465

error = UFS_BALLOC(vp, lfragtosize(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_snapshot.c

466

fs->fs_bsize, KERNCRED, 0, &nbp);

sys/ufs/ffs/ffs_snapshot.c

478

copy_fs = malloc((uint64_t)fs->fs_bsize, M_UFSMNT, M_WAITOK);

sys/ufs/ffs/ffs_snapshot.c

479

bcopy(fs, copy_fs, fs->fs_sbsize);

sys/ufs/ffs/ffs_snapshot.c

482

if ((fs->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) == 0)

sys/ufs/ffs/ffs_snapshot.c

484

size = fs->fs_bsize < SBLOCKSIZE ? fs->fs_bsize : SBLOCKSIZE;

sys/ufs/ffs/ffs_snapshot.c

485

if (fs->fs_sbsize < size)

sys/ufs/ffs/ffs_snapshot.c

486

bzero(&((char *)copy_fs)[fs->fs_sbsize],

sys/ufs/ffs/ffs_snapshot.c

487

size - fs->fs_sbsize);

sys/ufs/ffs/ffs_snapshot.c

488

size = blkroundup(fs, fs->fs_cssize);

sys/ufs/ffs/ffs_snapshot.c

489

if (fs->fs_contigsumsize > 0)

sys/ufs/ffs/ffs_snapshot.c

490

size += fs->fs_ncg * sizeof(int32_t);

sys/ufs/ffs/ffs_snapshot.c

493

bcopy(fs->fs_csp, copy_fs->fs_csp, fs->fs_cssize);

sys/ufs/ffs/ffs_snapshot.c

494

space = (char *)space + fs->fs_cssize;

sys/ufs/ffs/ffs_snapshot.c

495

loc = howmany(fs->fs_cssize, fs->fs_fsize);

sys/ufs/ffs/ffs_snapshot.c

496

i = fs->fs_frag - loc % fs->fs_frag;

sys/ufs/ffs/ffs_snapshot.c

497

len = (i == fs->fs_frag) ? 0 : i * fs->fs_fsize;

sys/ufs/ffs/ffs_snapshot.c

499

if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + loc),

sys/ufs/ffs/ffs_snapshot.c

509

if (fs->fs_contigsumsize > 0) {

sys/ufs/ffs/ffs_snapshot.c

511

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

sys/ufs/ffs/ffs_snapshot.c

512

*lp++ = fs->fs_contigsumsize;

sys/ufs/ffs/ffs_snapshot.c

543

snaplistsize = fs->fs_ncg + howmany(fs->fs_cssize, fs->fs_bsize) +

sys/ufs/ffs/ffs_snapshot.c

600

loc = howmany(xp->i_size, fs->fs_bsize) - 1;

sys/ufs/ffs/ffs_snapshot.c

602

len = fragroundup(fs, blkoff(fs, xp->i_size));

sys/ufs/ffs/ffs_snapshot.c

603

if (len != 0 && len < fs->fs_bsize) {

sys/ufs/ffs/ffs_snapshot.c

633

if (fs->fs_flags & FS_SUJ) {

sys/ufs/ffs/ffs_snapshot.c

658

error = UFS_BALLOC(vp, lblktosize(fs, blockno),

sys/ufs/ffs/ffs_snapshot.c

659

fs->fs_bsize, KERNCRED, BA_CLRBUF, &bp);

sys/ufs/ffs/ffs_snapshot.c

688

*blkp++ = lblkno(fs, fs->fs_sblockloc);

sys/ufs/ffs/ffs_snapshot.c

689

blkno = fragstoblks(fs, fs->fs_csaddr);

sys/ufs/ffs/ffs_snapshot.c

690

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

sys/ufs/ffs/ffs_snapshot.c

691

if (fragstoblks(fs, cgtod(fs, cg)) > blkno)

sys/ufs/ffs/ffs_snapshot.c

693

*blkp++ = fragstoblks(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_snapshot.c

695

len = howmany(fs->fs_cssize, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

698

for (; cg < fs->fs_ncg; cg++)

sys/ufs/ffs/ffs_snapshot.c

699

*blkp++ = fragstoblks(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_snapshot.c

713

fs->fs_snapinum[snaploc] = ip->i_number;

sys/ufs/ffs/ffs_snapshot.c

740

endtime.tv_nsec / 1000000, redo, fs->fs_ncg);

sys/ufs/ffs/ffs_snapshot.c

753

error = expunge_ufs1(vp, xp, fs, snapacct_ufs1,

sys/ufs/ffs/ffs_snapshot.c

756

error = expunge_ufs2(vp, xp, fs, snapacct_ufs2,

sys/ufs/ffs/ffs_snapshot.c

766

fs->fs_snapinum[snaploc] = 0;

sys/ufs/ffs/ffs_snapshot.c

788

fs->fs_snapinum[snaploc] = 0;

sys/ufs/ffs/ffs_snapshot.c

805

auio.uio_offset = lblktosize(fs, (off_t)numblks);

sys/ufs/ffs/ffs_snapshot.c

810

fs->fs_snapinum[snaploc] = 0;

sys/ufs/ffs/ffs_snapshot.c

818

blkno = fragstoblks(fs, fs->fs_csaddr);

sys/ufs/ffs/ffs_snapshot.c

819

len = howmany(fs->fs_cssize, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

822

error = bread(vp, blkno + loc, fs->fs_bsize, KERNCRED, &nbp);

sys/ufs/ffs/ffs_snapshot.c

824

fs->fs_snapinum[snaploc] = 0;

sys/ufs/ffs/ffs_snapshot.c

828

bcopy(space, nbp->b_data, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

829

space = (char *)space + fs->fs_bsize;

sys/ufs/ffs/ffs_snapshot.c

832

error = bread(vp, lblkno(fs, fs->fs_sblockloc), fs->fs_bsize,

sys/ufs/ffs/ffs_snapshot.c

837

loc = blkoff(fs, fs->fs_sblockloc);

sys/ufs/ffs/ffs_snapshot.c

839

bpfs = (struct fs *)&nbp->b_data[loc];

sys/ufs/ffs/ffs_snapshot.c

840

bcopy((caddr_t)copy_fs, (caddr_t)bpfs, (uint64_t)fs->fs_sbsize);

sys/ufs/ffs/ffs_snapshot.c

85

ffs_snapblkfree(struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

871

if (fs->fs_active != 0) {

sys/ufs/ffs/ffs_snapshot.c

872

free(fs->fs_active, M_DEVBUF);

sys/ufs/ffs/ffs_snapshot.c

873

fs->fs_active = 0;

sys/ufs/ffs/ffs_snapshot.c

925

struct fs *fs;

sys/ufs/ffs/ffs_snapshot.c

930

fs = ITOFS(ip);

sys/ufs/ffs/ffs_snapshot.c

931

if ((error = ffs_getcg(fs, ITODEVVP(ip), cg, 0, &bp, &cgp)) != 0)

sys/ufs/ffs/ffs_snapshot.c

934

ACTIVESET(fs, cg);

sys/ufs/ffs/ffs_snapshot.c

941

fs->fs_cs(fs, cg) = cgp->cg_cs;

sys/ufs/ffs/ffs_snapshot.c

943

bcopy(bp->b_data, nbp->b_data, fs->fs_cgsize);

sys/ufs/ffs/ffs_snapshot.c

944

if (fs->fs_cgsize < fs->fs_bsize)

sys/ufs/ffs/ffs_snapshot.c

945

bzero(&nbp->b_data[fs->fs_cgsize],

sys/ufs/ffs/ffs_snapshot.c

946

fs->fs_bsize - fs->fs_cgsize);

sys/ufs/ffs/ffs_snapshot.c

951

numblks = howmany(fs->fs_size, fs->fs_frag);

sys/ufs/ffs/ffs_snapshot.c

952

len = howmany(fs->fs_fpg, fs->fs_frag);

sys/ufs/ffs/ffs_snapshot.c

953

base = cgbase(fs, cg) / fs->fs_frag;

sys/ufs/ffs/ffs_snapshot.c

959

if (ffs_isblock(fs, cg_blksfree(cgp), loc))

sys/ufs/ffs/ffs_snapshot.c

967

error = UFS_BALLOC(vp, lblktosize(fs, (off_t)(base + loc)),

sys/ufs/ffs/ffs_snapshot.c

968

fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

972

indiroff = (base + loc - UFS_NDADDR) % NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

974

if (indiroff >= NINDIR(fs)) {

sys/ufs/ffs/ffs_snapshot.c

979

lblktosize(fs, (off_t)(base + loc)),

sys/ufs/ffs/ffs_snapshot.c

980

fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

987

if (ffs_isblock(fs, cg_blksfree(cgp), loc))

sys/ufs/ffs/ffs_snapshot.c

998

if (ffs_isblock(fs, cg_blksfree(cgp), loc))

sys/ufs/ffs/ffs_softdep.c

10153

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

10161

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

10170

fs->fs_pendinginodes -= 1;

sys/ufs/ffs/ffs_softdep.c

10174

if ((error = ffs_freefile(ump, fs, freefile->fx_devvp,

sys/ufs/ffs/ffs_softdep.c

10409

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

10419

fs = inodedep->id_fs;

sys/ufs/ffs/ffs_softdep.c

10423

ino_to_fsbo(fs, inodedep->id_ino);

sys/ufs/ffs/ffs_softdep.c

10511

if (adp->ad_oldsize == 0 || adp->ad_oldsize == fs->fs_bsize)

sys/ufs/ffs/ffs_softdep.c

10513

dp->di_size = fs->fs_bsize * adp->ad_offset + adp->ad_oldsize;

sys/ufs/ffs/ffs_softdep.c

10540

dp->di_size <= (lastadp->ad_offset + 1) * fs->fs_bsize) {

sys/ufs/ffs/ffs_softdep.c

10544

dp->di_size = (i + 1) * fs->fs_bsize;

sys/ufs/ffs/ffs_softdep.c

10581

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

10591

fs = inodedep->id_fs;

sys/ufs/ffs/ffs_softdep.c

10595

ino_to_fsbo(fs, inodedep->id_ino);

sys/ufs/ffs/ffs_softdep.c

106

struct fs *fs,

sys/ufs/ffs/ffs_softdep.c

10606

ffs_update_dinode_ckhash(fs, dp);

sys/ufs/ffs/ffs_softdep.c

10676

if (adp->ad_oldsize == 0 || adp->ad_oldsize == fs->fs_bsize)

sys/ufs/ffs/ffs_softdep.c

10678

dp->di_extsize = fs->fs_bsize * adp->ad_offset + adp->ad_oldsize;

sys/ufs/ffs/ffs_softdep.c

10697

dp->di_extsize <= (lastadp->ad_offset + 1) * fs->fs_bsize) {

sys/ufs/ffs/ffs_softdep.c

10701

dp->di_extsize = (i + 1) * fs->fs_bsize;

sys/ufs/ffs/ffs_softdep.c

10750

if (adp->ad_oldsize == 0 || adp->ad_oldsize == fs->fs_bsize)

sys/ufs/ffs/ffs_softdep.c

10752

dp->di_size = fs->fs_bsize * adp->ad_offset + adp->ad_oldsize;

sys/ufs/ffs/ffs_softdep.c

10770

ffs_update_dinode_ckhash(fs, dp);

sys/ufs/ffs/ffs_softdep.c

10780

dp->di_size <= (lastadp->ad_offset + 1) * fs->fs_bsize) {

sys/ufs/ffs/ffs_softdep.c

10784

dp->di_size = (i + 1) * fs->fs_bsize;

sys/ufs/ffs/ffs_softdep.c

10799

ffs_update_dinode_ckhash(fs, dp);

sys/ufs/ffs/ffs_softdep.c

10995

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

11015

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

11016

bmsafemap = bmsafemap_lookup(mp, bp, dtog(fs, blkno), NULL);

sys/ufs/ffs/ffs_softdep.c

11043

bno = dtogd(fs, jnewblk->jn_blkno);

sys/ufs/ffs/ffs_softdep.c

11068

fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_softdep.c

11069

bmsafemap = bmsafemap_lookup(mp, bp, dtog(fs, blkno), NULL);

sys/ufs/ffs/ffs_softdep.c

11103

struct fs *fs,

sys/ufs/ffs/ffs_softdep.c

11113

cgbno = dtogd(fs, jnewblk->jn_blkno);

sys/ufs/ffs/ffs_softdep.c

11127

if (frags == fs->fs_frag) {

sys/ufs/ffs/ffs_softdep.c

11128

fragno = fragstoblks(fs, cgbno);

sys/ufs/ffs/ffs_softdep.c

11129

ffs_setblock(fs, blksfree, fragno);

sys/ufs/ffs/ffs_softdep.c

11130

ffs_clusteracct(fs, cgp, fragno, 1);

sys/ufs/ffs/ffs_softdep.c

11134

bbase = cgbno - fragnum(fs, cgbno);

sys/ufs/ffs/ffs_softdep.c

11136

blk = blkmap(fs, blksfree, bbase);

sys/ufs/ffs/ffs_softdep.c

11137

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

sys/ufs/ffs/ffs_softdep.c

11143

blk = blkmap(fs, blksfree, bbase);

sys/ufs/ffs/ffs_softdep.c

11144

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

sys/ufs/ffs/ffs_softdep.c

11146

fragno = fragstoblks(fs, bbase);

sys/ufs/ffs/ffs_softdep.c

11147

if (ffs_isblock(fs, blksfree, fragno)) {

sys/ufs/ffs/ffs_softdep.c

11148

cgp->cg_cs.cs_nffree -= fs->fs_frag;

sys/ufs/ffs/ffs_softdep.c

11149

ffs_clusteracct(fs, cgp, fragno, 1);

sys/ufs/ffs/ffs_softdep.c

11170

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

11185

fs = VFSTOUFS(bmsafemap->sm_list.wk_mp)->um_fs;

sys/ufs/ffs/ffs_softdep.c

11188

ino = jaddref->ja_ino % fs->fs_ipg;

sys/ufs/ffs/ffs_softdep.c

11207

fs = VFSTOUFS(bmsafemap->sm_list.wk_mp)->um_fs;

sys/ufs/ffs/ffs_softdep.c

11210

if (jnewblk_rollback(jnewblk, fs, cgp, blksfree))

sys/ufs/ffs/ffs_softdep.c

12080

struct fs *fs,

sys/ufs/ffs/ffs_softdep.c

12091

cgbno = dtogd(fs, jnewblk->jn_blkno);

sys/ufs/ffs/ffs_softdep.c

12097

if (frags == fs->fs_frag) {

sys/ufs/ffs/ffs_softdep.c

12098

blkno = fragstoblks(fs, cgbno);

sys/ufs/ffs/ffs_softdep.c

12099

ffs_clrblock(fs, blksfree, (long)blkno);

sys/ufs/ffs/ffs_softdep.c

12100

ffs_clusteracct(fs, cgp, blkno, -1);

sys/ufs/ffs/ffs_softdep.c

12103

bbase = cgbno - fragnum(fs, cgbno);

sys/ufs/ffs/ffs_softdep.c

12106

fragno = fragstoblks(fs, bbase);

sys/ufs/ffs/ffs_softdep.c

12107

if (ffs_isblock(fs, blksfree, fragno)) {

sys/ufs/ffs/ffs_softdep.c

12108

cgp->cg_cs.cs_nffree += fs->fs_frag;

sys/ufs/ffs/ffs_softdep.c

12109

ffs_clusteracct(fs, cgp, fragno, -1);

sys/ufs/ffs/ffs_softdep.c

12113

blk = blkmap(fs, blksfree, bbase);

sys/ufs/ffs/ffs_softdep.c

12114

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

sys/ufs/ffs/ffs_softdep.c

12120

blk = blkmap(fs, blksfree, bbase);

sys/ufs/ffs/ffs_softdep.c

12121

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

sys/ufs/ffs/ffs_softdep.c

12149

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

12175

fs = VFSTOUFS(bmsafemap->sm_list.wk_mp)->um_fs;

sys/ufs/ffs/ffs_softdep.c

12181

ino = jaddref->ja_ino % fs->fs_ipg;

sys/ufs/ffs/ffs_softdep.c

12203

fs = VFSTOUFS(bmsafemap->sm_list.wk_mp)->um_fs;

sys/ufs/ffs/ffs_softdep.c

12211

jnewblk_rollforward(jnewblk, fs, cgp, blksfree))

sys/ufs/ffs/ffs_softdep.c

12492

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

12499

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

12521

if (fs->fs_magic == FS_UFS1_MAGIC)

sys/ufs/ffs/ffs_softdep.c

12524

ino_to_fsbo(fs, ip->i_number))->di_freelink);

sys/ufs/ffs/ffs_softdep.c

12528

ino_to_fsbo(fs, ip->i_number))->di_freelink);

sys/ufs/ffs/ffs_softdep.c

12667

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

12676

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

12796

error = bread(pvp, lbn, blksize(fs, VTOI(pvp), lbn), td->td_ucred,

sys/ufs/ffs/ffs_softdep.c

13591

struct fs *fs,

sys/ufs/ffs/ffs_softdep.c

136

struct fs *fs,

sys/ufs/ffs/ffs_softdep.c

13661

MNT_COUNT_WRITEOPCOUNT) + 2) * fs->fs_contigsumsize;

sys/ufs/ffs/ffs_softdep.c

13663

needed += fragstoblks(fs,

sys/ufs/ffs/ffs_softdep.c

13664

roundup((fs->fs_dsize * fs->fs_minfree / 100) -

sys/ufs/ffs/ffs_softdep.c

13665

fs->fs_cstotal.cs_nffree, fs->fs_frag));

sys/ufs/ffs/ffs_softdep.c

13675

fs->fs_cstotal.cs_nbfree <= needed)

sys/ufs/ffs/ffs_softdep.c

13676

softdep_send_speedup(ump, needed * fs->fs_bsize,

sys/ufs/ffs/ffs_softdep.c

13679

fs->fs_cstotal.cs_nbfree <= needed) ||

sys/ufs/ffs/ffs_softdep.c

13680

(resource == FLUSH_INODES_WAIT && fs->fs_pendinginodes > 0 &&

sys/ufs/ffs/ffs_softdep.c

13681

fs->fs_cstotal.cs_nifree <= needed)) {

sys/ufs/ffs/ffs_softdep.c

13697

fs->fs_cstotal.cs_nifree <= needed &&

sys/ufs/ffs/ffs_softdep.c

13698

fs->fs_pendinginodes <= needed) {

sys/ufs/ffs/ffs_softdep.c

13734

fs->fs_cstotal.cs_nbfree <= needed) ||

sys/ufs/ffs/ffs_softdep.c

13735

(resource == FLUSH_INODES_WAIT && fs->fs_pendinginodes > 0 &&

sys/ufs/ffs/ffs_softdep.c

13736

fs->fs_cstotal.cs_nifree <= needed)) {

sys/ufs/ffs/ffs_softdep.c

14130

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

14135

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

14154

firstino = rounddown2(inodedep->id_ino, INOPB(fs));

sys/ufs/ffs/ffs_softdep.c

14155

for (lastino = firstino + INOPB(fs) - 1; lastino > firstino; lastino--)

sys/ufs/ffs/ffs_softdep.c

14232

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

14239

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

14240

error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),

sys/ufs/ffs/ffs_softdep.c

14241

(int)fs->fs_bsize, cred, &bp);

sys/ufs/ffs/ffs_softdep.c

2324

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

2328

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

2352

inodedep->id_fs = fs;

sys/ufs/ffs/ffs_softdep.c

2577

struct fs *fs,

sys/ufs/ffs/ffs_softdep.c

2632

if ((fs->fs_flags & FS_SUJ) &&

sys/ufs/ffs/ffs_softdep.c

2633

(error = journal_mount(mp, fs, cred)) != 0) {

sys/ufs/ffs/ffs_softdep.c

2670

if (compute_summary_at_mount == 0 || fs->fs_clean != 0)

sys/ufs/ffs/ffs_softdep.c

2673

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

sys/ufs/ffs/ffs_softdep.c

2674

if ((error = bread(devvp, fsbtodb(fs, cgtod(fs, cyl)),

sys/ufs/ffs/ffs_softdep.c

2675

fs->fs_cgsize, cred, &bp)) != 0) {

sys/ufs/ffs/ffs_softdep.c

2685

fs->fs_cs(fs, cyl) = cgp->cg_cs;

sys/ufs/ffs/ffs_softdep.c

2689

if (bcmp(&cstotal, &fs->fs_cstotal, sizeof cstotal))

sys/ufs/ffs/ffs_softdep.c

2690

printf("%s: superblock summary recomputed\n", fs->fs_fsmnt);

sys/ufs/ffs/ffs_softdep.c

2692

bcopy(&cstotal, &fs->fs_cstotal, sizeof cstotal);

sys/ufs/ffs/ffs_softdep.c

2904

struct fs *fs,

sys/ufs/ffs/ffs_softdep.c

2932

bcount = lblkno(fs, ip->i_size); /* Only use whole blocks. */

sys/ufs/ffs/ffs_softdep.c

2938

jblocks_add(jblocks, blkno, fsbtodb(fs, fs->fs_frag));

sys/ufs/ffs/ffs_softdep.c

2960

if (fs->fs_clean) {

sys/ufs/ffs/ffs_softdep.c

2961

DIP_SET(ip, i_modrev, fs->fs_mtime);

sys/ufs/ffs/ffs_softdep.c

3624

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

3642

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

3653

jrecmax = (fs->fs_bsize / devbsize) * jrecmin;

sys/ufs/ffs/ffs_softdep.c

3696

bp = geteblk(fs->fs_bsize, 0);

sys/ufs/ffs/ffs_softdep.c

3723

size = fs->fs_bsize;

sys/ufs/ffs/ffs_softdep.c

470

softdep_request_cleanup(struct fs *fs,

sys/ufs/ffs/ffs_softdep.c

5239

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

5244

fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_softdep.c

5280

bmsafemap = bmsafemap_lookup(mp, bp, ino_to_cg(fs, newinum), bmsafemap);

sys/ufs/ffs/ffs_softdep.c

5310

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

5315

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

5339

bno = dtogd(fs, jnewblk->jn_blkno);

sys/ufs/ffs/ffs_softdep.c

5362

dtog(fs, newblkno), NULL);

sys/ufs/ffs/ffs_softdep.c

5784

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

5786

fs = ITOFS(ip);

sys/ufs/ffs/ffs_softdep.c

5795

jfreefrag->fr_frags = numfrags(fs, size);

sys/ufs/ffs/ffs_softdep.c

5813

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

5818

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

5819

if (fragnum(fs, blkno) + numfrags(fs, size) > fs->fs_frag)

sys/ufs/ffs/ffs_softdep.c

6181

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

6188

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

6239

if (newblk_lookup(mp, dbtofsb(fs, bp->b_blkno), 0, &newblk))

sys/ufs/ffs/ffs_softdep.c

6258

struct fs *fs __diagused;

sys/ufs/ffs/ffs_softdep.c

6268

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

6271

KASSERT(aip->ai_offset >= 0 && aip->ai_offset < NINDIR(fs),

sys/ufs/ffs/ffs_softdep.c

6670

blkcount(struct fs *fs,

sys/ufs/ffs/ffs_softdep.c

6677

numblks = howmany(length, fs->fs_bsize);

sys/ufs/ffs/ffs_softdep.c

6679

totblks = howmany(length, fs->fs_fsize);

sys/ufs/ffs/ffs_softdep.c

6682

totblks = blkstofrags(fs, numblks);

sys/ufs/ffs/ffs_softdep.c

6690

totblks += blkstofrags(fs, howmany(numblks, NINDIR(fs)));

sys/ufs/ffs/ffs_softdep.c

6691

numblks -= NINDIR(fs);

sys/ufs/ffs/ffs_softdep.c

6694

numblks = howmany(numblks, NINDIR(fs));

sys/ufs/ffs/ffs_softdep.c

6697

totblks = fsbtodb(fs, totblks);

sys/ufs/ffs/ffs_softdep.c

6757

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

6768

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

6797

lastlbn = lblkno(fs, length + fs->fs_bsize - 1) - 1;

sys/ufs/ffs/ffs_softdep.c

6798

lastoff = blkoff(fs, length);

sys/ufs/ffs/ffs_softdep.c

6803

frags = fragroundup(fs, lastoff);

sys/ufs/ffs/ffs_softdep.c

6808

if (fs->fs_magic == FS_UFS2_MAGIC)

sys/ufs/ffs/ffs_softdep.c

6809

extblocks = btodb(fragroundup(fs, ip->i_din2->di_extsize));

sys/ufs/ffs/ffs_softdep.c

6821

for (i = 0, tmpval = NINDIR(fs), lbn = UFS_NDADDR;

sys/ufs/ffs/ffs_softdep.c

6823

i++, lbn += tmpval, tmpval *= NINDIR(fs)) {

sys/ufs/ffs/ffs_softdep.c

6845

oldfrags = blksize(fs, ip, lastlbn);

sys/ufs/ffs/ffs_softdep.c

6849

oldfrags = numfrags(fs, oldfrags);

sys/ufs/ffs/ffs_softdep.c

6850

blkno += numfrags(fs, frags);

sys/ufs/ffs/ffs_softdep.c

6855

numfrags(fs, frags));

sys/ufs/ffs/ffs_softdep.c

6873

datablocks = blkcount(fs, datablocks, length);

sys/ufs/ffs/ffs_softdep.c

6890

fs->fs_pendingblocks += datablocks;

sys/ufs/ffs/ffs_softdep.c

6901

dbn = fsbtodb(fs, ino_to_fsba(fs, ip->i_number));

sys/ufs/ffs/ffs_softdep.c

6902

error = ffs_breadz(ump, ump->um_devvp, dbn, dbn, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_softdep.c

6908

if (bp->b_bufsize == fs->fs_bsize)

sys/ufs/ffs/ffs_softdep.c

6913

ino_to_fsbo(fs, ip->i_number)) = *ip->i_din1;

sys/ufs/ffs/ffs_softdep.c

6915

ffs_update_dinode_ckhash(fs, ip->i_din2);

sys/ufs/ffs/ffs_softdep.c

6917

ino_to_fsbo(fs, ip->i_number)) = *ip->i_din2;

sys/ufs/ffs/ffs_softdep.c

7002

size = sblksize(fs, length, lastlbn);

sys/ufs/ffs/ffs_softdep.c

7102

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

7116

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

7118

fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),

sys/ufs/ffs/ffs_softdep.c

7119

(int)fs->fs_bsize, NOCRED, &bp)) != 0) {

sys/ufs/ffs/ffs_softdep.c

7127

if (fs->fs_magic == FS_UFS2_MAGIC)

sys/ufs/ffs/ffs_softdep.c

7128

extblocks = btodb(fragroundup(fs, ip->i_din2->di_extsize));

sys/ufs/ffs/ffs_softdep.c

7132

for (i = 0, tmpval = NINDIR(fs), lbn = UFS_NDADDR;

sys/ufs/ffs/ffs_softdep.c

7134

i++, lbn += tmpval, tmpval *= NINDIR(fs))

sys/ufs/ffs/ffs_softdep.c

7155

fs->fs_pendingblocks += datablocks;

sys/ufs/ffs/ffs_softdep.c

7165

ino_to_fsbo(fs, ip->i_number));

sys/ufs/ffs/ffs_softdep.c

7170

ino_to_fsbo(fs, ip->i_number));

sys/ufs/ffs/ffs_softdep.c

7172

ffs_update_dinode_ckhash(fs, ip->i_din2);

sys/ufs/ffs/ffs_softdep.c

7251

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

7256

fs = ITOFS(ip);

sys/ufs/ffs/ffs_softdep.c

7257

extend = OFF_TO_IDX(lblktosize(fs, -extblocks));

sys/ufs/ffs/ffs_softdep.c

726

static int jnewblk_rollforward(struct jnewblk *, struct fs *, struct cg *,

sys/ufs/ffs/ffs_softdep.c

7278

lbn = lblkno(fs, length);

sys/ufs/ffs/ffs_softdep.c

7282

end = OFF_TO_IDX(lblktosize(fs, lbn));

sys/ufs/ffs/ffs_softdep.c

760

static int jnewblk_rollback(struct jnewblk *, struct fs *, struct cg *,

sys/ufs/ffs/ffs_softdep.c

7974

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

7988

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

7990

bsize = lfragtosize(fs, freework->fw_frags);

sys/ufs/ffs/ffs_softdep.c

8024

ffs_blkfree(ump, fs, freeblks->fb_devvp, freework->fw_blkno, bsize,

sys/ufs/ffs/ffs_softdep.c

8066

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

8070

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

8075

if (freework->fw_off == NINDIR(fs)) {

sys/ufs/ffs/ffs_softdep.c

8081

indir_trunc(freework, fsbtodb(fs, freework->fw_blkno),

sys/ufs/ffs/ffs_softdep.c

819

static ufs2_daddr_t blkcount(struct fs *, ufs2_daddr_t, off_t);

sys/ufs/ffs/ffs_softdep.c

8205

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

8214

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

8215

fs->fs_pendingblocks -= blocks;

sys/ufs/ffs/ffs_softdep.c

8231

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

8236

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

8265

fs->fs_pendingblocks += spare;

sys/ufs/ffs/ffs_softdep.c

8313

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

8327

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

8362

(int)fs->fs_bsize, NULL, NULL, 0, NOCRED, 0, NULL, &bp);

sys/ufs/ffs/ffs_softdep.c

8413

lbnadd = lbn_offset(fs, level);

sys/ufs/ffs/ffs_softdep.c

8414

nblocks = btodb(fs->fs_bsize);

sys/ufs/ffs/ffs_softdep.c

8424

for (i = freework->fw_off; i < NINDIR(fs); i++, nb = nnb) {

sys/ufs/ffs/ffs_softdep.c

8426

fs->fs_bsize) != 0)

sys/ufs/ffs/ffs_softdep.c

8428

if (i != NINDIR(fs) - 1) {

sys/ufs/ffs/ffs_softdep.c

8442

nlbn, nb, fs->fs_frag, 0, 0);

sys/ufs/ffs/ffs_softdep.c

8445

indir_trunc(nfreework, fsbtodb(fs, nb), nlbn);

sys/ufs/ffs/ffs_softdep.c

8455

(nnb == 0 || (dtog(fs, nb) != dtog(fs, nnb)))) {

sys/ufs/ffs/ffs_softdep.c

8463

freeblks->fb_inum, nb, fs->fs_bsize);

sys/ufs/ffs/ffs_softdep.c

8464

ffs_blkfree(ump, fs, freeblks->fb_devvp, nb,

sys/ufs/ffs/ffs_softdep.c

8465

fs->fs_bsize, freeblks->fb_inum,

sys/ufs/ffs/ffs_softdep.c

8488

freework->fw_ref -= NINDIR(fs) + 1;

sys/ufs/ffs/ffs_softdep.c

8499

dbn = dbtofsb(fs, dbn);

sys/ufs/ffs/ffs_softdep.c

8502

freeblks->fb_inum, dbn, fs->fs_bsize);

sys/ufs/ffs/ffs_softdep.c

8503

ffs_blkfree(ump, fs, freeblks->fb_devvp, dbn, fs->fs_bsize,

sys/ufs/ffs/ffs_softdep.c

8711

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

8737

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

8738

lbn = lblkno(fs, diroffset);

sys/ufs/ffs/ffs_softdep.c

8739

offset = blkoff(fs, diroffset);

sys/ufs/ffs/ffs_softdep.c

8750

(isindir ? blkoff(fs, diroffset) : fragoff(fs, diroffset)) == 0) {

sys/ufs/ffs/ffs_softdep.c

8849

if (newblk_lookup(mp, dbtofsb(fs, bp->b_blkno), 0, &newblk)

sys/ufs/ffs/ffs_softdep.c

885

static int journal_mount(struct mount *, struct fs *, struct ucred *);

sys/ufs/ffs/ffs_softdep.c

9699

struct fs *fs,

sys/ufs/ffs/ffs_softdep.c

9714

sbdep->sb_fs = fs;

sys/ufs/ffs/ffs_softdep.c

9752

struct fs *bpfs;

sys/ufs/ffs/ffs_softdep.c

9753

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

9756

fs = sbdep->sb_ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

9759

fs->fs_sujfree = inodedep->id_ino;

sys/ufs/ffs/ffs_softdep.c

9762

fs->fs_sujfree = 0;

sys/ufs/ffs/ffs_softdep.c

9763

bpfs->fs_sujfree = fs->fs_sujfree;

sys/ufs/ffs/ffs_softdep.c

9779

struct fs *fs;

sys/ufs/ffs/ffs_softdep.c

9782

fs = sbdep->sb_fs;

sys/ufs/ffs/ffs_softdep.c

9787

if ((inodedep && fs->fs_sujfree != inodedep->id_ino) ||

sys/ufs/ffs/ffs_softdep.c

9788

(inodedep == NULL && fs->fs_sujfree != 0)) {

sys/ufs/ffs/ffs_softdep.c

9793

if (fs->fs_sujfree == 0)

sys/ufs/ffs/ffs_softdep.c

9842

struct fs *fs, *bpfs;

sys/ufs/ffs/ffs_softdep.c

9851

fs = ump->um_fs;

sys/ufs/ffs/ffs_softdep.c

9875

if (idn && fs->fs_sujfree != idn->id_ino)

sys/ufs/ffs/ffs_softdep.c

9895

bp = getblk(ump->um_devvp, btodb(fs->fs_sblockloc),

sys/ufs/ffs/ffs_softdep.c

9896

(int)fs->fs_sbsize, 0, 0, 0);

sys/ufs/ffs/ffs_softdep.c

9898

dbn = fsbtodb(fs, ino_to_fsba(fs, pino));

sys/ufs/ffs/ffs_softdep.c

9900

(int)fs->fs_bsize, NULL, NULL, 0, NOCRED, 0, NULL,

sys/ufs/ffs/ffs_softdep.c

9938

bcopy((caddr_t)fs, bp->b_data, (uint64_t)fs->fs_sbsize);

sys/ufs/ffs/ffs_softdep.c

9939

bpfs = (struct fs *)bp->b_data;

sys/ufs/ffs/ffs_softdep.c

9947

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

sys/ufs/ffs/ffs_softdep.c

9949

ino_to_fsbo(fs, pino))->di_freelink = nino;

sys/ufs/ffs/ffs_softdep.c

9952

ino_to_fsbo(fs, pino);

sys/ufs/ffs/ffs_softdep.c

9954

ffs_update_dinode_ckhash(fs, dip);

sys/ufs/ffs/ffs_softdep.c

9966

if (fs->fs_sujfree == ino) {

sys/ufs/ffs/ffs_softdep.c

9968

bp = getblk(ump->um_devvp, btodb(fs->fs_sblockloc),

sys/ufs/ffs/ffs_softdep.c

9969

(int)fs->fs_sbsize, 0, 0, 0);

sys/ufs/ffs/ffs_softdep.c

9970

bcopy((caddr_t)fs, bp->b_data, (uint64_t)fs->fs_sbsize);

sys/ufs/ffs/ffs_softdep.c

9971

bpfs = (struct fs *)bp->b_data;

sys/ufs/ffs/ffs_softdep.c

9983

if (fs->fs_sujfree != ino)

sys/ufs/ffs/ffs_softdep.c

9987

if (inodedep->id_ino == fs->fs_sujfree)

sys/ufs/ffs/ffs_subr.c

1000

fs->fs_si = fs_si;

sys/ufs/ffs/ffs_subr.c

1008

ffs_calc_sbhash(struct fs *fs)

sys/ufs/ffs/ffs_subr.c

1026

if ((fs->fs_metackhash & CK_SUPERBLOCK) == 0)

sys/ufs/ffs/ffs_subr.c

1027

return (fs->fs_ckhash);

sys/ufs/ffs/ffs_subr.c

1029

save_ckhash = fs->fs_ckhash;

sys/ufs/ffs/ffs_subr.c

1030

fs->fs_ckhash = 0;

sys/ufs/ffs/ffs_subr.c

1035

ckhash = calculate_crc32c(~0L, (void *)fs, fs->fs_sbsize);

sys/ufs/ffs/ffs_subr.c

1036

fs->fs_ckhash = save_ckhash;

sys/ufs/ffs/ffs_subr.c

1045

ffs_fragacct(struct fs *fs, int fragmap, int32_t fraglist[], int cnt)

sys/ufs/ffs/ffs_subr.c

1051

inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1;

sys/ufs/ffs/ffs_subr.c

1053

for (siz = 1; siz < fs->fs_frag; siz++) {

sys/ufs/ffs/ffs_subr.c

1054

if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0)

sys/ufs/ffs/ffs_subr.c

1058

for (pos = siz; pos <= fs->fs_frag; pos++) {

sys/ufs/ffs/ffs_subr.c

1077

ffs_isblock(struct fs *fs, unsigned char *cp, ufs1_daddr_t h)

sys/ufs/ffs/ffs_subr.c

108

ffs_update_dinode_ckhash(struct fs *fs, struct ufs2_dinode *dip)

sys/ufs/ffs/ffs_subr.c

1081

switch ((int)fs->fs_frag) {

sys/ufs/ffs/ffs_subr.c

1106

ffs_isfreeblock(struct fs *fs, uint8_t *cp, ufs1_daddr_t h)

sys/ufs/ffs/ffs_subr.c

1109

switch ((int)fs->fs_frag) {

sys/ufs/ffs/ffs_subr.c

111

if (dip->di_mode == 0 || (fs->fs_metackhash & CK_INODE) == 0)

sys/ufs/ffs/ffs_subr.c

1131

ffs_clrblock(struct fs *fs, uint8_t *cp, ufs1_daddr_t h)

sys/ufs/ffs/ffs_subr.c

1134

switch ((int)fs->fs_frag) {

sys/ufs/ffs/ffs_subr.c

1159

ffs_setblock(struct fs *fs, unsigned char *cp, ufs1_daddr_t h)

sys/ufs/ffs/ffs_subr.c

1162

switch ((int)fs->fs_frag) {

sys/ufs/ffs/ffs_subr.c

1189

ffs_clusteracct(struct fs *fs, struct cg *cgp, ufs1_daddr_t blkno, int cnt)

sys/ufs/ffs/ffs_subr.c

1197

if (fs->fs_contigsumsize <= 0)

sys/ufs/ffs/ffs_subr.c

1212

end = start + fs->fs_contigsumsize;

sys/ufs/ffs/ffs_subr.c

1233

end = start - fs->fs_contigsumsize;

sys/ufs/ffs/ffs_subr.c

1255

if (i > fs->fs_contigsumsize)

sys/ufs/ffs/ffs_subr.c

1256

i = fs->fs_contigsumsize;

sys/ufs/ffs/ffs_subr.c

126

static int readsuper(void *, struct fs **, off_t, int,

sys/ufs/ffs/ffs_subr.c

1265

lp = &sump[fs->fs_contigsumsize];

sys/ufs/ffs/ffs_subr.c

1266

for (i = fs->fs_contigsumsize; i > 0; i--)

sys/ufs/ffs/ffs_subr.c

1269

fs->fs_maxcluster[cgp->cg_cgx] = i;

sys/ufs/ffs/ffs_subr.c

128

static void ffs_oldfscompat_read(struct fs *, ufs2_daddr_t);

sys/ufs/ffs/ffs_subr.c

129

static int validate_sblock(struct fs *, int);

sys/ufs/ffs/ffs_subr.c

152

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

sys/ufs/ffs/ffs_subr.c

156

struct fs *fs;

sys/ufs/ffs/ffs_subr.c

164

fs = NULL;

sys/ufs/ffs/ffs_subr.c

167

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

sys/ufs/ffs/ffs_subr.c

169

if (fs != NULL)

sys/ufs/ffs/ffs_subr.c

170

UFS_FREE(fs, filltype);

sys/ufs/ffs/ffs_subr.c

175

if ((error = readsuper(devfd, &fs, sblock_try[i],

sys/ufs/ffs/ffs_subr.c

178

*fsp = fs;

sys/ufs/ffs/ffs_subr.c

183

if (fs != NULL) {

sys/ufs/ffs/ffs_subr.c

184

UFS_FREE(fs, filltype);

sys/ufs/ffs/ffs_subr.c

185

fs = NULL;

sys/ufs/ffs/ffs_subr.c

197

size = fs->fs_cssize;

sys/ufs/ffs/ffs_subr.c

198

blks = howmany(size, fs->fs_fsize);

sys/ufs/ffs/ffs_subr.c

199

if (fs->fs_contigsumsize > 0)

sys/ufs/ffs/ffs_subr.c

200

size += fs->fs_ncg * sizeof(int32_t);

sys/ufs/ffs/ffs_subr.c

201

size += fs->fs_ncg * sizeof(uint8_t);

sys/ufs/ffs/ffs_subr.c

203

UFS_FREE(fs, filltype);

sys/ufs/ffs/ffs_subr.c

207

fs->fs_si = fs_si;

sys/ufs/ffs/ffs_subr.c

209

UFS_FREE(fs->fs_si, filltype);

sys/ufs/ffs/ffs_subr.c

210

UFS_FREE(fs, filltype);

sys/ufs/ffs/ffs_subr.c

213

fs->fs_csp = (struct csum *)space;

sys/ufs/ffs/ffs_subr.c

214

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

sys/ufs/ffs/ffs_subr.c

215

size = fs->fs_bsize;

sys/ufs/ffs/ffs_subr.c

216

if (i + fs->fs_frag > blks)

sys/ufs/ffs/ffs_subr.c

217

size = (blks - i) * fs->fs_fsize;

sys/ufs/ffs/ffs_subr.c

220

dbtob(fsbtodb(fs, fs->fs_csaddr + i)), (void **)&buf, size);

sys/ufs/ffs/ffs_subr.c

224

UFS_FREE(fs->fs_csp, filltype);

sys/ufs/ffs/ffs_subr.c

225

UFS_FREE(fs->fs_si, filltype);

sys/ufs/ffs/ffs_subr.c

226

UFS_FREE(fs, filltype);

sys/ufs/ffs/ffs_subr.c

233

if (fs->fs_contigsumsize > 0) {

sys/ufs/ffs/ffs_subr.c

234

fs->fs_maxcluster = lp = (int32_t *)space;

sys/ufs/ffs/ffs_subr.c

235

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

sys/ufs/ffs/ffs_subr.c

236

*lp++ = fs->fs_contigsumsize;

sys/ufs/ffs/ffs_subr.c

239

size = fs->fs_ncg * sizeof(uint8_t);

sys/ufs/ffs/ffs_subr.c

240

fs->fs_contigdirs = (uint8_t *)space;

sys/ufs/ffs/ffs_subr.c

241

bzero(fs->fs_contigdirs, size);

sys/ufs/ffs/ffs_subr.c

242

*fsp = fs;

sys/ufs/ffs/ffs_subr.c

251

readsuper(void *devfd, struct fs **fsp, off_t sblockloc, int flags,

sys/ufs/ffs/ffs_subr.c

254

struct fs *fs;

sys/ufs/ffs/ffs_subr.c

261

fs = *fsp;

sys/ufs/ffs/ffs_subr.c

262

if (fs->fs_magic == FS_BAD_MAGIC)

sys/ufs/ffs/ffs_subr.c

271

if (fs->fs_magic == FS_UFS1_MAGIC && (flags & UFS_ALTSBLK) == 0 &&

sys/ufs/ffs/ffs_subr.c

272

fs->fs_bsize == SBLOCK_UFS2 && sblockloc == SBLOCK_UFS2)

sys/ufs/ffs/ffs_subr.c

274

ffs_oldfscompat_read(fs, sblockloc);

sys/ufs/ffs/ffs_subr.c

275

if ((error = validate_sblock(fs, flags)) > 0)

sys/ufs/ffs/ffs_subr.c

281

if ((fs->fs_flags & FS_METACKHASH) == 0)

sys/ufs/ffs/ffs_subr.c

282

fs->fs_metackhash = 0;

sys/ufs/ffs/ffs_subr.c

287

fs->fs_metackhash &= CK_SUPPORTED;

sys/ufs/ffs/ffs_subr.c

288

fs->fs_flags &= FS_SUPPORTED;

sys/ufs/ffs/ffs_subr.c

289

if (fs->fs_ckhash != (ckhash = ffs_calc_sbhash(fs))) {

sys/ufs/ffs/ffs_subr.c

298

fs->fs_ckhash, ckhash,

sys/ufs/ffs/ffs_subr.c

310

"0x%x%s\n", fs->fs_ckhash, ckhash,

sys/ufs/ffs/ffs_subr.c

317

fs->fs_sblockactualloc = sblockloc;

sys/ufs/ffs/ffs_subr.c

319

fs->fs_si = NULL;

sys/ufs/ffs/ffs_subr.c

331

ffs_oldfscompat_read(struct fs *fs, ufs2_daddr_t sblockloc)

sys/ufs/ffs/ffs_subr.c

338

if ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) {

sys/ufs/ffs/ffs_subr.c

339

fs->fs_flags = fs->fs_old_flags;

sys/ufs/ffs/ffs_subr.c

340

fs->fs_old_flags |= FS_FLAGS_UPDATED;

sys/ufs/ffs/ffs_subr.c

341

fs->fs_sblockloc = sblockloc;

sys/ufs/ffs/ffs_subr.c

343

switch (fs->fs_magic) {

sys/ufs/ffs/ffs_subr.c

352

if (fs->fs_maxbsize != fs->fs_bsize) {

sys/ufs/ffs/ffs_subr.c

353

fs->fs_maxbsize = fs->fs_bsize;

sys/ufs/ffs/ffs_subr.c

354

fs->fs_time = fs->fs_old_time;

sys/ufs/ffs/ffs_subr.c

355

fs->fs_size = fs->fs_old_size;

sys/ufs/ffs/ffs_subr.c

356

fs->fs_dsize = fs->fs_old_dsize;

sys/ufs/ffs/ffs_subr.c

357

fs->fs_csaddr = fs->fs_old_csaddr;

sys/ufs/ffs/ffs_subr.c

358

fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;

sys/ufs/ffs/ffs_subr.c

359

fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;

sys/ufs/ffs/ffs_subr.c

360

fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;

sys/ufs/ffs/ffs_subr.c

361

fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;

sys/ufs/ffs/ffs_subr.c

363

if (fs->fs_old_inodefmt < FS_44INODEFMT) {

sys/ufs/ffs/ffs_subr.c

364

fs->fs_maxfilesize = ((uint64_t)1 << 31) - 1;

sys/ufs/ffs/ffs_subr.c

365

fs->fs_qbmask = ~fs->fs_bmask;

sys/ufs/ffs/ffs_subr.c

366

fs->fs_qfmask = ~fs->fs_fmask;

sys/ufs/ffs/ffs_subr.c

368

fs->fs_save_maxfilesize = fs->fs_maxfilesize;

sys/ufs/ffs/ffs_subr.c

369

maxfilesize = (uint64_t)0x80000000 * fs->fs_bsize - 1;

sys/ufs/ffs/ffs_subr.c

370

if (fs->fs_maxfilesize > maxfilesize)

sys/ufs/ffs/ffs_subr.c

371

fs->fs_maxfilesize = maxfilesize;

sys/ufs/ffs/ffs_subr.c

375

if (fs->fs_avgfilesize <= 0)

sys/ufs/ffs/ffs_subr.c

376

fs->fs_avgfilesize = AVFILESIZ;

sys/ufs/ffs/ffs_subr.c

377

if (fs->fs_avgfpdir <= 0)

sys/ufs/ffs/ffs_subr.c

378

fs->fs_avgfpdir = AFPDIR;

sys/ufs/ffs/ffs_subr.c

389

ffs_oldfscompat_write(struct fs *fs)

sys/ufs/ffs/ffs_subr.c

392

switch (fs->fs_magic) {

sys/ufs/ffs/ffs_subr.c

394

if (fs->fs_sblockloc != SBLOCK_UFS1 &&

sys/ufs/ffs/ffs_subr.c

395

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

sys/ufs/ffs/ffs_subr.c

398

fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS1);

sys/ufs/ffs/ffs_subr.c

399

fs->fs_sblockloc = SBLOCK_UFS1;

sys/ufs/ffs/ffs_subr.c

404

fs->fs_old_time = fs->fs_time;

sys/ufs/ffs/ffs_subr.c

405

fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;

sys/ufs/ffs/ffs_subr.c

406

fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;

sys/ufs/ffs/ffs_subr.c

407

fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;

sys/ufs/ffs/ffs_subr.c

408

fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;

sys/ufs/ffs/ffs_subr.c

409

if (fs->fs_save_maxfilesize != 0)

sys/ufs/ffs/ffs_subr.c

410

fs->fs_maxfilesize = fs->fs_save_maxfilesize;

sys/ufs/ffs/ffs_subr.c

413

if (fs->fs_sblockloc != SBLOCK_UFS2 &&

sys/ufs/ffs/ffs_subr.c

414

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

sys/ufs/ffs/ffs_subr.c

417

fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS2);

sys/ufs/ffs/ffs_subr.c

418

fs->fs_sblockloc = SBLOCK_UFS2;

sys/ufs/ffs/ffs_subr.c

438

ffs_oldfscompat_inode_read(struct fs *fs, union dinodep dp, time_t now)

sys/ufs/ffs/ffs_subr.c

443

switch (fs->fs_magic) {

sys/ufs/ffs/ffs_subr.c

47

uint32_t ffs_calc_sbhash(struct fs *);

sys/ufs/ffs/ffs_subr.c

494

#fmt ")\n", fs->fs_magic == FS_UFS1_MAGIC ? 1 : 2, \

sys/ufs/ffs/ffs_subr.c

504

#fmt ")%s\n", fs->fs_magic == FS_UFS1_MAGIC ? 1 : 2,\

sys/ufs/ffs/ffs_subr.c

515

fs->fs_magic == FS_UFS1_MAGIC ? 1 : 2, #lhs1, \

sys/ufs/ffs/ffs_subr.c

525

validate_sblock(struct fs *fs, int flags)

sys/ufs/ffs/ffs_subr.c

540

if (((fs->fs_magic != FS_UFS2_MAGIC) &&

sys/ufs/ffs/ffs_subr.c

541

(bswap32(fs->fs_magic) == FS_UFS2_MAGIC)) ||

sys/ufs/ffs/ffs_subr.c

542

((fs->fs_magic != FS_UFS1_MAGIC) &&

sys/ufs/ffs/ffs_subr.c

543

(bswap32(fs->fs_magic) == FS_UFS1_MAGIC))) {

sys/ufs/ffs/ffs_subr.c

554

(fs->fs_magic == FS_UFS1_MAGIC || fs->fs_magic == FS_UFS2_MAGIC)) {

sys/ufs/ffs/ffs_subr.c

556

if (fs->fs_magic == FS_UFS2_MAGIC) {

sys/ufs/ffs/ffs_subr.c

557

FCHK(fs->fs_sblockloc, !=, SBLOCK_UFS2, %#jx);

sys/ufs/ffs/ffs_subr.c

558

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

sys/ufs/ffs/ffs_subr.c

559

FCHK(fs->fs_sblockloc, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

560

FCHK(fs->fs_sblockloc, >, SBLOCK_UFS1, %jd);

sys/ufs/ffs/ffs_subr.c

562

FCHK(fs->fs_frag, <, 1, %jd);

sys/ufs/ffs/ffs_subr.c

563

FCHK(fs->fs_frag, >, MAXFRAG, %jd);

sys/ufs/ffs/ffs_subr.c

564

FCHK(fs->fs_bsize, <, MINBSIZE, %jd);

sys/ufs/ffs/ffs_subr.c

565

FCHK(fs->fs_bsize, >, MAXBSIZE, %jd);

sys/ufs/ffs/ffs_subr.c

566

FCHK(fs->fs_bsize, <, roundup(sizeof(struct fs), DEV_BSIZE),

sys/ufs/ffs/ffs_subr.c

568

FCHK(fs->fs_fsize, <, sectorsize, %jd);

sys/ufs/ffs/ffs_subr.c

569

FCHK(fs->fs_fsize * fs->fs_frag, !=, fs->fs_bsize, %jd);

sys/ufs/ffs/ffs_subr.c

570

FCHK(powerof2(fs->fs_fsize), ==, 0, %jd);

sys/ufs/ffs/ffs_subr.c

571

FCHK(fs->fs_sbsize, >, SBLOCKSIZE, %jd);

sys/ufs/ffs/ffs_subr.c

572

FCHK(fs->fs_sbsize, <, (signed)sizeof(struct fs), %jd);

sys/ufs/ffs/ffs_subr.c

573

FCHK(fs->fs_sbsize % sectorsize, !=, 0, %jd);

sys/ufs/ffs/ffs_subr.c

574

FCHK(fs->fs_fpg, <, 3 * fs->fs_frag, %jd);

sys/ufs/ffs/ffs_subr.c

575

FCHK(fs->fs_ncg, <, 1, %jd);

sys/ufs/ffs/ffs_subr.c

576

FCHK(fs->fs_fsbtodb, !=, ILOG2(fs->fs_fsize / sectorsize), %jd);

sys/ufs/ffs/ffs_subr.c

577

FCHK(fs->fs_old_cgoffset, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

578

FCHK2(fs->fs_old_cgoffset, >, 0, ~fs->fs_old_cgmask, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

579

FCHK(fs->fs_old_cgoffset * (~fs->fs_old_cgmask), >, fs->fs_fpg,

sys/ufs/ffs/ffs_subr.c

581

FCHK(fs->fs_sblkno, !=, roundup(

sys/ufs/ffs/ffs_subr.c

582

howmany(fs->fs_sblockloc + SBLOCKSIZE, fs->fs_fsize),

sys/ufs/ffs/ffs_subr.c

583

fs->fs_frag), %jd);

sys/ufs/ffs/ffs_subr.c

584

FCHK(CGSIZE(fs), >, fs->fs_bsize, %jd);

sys/ufs/ffs/ffs_subr.c

588

FCHK((uint64_t)fs->fs_ipg * fs->fs_ncg, >,

sys/ufs/ffs/ffs_subr.c

589

(((int64_t)(1)) << 32) - INOPB(fs), %jd);

sys/ufs/ffs/ffs_subr.c

590

FCHK(fs->fs_cstotal.cs_nifree, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

591

FCHK(fs->fs_cstotal.cs_nifree, >,

sys/ufs/ffs/ffs_subr.c

592

(uint64_t)fs->fs_ipg * fs->fs_ncg, %jd);

sys/ufs/ffs/ffs_subr.c

593

FCHK(fs->fs_cstotal.cs_ndir, >,

sys/ufs/ffs/ffs_subr.c

594

((uint64_t)fs->fs_ipg * fs->fs_ncg) -

sys/ufs/ffs/ffs_subr.c

595

fs->fs_cstotal.cs_nifree, %jd);

sys/ufs/ffs/ffs_subr.c

596

FCHK(fs->fs_size, <, 8 * fs->fs_frag, %jd);

sys/ufs/ffs/ffs_subr.c

597

FCHK(fs->fs_size, <=, ((int64_t)fs->fs_ncg - 1) * fs->fs_fpg,

sys/ufs/ffs/ffs_subr.c

599

FCHK(fs->fs_size, >, (int64_t)fs->fs_ncg * fs->fs_fpg, %jd);

sys/ufs/ffs/ffs_subr.c

600

FCHK(fs->fs_csaddr, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

601

FCHK(fs->fs_cssize, !=,

sys/ufs/ffs/ffs_subr.c

602

fragroundup(fs, fs->fs_ncg * sizeof(struct csum)), %jd);

sys/ufs/ffs/ffs_subr.c

603

FCHK(fs->fs_csaddr + howmany(fs->fs_cssize, fs->fs_fsize), >,

sys/ufs/ffs/ffs_subr.c

604

fs->fs_size, %jd);

sys/ufs/ffs/ffs_subr.c

605

FCHK(fs->fs_csaddr, <, cgdmin(fs, dtog(fs, fs->fs_csaddr)),

sys/ufs/ffs/ffs_subr.c

607

FCHK(dtog(fs, fs->fs_csaddr + howmany(fs->fs_cssize,

sys/ufs/ffs/ffs_subr.c

608

fs->fs_fsize)), >, dtog(fs, fs->fs_csaddr), %jd);

sys/ufs/ffs/ffs_subr.c

611

if (fs->fs_magic == FS_UFS2_MAGIC) {

sys/ufs/ffs/ffs_subr.c

613

FCHK2(fs->fs_sblockactualloc, !=, SBLOCK_UFS2,

sys/ufs/ffs/ffs_subr.c

614

fs->fs_sblockactualloc, !=, 0, %jd);

sys/ufs/ffs/ffs_subr.c

615

FCHK(fs->fs_sblockloc, !=, SBLOCK_UFS2, %#jx);

sys/ufs/ffs/ffs_subr.c

616

FCHK(fs->fs_maxsymlinklen, !=, ((UFS_NDADDR + UFS_NIADDR) *

sys/ufs/ffs/ffs_subr.c

618

FCHK(fs->fs_nindir, !=, fs->fs_bsize / sizeof(ufs2_daddr_t),

sys/ufs/ffs/ffs_subr.c

620

FCHK(fs->fs_inopb, !=,

sys/ufs/ffs/ffs_subr.c

621

fs->fs_bsize / sizeof(struct ufs2_dinode), %jd);

sys/ufs/ffs/ffs_subr.c

622

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

sys/ufs/ffs/ffs_subr.c

624

FCHK(fs->fs_sblockactualloc, >, SBLOCK_UFS1, %jd);

sys/ufs/ffs/ffs_subr.c

625

FCHK(fs->fs_sblockloc, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

626

FCHK(fs->fs_sblockloc, >, SBLOCK_UFS1, %jd);

sys/ufs/ffs/ffs_subr.c

627

FCHK(fs->fs_nindir, !=, fs->fs_bsize / sizeof(ufs1_daddr_t),

sys/ufs/ffs/ffs_subr.c

629

FCHK(fs->fs_inopb, !=,

sys/ufs/ffs/ffs_subr.c

630

fs->fs_bsize / sizeof(struct ufs1_dinode), %jd);

sys/ufs/ffs/ffs_subr.c

631

FCHK(fs->fs_maxsymlinklen, !=, ((UFS_NDADDR + UFS_NIADDR) *

sys/ufs/ffs/ffs_subr.c

633

WCHK(fs->fs_old_inodefmt, !=, FS_44INODEFMT, %jd);

sys/ufs/ffs/ffs_subr.c

634

WCHK(fs->fs_old_rotdelay, !=, 0, %jd);

sys/ufs/ffs/ffs_subr.c

635

WCHK(fs->fs_old_rps, !=, 60, %jd);

sys/ufs/ffs/ffs_subr.c

636

WCHK(fs->fs_old_nspf, !=, fs->fs_fsize / sectorsize, %jd);

sys/ufs/ffs/ffs_subr.c

637

WCHK(fs->fs_old_interleave, !=, 1, %jd);

sys/ufs/ffs/ffs_subr.c

638

WCHK(fs->fs_old_trackskew, !=, 0, %jd);

sys/ufs/ffs/ffs_subr.c

639

WCHK(fs->fs_old_cpc, !=, 0, %jd);

sys/ufs/ffs/ffs_subr.c

640

WCHK(fs->fs_old_postblformat, !=, 1, %jd);

sys/ufs/ffs/ffs_subr.c

641

FCHK(fs->fs_old_nrpos, !=, 1, %jd);

sys/ufs/ffs/ffs_subr.c

642

WCHK(fs->fs_old_nsect, !=, fs->fs_old_spc, %jd);

sys/ufs/ffs/ffs_subr.c

643

WCHK(fs->fs_old_npsect, !=, fs->fs_old_spc, %jd);

sys/ufs/ffs/ffs_subr.c

648

FCHK(fs->fs_bsize, <, MINBSIZE, %jd);

sys/ufs/ffs/ffs_subr.c

649

FCHK(fs->fs_bsize, >, MAXBSIZE, %jd);

sys/ufs/ffs/ffs_subr.c

650

FCHK(fs->fs_bsize, <, roundup(sizeof(struct fs), DEV_BSIZE), %jd);

sys/ufs/ffs/ffs_subr.c

651

FCHK(powerof2(fs->fs_bsize), ==, 0, %jd);

sys/ufs/ffs/ffs_subr.c

652

FCHK(fs->fs_frag, <, 1, %jd);

sys/ufs/ffs/ffs_subr.c

653

FCHK(fs->fs_frag, >, MAXFRAG, %jd);

sys/ufs/ffs/ffs_subr.c

654

FCHK(fs->fs_frag, !=, numfrags(fs, fs->fs_bsize), %jd);

sys/ufs/ffs/ffs_subr.c

655

FCHK(fs->fs_fsize, <, sectorsize, %jd);

sys/ufs/ffs/ffs_subr.c

656

FCHK(fs->fs_fsize * fs->fs_frag, !=, fs->fs_bsize, %jd);

sys/ufs/ffs/ffs_subr.c

657

FCHK(powerof2(fs->fs_fsize), ==, 0, %jd);

sys/ufs/ffs/ffs_subr.c

658

FCHK(fs->fs_fpg, <, 3 * fs->fs_frag, %jd);

sys/ufs/ffs/ffs_subr.c

659

FCHK(fs->fs_ncg, <, 1, %jd);

sys/ufs/ffs/ffs_subr.c

660

FCHK(fs->fs_ipg, <, fs->fs_inopb, %jd);

sys/ufs/ffs/ffs_subr.c

661

FCHK((uint64_t)fs->fs_ipg * fs->fs_ncg, >,

sys/ufs/ffs/ffs_subr.c

662

(((int64_t)(1)) << 32) - INOPB(fs), %jd);

sys/ufs/ffs/ffs_subr.c

663

FCHK(fs->fs_cstotal.cs_nifree, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

664

FCHK(fs->fs_cstotal.cs_nifree, >, (uint64_t)fs->fs_ipg * fs->fs_ncg,

sys/ufs/ffs/ffs_subr.c

666

FCHK(fs->fs_cstotal.cs_ndir, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

667

FCHK(fs->fs_cstotal.cs_ndir, >,

sys/ufs/ffs/ffs_subr.c

668

((uint64_t)fs->fs_ipg * fs->fs_ncg) - fs->fs_cstotal.cs_nifree,

sys/ufs/ffs/ffs_subr.c

670

FCHK(fs->fs_sbsize, >, SBLOCKSIZE, %jd);

sys/ufs/ffs/ffs_subr.c

671

FCHK(fs->fs_sbsize, <, (signed)sizeof(struct fs), %jd);

sys/ufs/ffs/ffs_subr.c

673

if (fs->fs_maxbsize == 0)

sys/ufs/ffs/ffs_subr.c

674

fs->fs_maxbsize = fs->fs_bsize;

sys/ufs/ffs/ffs_subr.c

675

FCHK(fs->fs_maxbsize, <, fs->fs_bsize, %jd);

sys/ufs/ffs/ffs_subr.c

676

FCHK(powerof2(fs->fs_maxbsize), ==, 0, %jd);

sys/ufs/ffs/ffs_subr.c

677

FCHK(fs->fs_maxbsize, >, FS_MAXCONTIG * fs->fs_bsize, %jd);

sys/ufs/ffs/ffs_subr.c

678

FCHK(fs->fs_bmask, !=, ~(fs->fs_bsize - 1), %#jx);

sys/ufs/ffs/ffs_subr.c

679

FCHK(fs->fs_fmask, !=, ~(fs->fs_fsize - 1), %#jx);

sys/ufs/ffs/ffs_subr.c

680

FCHK(fs->fs_qbmask, !=, ~fs->fs_bmask, %#jx);

sys/ufs/ffs/ffs_subr.c

681

FCHK(fs->fs_qfmask, !=, ~fs->fs_fmask, %#jx);

sys/ufs/ffs/ffs_subr.c

682

FCHK(fs->fs_bshift, !=, ILOG2(fs->fs_bsize), %jd);

sys/ufs/ffs/ffs_subr.c

683

FCHK(fs->fs_fshift, !=, ILOG2(fs->fs_fsize), %jd);

sys/ufs/ffs/ffs_subr.c

684

FCHK(fs->fs_fragshift, !=, ILOG2(fs->fs_frag), %jd);

sys/ufs/ffs/ffs_subr.c

685

FCHK(fs->fs_fsbtodb, !=, ILOG2(fs->fs_fsize / sectorsize), %jd);

sys/ufs/ffs/ffs_subr.c

686

FCHK(fs->fs_old_cgoffset, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

687

FCHK2(fs->fs_old_cgoffset, >, 0, ~fs->fs_old_cgmask, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

688

FCHK(fs->fs_old_cgoffset * (~fs->fs_old_cgmask), >, fs->fs_fpg, %jd);

sys/ufs/ffs/ffs_subr.c

689

FCHK(CGSIZE(fs), >, fs->fs_bsize, %jd);

sys/ufs/ffs/ffs_subr.c

697

FCHK(fs->fs_sbsize % sectorsize, !=, 0, %jd);

sys/ufs/ffs/ffs_subr.c

698

FCHK(fs->fs_ipg % fs->fs_inopb, !=, 0, %jd);

sys/ufs/ffs/ffs_subr.c

699

FCHK(fs->fs_sblkno, !=, roundup(

sys/ufs/ffs/ffs_subr.c

700

howmany(fs->fs_sblockloc + SBLOCKSIZE, fs->fs_fsize),

sys/ufs/ffs/ffs_subr.c

701

fs->fs_frag), %jd);

sys/ufs/ffs/ffs_subr.c

702

FCHK(fs->fs_cblkno, !=, fs->fs_sblkno +

sys/ufs/ffs/ffs_subr.c

703

roundup(howmany(SBLOCKSIZE, fs->fs_fsize), fs->fs_frag), %jd);

sys/ufs/ffs/ffs_subr.c

704

FCHK(fs->fs_iblkno, !=, fs->fs_cblkno + fs->fs_frag, %jd);

sys/ufs/ffs/ffs_subr.c

705

FCHK(fs->fs_dblkno, !=, fs->fs_iblkno + fs->fs_ipg / INOPF(fs), %jd);

sys/ufs/ffs/ffs_subr.c

706

FCHK(fs->fs_cgsize, >, fs->fs_bsize, %jd);

sys/ufs/ffs/ffs_subr.c

707

FCHK(fs->fs_cgsize, <, fs->fs_fsize, %jd);

sys/ufs/ffs/ffs_subr.c

708

FCHK(fs->fs_cgsize % fs->fs_fsize, !=, 0, %jd);

sys/ufs/ffs/ffs_subr.c

715

WCHK(fs->fs_dsize, !=, fs->fs_size - fs->fs_sblkno -

sys/ufs/ffs/ffs_subr.c

716

fs->fs_ncg * (fs->fs_dblkno - fs->fs_sblkno) -

sys/ufs/ffs/ffs_subr.c

717

howmany(fs->fs_cssize, fs->fs_fsize), %jd);

sys/ufs/ffs/ffs_subr.c

719

WCHK(fs->fs_metaspace, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

720

WCHK(fs->fs_metaspace, >, fs->fs_fpg / 2, %jd);

sys/ufs/ffs/ffs_subr.c

721

WCHK(fs->fs_minfree, >, 99, %jd%%);

sys/ufs/ffs/ffs_subr.c

722

maxfilesize = fs->fs_bsize * UFS_NDADDR - 1;

sys/ufs/ffs/ffs_subr.c

723

for (sizepb = fs->fs_bsize, i = 0; i < UFS_NIADDR; i++) {

sys/ufs/ffs/ffs_subr.c

724

sizepb *= NINDIR(fs);

sys/ufs/ffs/ffs_subr.c

727

WCHK(fs->fs_maxfilesize, >, maxfilesize, %jd);

sys/ufs/ffs/ffs_subr.c

739

FCHK(fs->fs_size, <, 8 * fs->fs_frag, %jd);

sys/ufs/ffs/ffs_subr.c

740

FCHK(fs->fs_size, <=, ((int64_t)fs->fs_ncg - 1) * fs->fs_fpg, %jd);

sys/ufs/ffs/ffs_subr.c

741

FCHK(fs->fs_size, >, (int64_t)fs->fs_ncg * fs->fs_fpg, %jd);

sys/ufs/ffs/ffs_subr.c

749

FCHK(fs->fs_csaddr, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

750

FCHK(fs->fs_cssize, !=,

sys/ufs/ffs/ffs_subr.c

751

fragroundup(fs, fs->fs_ncg * sizeof(struct csum)), %jd);

sys/ufs/ffs/ffs_subr.c

752

FCHK(fs->fs_csaddr + howmany(fs->fs_cssize, fs->fs_fsize), >,

sys/ufs/ffs/ffs_subr.c

753

fs->fs_size, %jd);

sys/ufs/ffs/ffs_subr.c

754

FCHK(fs->fs_csaddr, <, cgdmin(fs, dtog(fs, fs->fs_csaddr)), %jd);

sys/ufs/ffs/ffs_subr.c

755

FCHK(dtog(fs, fs->fs_csaddr + howmany(fs->fs_cssize, fs->fs_fsize)), >,

sys/ufs/ffs/ffs_subr.c

756

dtog(fs, fs->fs_csaddr), %jd);

sys/ufs/ffs/ffs_subr.c

776

WCHK(fs->fs_maxcontig, <, 0, %jd);

sys/ufs/ffs/ffs_subr.c

777

WCHK(fs->fs_maxcontig, >, MAX(256, maxphys / fs->fs_bsize), %jd);

sys/ufs/ffs/ffs_subr.c

778

FCHK2(fs->fs_maxcontig, ==, 0, fs->fs_contigsumsize, !=, 0, %jd);

sys/ufs/ffs/ffs_subr.c

779

FCHK2(fs->fs_maxcontig, >, 1, fs->fs_contigsumsize, !=,

sys/ufs/ffs/ffs_subr.c

780

MIN(fs->fs_maxcontig, FS_MAXCONTIG), %jd);

sys/ufs/ffs/ffs_subr.c

799

ffs_sbsearch(void *devfd, struct fs **fsp, int reqflags,

sys/ufs/ffs/ffs_subr.c

804

struct fs *protofs;

sys/ufs/ffs/ffs_subr.c

82

ffs_verify_dinode_ckhash(struct fs *fs, struct ufs2_dinode *dip)

sys/ufs/ffs/ffs_subr.c

89

if (dip->di_mode == 0 || (fs->fs_metackhash & CK_INODE) == 0)

sys/ufs/ffs/ffs_subr.c

893

memset(protofs, 0, sizeof(struct fs));

sys/ufs/ffs/ffs_subr.c

954

ffs_sbput(void *devfd, struct fs *fs, off_t loc,

sys/ufs/ffs/ffs_subr.c

965

if (fs->fs_si != NULL && fs->fs_csp != NULL) {

sys/ufs/ffs/ffs_subr.c

966

blks = howmany(fs->fs_cssize, fs->fs_fsize);

sys/ufs/ffs/ffs_subr.c

967

space = (uint8_t *)fs->fs_csp;

sys/ufs/ffs/ffs_subr.c

968

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

sys/ufs/ffs/ffs_subr.c

969

size = fs->fs_bsize;

sys/ufs/ffs/ffs_subr.c

970

if (i + fs->fs_frag > blks)

sys/ufs/ffs/ffs_subr.c

971

size = (blks - i) * fs->fs_fsize;

sys/ufs/ffs/ffs_subr.c

973

dbtob(fsbtodb(fs, fs->fs_csaddr + i)),

sys/ufs/ffs/ffs_subr.c

979

fs->fs_fmod = 0;

sys/ufs/ffs/ffs_subr.c

980

ffs_oldfscompat_write(fs);

sys/ufs/ffs/ffs_subr.c

982

fs->fs_time = time_second;

sys/ufs/ffs/ffs_subr.c

984

fs->fs_time = time(NULL);

sys/ufs/ffs/ffs_subr.c

987

fs_si = fs->fs_si;

sys/ufs/ffs/ffs_subr.c

988

fs->fs_si = NULL;

sys/ufs/ffs/ffs_subr.c

989

fs->fs_ckhash = ffs_calc_sbhash(fs);

sys/ufs/ffs/ffs_subr.c

990

error = (*writefunc)(devfd, loc, fs, fs->fs_sbsize);

sys/ufs/ffs/ffs_suspend.c

100

struct fs *fs;

sys/ufs/ffs/ffs_suspend.c

112

fs = ump->um_fs;

sys/ufs/ffs/ffs_suspend.c

130

if (len > fs->fs_bsize)

sys/ufs/ffs/ffs_suspend.c

131

len = fs->fs_bsize;

sys/ufs/ffs/ffs_suspend.c

132

if (fragoff(fs, uio->uio_offset) != 0 ||

sys/ufs/ffs/ffs_suspend.c

133

fragoff(fs, len) != 0) {

sys/ufs/ffs/ffs_vfsops.c

1015

fs->fs_ronly = ronly;

sys/ufs/ffs/ffs_vfsops.c

1016

fs->fs_active = NULL;

sys/ufs/ffs/ffs_vfsops.c

1018

mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0];

sys/ufs/ffs/ffs_vfsops.c

1019

mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];

sys/ufs/ffs/ffs_vfsops.c

1021

if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 ||

sys/ufs/ffs/ffs_vfsops.c

1027

ump->um_bsize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

1028

ump->um_maxsymlinklen = fs->fs_maxsymlinklen;

sys/ufs/ffs/ffs_vfsops.c

1032

if ((fs->fs_flags & FS_MULTILABEL) != 0) {

sys/ufs/ffs/ffs_vfsops.c

1042

if ((fs->fs_flags & FS_ACLS) != 0) {

sys/ufs/ffs/ffs_vfsops.c

1059

if ((fs->fs_flags & FS_NFS4ACLS) != 0) {

sys/ufs/ffs/ffs_vfsops.c

1076

if ((fs->fs_flags & FS_TRIM) != 0) {

sys/ufs/ffs/ffs_vfsops.c

1111

ump->um_nindir = fs->fs_nindir;

sys/ufs/ffs/ffs_vfsops.c

1112

ump->um_bptrtodb = fs->fs_fsbtodb;

sys/ufs/ffs/ffs_vfsops.c

1113

ump->um_seqinc = fs->fs_frag;

sys/ufs/ffs/ffs_vfsops.c

1122

bzero(fs->fs_fsmnt, MAXMNTLEN);

sys/ufs/ffs/ffs_vfsops.c

1123

strlcpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname, MAXMNTLEN);

sys/ufs/ffs/ffs_vfsops.c

1124

mp->mnt_stat.f_iosize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

1132

mp->mnt_time = fs->fs_time;

sys/ufs/ffs/ffs_vfsops.c

1136

fs->fs_mtime = time_second;

sys/ufs/ffs/ffs_vfsops.c

1137

if ((fs->fs_flags & FS_DOSOFTDEP) &&

sys/ufs/ffs/ffs_vfsops.c

1138

(error = softdep_mount(devvp, mp, fs, cred)) != 0) {

sys/ufs/ffs/ffs_vfsops.c

1142

if (fs->fs_snapinum[0] != 0)

sys/ufs/ffs/ffs_vfsops.c

1144

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_vfsops.c

1145

fs->fs_clean = 0;

sys/ufs/ffs/ffs_vfsops.c

1172

if (fs != NULL) {

sys/ufs/ffs/ffs_vfsops.c

1173

free(fs->fs_csp, M_UFSMNT);

sys/ufs/ffs/ffs_vfsops.c

1174

free(fs->fs_si, M_UFSMNT);

sys/ufs/ffs/ffs_vfsops.c

1175

free(fs, M_UFSMNT);

sys/ufs/ffs/ffs_vfsops.c

1230

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

1238

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

1241

susp = fs->fs_ronly == 0;

sys/ufs/ffs/ffs_vfsops.c

1267

if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {

sys/ufs/ffs/ffs_vfsops.c

1269

"files %d\n", fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,

sys/ufs/ffs/ffs_vfsops.c

1270

fs->fs_pendinginodes);

sys/ufs/ffs/ffs_vfsops.c

1271

fs->fs_pendingblocks = 0;

sys/ufs/ffs/ffs_vfsops.c

1272

fs->fs_pendinginodes = 0;

sys/ufs/ffs/ffs_vfsops.c

1278

if (fs->fs_ronly == 0) {

sys/ufs/ffs/ffs_vfsops.c

1279

fs->fs_clean = fs->fs_flags & (FS_UNCLEAN|FS_NEEDSFSCK) ? 0 : 1;

sys/ufs/ffs/ffs_vfsops.c

1284

fs->fs_clean = 0;

sys/ufs/ffs/ffs_vfsops.c

1311

free(fs->fs_csp, M_UFSMNT);

sys/ufs/ffs/ffs_vfsops.c

1312

free(fs->fs_si, M_UFSMNT);

sys/ufs/ffs/ffs_vfsops.c

1313

free(fs, M_UFSMNT);

sys/ufs/ffs/ffs_vfsops.c

1428

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

1431

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

1432

if (fs->fs_magic != FS_UFS1_MAGIC && fs->fs_magic != FS_UFS2_MAGIC)

sys/ufs/ffs/ffs_vfsops.c

1435

sbp->f_bsize = fs->fs_fsize;

sys/ufs/ffs/ffs_vfsops.c

1436

sbp->f_iosize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

1437

sbp->f_blocks = fs->fs_dsize;

sys/ufs/ffs/ffs_vfsops.c

1439

sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +

sys/ufs/ffs/ffs_vfsops.c

1440

fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);

sys/ufs/ffs/ffs_vfsops.c

1441

sbp->f_bavail = freespace(fs, fs->fs_minfree) +

sys/ufs/ffs/ffs_vfsops.c

1442

dbtofsb(fs, fs->fs_pendingblocks);

sys/ufs/ffs/ffs_vfsops.c

1443

sbp->f_files = fs->fs_ncg * fs->fs_ipg - UFS_ROOTINO;

sys/ufs/ffs/ffs_vfsops.c

1444

sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;

sys/ufs/ffs/ffs_vfsops.c

1546

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

1559

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

1560

if (fs->fs_fmod != 0 && fs->fs_ronly != 0)

sys/ufs/ffs/ffs_vfsops.c

1562

fs->fs_fsmnt);

sys/ufs/ffs/ffs_vfsops.c

162

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

1676

if (fs->fs_fmod != 0 &&

sys/ufs/ffs/ffs_vfsops.c

168

fs = ITOFS(ip);

sys/ufs/ffs/ffs_vfsops.c

169

lbn = lblkno(fs, offset);

sys/ufs/ffs/ffs_vfsops.c

1697

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

170

bsize = blksize(fs, ip, lbn);

sys/ufs/ffs/ffs_vfsops.c

1737

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

1741

error = getnewvnode("ufs", mp, fs->fs_magic == FS_UFS1_MAGIC ?

sys/ufs/ffs/ffs_vfsops.c

1754

vp->v_bufobj.bo_bsize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

1760

ip->i_flag = fs->fs_magic == FS_UFS1_MAGIC ? 0 : IN_UFS2;

sys/ufs/ffs/ffs_vfsops.c

178

*res = (char *)bp->b_data + blkoff(fs, offset);

sys/ufs/ffs/ffs_vfsops.c

1810

dbn = fsbtodb(fs, ino_to_fsba(fs, ino));

sys/ufs/ffs/ffs_vfsops.c

1812

(int)fs->fs_bsize, NULL, NULL, 0, NOCRED, 0, NULL, &bp);

sys/ufs/ffs/ffs_vfsops.c

1825

if ((error = ffs_load_inode(bp, ip, fs, ino)) != 0) {

sys/ufs/ffs/ffs_vfsops.c

1834

if (DOINGSOFTDEP(vp) && (!fs->fs_ronly ||

sys/ufs/ffs/ffs_vfsops.c

188

ffs_load_inode(struct buf *bp, struct inode *ip, struct fs *fs, ino_t ino)

sys/ufs/ffs/ffs_vfsops.c

1933

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

1939

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

1942

if (ino < UFS_ROOTINO || ino >= fs->fs_ncg * fs->fs_ipg)

sys/ufs/ffs/ffs_vfsops.c

1949

if (fs->fs_magic == FS_UFS2_MAGIC) {

sys/ufs/ffs/ffs_vfsops.c

1950

cg = ino_to_cg(fs, ino);

sys/ufs/ffs/ffs_vfsops.c

1951

if (ffs_getcg(fs, ump->um_devvp, cg, 0, &bp, &cgp) != 0)

sys/ufs/ffs/ffs_vfsops.c

1953

if (ino >= cg * fs->fs_ipg + cgp->cg_initediblk) {

sys/ufs/ffs/ffs_vfsops.c

197

*((struct ufs1_dinode *)bp->b_data + ino_to_fsbo(fs, ino));

sys/ufs/ffs/ffs_vfsops.c

2021

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

2025

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

2026

if (fs->fs_ronly == 1 &&

sys/ufs/ffs/ffs_vfsops.c

2034

sbbp = getblk(ump->um_devvp, btodb(fs->fs_sblockloc),

sys/ufs/ffs/ffs_vfsops.c

2035

(int)fs->fs_sbsize, 0, 0, 0);

sys/ufs/ffs/ffs_vfsops.c

2037

fs->fs_fmod = 0;

sys/ufs/ffs/ffs_vfsops.c

2038

bcopy((caddr_t)fs, sbbp->b_data, (uint64_t)fs->fs_sbsize);

sys/ufs/ffs/ffs_vfsops.c

2040

fs = (struct fs *)sbbp->b_data;

sys/ufs/ffs/ffs_vfsops.c

2049

return (ffs_sbput(&devfd, fs, fs->fs_sblockloc, ffs_use_bwrite));

sys/ufs/ffs/ffs_vfsops.c

206

if (ffs_oldfscompat_inode_read(fs, ip->i_dp, time_second) &&

sys/ufs/ffs/ffs_vfsops.c

2061

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

2067

fs = (struct fs *)bp->b_data;

sys/ufs/ffs/ffs_vfsops.c

207

fs->fs_ronly == 0)

sys/ufs/ffs/ffs_vfsops.c

2071

if (loc != fs->fs_sblockloc) {

sys/ufs/ffs/ffs_vfsops.c

2097

softdep_setup_sbupdate(ump, fs, bp);

sys/ufs/ffs/ffs_vfsops.c

211

dip2 = ((struct ufs2_dinode *)bp->b_data + ino_to_fsbo(fs, ino));

sys/ufs/ffs/ffs_vfsops.c

212

if ((error = ffs_verify_dinode_ckhash(fs, dip2)) != 0 &&

sys/ufs/ffs/ffs_vfsops.c

214

printf("%s: inode %jd: check-hash failed\n", fs->fs_fsmnt,

sys/ufs/ffs/ffs_vfsops.c

228

if (ffs_oldfscompat_inode_read(fs, ip->i_dp, time_second) &&

sys/ufs/ffs/ffs_vfsops.c

229

fs->fs_ronly == 0)

sys/ufs/ffs/ffs_vfsops.c

241

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

249

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

250

cg = dtog(fs, daddr);

sys/ufs/ffs/ffs_vfsops.c

251

end_daddr = daddr + numfrags(fs, blksize);

sys/ufs/ffs/ffs_vfsops.c

264

((uint64_t)end_daddr <= fs->fs_size &&

sys/ufs/ffs/ffs_vfsops.c

265

((cg > 0 && end_daddr <= cgsblock(fs, cg)) ||

sys/ufs/ffs/ffs_vfsops.c

266

(daddr >= cgdmin(fs, cg) &&

sys/ufs/ffs/ffs_vfsops.c

267

end_daddr <= cgbase(fs, cg) + fs->fs_fpg))))

sys/ufs/ffs/ffs_vfsops.c

352

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

489

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

502

if (fs->fs_ronly == 0 &&

sys/ufs/ffs/ffs_vfsops.c

513

fs->fs_ronly = 1;

sys/ufs/ffs/ffs_vfsops.c

535

fs->fs_ronly = 0;

sys/ufs/ffs/ffs_vfsops.c

545

if (fs->fs_pendingblocks != 0 ||

sys/ufs/ffs/ffs_vfsops.c

546

fs->fs_pendinginodes != 0) {

sys/ufs/ffs/ffs_vfsops.c

548

"files %d\n", fs->fs_fsmnt,

sys/ufs/ffs/ffs_vfsops.c

549

(intmax_t)fs->fs_pendingblocks,

sys/ufs/ffs/ffs_vfsops.c

550

fs->fs_pendinginodes);

sys/ufs/ffs/ffs_vfsops.c

551

fs->fs_pendingblocks = 0;

sys/ufs/ffs/ffs_vfsops.c

552

fs->fs_pendinginodes = 0;

sys/ufs/ffs/ffs_vfsops.c

554

if ((fs->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) == 0)

sys/ufs/ffs/ffs_vfsops.c

555

fs->fs_clean = 1;

sys/ufs/ffs/ffs_vfsops.c

557

fs->fs_ronly = 0;

sys/ufs/ffs/ffs_vfsops.c

558

fs->fs_clean = 0;

sys/ufs/ffs/ffs_vfsops.c

589

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

591

if (fs->fs_ronly &&

sys/ufs/ffs/ffs_vfsops.c

606

fs->fs_flags &= ~FS_UNCLEAN;

sys/ufs/ffs/ffs_vfsops.c

607

if (fs->fs_clean == 0) {

sys/ufs/ffs/ffs_vfsops.c

608

fs->fs_flags |= FS_UNCLEAN;

sys/ufs/ffs/ffs_vfsops.c

610

((fs->fs_flags &

sys/ufs/ffs/ffs_vfsops.c

612

(fs->fs_flags & FS_DOSOFTDEP))) {

sys/ufs/ffs/ffs_vfsops.c

621

(fs->fs_flags & FS_SUJ) == 0 ? "" :

sys/ufs/ffs/ffs_vfsops.c

640

fs->fs_ronly = 0;

sys/ufs/ffs/ffs_vfsops.c

648

fs->fs_mtime = time_second;

sys/ufs/ffs/ffs_vfsops.c

650

if ((fs->fs_flags & FS_DOSOFTDEP) &&

sys/ufs/ffs/ffs_vfsops.c

651

(error = softdep_mount(devvp, mp, fs, td->td_ucred))){

sys/ufs/ffs/ffs_vfsops.c

652

fs->fs_ronly = 1;

sys/ufs/ffs/ffs_vfsops.c

659

fs->fs_clean = 0;

sys/ufs/ffs/ffs_vfsops.c

661

fs->fs_ronly = 1;

sys/ufs/ffs/ffs_vfsops.c

662

if ((fs->fs_flags & FS_DOSOFTDEP) != 0)

sys/ufs/ffs/ffs_vfsops.c

670

if (fs->fs_snapinum[0] != 0)

sys/ufs/ffs/ffs_vfsops.c

690

if ((fs->fs_flags & FS_ACLS) != 0) {

sys/ufs/ffs/ffs_vfsops.c

697

if ((fs->fs_flags & FS_NFS4ACLS) != 0) {

sys/ufs/ffs/ffs_vfsops.c

762

struct fs *fs, *newfs;

sys/ufs/ffs/ffs_vfsops.c

794

fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_vfsops.c

795

newfs->fs_ronly = fs->fs_ronly;

sys/ufs/ffs/ffs_vfsops.c

796

free(fs->fs_csp, M_UFSMNT);

sys/ufs/ffs/ffs_vfsops.c

797

free(fs->fs_si, M_UFSMNT);

sys/ufs/ffs/ffs_vfsops.c

798

free(fs, M_UFSMNT);

sys/ufs/ffs/ffs_vfsops.c

799

fs = VFSTOUFS(mp)->um_fs = newfs;

sys/ufs/ffs/ffs_vfsops.c

800

ump->um_bsize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

801

ump->um_maxsymlinklen = fs->fs_maxsymlinklen;

sys/ufs/ffs/ffs_vfsops.c

803

if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {

sys/ufs/ffs/ffs_vfsops.c

806

(intmax_t)fs->fs_pendingblocks, fs->fs_pendinginodes);

sys/ufs/ffs/ffs_vfsops.c

807

fs->fs_pendingblocks = 0;

sys/ufs/ffs/ffs_vfsops.c

808

fs->fs_pendinginodes = 0;

sys/ufs/ffs/ffs_vfsops.c

845

bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),

sys/ufs/ffs/ffs_vfsops.c

846

(int)fs->fs_bsize, NOCRED, &bp);

sys/ufs/ffs/ffs_vfsops.c

852

if ((error = ffs_load_inode(bp, ip, fs, ip->i_number)) != 0) {

sys/ufs/ffs/ffs_vfsops.c

872

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

881

fs = NULL;

sys/ufs/ffs/ffs_vfsops.c

922

error = ffs_sbsearch(devvp, &fs, 0, M_UFSMNT, ffs_use_bread);

sys/ufs/ffs/ffs_vfsops.c

924

error = ffs_sbget(devvp, &fs, UFS_STDSB, 0, M_UFSMNT,

sys/ufs/ffs/ffs_vfsops.c

928

fs->fs_flags &= ~FS_UNCLEAN;

sys/ufs/ffs/ffs_vfsops.c

929

if (fs->fs_clean == 0) {

sys/ufs/ffs/ffs_vfsops.c

930

fs->fs_flags |= FS_UNCLEAN;

sys/ufs/ffs/ffs_vfsops.c

932

((fs->fs_flags & (FS_SUJ | FS_NEEDSFSCK)) == 0 &&

sys/ufs/ffs/ffs_vfsops.c

933

(fs->fs_flags & FS_DOSOFTDEP))) {

sys/ufs/ffs/ffs_vfsops.c

940

(fs->fs_flags & FS_SUJ) == 0 ? "" :

sys/ufs/ffs/ffs_vfsops.c

945

if ((fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) &&

sys/ufs/ffs/ffs_vfsops.c

949

(intmax_t)fs->fs_pendingblocks,

sys/ufs/ffs/ffs_vfsops.c

950

fs->fs_pendinginodes);

sys/ufs/ffs/ffs_vfsops.c

951

fs->fs_pendingblocks = 0;

sys/ufs/ffs/ffs_vfsops.c

952

fs->fs_pendinginodes = 0;

sys/ufs/ffs/ffs_vfsops.c

955

if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {

sys/ufs/ffs/ffs_vfsops.c

958

(intmax_t)fs->fs_pendingblocks, fs->fs_pendinginodes);

sys/ufs/ffs/ffs_vfsops.c

959

fs->fs_pendingblocks = 0;

sys/ufs/ffs/ffs_vfsops.c

960

fs->fs_pendinginodes = 0;

sys/ufs/ffs/ffs_vfsops.c

962

if ((fs->fs_flags & FS_GJOURNAL) != 0) {

sys/ufs/ffs/ffs_vfsops.c

994

ump->um_fs = fs;

sys/ufs/ffs/ffs_vfsops.c

995

if (fs->fs_magic == FS_UFS1_MAGIC) {

sys/ufs/ffs/ffs_vnops.c

1005

} else if (xfersize + blkoffset == fs->fs_bsize) {

sys/ufs/ffs/ffs_vnops.c

1064

struct fs *fs;

sys/ufs/ffs/ffs_vnops.c

1073

fs = ITOFS(ip);

sys/ufs/ffs/ffs_vnops.c

1077

if (uio->uio_rw != UIO_READ || fs->fs_magic != FS_UFS2_MAGIC)

sys/ufs/ffs/ffs_vnops.c

1090

lbn = lblkno(fs, uio->uio_offset);

sys/ufs/ffs/ffs_vnops.c

1099

size = sblksize(fs, dp->di_extsize, lbn);

sys/ufs/ffs/ffs_vnops.c

1100

blkoffset = blkoff(fs, uio->uio_offset);

sys/ufs/ffs/ffs_vnops.c

1107

xfersize = fs->fs_bsize - blkoffset;

sys/ufs/ffs/ffs_vnops.c

1119

if (lblktosize(fs, nextlbn) >= dp->di_extsize) {

sys/ufs/ffs/ffs_vnops.c

1132

int nextsize = sblksize(fs, dp->di_extsize, nextlbn);

sys/ufs/ffs/ffs_vnops.c

1183

struct fs *fs;

sys/ufs/ffs/ffs_vnops.c

1191

fs = ITOFS(ip);

sys/ufs/ffs/ffs_vnops.c

1195

if (uio->uio_rw != UIO_WRITE || fs->fs_magic != FS_UFS2_MAGIC)

sys/ufs/ffs/ffs_vnops.c

1204

UFS_NXADDR * fs->fs_bsize)

sys/ufs/ffs/ffs_vnops.c

1214

lbn = lblkno(fs, uio->uio_offset);

sys/ufs/ffs/ffs_vnops.c

1215

blkoffset = blkoff(fs, uio->uio_offset);

sys/ufs/ffs/ffs_vnops.c

1216

xfersize = fs->fs_bsize - blkoffset;

sys/ufs/ffs/ffs_vnops.c

1224

if (fs->fs_bsize > xfersize)

sys/ufs/ffs/ffs_vnops.c

1239

if ((bp->b_flags & B_CACHE) == 0 && fs->fs_bsize <= xfersize)

sys/ufs/ffs/ffs_vnops.c

1247

size = sblksize(fs, dp->di_extsize, lbn) - bp->b_resid;

sys/ufs/ffs/ffs_vnops.c

1267

xfersize + blkoffset == fs->fs_bsize ||

sys/ufs/ffs/ffs_vnops.c

1339

struct fs *fs;

sys/ufs/ffs/ffs_vnops.c

1347

fs = ITOFS(ip);

sys/ufs/ffs/ffs_vnops.c

1350

if ((uoff_t)easize > UFS_NXADDR * fs->fs_bsize)

sys/ufs/ffs/ffs_vnops.c

1794

struct fs *fs;

sys/ufs/ffs/ffs_vnops.c

1804

fs = ITOFS(ip);

sys/ufs/ffs/ffs_vnops.c

1819

if (ealen < 0 || ealen > lblktosize(fs, UFS_NXADDR))

sys/ufs/ffs/ffs_vnops.c

1876

if (easize > lblktosize(fs, UFS_NXADDR)) {

sys/ufs/ffs/ffs_vnops.c

650

struct fs *fs;

sys/ufs/ffs/ffs_vnops.c

695

fs = ITOFS(ip);

sys/ufs/ffs/ffs_vnops.c

697

uio->uio_offset >= fs->fs_maxfilesize)

sys/ufs/ffs/ffs_vnops.c

707

lbn = lblkno(fs, uio->uio_offset);

sys/ufs/ffs/ffs_vnops.c

716

size = blksize(fs, ip, lbn);

sys/ufs/ffs/ffs_vnops.c

717

blkoffset = blkoff(fs, uio->uio_offset);

sys/ufs/ffs/ffs_vnops.c

724

xfersize = fs->fs_bsize - blkoffset;

sys/ufs/ffs/ffs_vnops.c

736

if (lblktosize(fs, nextlbn) >= ip->i_size) {

sys/ufs/ffs/ffs_vnops.c

761

int nextsize = blksize(fs, ip, nextlbn);

sys/ufs/ffs/ffs_vnops.c

841

struct fs *fs;

sys/ufs/ffs/ffs_vnops.c

893

fs = ITOFS(ip);

sys/ufs/ffs/ffs_vnops.c

899

error = vn_rlimit_fsizex(vp, uio, fs->fs_maxfilesize, &r,

sys/ufs/ffs/ffs_vnops.c

917

lbn = lblkno(fs, uio->uio_offset);

sys/ufs/ffs/ffs_vnops.c

918

blkoffset = blkoff(fs, uio->uio_offset);

sys/ufs/ffs/ffs_vnops.c

919

xfersize = fs->fs_bsize - blkoffset;

sys/ufs/ffs/ffs_vnops.c

929

if (fs->fs_bsize > xfersize)

sys/ufs/ffs/ffs_vnops.c

949

size = blksize(fs, ip, lbn) - bp->b_resid;

sys/ufs/ffs/ffs_vnops.c

979

fs->fs_bsize == xfersize) {

sys/ufs/ffs/fs.h

451

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

sys/ufs/ffs/fs.h

557

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

sys/ufs/ffs/fs.h

559

#define ACTIVESET(fs, cg) do { \

sys/ufs/ffs/fs.h

560

if ((fs)->fs_active) \

sys/ufs/ffs/fs.h

561

ACTIVECGNUM((fs), (cg)) |= ACTIVECGOFF((cg)); \

sys/ufs/ffs/fs.h

563

#define ACTIVECLEAR(fs, cg) do { \

sys/ufs/ffs/fs.h

564

if ((fs)->fs_active) \

sys/ufs/ffs/fs.h

565

ACTIVECGNUM((fs), (cg)) &= ~ACTIVECGOFF((cg)); \

sys/ufs/ffs/fs.h

574

#define CGSIZE(fs) \

sys/ufs/ffs/fs.h

576

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

sys/ufs/ffs/fs.h

577

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

sys/ufs/ffs/fs.h

578

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

sys/ufs/ffs/fs.h

579

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

sys/ufs/ffs/fs.h

580

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

sys/ufs/ffs/fs.h

581

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

sys/ufs/ffs/fs.h

582

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

sys/ufs/ffs/fs.h

592

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

sys/ufs/ffs/fs.h

646

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

sys/ufs/ffs/fs.h

647

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

sys/ufs/ffs/fs.h

653

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

sys/ufs/ffs/fs.h

654

#define cgdata(fs, c) (cgdmin(fs, c) + (fs)->fs_metaspace) /* data zone */

sys/ufs/ffs/fs.h

655

#define cgmeta(fs, c) (cgdmin(fs, c)) /* meta data */

sys/ufs/ffs/fs.h

656

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

sys/ufs/ffs/fs.h

657

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

sys/ufs/ffs/fs.h

658

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

sys/ufs/ffs/fs.h

659

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

sys/ufs/ffs/fs.h

660

#define cgstart(fs, c) \

sys/ufs/ffs/fs.h

661

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

sys/ufs/ffs/fs.h

662

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

sys/ufs/ffs/fs.h

670

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

sys/ufs/ffs/fs.h

671

#define ino_to_fsba(fs, x) \

sys/ufs/ffs/fs.h

672

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

sys/ufs/ffs/fs.h

673

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

sys/ufs/ffs/fs.h

674

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

sys/ufs/ffs/fs.h

680

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

sys/ufs/ffs/fs.h

681

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

sys/ufs/ffs/fs.h

687

#define blkmap(fs, map, loc) \

sys/ufs/ffs/fs.h

688

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

sys/ufs/ffs/fs.h

695

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

sys/ufs/ffs/fs.h

696

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

sys/ufs/ffs/fs.h

697

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

sys/ufs/ffs/fs.h

698

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

sys/ufs/ffs/fs.h

699

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

sys/ufs/ffs/fs.h

700

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

sys/ufs/ffs/fs.h

701

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

sys/ufs/ffs/fs.h

702

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

sys/ufs/ffs/fs.h

704

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

sys/ufs/ffs/fs.h

705

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

sys/ufs/ffs/fs.h

706

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

sys/ufs/ffs/fs.h

707

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

sys/ufs/ffs/fs.h

708

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

sys/ufs/ffs/fs.h

709

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

sys/ufs/ffs/fs.h

710

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

sys/ufs/ffs/fs.h

711

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

sys/ufs/ffs/fs.h

712

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

sys/ufs/ffs/fs.h

713

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

sys/ufs/ffs/fs.h

714

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

sys/ufs/ffs/fs.h

715

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

sys/ufs/ffs/fs.h

716

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

sys/ufs/ffs/fs.h

717

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

sys/ufs/ffs/fs.h

718

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

sys/ufs/ffs/fs.h

719

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

sys/ufs/ffs/fs.h

720

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

sys/ufs/ffs/fs.h

721

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

sys/ufs/ffs/fs.h

727

#define freespace(fs, percentreserved) \

sys/ufs/ffs/fs.h

728

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

sys/ufs/ffs/fs.h

729

(fs)->fs_cstotal.cs_nffree - \

sys/ufs/ffs/fs.h

730

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

sys/ufs/ffs/fs.h

735

#define blksize(fs, ip, lbn) \

sys/ufs/ffs/fs.h

737

(uint64_t)smalllblktosize(fs, (lbn) + 1)) \

sys/ufs/ffs/fs.h

738

? (fs)->fs_bsize \

sys/ufs/ffs/fs.h

739

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

sys/ufs/ffs/fs.h

740

#define sblksize(fs, size, lbn) \

sys/ufs/ffs/fs.h

741

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

sys/ufs/ffs/fs.h

742

? (fs)->fs_bsize \

sys/ufs/ffs/fs.h

743

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

sys/ufs/ffs/fs.h

748

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

sys/ufs/ffs/fs.h

777

lbn_offset(struct fs *fs, int level)

sys/ufs/ffs/fs.h

782

res *= NINDIR(fs);

sys/ufs/ffs/fs.h

789

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

sys/ufs/ffs/fs.h

790

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

sys/ufs/ffs/softdep.h

355

struct fs *id_fs; /* associated filesystem */

sys/ufs/ffs/softdep.h

996

struct fs *sb_fs; /* Filesystem pointer within buf. */

sys/ufs/ufs/ufs_gjournal.c

62

struct fs *fs;

sys/ufs/ufs/ufs_gjournal.c

68

fs = ump->um_fs;

sys/ufs/ufs/ufs_gjournal.c

72

cg = ino_to_cg(fs, ino);

sys/ufs/ufs/ufs_gjournal.c

83

if ((uint64_t)ino >= fs->fs_ipg * fs->fs_ncg)

sys/ufs/ufs/ufs_gjournal.c

85

"fs = %s", devtoname(dev), (intmax_t)ino, fs->fs_fsmnt);

sys/ufs/ufs/ufs_gjournal.c

86

if ((error = ffs_getcg(fs, devvp, cg, 0, &bp, &cgp)) != 0)

sys/ufs/ufs/ufs_gjournal.c

90

fs->fs_unrefs += count;

sys/ufs/ufs/ufs_gjournal.c

91

fs->fs_fmod = 1;

sys/ufs/ufs/ufs_gjournal.c

92

ACTIVECLEAR(fs, cg);

sys/ufs/ufs/ufsmount.h

91

struct fs *um_fs; /* (r) pointer to superblock */

sys/vm/vm_fault.c

1001

result = vm_map_lookup_locked(&fs->map, fs->vaddr, fs->fault_type,

sys/vm/vm_fault.c

1002

&fs->entry, &retry_object, &retry_pindex, &retry_prot,

sys/vm/vm_fault.c

1003

&fs->wired);

sys/vm/vm_fault.c

1013

if (retry_object != fs->first_object ||

sys/vm/vm_fault.c

1014

retry_pindex != fs->first_pindex)

sys/vm/vm_fault.c

1025

fs->prot &= retry_prot;

sys/vm/vm_fault.c

1026

fs->fault_type &= retry_prot;

sys/vm/vm_fault.c

1027

if (fs->prot == 0)

sys/vm/vm_fault.c

1031

KASSERT(fs->wired || (fs->fault_flags & VM_FAULT_WIRE) == 0,

sys/vm/vm_fault.c

1038

vm_fault_can_cow_rename(struct faultstate *fs)

sys/vm/vm_fault.c

1042

fs->object->shadow_count == 1 && fs->object->ref_count == 1 &&

sys/vm/vm_fault.c

1044

fs->object->handle == NULL && (fs->object->flags & OBJ_ANON) != 0);

sys/vm/vm_fault.c

1048

vm_fault_cow(struct faultstate *fs)

sys/vm/vm_fault.c

1052

KASSERT(vm_fault_might_be_cow(fs),

sys/vm/vm_fault.c

1066

if (vm_fault_can_cow_rename(fs) && vm_page_xbusied(fs->m)) {

sys/vm/vm_fault.c

1073

is_first_object_locked = VM_OBJECT_TRYWLOCK(fs->first_object);

sys/vm/vm_fault.c

1075

fs->object == fs->first_object->backing_object) {

sys/vm/vm_fault.c

1076

if (VM_OBJECT_TRYWLOCK(fs->object)) {

sys/vm/vm_fault.c

1077

rename_cow = vm_fault_can_cow_rename(fs);

sys/vm/vm_fault.c

1079

VM_OBJECT_WUNLOCK(fs->object);

sys/vm/vm_fault.c

1085

vm_page_assert_xbusied(fs->m);

sys/vm/vm_fault.c

1092

vm_page_remove_xbusy(fs->m);

sys/vm/vm_fault.c

1093

vm_page_replace(fs->m, fs->first_object, fs->first_pindex,

sys/vm/vm_fault.c

1094

fs->first_m);

sys/vm/vm_fault.c

1095

vm_page_dirty(fs->m);

sys/vm/vm_fault.c

1100

vm_reserv_rename(fs->m, fs->first_object, fs->object,

sys/vm/vm_fault.c

1101

OFF_TO_IDX(fs->first_object->backing_object_offset));

sys/vm/vm_fault.c

1103

VM_OBJECT_WUNLOCK(fs->object);

sys/vm/vm_fault.c

1104

VM_OBJECT_WUNLOCK(fs->first_object);

sys/vm/vm_fault.c

1105

fs->first_m = fs->m;

sys/vm/vm_fault.c

1106

fs->m = NULL;

sys/vm/vm_fault.c

1110

VM_OBJECT_WUNLOCK(fs->first_object);

sys/vm/vm_fault.c

1114

pmap_copy_page(fs->m, fs->first_m);

sys/vm/vm_fault.c

1115

if (fs->wired && (fs->fault_flags & VM_FAULT_WIRE) == 0) {

sys/vm/vm_fault.c

1116

vm_page_wire(fs->first_m);

sys/vm/vm_fault.c

1117

vm_page_unwire(fs->m, PQ_INACTIVE);

sys/vm/vm_fault.c

1124

fs->m_cow = fs->m;

sys/vm/vm_fault.c

1125

fs->m = NULL;

sys/vm/vm_fault.c

1149

if ((fs->first_object->flags & OBJ_ONEMAPPING) == 0)

sys/vm/vm_fault.c

1150

pmap_remove_all(fs->m_cow);

sys/vm/vm_fault.c

1153

vm_object_pip_wakeup(fs->object);

sys/vm/vm_fault.c

1158

fs->object = fs->first_object;

sys/vm/vm_fault.c

1159

fs->pindex = fs->first_pindex;

sys/vm/vm_fault.c

1160

fs->m = fs->first_m;

sys/vm/vm_fault.c

1166

vm_fault_next(struct faultstate *fs)

sys/vm/vm_fault.c

1170

if (fs->object == fs->first_object || !fs->can_read_lock)

sys/vm/vm_fault.c

1171

VM_OBJECT_ASSERT_WLOCKED(fs->object);

sys/vm/vm_fault.c

1173

VM_OBJECT_ASSERT_LOCKED(fs->object);

sys/vm/vm_fault.c

1185

if (fs->object == fs->first_object) {

sys/vm/vm_fault.c

1186

fs->first_m = fs->m;

sys/vm/vm_fault.c

1187

fs->m = NULL;

sys/vm/vm_fault.c

1188

} else if (fs->m != NULL) {

sys/vm/vm_fault.c

1189

if (!vm_fault_object_ensure_wlocked(fs)) {

sys/vm/vm_fault.c

1190

fs->can_read_lock = false;

sys/vm/vm_fault.c

1191

vm_fault_unlock_and_deallocate(fs);

sys/vm/vm_fault.c

1194

vm_fault_page_free(&fs->m);

sys/vm/vm_fault.c

1201

next_object = fs->object->backing_object;

sys/vm/vm_fault.c

1204

MPASS(fs->first_m != NULL);

sys/vm/vm_fault.c

1205

KASSERT(fs->object != next_object, ("object loop %p", next_object));

sys/vm/vm_fault.c

1206

if (fs->can_read_lock)

sys/vm/vm_fault.c

1211

if (fs->object != fs->first_object)

sys/vm/vm_fault.c

1212

vm_object_pip_wakeup(fs->object);

sys/vm/vm_fault.c

1213

fs->pindex += OFF_TO_IDX(fs->object->backing_object_offset);

sys/vm/vm_fault.c

1214

VM_OBJECT_UNLOCK(fs->object);

sys/vm/vm_fault.c

1215

fs->object = next_object;

sys/vm/vm_fault.c

1221

vm_fault_zerofill(struct faultstate *fs)

sys/vm/vm_fault.c

1228

if (vm_fault_might_be_cow(fs)) {

sys/vm/vm_fault.c

1229

vm_object_pip_wakeup(fs->object);

sys/vm/vm_fault.c

1230

fs->object = fs->first_object;

sys/vm/vm_fault.c

1231

fs->pindex = fs->first_pindex;

sys/vm/vm_fault.c

1233

MPASS(fs->first_m != NULL);

sys/vm/vm_fault.c

1234

MPASS(fs->m == NULL);

sys/vm/vm_fault.c

1235

fs->m = fs->first_m;

sys/vm/vm_fault.c

1236

fs->first_m = NULL;

sys/vm/vm_fault.c

1241

if (fs->m_needs_zeroing) {

sys/vm/vm_fault.c

1242

pmap_zero_page(fs->m);

sys/vm/vm_fault.c

1251

sf = sf_buf_alloc(fs->m, SFB_CPUPRIVATE);

sys/vm/vm_fault.c

1256

fs->m, i, (uintmax_t)*p));

sys/vm/vm_fault.c

1265

vm_page_valid(fs->m);

sys/vm/vm_fault.c

1273

vm_fault_allocate_oom(struct faultstate *fs)

sys/vm/vm_fault.c

1277

vm_fault_unlock_and_deallocate(fs);

sys/vm/vm_fault.c

1280

if (!fs->oom_started) {

sys/vm/vm_fault.c

1281

fs->oom_started = true;

sys/vm/vm_fault.c

1282

getmicrotime(&fs->oom_start_time);

sys/vm/vm_fault.c

1287

timevalsub(&now, &fs->oom_start_time);

sys/vm/vm_fault.c

1296

fs->oom_started = false;

sys/vm/vm_fault.c

1304

vm_fault_allocate(struct faultstate *fs, struct pctrie_iter *pages)

sys/vm/vm_fault.c

1309

if ((fs->object->flags & OBJ_SIZEVNLOCK) != 0) {

sys/vm/vm_fault.c

1310

res = vm_fault_lock_vnode(fs, true);

sys/vm/vm_fault.c

1316

if (fs->pindex >= fs->object->size) {

sys/vm/vm_fault.c

1317

vm_fault_unlock_and_deallocate(fs);

sys/vm/vm_fault.c

1321

if (fs->object == fs->first_object &&

sys/vm/vm_fault.c

1322

(fs->first_object->flags & OBJ_POPULATE) != 0 &&

sys/vm/vm_fault.c

1323

fs->first_object->shadow_count == 0) {

sys/vm/vm_fault.c

1324

res = vm_fault_populate(fs);

sys/vm/vm_fault.c

1329

vm_fault_unlock_and_deallocate(fs);

sys/vm/vm_fault.c

1355

dset = fs->object->domain.dr_policy;

sys/vm/vm_fault.c

1360

vm_object_color(fs->object, atop(fs->vaddr) - fs->pindex);

sys/vm/vm_fault.c

1362

if (!vm_pager_can_alloc_page(fs->object, fs->pindex)) {

sys/vm/vm_fault.c

1363

vm_fault_unlock_and_deallocate(fs);

sys/vm/vm_fault.c

1366

fs->m = vm_page_alloc_iter(fs->object, fs->pindex,

sys/vm/vm_fault.c

1369

if (fs->m == NULL) {

sys/vm/vm_fault.c

1370

if (vm_fault_allocate_oom(fs))

sys/vm/vm_fault.c

1374

if (fs->object == fs->first_object)

sys/vm/vm_fault.c

1375

fs->m_needs_zeroing = (fs->m->flags & PG_ZERO) == 0;

sys/vm/vm_fault.c

1376

fs->oom_started = false;

sys/vm/vm_fault.c

1387

vm_fault_getpages(struct faultstate *fs, int *behindp, int *aheadp)

sys/vm/vm_fault.c

1402

e_start = fs->entry->start;

sys/vm/vm_fault.c

1403

e_end = fs->entry->end;

sys/vm/vm_fault.c

1404

behavior = vm_map_entry_behavior(fs->entry);

sys/vm/vm_fault.c

1417

if (fs->nera == -1 && !P_KILLED(curproc))

sys/vm/vm_fault.c

1418

fs->nera = vm_fault_readahead(fs);

sys/vm/vm_fault.c

1426

vm_fault_unlock_map(fs);

sys/vm/vm_fault.c

1428

status = vm_fault_lock_vnode(fs, false);

sys/vm/vm_fault.c

1432

KASSERT(fs->vp == NULL || !vm_map_is_system(fs->map),

sys/vm/vm_fault.c

1439

if (fs->nera == -1 || behavior == MAP_ENTRY_BEHAV_RANDOM ||

sys/vm/vm_fault.c

1445

if (fs->nera > 0) {

sys/vm/vm_fault.c

1447

ahead = fs->nera;

sys/vm/vm_fault.c

1459

cluster_offset = fs->pindex % VM_FAULT_READ_DEFAULT;

sys/vm/vm_fault.c

1461

atop(fs->vaddr - e_start));

sys/vm/vm_fault.c

1464

ahead = ulmin(ahead, atop(e_end - fs->vaddr) - 1);

sys/vm/vm_fault.c

1468

rv = vm_pager_get_pages(fs->object, &fs->m, 1, behindp, aheadp);

sys/vm/vm_fault.c

1480

VM_OBJECT_WLOCK(fs->object);

sys/vm/vm_fault.c

1481

vm_fault_page_free(&fs->m);

sys/vm/vm_fault.c

1482

vm_fault_unlock_and_deallocate(fs);

sys/vm/vm_fault.c

1503

vm_fault_busy_sleep(struct faultstate *fs, int allocflags)

sys/vm/vm_fault.c

1510

vm_page_aflag_set(fs->m, PGA_REFERENCED);

sys/vm/vm_fault.c

1511

if (vm_fault_might_be_cow(fs)) {

sys/vm/vm_fault.c

1512

vm_fault_page_release(&fs->first_m);

sys/vm/vm_fault.c

1513

vm_object_pip_wakeup(fs->first_object);

sys/vm/vm_fault.c

1515

vm_object_pip_wakeup(fs->object);

sys/vm/vm_fault.c

1516

vm_fault_unlock_map(fs);

sys/vm/vm_fault.c

1517

if (!vm_page_busy_sleep(fs->m, "vmpfw", allocflags))

sys/vm/vm_fault.c

1518

VM_OBJECT_UNLOCK(fs->object);

sys/vm/vm_fault.c

1520

vm_object_deallocate(fs->first_object);

sys/vm/vm_fault.c

1532

vm_fault_object(struct faultstate *fs, int *behindp, int *aheadp)

sys/vm/vm_fault.c

1538

if (fs->object == fs->first_object || !fs->can_read_lock)

sys/vm/vm_fault.c

1539

VM_OBJECT_ASSERT_WLOCKED(fs->object);

sys/vm/vm_fault.c

1541

VM_OBJECT_ASSERT_LOCKED(fs->object);

sys/vm/vm_fault.c

1548

if ((fs->object->flags & OBJ_DEAD) != 0) {

sys/vm/vm_fault.c

1549

dead = fs->object->type == OBJT_DEAD;

sys/vm/vm_fault.c

1550

vm_fault_unlock_and_deallocate(fs);

sys/vm/vm_fault.c

1560

vm_page_iter_init(&pages, fs->object);

sys/vm/vm_fault.c

1561

fs->m = vm_radix_iter_lookup(&pages, fs->pindex);

sys/vm/vm_fault.c

1562

if (fs->m != NULL) {

sys/vm/vm_fault.c

1573

if (vm_page_all_valid(fs->m) &&

sys/vm/vm_fault.c

1580

(vm_fault_is_read(fs) || vm_fault_might_be_cow(fs)) &&

sys/vm/vm_fault.c

1587

(!vm_fault_can_cow_rename(fs) ||

sys/vm/vm_fault.c

1588

fs->object != fs->first_object->backing_object)) {

sys/vm/vm_fault.c

1589

if (!vm_page_trysbusy(fs->m)) {

sys/vm/vm_fault.c

1590

vm_fault_busy_sleep(fs, VM_ALLOC_SBUSY);

sys/vm/vm_fault.c

1598

if (__predict_true(vm_page_all_valid(fs->m) &&

sys/vm/vm_fault.c

1599

(vm_fault_is_read(fs) ||

sys/vm/vm_fault.c

1600

vm_fault_might_be_cow(fs)))) {

sys/vm/vm_fault.c

1601

VM_OBJECT_UNLOCK(fs->object);

sys/vm/vm_fault.c

1605

vm_page_sunbusy(fs->m);

sys/vm/vm_fault.c

1608

if (!vm_page_tryxbusy(fs->m)) {

sys/vm/vm_fault.c

1609

vm_fault_busy_sleep(fs, 0);

sys/vm/vm_fault.c

1618

if (vm_page_all_valid(fs->m)) {

sys/vm/vm_fault.c

1619

VM_OBJECT_UNLOCK(fs->object);

sys/vm/vm_fault.c

1629

if (fs->m == NULL && (vm_fault_object_needs_getpages(fs->object) ||

sys/vm/vm_fault.c

1630

fs->object == fs->first_object)) {

sys/vm/vm_fault.c

1631

if (!vm_fault_object_ensure_wlocked(fs)) {

sys/vm/vm_fault.c

1632

fs->can_read_lock = false;

sys/vm/vm_fault.c

1633

vm_fault_unlock_and_deallocate(fs);

sys/vm/vm_fault.c

1636

res = vm_fault_allocate(fs, &pages);

sys/vm/vm_fault.c

1646

if (vm_fault_object_needs_getpages(fs->object)) {

sys/vm/vm_fault.c

1657

VM_OBJECT_UNLOCK(fs->object);

sys/vm/vm_fault.c

1658

res = vm_fault_getpages(fs, behindp, aheadp);

sys/vm/vm_fault.c

1660

VM_OBJECT_WLOCK(fs->object);

sys/vm/vm_fault.c

1693

struct faultstate fs;

sys/vm/vm_fault.c

1704

fs.vp = NULL;

sys/vm/vm_fault.c

1705

fs.vaddr = vaddr;

sys/vm/vm_fault.c

1706

fs.m_hold = m_hold;

sys/vm/vm_fault.c

1707

fs.fault_flags = fault_flags;

sys/vm/vm_fault.c

1708

fs.map = map;

sys/vm/vm_fault.c

1709

fs.lookup_still_valid = false;

sys/vm/vm_fault.c

1710

fs.oom_started = false;

sys/vm/vm_fault.c

1711

fs.nera = -1;

sys/vm/vm_fault.c

1712

fs.can_read_lock = true;

sys/vm/vm_fault.c

1717

fs.fault_type = fault_type;

sys/vm/vm_fault.c

1718

fs.m_needs_zeroing = true;

sys/vm/vm_fault.c

1724

rv = vm_fault_lookup(&fs);

sys/vm/vm_fault.c

1738

if (fs.vp == NULL /* avoid locked vnode leak */ &&

sys/vm/vm_fault.c

1739

(fs.entry->eflags & MAP_ENTRY_SPLIT_BOUNDARY_MASK) == 0 &&

sys/vm/vm_fault.c

1740

(fs.fault_flags & (VM_FAULT_WIRE | VM_FAULT_DIRTY)) == 0) {

sys/vm/vm_fault.c

1741

res = vm_fault_soft_fast(&fs);

sys/vm/vm_fault.c

1743

VM_OBJECT_ASSERT_UNLOCKED(fs.first_object);

sys/vm/vm_fault.c

1746

VM_OBJECT_ASSERT_WLOCKED(fs.first_object);

sys/vm/vm_fault.c

1748

vm_page_iter_init(&pages, fs.first_object);

sys/vm/vm_fault.c

1749

VM_OBJECT_WLOCK(fs.first_object);

sys/vm/vm_fault.c

1761

vm_object_reference_locked(fs.first_object);

sys/vm/vm_fault.c

1762

vm_object_pip_add(fs.first_object, 1);

sys/vm/vm_fault.c

1764

fs.m_cow = fs.m = fs.first_m = NULL;

sys/vm/vm_fault.c

1769

fs.object = fs.first_object;

sys/vm/vm_fault.c

1770

fs.pindex = fs.first_pindex;

sys/vm/vm_fault.c

1772

if ((fs.entry->eflags & MAP_ENTRY_SPLIT_BOUNDARY_MASK) != 0) {

sys/vm/vm_fault.c

1773

res = vm_fault_allocate(&fs, &pages);

sys/vm/vm_fault.c

178

static void vm_fault_dontneed(const struct faultstate *fs, vm_offset_t vaddr,

sys/vm/vm_fault.c

1791

KASSERT(fs.m == NULL,

sys/vm/vm_fault.c

1792

("page still set %p at loop start", fs.m));

sys/vm/vm_fault.c

1794

res = vm_fault_object(&fs, &behind, &ahead);

sys/vm/vm_fault.c

180

static void vm_fault_prefault(const struct faultstate *fs, vm_offset_t addra,

sys/vm/vm_fault.c

1823

res_next = vm_fault_next(&fs);

sys/vm/vm_fault.c

1829

if ((fs.fault_flags & VM_FAULT_NOFILL) != 0) {

sys/vm/vm_fault.c

1830

if (fs.first_object == fs.object)

sys/vm/vm_fault.c

1831

vm_fault_page_free(&fs.first_m);

sys/vm/vm_fault.c

1832

vm_fault_unlock_and_deallocate(&fs);

sys/vm/vm_fault.c

1835

VM_OBJECT_UNLOCK(fs.object);

sys/vm/vm_fault.c

1836

vm_fault_zerofill(&fs);

sys/vm/vm_fault.c

1852

vm_page_assert_busied(fs.m);

sys/vm/vm_fault.c

1853

VM_OBJECT_ASSERT_UNLOCKED(fs.object);

sys/vm/vm_fault.c

1860

if (vm_fault_might_be_cow(&fs)) {

sys/vm/vm_fault.c

1864

if ((fs.fault_type & (VM_PROT_COPY | VM_PROT_WRITE)) != 0) {

sys/vm/vm_fault.c

1865

vm_fault_cow(&fs);

sys/vm/vm_fault.c

1876

fs.prot &= ~VM_PROT_WRITE;

sys/vm/vm_fault.c

1884

if (!fs.lookup_still_valid) {

sys/vm/vm_fault.c

1885

rv = vm_fault_relookup(&fs);

sys/vm/vm_fault.c

1887

vm_fault_deallocate(&fs);

sys/vm/vm_fault.c

1893

VM_OBJECT_ASSERT_UNLOCKED(fs.object);

sys/vm/vm_fault.c

1902

fs.entry->next_read = vaddr + ptoa(ahead) + PAGE_SIZE;

sys/vm/vm_fault.c

1911

if (fs.m_cow != NULL) {

sys/vm/vm_fault.c

1912

KASSERT(vm_page_none_valid(fs.m),

sys/vm/vm_fault.c

1913

("vm_fault: page %p is already valid", fs.m_cow));

sys/vm/vm_fault.c

1914

vm_page_valid(fs.m);

sys/vm/vm_fault.c

1921

vm_page_assert_busied(fs.m);

sys/vm/vm_fault.c

1922

KASSERT(vm_page_all_valid(fs.m),

sys/vm/vm_fault.c

1923

("vm_fault: page %p partially invalid", fs.m));

sys/vm/vm_fault.c

1925

vm_fault_dirty(&fs, fs.m);

sys/vm/vm_fault.c

1933

pmap_enter(fs.map->pmap, vaddr, fs.m, fs.prot,

sys/vm/vm_fault.c

1934

fs.fault_type | (fs.wired ? PMAP_ENTER_WIRED : 0), 0);

sys/vm/vm_fault.c

1935

if (faultcount != 1 && (fs.fault_flags & VM_FAULT_WIRE) == 0 &&

sys/vm/vm_fault.c

1936

fs.wired == 0)

sys/vm/vm_fault.c

1937

vm_fault_prefault(&fs, vaddr,

sys/vm/vm_fault.c

1945

if ((fs.fault_flags & VM_FAULT_WIRE) != 0)

sys/vm/vm_fault.c

1946

vm_page_wire(fs.m);

sys/vm/vm_fault.c

1948

vm_page_activate(fs.m);

sys/vm/vm_fault.c

1949

if (fs.m_hold != NULL) {

sys/vm/vm_fault.c

1950

(*fs.m_hold) = fs.m;

sys/vm/vm_fault.c

1951

vm_page_wire(fs.m);

sys/vm/vm_fault.c

1954

KASSERT(fs.first_object == fs.object || vm_page_xbusied(fs.first_m),

sys/vm/vm_fault.c

1956

if (vm_page_xbusied(fs.m))

sys/vm/vm_fault.c

1957

vm_page_xunbusy(fs.m);

sys/vm/vm_fault.c

1959

vm_page_sunbusy(fs.m);

sys/vm/vm_fault.c

1960

fs.m = NULL;

sys/vm/vm_fault.c

1965

vm_fault_deallocate(&fs);

sys/vm/vm_fault.c

1970

if (racct_enable && fs.object->type == OBJT_VNODE) {

sys/vm/vm_fault.c

1972

if ((fs.fault_type & (VM_PROT_COPY | VM_PROT_WRITE)) != 0) {

sys/vm/vm_fault.c

2003

vm_fault_dontneed(const struct faultstate *fs, vm_offset_t vaddr, int ahead)

sys/vm/vm_fault.c

2012

VM_OBJECT_ASSERT_UNLOCKED(fs->object);

sys/vm/vm_fault.c

2013

first_object = fs->first_object;

sys/vm/vm_fault.c

2022

(entry = fs->entry)->start < end) {

sys/vm/vm_fault.c

2027

pmap_advise(fs->map->pmap, start, end, MADV_DONTNEED);

sys/vm/vm_fault.c

2066

vm_fault_prefault(const struct faultstate *fs, vm_offset_t addra,

sys/vm/vm_fault.c

2078

pmap = fs->map->pmap;

sys/vm/vm_fault.c

2082

entry = fs->entry;

sys/vm/vm_fault.c

2097

if ((fs->prot & VM_PROT_WRITE) != 0)

sys/vm/vm_fault.c

248

vm_fault_unlock_map(struct faultstate *fs)

sys/vm/vm_fault.c

251

if (fs->lookup_still_valid) {

sys/vm/vm_fault.c

252

vm_map_lookup_done(fs->map, fs->entry);

sys/vm/vm_fault.c

253

fs->lookup_still_valid = false;

sys/vm/vm_fault.c

258

vm_fault_unlock_vp(struct faultstate *fs)

sys/vm/vm_fault.c

261

if (fs->vp != NULL) {

sys/vm/vm_fault.c

262

vput(fs->vp);

sys/vm/vm_fault.c

263

fs->vp = NULL;

sys/vm/vm_fault.c

268

vm_fault_might_be_cow(struct faultstate *fs)

sys/vm/vm_fault.c

270

return (fs->object != fs->first_object);

sys/vm/vm_fault.c

274

vm_fault_deallocate(struct faultstate *fs)

sys/vm/vm_fault.c

276

vm_fault_page_release(&fs->m_cow);

sys/vm/vm_fault.c

277

vm_fault_page_release(&fs->m);

sys/vm/vm_fault.c

278

vm_object_pip_wakeup(fs->object);

sys/vm/vm_fault.c

279

if (vm_fault_might_be_cow(fs)) {

sys/vm/vm_fault.c

280

VM_OBJECT_WLOCK(fs->first_object);

sys/vm/vm_fault.c

281

vm_fault_page_free(&fs->first_m);

sys/vm/vm_fault.c

282

VM_OBJECT_WUNLOCK(fs->first_object);

sys/vm/vm_fault.c

283

vm_object_pip_wakeup(fs->first_object);

sys/vm/vm_fault.c

285

vm_object_deallocate(fs->first_object);

sys/vm/vm_fault.c

286

vm_fault_unlock_map(fs);

sys/vm/vm_fault.c

287

vm_fault_unlock_vp(fs);

sys/vm/vm_fault.c

291

vm_fault_unlock_and_deallocate(struct faultstate *fs)

sys/vm/vm_fault.c

294

VM_OBJECT_UNLOCK(fs->object);

sys/vm/vm_fault.c

295

vm_fault_deallocate(fs);

sys/vm/vm_fault.c

299

vm_fault_dirty(struct faultstate *fs, vm_page_t m)

sys/vm/vm_fault.c

303

if (((fs->prot & VM_PROT_WRITE) == 0 &&

sys/vm/vm_fault.c

304

(fs->fault_flags & VM_FAULT_DIRTY) == 0) ||

sys/vm/vm_fault.c

310

need_dirty = ((fs->fault_type & VM_PROT_WRITE) != 0 &&

sys/vm/vm_fault.c

311

(fs->fault_flags & VM_FAULT_WIRE) == 0) ||

sys/vm/vm_fault.c

312

(fs->fault_flags & VM_FAULT_DIRTY) != 0;

sys/vm/vm_fault.c

333

if ((fs->entry->eflags & MAP_ENTRY_NOSYNC) != 0)

sys/vm/vm_fault.c

342

vm_fault_is_read(const struct faultstate *fs)

sys/vm/vm_fault.c

344

return ((fs->prot & VM_PROT_WRITE) == 0 &&

sys/vm/vm_fault.c

345

(fs->fault_type & (VM_PROT_COPY | VM_PROT_WRITE)) == 0);

sys/vm/vm_fault.c

352

vm_fault_soft_fast(struct faultstate *fs)

sys/vm/vm_fault.c

362

MPASS(fs->vp == NULL);

sys/vm/vm_fault.c

371

m = vm_page_lookup_unlocked(fs->first_object, fs->first_pindex);

sys/vm/vm_fault.c

373

((fs->prot & VM_PROT_WRITE) != 0 && vm_page_busied(m))) {

sys/vm/vm_fault.c

374

VM_OBJECT_WLOCK(fs->first_object);

sys/vm/vm_fault.c

378

vaddr = fs->vaddr;

sys/vm/vm_fault.c

380

VM_OBJECT_RLOCK(fs->first_object);

sys/vm/vm_fault.c

387

if (m->object != fs->first_object || m->pindex != fs->first_pindex)

sys/vm/vm_fault.c

390

vm_object_busy(fs->first_object);

sys/vm/vm_fault.c

393

((fs->prot & VM_PROT_WRITE) != 0 && vm_page_busied(m)))

sys/vm/vm_fault.c

405

if ((fs->prot & VM_PROT_WRITE) != 0) {

sys/vm/vm_fault.c

413

if ((fs->first_object->flags & OBJ_UNMANAGED) == 0)

sys/vm/vm_fault.c

416

while (rounddown2(vaddr, pagesizes[psind]) < fs->entry->start ||

sys/vm/vm_fault.c

417

roundup2(vaddr + 1, pagesizes[psind]) > fs->entry->end ||

sys/vm/vm_fault.c

421

!pmap_ps_enabled(fs->map->pmap)) {

sys/vm/vm_fault.c

436

fs->fault_type |= VM_PROT_WRITE;

sys/vm/vm_fault.c

440

if (pmap_enter(fs->map->pmap, vaddr, m_map, fs->prot, fs->fault_type |

sys/vm/vm_fault.c

441

PMAP_ENTER_NOSLEEP | (fs->wired ? PMAP_ENTER_WIRED : 0), psind) !=

sys/vm/vm_fault.c

444

if (fs->m_hold != NULL) {

sys/vm/vm_fault.c

445

(*fs->m_hold) = m;

sys/vm/vm_fault.c

448

if (psind == 0 && !fs->wired)

sys/vm/vm_fault.c

449

vm_fault_prefault(fs, vaddr, PFBAK, PFFOR, true);

sys/vm/vm_fault.c

450

VM_OBJECT_RUNLOCK(fs->first_object);

sys/vm/vm_fault.c

451

vm_fault_dirty(fs, m);

sys/vm/vm_fault.c

452

vm_object_unbusy(fs->first_object);

sys/vm/vm_fault.c

453

vm_map_lookup_done(fs->map, fs->entry);

sys/vm/vm_fault.c

457

vm_object_unbusy(fs->first_object);

sys/vm/vm_fault.c

459

if (!VM_OBJECT_TRYUPGRADE(fs->first_object)) {

sys/vm/vm_fault.c

460

VM_OBJECT_RUNLOCK(fs->first_object);

sys/vm/vm_fault.c

461

VM_OBJECT_WLOCK(fs->first_object);

sys/vm/vm_fault.c

467

vm_fault_restore_map_lock(struct faultstate *fs)

sys/vm/vm_fault.c

470

VM_OBJECT_ASSERT_WLOCKED(fs->first_object);

sys/vm/vm_fault.c

471

MPASS(blockcount_read(&fs->first_object->paging_in_progress) > 0);

sys/vm/vm_fault.c

473

if (!vm_map_trylock_read(fs->map)) {

sys/vm/vm_fault.c

474

VM_OBJECT_WUNLOCK(fs->first_object);

sys/vm/vm_fault.c

475

vm_map_lock_read(fs->map);

sys/vm/vm_fault.c

476

VM_OBJECT_WLOCK(fs->first_object);

sys/vm/vm_fault.c

478

fs->lookup_still_valid = true;

sys/vm/vm_fault.c

517

vm_fault_populate(struct faultstate *fs)

sys/vm/vm_fault.c

525

MPASS(fs->object == fs->first_object);

sys/vm/vm_fault.c

526

VM_OBJECT_ASSERT_WLOCKED(fs->first_object);

sys/vm/vm_fault.c

527

MPASS(blockcount_read(&fs->first_object->paging_in_progress) > 0);

sys/vm/vm_fault.c

528

MPASS(fs->first_object->backing_object == NULL);

sys/vm/vm_fault.c

529

MPASS(fs->lookup_still_valid);

sys/vm/vm_fault.c

531

pager_first = OFF_TO_IDX(fs->entry->offset);

sys/vm/vm_fault.c

532

pager_last = pager_first + atop(fs->entry->end - fs->entry->start) - 1;

sys/vm/vm_fault.c

533

vm_fault_unlock_map(fs);

sys/vm/vm_fault.c

534

vm_fault_unlock_vp(fs);

sys/vm/vm_fault.c

546

rv = vm_pager_populate(fs->first_object, fs->first_pindex,

sys/vm/vm_fault.c

547

fs->fault_type, fs->entry->max_protection, &pager_first,

sys/vm/vm_fault.c

550

VM_OBJECT_ASSERT_WLOCKED(fs->first_object);

sys/vm/vm_fault.c

556

vm_fault_restore_map_lock(fs);

sys/vm/vm_fault.c

557

if (fs->map->timestamp != fs->map_generation)

sys/vm/vm_fault.c

566

MPASS(fs->first_pindex <= pager_last);

sys/vm/vm_fault.c

567

MPASS(fs->first_pindex >= pager_first);

sys/vm/vm_fault.c

568

MPASS(pager_last < fs->first_object->size);

sys/vm/vm_fault.c

570

vm_fault_restore_map_lock(fs);

sys/vm/vm_fault.c

571

bdry_idx = MAP_ENTRY_SPLIT_BOUNDARY_INDEX(fs->entry);

sys/vm/vm_fault.c

572

if (fs->map->timestamp != fs->map_generation) {

sys/vm/vm_fault.c

574

vm_fault_populate_cleanup(fs->first_object, pager_first,

sys/vm/vm_fault.c

577

m = vm_page_lookup(fs->first_object, pager_first);

sys/vm/vm_fault.c

578

if (m != fs->m)

sys/vm/vm_fault.c

593

m = vm_page_lookup(fs->first_object, pager_first);

sys/vm/vm_fault.c

595

VM_OBJECT_WUNLOCK(fs->first_object);

sys/vm/vm_fault.c

596

vaddr = fs->entry->start + IDX_TO_OFF(pager_first) -

sys/vm/vm_fault.c

597

fs->entry->offset;

sys/vm/vm_fault.c

601

(uintmax_t)fs->entry->start, (uintmax_t)pager_first,

sys/vm/vm_fault.c

602

(uintmax_t)fs->entry->offset, (uintmax_t)vaddr));

sys/vm/vm_fault.c

606

rv = pmap_enter(fs->map->pmap, vaddr, m, fs->prot,

sys/vm/vm_fault.c

607

fs->fault_type | (fs->wired ? PMAP_ENTER_WIRED : 0) |

sys/vm/vm_fault.c

609

VM_OBJECT_WLOCK(fs->first_object);

sys/vm/vm_fault.c

615

if ((fs->fault_flags & VM_FAULT_WIRE) != 0) {

sys/vm/vm_fault.c

619

if (fs->m_hold != NULL) {

sys/vm/vm_fault.c

620

*fs->m_hold = m + (fs->first_pindex - pager_first);

sys/vm/vm_fault.c

621

vm_page_wire(*fs->m_hold);

sys/vm/vm_fault.c

633

map_first = OFF_TO_IDX(fs->entry->offset);

sys/vm/vm_fault.c

635

vm_fault_populate_cleanup(fs->first_object, pager_first,

sys/vm/vm_fault.c

639

map_last = map_first + atop(fs->entry->end - fs->entry->start) - 1;

sys/vm/vm_fault.c

641

vm_fault_populate_cleanup(fs->first_object, map_last + 1,

sys/vm/vm_fault.c

648

m = vm_page_lookup(fs->first_object, pidx);

sys/vm/vm_fault.c

649

vaddr = fs->entry->start + IDX_TO_OFF(pidx) - fs->entry->offset;

sys/vm/vm_fault.c

655

!pmap_ps_enabled(fs->map->pmap)))

sys/vm/vm_fault.c

658

writeable = (fs->prot & VM_PROT_WRITE) != 0;

sys/vm/vm_fault.c

662

vm_fault_dirty(fs, &m[i]);

sys/vm/vm_fault.c

675

fs->fault_type |= VM_PROT_WRITE;

sys/vm/vm_fault.c

676

VM_OBJECT_WUNLOCK(fs->first_object);

sys/vm/vm_fault.c

677

rv = pmap_enter(fs->map->pmap, vaddr, m,

sys/vm/vm_fault.c

678

fs->prot & ~(writeable ? 0 : VM_PROT_WRITE),

sys/vm/vm_fault.c

679

fs->fault_type | (fs->wired ? PMAP_ENTER_WIRED : 0), psind);

sys/vm/vm_fault.c

692

MPASS(!fs->wired);

sys/vm/vm_fault.c

694

rv = pmap_enter(fs->map->pmap, vaddr + ptoa(i),

sys/vm/vm_fault.c

695

&m[i], fs->prot, fs->fault_type, 0);

sys/vm/vm_fault.c

700

VM_OBJECT_WLOCK(fs->first_object);

sys/vm/vm_fault.c

702

if ((fs->fault_flags & VM_FAULT_WIRE) != 0 &&

sys/vm/vm_fault.c

703

m[i].pindex == fs->first_pindex)

sys/vm/vm_fault.c

707

if (fs->m_hold != NULL &&

sys/vm/vm_fault.c

708

m[i].pindex == fs->first_pindex) {

sys/vm/vm_fault.c

709

(*fs->m_hold) = &m[i];

sys/vm/vm_fault.c

818

vm_fault_object_ensure_wlocked(struct faultstate *fs)

sys/vm/vm_fault.c

820

if (fs->object == fs->first_object)

sys/vm/vm_fault.c

821

VM_OBJECT_ASSERT_WLOCKED(fs->object);

sys/vm/vm_fault.c

823

if (!fs->can_read_lock) {

sys/vm/vm_fault.c

824

VM_OBJECT_ASSERT_WLOCKED(fs->object);

sys/vm/vm_fault.c

828

if (VM_OBJECT_WOWNED(fs->object))

sys/vm/vm_fault.c

831

if (VM_OBJECT_TRYUPGRADE(fs->object))

sys/vm/vm_fault.c

838

vm_fault_lock_vnode(struct faultstate *fs, bool objlocked)

sys/vm/vm_fault.c

843

if (fs->object->type != OBJT_VNODE)

sys/vm/vm_fault.c

845

vp = fs->object->handle;

sys/vm/vm_fault.c

846

if (vp == fs->vp) {

sys/vm/vm_fault.c

855

vm_fault_unlock_vp(fs);

sys/vm/vm_fault.c

869

fs->vp = vp;

sys/vm/vm_fault.c

875

vm_fault_unlock_and_deallocate(fs);

sys/vm/vm_fault.c

877

vm_fault_deallocate(fs);

sys/vm/vm_fault.c

880

fs->vp = vp;

sys/vm/vm_fault.c

891

vm_fault_readahead(struct faultstate *fs)

sys/vm/vm_fault.c

896

KASSERT(fs->lookup_still_valid, ("map unlocked"));

sys/vm/vm_fault.c

897

era = fs->entry->read_ahead;

sys/vm/vm_fault.c

898

behavior = vm_map_entry_behavior(fs->entry);

sys/vm/vm_fault.c

903

if (fs->vaddr == fs->entry->next_read)

sys/vm/vm_fault.c

904

vm_fault_dontneed(fs, fs->vaddr, nera);

sys/vm/vm_fault.c

905

} else if (fs->vaddr == fs->entry->next_read) {

sys/vm/vm_fault.c

920

vm_fault_dontneed(fs, fs->vaddr, nera);

sys/vm/vm_fault.c

932

fs->entry->read_ahead = nera;

sys/vm/vm_fault.c

939

vm_fault_lookup(struct faultstate *fs)

sys/vm/vm_fault.c

943

KASSERT(!fs->lookup_still_valid,

sys/vm/vm_fault.c

945

result = vm_map_lookup(&fs->map, fs->vaddr, fs->fault_type |

sys/vm/vm_fault.c

946

VM_PROT_FAULT_LOOKUP, &fs->entry, &fs->first_object,

sys/vm/vm_fault.c

947

&fs->first_pindex, &fs->prot, &fs->wired);

sys/vm/vm_fault.c

949

vm_fault_unlock_vp(fs);

sys/vm/vm_fault.c

953

fs->map_generation = fs->map->timestamp;

sys/vm/vm_fault.c

955

if (fs->entry->eflags & MAP_ENTRY_NOFAULT) {

sys/vm/vm_fault.c

957

__func__, (u_long)fs->vaddr);

sys/vm/vm_fault.c

960

if (fs->entry->eflags & MAP_ENTRY_IN_TRANSITION &&

sys/vm/vm_fault.c

961

fs->entry->wiring_thread != curthread) {

sys/vm/vm_fault.c

962

vm_map_unlock_read(fs->map);

sys/vm/vm_fault.c

963

vm_map_lock(fs->map);

sys/vm/vm_fault.c

964

if (vm_map_lookup_entry(fs->map, fs->vaddr, &fs->entry) &&

sys/vm/vm_fault.c

965

(fs->entry->eflags & MAP_ENTRY_IN_TRANSITION)) {

sys/vm/vm_fault.c

966

vm_fault_unlock_vp(fs);

sys/vm/vm_fault.c

967

fs->entry->eflags |= MAP_ENTRY_NEEDS_WAKEUP;

sys/vm/vm_fault.c

968

vm_map_unlock_and_wait(fs->map, 0);

sys/vm/vm_fault.c

970

vm_map_unlock(fs->map);

sys/vm/vm_fault.c

974

MPASS((fs->entry->eflags & MAP_ENTRY_GUARD) == 0);

sys/vm/vm_fault.c

976

if (fs->wired)

sys/vm/vm_fault.c

977

fs->fault_type = fs->prot | (fs->fault_type & VM_PROT_COPY);

sys/vm/vm_fault.c

979

KASSERT((fs->fault_flags & VM_FAULT_WIRE) == 0,

sys/vm/vm_fault.c

981

fs->lookup_still_valid = true;

sys/vm/vm_fault.c

987

vm_fault_relookup(struct faultstate *fs)

sys/vm/vm_fault.c

994

if (!vm_map_trylock_read(fs->map))

sys/vm/vm_fault.c

997

fs->lookup_still_valid = true;

sys/vm/vm_fault.c

998

if (fs->map->timestamp == fs->map_generation)

tests/sys/capsicum/capmode.cc

411

struct stat fs;

tests/sys/capsicum/capmode.cc

412

EXPECT_OK(fstatat(dfd, "testfile", &fs, 0));

tests/sys/capsicum/capmode.cc

424

EXPECT_OK(fchownat(dfd, "testfile", fs.st_uid, fs.st_gid, 0));

tests/sys/capsicum/capmode.cc

475

struct stat fs;

tests/sys/capsicum/capmode.cc

476

EXPECT_CAPMODE(fstatat(AT_FDCWD, "testfile", &fs, 0));

tests/sys/capsicum/capmode.cc

488

EXPECT_CAPMODE(fchownat(AT_FDCWD, "testfile", fs.st_uid, fs.st_gid, 0));

tests/sys/kern/jail_lookup_root.c

103

struct statfs fs;

tests/sys/kern/jail_lookup_root.c

107

error = statfs("./root/b", &fs);

tests/sys/kern/jail_lookup_root.c

110

fsid = fs.f_fsid;

tests/sys/kern/jail_lookup_root.c

111

error = statfs("./root", &fs);

tests/sys/kern/jail_lookup_root.c

114

if (fsid.val[0] != fs.f_fsid.val[0] ||

tests/sys/kern/jail_lookup_root.c

115

fsid.val[1] != fs.f_fsid.val[1]) {

tests/sys/sys/bitstring_test.c

880

ssize_t fc, fs;

tests/sys/sys/bitstring_test.c

896

bit_ffs(b, nbits, &fs);

tests/sys/sys/bitstring_test.c

897

ATF_CHECK_EQ(-1L, fs);

tests/sys/sys/bitstring_test.c

901

bit_ffs(b, nbits, &fs);

tests/sys/sys/bitstring_test.c

902

ATF_CHECK_EQ((ssize_t)early, fs);

tests/sys/sys/bitstring_test.c

911

bit_ffs(b, nbits, &fs);

tests/sys/sys/bitstring_test.c

912

ATF_CHECK_EQ((ssize_t)early - 1, fs);

tests/sys/sys/bitstring_test.c

925

bit_ffs(b, nbits, &fs);

tests/sys/sys/bitstring_test.c

926

ATF_CHECK_EQ((ssize_t)late, fs);

tests/sys/sys/bitstring_test.c

935

bit_ffs(b, nbits, &fs);

tests/sys/sys/bitstring_test.c

936

ATF_CHECK_EQ((ssize_t)late - 1, fs);

tools/diag/prtblknos/main.c

35

void prtblknos(struct fs *fs, union dinode *dp);

tools/diag/prtblknos/main.c

43

struct fs *fs;

tools/diag/prtblknos/main.c

79

fs = (struct fs *)&disk.d_sbunion.d_sb;

tools/diag/prtblknos/main.c

85

inonum >= (ino_t)fs->fs_ipg * fs->fs_ncg)

tools/diag/prtblknos/main.c

97

prtblknos(fs, (union dinode *)dp.dp1);

tools/diag/prtblknos/prtblknos.c

115

lastlbn = howmany(size, fs->fs_bsize);

tools/diag/prtblknos/prtblknos.c

119

frags = fs->fs_frag;

tools/diag/prtblknos/prtblknos.c

121

frags = howmany(size - (lastlbn - 1) * fs->fs_bsize,

tools/diag/prtblknos/prtblknos.c

122

fs->fs_fsize);

tools/diag/prtblknos/prtblknos.c

123

if (fs->fs_magic == FS_UFS1_MAGIC)

tools/diag/prtblknos/prtblknos.c

127

printblk(fs, i, blkno, frags, lastlbn);

tools/diag/prtblknos/prtblknos.c

134

if (fs->fs_magic == FS_UFS1_MAGIC)

tools/diag/prtblknos/prtblknos.c

138

indirprt(fs, i, blksperindir, lbn, blkno, lastlbn);

tools/diag/prtblknos/prtblknos.c

139

blksperindir *= NINDIR(fs);

tools/diag/prtblknos/prtblknos.c

145

printblk(fs, lastlbn, 0, frags, 0);

tools/diag/prtblknos/prtblknos.c

149

indirprt(struct fs *fs, int level, ufs_lbn_t blksperindir, ufs_lbn_t lbn,

tools/diag/prtblknos/prtblknos.c

156

printblk(fs, lbn, blkno,

tools/diag/prtblknos/prtblknos.c

157

blksperindir * NINDIR(fs) * fs->fs_frag, lastlbn);

tools/diag/prtblknos/prtblknos.c

160

printblk(fs, lbn, blkno, fs->fs_frag, -level);

tools/diag/prtblknos/prtblknos.c

163

if (bread(&disk, fsbtodb(fs, blkno), indir, fs->fs_bsize) == -1) {

tools/diag/prtblknos/prtblknos.c

165

bp = getdatablk(blkno, fs->fs_bsize, BT_LEVEL1 + level);

tools/diag/prtblknos/prtblknos.c

167

memcpy(indir, bp->b_un.b_buf, fs->fs_bsize);

tools/diag/prtblknos/prtblknos.c

172

printblk(fs, lbn, 0,

tools/diag/prtblknos/prtblknos.c

173

blksperindir * NINDIR(fs) * fs->fs_frag, lastlbn);

tools/diag/prtblknos/prtblknos.c

176

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

tools/diag/prtblknos/prtblknos.c

177

howmany(lastlbn - lbn, blksperindir) : NINDIR(fs);

tools/diag/prtblknos/prtblknos.c

180

if (fs->fs_magic == FS_UFS1_MAGIC)

tools/diag/prtblknos/prtblknos.c

184

printblk(fs, lbn + i, blkno, fs->fs_frag, lastlbn);

tools/diag/prtblknos/prtblknos.c

189

if (fs->fs_magic == FS_UFS1_MAGIC)

tools/diag/prtblknos/prtblknos.c

193

indirprt(fs, level - 1, blksperindir / NINDIR(fs),

tools/diag/prtblknos/prtblknos.c

199

distance(struct fs *fs, ufs2_daddr_t lastblk, ufs2_daddr_t firstblk)

tools/diag/prtblknos/prtblknos.c

208

firstcg = dtog(fs, firstblk);

tools/diag/prtblknos/prtblknos.c

209

lastcg = dtog(fs, lastblk);

tools/diag/prtblknos/prtblknos.c

215

lastcg, (intmax_t)dtogd(fs, lastblk), firstcg,

tools/diag/prtblknos/prtblknos.c

216

(intmax_t)dtogd(fs, firstblk));

tools/diag/prtblknos/prtblknos.c

224

printblk(struct fs *fs, ufs_lbn_t lbn, ufs2_daddr_t blkno, int numfrags,

tools/diag/prtblknos/prtblknos.c

233

seq = howmany(numfrags, fs->fs_frag);

tools/diag/prtblknos/prtblknos.c

239

seq = howmany(numfrags, fs->fs_frag);

tools/diag/prtblknos/prtblknos.c

249

blkno == firstblk + seq * fs->fs_frag)) {

tools/diag/prtblknos/prtblknos.c

250

seq += howmany(numfrags, fs->fs_frag);

tools/diag/prtblknos/prtblknos.c

272

(intmax_t)firstblk, distance(fs, lastblk, firstblk));

tools/diag/prtblknos/prtblknos.c

277

distance(fs, lastblk, firstblk));

tools/diag/prtblknos/prtblknos.c

283

distance(fs, lastblk, firstblk));

tools/diag/prtblknos/prtblknos.c

293

if (seq != 0 && (fs->fs_metaspace == 0 || lastindirblk == 0))

tools/diag/prtblknos/prtblknos.c

297

distance(fs, lastindirblk, blkno));

tools/diag/prtblknos/prtblknos.c

299

if (fs->fs_metaspace == 0)

tools/diag/prtblknos/prtblknos.c

42

void prtblknos(struct fs *fs, union dinode *dp);

tools/diag/prtblknos/prtblknos.c

44

static const char *distance(struct fs *, ufs2_daddr_t, ufs2_daddr_t);

tools/diag/prtblknos/prtblknos.c

45

static void printblk(struct fs *, ufs_lbn_t, ufs2_daddr_t, int, ufs_lbn_t);

tools/diag/prtblknos/prtblknos.c

46

static void indirprt(struct fs *, int, ufs_lbn_t, ufs_lbn_t, ufs2_daddr_t,

tools/diag/prtblknos/prtblknos.c

50

prtblknos(struct fs *fs, union dinode *dp)

tools/diag/prtblknos/prtblknos.c

57

if (fs->fs_magic == FS_UFS1_MAGIC) {

tools/diag/prtblknos/prtblknos.c

91

if (size < fs->fs_maxsymlinklen) {

tools/diag/prtblknos/prtblknos.c

93

(fs->fs_magic == FS_UFS1_MAGIC) ?

tools/test/stress2/tools/fstool.c

168

fs = 1024;

tools/test/stress2/tools/fstool.c

194

sscanf(optarg, "%d%c", &fs, &ch);

tools/test/stress2/tools/fstool.c

196

fs = fs * 1024;

tools/test/stress2/tools/fstool.c

198

fs = fs * 1024 * 1024;

tools/test/stress2/tools/fstool.c

224

if ((buffer = calloc(1, fs)) == NULL)

tools/test/stress2/tools/fstool.c

225

err(1, "calloc(%d)", fs);

tools/test/stress2/tools/fstool.c

43

static int edirs, dirs, files, fs;

tools/test/stress2/tools/fstool.c

66

len = fs;

tools/test/stress2/tools/fstool.c

69

len = arc4random() % fs + 1;

tools/test/stress2/tools/zapsb.c

34

char *fs, sblock[SBLOCKSIZE];

tools/test/stress2/tools/zapsb.c

35

struct fs *sbp;

tools/test/stress2/tools/zapsb.c

41

fs = *++argv;

tools/test/stress2/tools/zapsb.c

44

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

tools/test/stress2/tools/zapsb.c

45

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

tools/test/stress2/tools/zapsb.c

48

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

tools/test/stress2/tools/zapsb.c

50

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

tools/test/stress2/tools/zapsb.c

51

sbp = (struct fs *)sblock;

tools/test/stress2/tools/zapsb.c

56

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

tools/test/stress2/tools/zapsb.c

70

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

tools/test/stress2/tools/zapsb.c

72

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

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

25

struct fs sblock;

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

90

if (len >= sizeof(struct fs)) {

tools/tools/net80211/wesside/wesside/wesside.c

1688

void send_fragment(int tx, struct frag_state* fs, struct prga_info *pi) {

tools/tools/net80211/wesside/wesside/wesside.c

1700

memcpy(wh, &fs->wh, sizeof(*wh));

tools/tools/net80211/wesside/wesside/wesside.c

1707

fragsize = fs->data + fs->len - fs->ptr;

tools/tools/net80211/wesside/wesside/wesside.c

1720

memcpy(body, fs->ptr, fragsize);

tools/tools/net80211/wesside/wesside/wesside.c

1737

seq = (unsigned short*) &fs->wh.i_seq;

tools/tools/net80211/wesside/wesside/wesside.c

1739

fs->ptr += fragsize;

tools/tools/net80211/wesside/wesside/wesside.c

1741

if (fs->ptr - fs->data == fs->len) {

tools/tools/net80211/wesside/wesside/wesside.c

1743

fs->waiting_relay = 1;

tools/tools/net80211/wesside/wesside/wesside.c

1747

void prepare_fragstate(struct frag_state* fs, int pad) {

tools/tools/net80211/wesside/wesside/wesside.c

1748

fs->waiting_relay = 0;

tools/tools/net80211/wesside/wesside/wesside.c

1749

fs->len = 8 + 8 + 20 + pad;

tools/tools/net80211/wesside/wesside/wesside.c

1750

fs->data = (unsigned char*) malloc(fs->len);

tools/tools/net80211/wesside/wesside/wesside.c

1752

if(!fs->data) {

tools/tools/net80211/wesside/wesside/wesside.c

1757

fs->ptr = fs->data;

tools/tools/net80211/wesside/wesside/wesside.c

1759

do_llc(fs->data, ETHERTYPE_ARP);

tools/tools/net80211/wesside/wesside/wesside.c

1760

do_arp(&fs->data[8], ARPOP_REQUEST,

tools/tools/net80211/wesside/wesside/wesside.c

1764

memset(&fs->wh, 0, sizeof(fs->wh));

tools/tools/net80211/wesside/wesside/wesside.c

1765

fill_basic(&fs->wh);

tools/tools/net80211/wesside/wesside/wesside.c

1767

memset(fs->wh.i_addr3, 0xff, 6);

tools/tools/net80211/wesside/wesside/wesside.c

1768

fs->wh.i_fc[0] |= IEEE80211_FC0_TYPE_DATA;

tools/tools/net80211/wesside/wesside/wesside.c

1769

fs->wh.i_fc[1] |= IEEE80211_FC1_DIR_TODS |

tools/tools/net80211/wesside/wesside/wesside.c

1773

memset(&fs->data[8+8+20], 0, pad);

usr.bin/calendar/sunpos.c

202

double fe[2], fs[2];

usr.bin/calendar/sunpos.c

204

fequinoxsolstice(year, UTCoffset, fe, fs);

usr.bin/calendar/sunpos.c

207

solsticedays[0] = round(fs[0]);

usr.bin/calendar/sunpos.c

208

solsticedays[1] = round(fs[1]);

usr.bin/compress/compress.c

351

setfile(const char *name, struct stat *fs)

usr.bin/compress/compress.c

355

fs->st_mode &= S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO;

usr.bin/compress/compress.c

357

tspec[0] = fs->st_atim;

usr.bin/compress/compress.c

358

tspec[1] = fs->st_mtim;

usr.bin/compress/compress.c

368

if (chown(name, fs->st_uid, fs->st_gid)) {

usr.bin/compress/compress.c

371

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

usr.bin/compress/compress.c

373

if (chmod(name, fs->st_mode) && errno != EOPNOTSUPP)

usr.bin/compress/compress.c

376

if (chflags(name, fs->st_flags) && errno != EOPNOTSUPP)

usr.bin/hexdump/display.c

59

FS *fs;

usr.bin/hexdump/display.c

69

for (fs = fshead, savebp = bp, saveaddress = address; fs;

usr.bin/hexdump/display.c

70

fs = fs->nextfs, bp = savebp, address = saveaddress)

usr.bin/hexdump/display.c

71

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

144

size(FS *fs)

usr.bin/hexdump/parse.c

152

for (cursize = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

200

rewrite(FS *fs)

usr.bin/hexdump/parse.c

211

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

424

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

425

if (!fu->nextfu && fs->bcnt < blocksize &&

usr.bin/hexdump/parse.c

427

fu->reps += (blocksize - fs->bcnt) / fu->bcnt;

usr.bin/hexdump/parse.c

439

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/quota/quota.c

481

struct fstab *fs;

usr.bin/quota/quota.c

522

if ((fs = getfsspec(fst[i].f_mntfromname)) == NULL)

usr.bin/quota/quota.c

524

if (getufsquota(fs, qup, id, quotatype) == 0)

usr.bin/quota/quota.c

547

getufsquota(struct fstab *fs, struct quotause *qup, long id, int quotatype)

usr.bin/quota/quota.c

551

if ((qf = quota_open(fs, quotatype, O_RDONLY)) == NULL)

usr.bin/quota/quota.c

85

static int getufsquota(struct fstab *fs, struct quotause *qup, long id,

usr.sbin/bhyvectl/amd64/bhyvectl_machdep.c

643

uint64_t cs, ds, es, fs, gs, ss, tr, ldtr;

usr.sbin/bhyvectl/amd64/bhyvectl_machdep.c

755

error = vm_get_register(vcpu, VM_REG_GUEST_FS, &fs);

usr.sbin/bhyvectl/amd64/bhyvectl_machdep.c

757

printf("fs[%d]\t\t0x%04lx\n", vcpuid, fs);

usr.sbin/bsdinstall/partedit/partedit.h

85

int is_fs_bootable(const char *scheme, const char *fs); /* Ditto if FS boots */

usr.sbin/bsdinstall/partedit/partedit_efi.c

61

is_fs_bootable(const char *part_type, const char *fs)

usr.sbin/bsdinstall/partedit/partedit_efi.c

64

if (strcmp(fs, "freebsd-ufs") == 0)

usr.sbin/bsdinstall/partedit/partedit_generic.c

54

is_fs_bootable(const char *part_type, const char *fs) {

usr.sbin/bsdinstall/partedit/partedit_powerpc.c

74

is_fs_bootable(const char *part_type, const char *fs)

usr.sbin/bsdinstall/partedit/partedit_powerpc.c

76

if (strcmp(fs, "freebsd-ufs") == 0)

usr.sbin/bsdinstall/partedit/partedit_x86.c

80

is_fs_bootable(const char *part_type, const char *fs)

usr.sbin/bsdinstall/partedit/partedit_x86.c

83

if (strcmp(fs, "freebsd-ufs") == 0)

usr.sbin/bsdinstall/partedit/partedit_x86.c

86

if (strcmp(fs, "freebsd-zfs") == 0 &&

usr.sbin/cxgbetool/cxgbetool.c

1016

t.fs.hash = hash;

usr.sbin/cxgbetool/cxgbetool.c

1158

t.fs.prio = prio;

usr.sbin/cxgbetool/cxgbetool.c

1159

t.fs.hash = hashfilter;

usr.sbin/cxgbetool/cxgbetool.c

1179

t.fs.hitcnts = 1;

usr.sbin/cxgbetool/cxgbetool.c

1180

t.fs.hash = hash;

usr.sbin/cxgbetool/cxgbetool.c

1205

t.fs.val.fcoe = val;

usr.sbin/cxgbetool/cxgbetool.c

1206

t.fs.mask.fcoe = mask;

usr.sbin/cxgbetool/cxgbetool.c

1208

t.fs.val.iport = val;

usr.sbin/cxgbetool/cxgbetool.c

1209

t.fs.mask.iport = mask;

usr.sbin/cxgbetool/cxgbetool.c

1211

t.fs.val.vnic = val;

usr.sbin/cxgbetool/cxgbetool.c

1212

t.fs.mask.vnic = mask;

usr.sbin/cxgbetool/cxgbetool.c

1213

t.fs.val.ovlan_vld = 1;

usr.sbin/cxgbetool/cxgbetool.c

1214

t.fs.mask.ovlan_vld = 1;

usr.sbin/cxgbetool/cxgbetool.c

1216

t.fs.val.vlan = val;

usr.sbin/cxgbetool/cxgbetool.c

1217

t.fs.mask.vlan = mask;

usr.sbin/cxgbetool/cxgbetool.c

1218

t.fs.val.vlan_vld = 1;

usr.sbin/cxgbetool/cxgbetool.c

1219

t.fs.mask.vlan_vld = 1;

usr.sbin/cxgbetool/cxgbetool.c

1221

t.fs.val.vnic &= 0x1fff;

usr.sbin/cxgbetool/cxgbetool.c

1222

t.fs.val.vnic |= (val & 0x7) << 13;

usr.sbin/cxgbetool/cxgbetool.c

1223

t.fs.mask.vnic &= 0x1fff;

usr.sbin/cxgbetool/cxgbetool.c

1224

t.fs.mask.vnic |= (mask & 0x7) << 13;

usr.sbin/cxgbetool/cxgbetool.c

1225

t.fs.val.pfvf_vld = 1;

usr.sbin/cxgbetool/cxgbetool.c

1226

t.fs.mask.pfvf_vld = 1;

usr.sbin/cxgbetool/cxgbetool.c

1228

t.fs.val.vnic &= 0xe000;

usr.sbin/cxgbetool/cxgbetool.c

1229

t.fs.val.vnic |= val & 0x1fff;

usr.sbin/cxgbetool/cxgbetool.c

1230

t.fs.mask.vnic &= 0xe000;

usr.sbin/cxgbetool/cxgbetool.c

1231

t.fs.mask.vnic |= mask & 0x1fff;

usr.sbin/cxgbetool/cxgbetool.c

1232

t.fs.val.pfvf_vld = 1;

usr.sbin/cxgbetool/cxgbetool.c

1233

t.fs.mask.pfvf_vld = 1;

usr.sbin/cxgbetool/cxgbetool.c

1235

t.fs.val.tos = val;

usr.sbin/cxgbetool/cxgbetool.c

1236

t.fs.mask.tos = mask;

usr.sbin/cxgbetool/cxgbetool.c

1238

t.fs.val.proto = val;

usr.sbin/cxgbetool/cxgbetool.c

1239

t.fs.mask.proto = mask;

usr.sbin/cxgbetool/cxgbetool.c

1241

t.fs.val.ethtype = val;

usr.sbin/cxgbetool/cxgbetool.c

1242

t.fs.mask.ethtype = mask;

usr.sbin/cxgbetool/cxgbetool.c

1244

t.fs.val.macidx = val;

usr.sbin/cxgbetool/cxgbetool.c

1245

t.fs.mask.macidx = mask;

usr.sbin/cxgbetool/cxgbetool.c

1247

t.fs.val.matchtype = val;

usr.sbin/cxgbetool/cxgbetool.c

1248

t.fs.mask.matchtype = mask;

usr.sbin/cxgbetool/cxgbetool.c

1250

t.fs.val.frag = val;

usr.sbin/cxgbetool/cxgbetool.c

1251

t.fs.mask.frag = mask;

usr.sbin/cxgbetool/cxgbetool.c

1253

t.fs.val.dport = val;

usr.sbin/cxgbetool/cxgbetool.c

1254

t.fs.mask.dport = mask;

usr.sbin/cxgbetool/cxgbetool.c

1256

t.fs.val.sport = val;

usr.sbin/cxgbetool/cxgbetool.c

1257

t.fs.mask.sport = mask;

usr.sbin/cxgbetool/cxgbetool.c

1258

} else if (!parse_ipaddr("dip", args, &af, t.fs.val.dip,

usr.sbin/cxgbetool/cxgbetool.c

1259

t.fs.mask.dip, hash)) {

usr.sbin/cxgbetool/cxgbetool.c

1261

} else if (!parse_ipaddr("sip", args, &af, t.fs.val.sip,

usr.sbin/cxgbetool/cxgbetool.c

1262

t.fs.mask.sip, hash)) {

usr.sbin/cxgbetool/cxgbetool.c

1264

} else if (!parse_ipaddr("nat_dip", args, &af, t.fs.nat_dip, NULL, 1)) {

usr.sbin/cxgbetool/cxgbetool.c

1266

} else if (!parse_ipaddr("nat_sip", args, &af, t.fs.nat_sip, NULL, 1)) {

usr.sbin/cxgbetool/cxgbetool.c

1269

t.fs.nat_dport = val;

usr.sbin/cxgbetool/cxgbetool.c

1271

t.fs.nat_sport = val;

usr.sbin/cxgbetool/cxgbetool.c

1274

t.fs.action = FILTER_PASS;

usr.sbin/cxgbetool/cxgbetool.c

1276

t.fs.action = FILTER_DROP;

usr.sbin/cxgbetool/cxgbetool.c

1278

t.fs.action = FILTER_SWITCH;

usr.sbin/cxgbetool/cxgbetool.c

1286

t.fs.hitcnts = val;

usr.sbin/cxgbetool/cxgbetool.c

1297

t.fs.prio = val;

usr.sbin/cxgbetool/cxgbetool.c

1299

t.fs.rpttid = 1;

usr.sbin/cxgbetool/cxgbetool.c

1301

t.fs.dirsteer = 1; /* direct steer */

usr.sbin/cxgbetool/cxgbetool.c

1302

t.fs.iq = val; /* to the iq with this cntxt_id */

usr.sbin/cxgbetool/cxgbetool.c

1304

t.fs.dirsteerhash = 1; /* direct steer */

usr.sbin/cxgbetool/cxgbetool.c

1306

t.fs.iq = val;

usr.sbin/cxgbetool/cxgbetool.c

1308

t.fs.maskhash = 1; /* steer to RSS region */

usr.sbin/cxgbetool/cxgbetool.c

1313

t.fs.iq = val >> 1;

usr.sbin/cxgbetool/cxgbetool.c

1315

t.fs.eport = val;

usr.sbin/cxgbetool/cxgbetool.c

1317

t.fs.swapmac = 1;

usr.sbin/cxgbetool/cxgbetool.c

1320

t.fs.nat_mode = NAT_MODE_DIP;

usr.sbin/cxgbetool/cxgbetool.c

1322

t.fs.nat_mode = NAT_MODE_DIP_DP;

usr.sbin/cxgbetool/cxgbetool.c

1324

t.fs.nat_mode = NAT_MODE_DIP_DP_SIP;

usr.sbin/cxgbetool/cxgbetool.c

1326

t.fs.nat_mode = NAT_MODE_DIP_DP_SP;

usr.sbin/cxgbetool/cxgbetool.c

1328

t.fs.nat_mode = NAT_MODE_SIP_SP;

usr.sbin/cxgbetool/cxgbetool.c

1330

t.fs.nat_mode = NAT_MODE_DIP_SIP_SP;

usr.sbin/cxgbetool/cxgbetool.c

1332

t.fs.nat_mode = NAT_MODE_ALL;

usr.sbin/cxgbetool/cxgbetool.c

1340

t.fs.nat_seq_chk = val;

usr.sbin/cxgbetool/cxgbetool.c

1342

t.fs.nat_flag_chk = 1;

usr.sbin/cxgbetool/cxgbetool.c

1352

memcpy(t.fs.dmac, daddr, ETHER_ADDR_LEN);

usr.sbin/cxgbetool/cxgbetool.c

1353

t.fs.newdmac = 1;

usr.sbin/cxgbetool/cxgbetool.c

1363

memcpy(t.fs.smac, saddr, ETHER_ADDR_LEN);

usr.sbin/cxgbetool/cxgbetool.c

1364

t.fs.newsmac = 1;

usr.sbin/cxgbetool/cxgbetool.c

1368

t.fs.newvlan = VLAN_REMOVE;

usr.sbin/cxgbetool/cxgbetool.c

1370

t.fs.newvlan = VLAN_REWRITE;

usr.sbin/cxgbetool/cxgbetool.c

1372

t.fs.newvlan = VLAN_INSERT;

usr.sbin/cxgbetool/cxgbetool.c

1379

if (t.fs.newvlan == VLAN_REWRITE ||

usr.sbin/cxgbetool/cxgbetool.c

1380

t.fs.newvlan == VLAN_INSERT) {

usr.sbin/cxgbetool/cxgbetool.c

1381

t.fs.vlan = strtoul(argv[start_arg + 1] + 1,

usr.sbin/cxgbetool/cxgbetool.c

1384

t.fs.vlan > MAX_VLANID) {

usr.sbin/cxgbetool/cxgbetool.c

1403

if (t.fs.action != FILTER_SWITCH &&

usr.sbin/cxgbetool/cxgbetool.c

1404

(t.fs.eport || t.fs.newdmac || t.fs.newsmac || t.fs.newvlan ||

usr.sbin/cxgbetool/cxgbetool.c

1405

t.fs.swapmac || t.fs.nat_mode)) {

usr.sbin/cxgbetool/cxgbetool.c

1410

if (!t.fs.nat_mode && (t.fs.nat_seq_chk || t.fs.nat_flag_chk ||

usr.sbin/cxgbetool/cxgbetool.c

1411

*t.fs.nat_dip || *t.fs.nat_sip || t.fs.nat_dport || t.fs.nat_sport)) {

usr.sbin/cxgbetool/cxgbetool.c

1415

if (t.fs.action != FILTER_PASS &&

usr.sbin/cxgbetool/cxgbetool.c

1416

(t.fs.rpttid || t.fs.dirsteer || t.fs.maskhash)) {

usr.sbin/cxgbetool/cxgbetool.c

1421

if (t.fs.val.ovlan_vld && t.fs.val.pfvf_vld) {

usr.sbin/cxgbetool/cxgbetool.c

1426

t.fs.type = (af == AF_INET6 ? 1 : 0); /* default IPv4 */

usr.sbin/cxgbetool/cxgbetool.c

869

printf(" %1d/%1d", t->fs.val.fcoe, t->fs.mask.fcoe);

usr.sbin/cxgbetool/cxgbetool.c

872

printf(" %1d/%1d", t->fs.val.iport, t->fs.mask.iport);

usr.sbin/cxgbetool/cxgbetool.c

877

t->fs.val.pfvf_vld,

usr.sbin/cxgbetool/cxgbetool.c

878

(t->fs.val.vnic >> 13) & 0x7,

usr.sbin/cxgbetool/cxgbetool.c

879

t->fs.val.vnic & 0x1fff,

usr.sbin/cxgbetool/cxgbetool.c

880

t->fs.mask.pfvf_vld,

usr.sbin/cxgbetool/cxgbetool.c

881

(t->fs.mask.vnic >> 13) & 0x7,

usr.sbin/cxgbetool/cxgbetool.c

882

t->fs.mask.vnic & 0x1fff);

usr.sbin/cxgbetool/cxgbetool.c

885

t->fs.val.ovlan_vld, t->fs.val.vnic,

usr.sbin/cxgbetool/cxgbetool.c

886

t->fs.mask.ovlan_vld, t->fs.mask.vnic);

usr.sbin/cxgbetool/cxgbetool.c

891

t->fs.val.vlan_vld, t->fs.val.vlan,

usr.sbin/cxgbetool/cxgbetool.c

892

t->fs.mask.vlan_vld, t->fs.mask.vlan);

usr.sbin/cxgbetool/cxgbetool.c

895

printf(" %02x/%02x", t->fs.val.tos, t->fs.mask.tos);

usr.sbin/cxgbetool/cxgbetool.c

898

printf(" %02x/%02x", t->fs.val.proto, t->fs.mask.proto);

usr.sbin/cxgbetool/cxgbetool.c

901

printf(" %04x/%04x", t->fs.val.ethtype,

usr.sbin/cxgbetool/cxgbetool.c

902

t->fs.mask.ethtype);

usr.sbin/cxgbetool/cxgbetool.c

905

printf(" %03x/%03x", t->fs.val.macidx,

usr.sbin/cxgbetool/cxgbetool.c

906

t->fs.mask.macidx);

usr.sbin/cxgbetool/cxgbetool.c

909

printf(" %1x/%1x", t->fs.val.matchtype,

usr.sbin/cxgbetool/cxgbetool.c

910

t->fs.mask.matchtype);

usr.sbin/cxgbetool/cxgbetool.c

913

printf(" %1d/%1d", t->fs.val.frag, t->fs.mask.frag);

usr.sbin/cxgbetool/cxgbetool.c

924

filters_show_ipaddr(t->fs.type, t->fs.val.dip, t->fs.mask.dip);

usr.sbin/cxgbetool/cxgbetool.c

925

filters_show_ipaddr(t->fs.type, t->fs.val.sip, t->fs.mask.sip);

usr.sbin/cxgbetool/cxgbetool.c

927

t->fs.val.dport, t->fs.mask.dport,

usr.sbin/cxgbetool/cxgbetool.c

928

t->fs.val.sport, t->fs.mask.sport);

usr.sbin/cxgbetool/cxgbetool.c

933

if (t->fs.action == FILTER_DROP)

usr.sbin/cxgbetool/cxgbetool.c

935

else if (t->fs.action == FILTER_SWITCH) {

usr.sbin/cxgbetool/cxgbetool.c

936

printf(" Switch: port=%d", t->fs.eport);

usr.sbin/cxgbetool/cxgbetool.c

937

if (t->fs.newdmac)

usr.sbin/cxgbetool/cxgbetool.c

941

t->fs.dmac[0], t->fs.dmac[1],

usr.sbin/cxgbetool/cxgbetool.c

942

t->fs.dmac[2], t->fs.dmac[3],

usr.sbin/cxgbetool/cxgbetool.c

943

t->fs.dmac[4], t->fs.dmac[5],

usr.sbin/cxgbetool/cxgbetool.c

945

if (t->fs.newsmac)

usr.sbin/cxgbetool/cxgbetool.c

949

t->fs.smac[0], t->fs.smac[1],

usr.sbin/cxgbetool/cxgbetool.c

950

t->fs.smac[2], t->fs.smac[3],

usr.sbin/cxgbetool/cxgbetool.c

951

t->fs.smac[4], t->fs.smac[5],

usr.sbin/cxgbetool/cxgbetool.c

953

if (t->fs.newvlan == VLAN_REMOVE)

usr.sbin/cxgbetool/cxgbetool.c

955

else if (t->fs.newvlan == VLAN_INSERT)

usr.sbin/cxgbetool/cxgbetool.c

956

printf(", vlan=insert(%x)", t->fs.vlan);

usr.sbin/cxgbetool/cxgbetool.c

957

else if (t->fs.newvlan == VLAN_REWRITE)

usr.sbin/cxgbetool/cxgbetool.c

958

printf(", vlan=rewrite(%x)", t->fs.vlan);

usr.sbin/cxgbetool/cxgbetool.c

961

if (t->fs.dirsteer == 0) {

usr.sbin/cxgbetool/cxgbetool.c

963

if (t->fs.maskhash)

usr.sbin/cxgbetool/cxgbetool.c

964

printf("(region %d)", t->fs.iq << 1);

usr.sbin/cxgbetool/cxgbetool.c

966

printf("%d", t->fs.iq);

usr.sbin/cxgbetool/cxgbetool.c

967

if (t->fs.dirsteerhash == 0)

usr.sbin/cxgbetool/cxgbetool.c

973

if (g.chip_id <= 5 && t->fs.prio)

usr.sbin/cxgbetool/cxgbetool.c

975

if (t->fs.rpttid)

usr.sbin/cxgbetool/cxgbetool.c

996

t.fs.hash = 0;

usr.sbin/cxgbetool/cxgbetool.c

997

t.fs.prio = 1;

usr.sbin/edquota/edquota.c

360

struct fstab *fs;

usr.sbin/edquota/edquota.c

366

while ((fs = getfsent())) {

usr.sbin/edquota/edquota.c

367

if (fspath && *fspath && strcmp(fspath, fs->fs_spec) &&

usr.sbin/edquota/edquota.c

368

strcmp(fspath, fs->fs_file))

usr.sbin/edquota/edquota.c

370

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

usr.sbin/edquota/edquota.c

372

if ((qf = quota_open(fs, quotatype, O_CREAT|O_RDWR)) == NULL) {

usr.sbin/edquota/edquota.c

374

warn("cannot open quotas on %s", fs->fs_file);

usr.sbin/edquota/edquota.c

380

strlcpy(qup->fsname, fs->fs_file, sizeof(qup->fsname));

usr.sbin/edquota/edquota.c

382

warn("cannot read quotas on %s", fs->fs_file);

usr.sbin/fifolog/lib/fifolog_int.c

138

struct fifolog_file fs, *f;

usr.sbin/fifolog/lib/fifolog_int.c

142

f = &fs;

usr.sbin/fstyp/ext2fs.c

57

e2sb_t *fs;

usr.sbin/fstyp/ext2fs.c

60

fs = (e2sb_t *)read_buf(fp, EXT2FS_SB_OFFSET, 512);

usr.sbin/fstyp/ext2fs.c

61

if (fs == NULL)

usr.sbin/fstyp/ext2fs.c

65

if (fs->s_magic == EXT2_SUPER_MAGIC &&

usr.sbin/fstyp/ext2fs.c

66

fs->s_rev_level == EXT2_DYNAMIC_REV) {

usr.sbin/fstyp/ext2fs.c

70

free(fs);

usr.sbin/fstyp/ext2fs.c

74

s_volume_name = fs->s_volume_name;

usr.sbin/fstyp/ext2fs.c

76

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

usr.sbin/fstyp/ext2fs.c

82

free(fs);

usr.sbin/fstyp/ufs.c

50

struct fs *fs;

usr.sbin/fstyp/ufs.c

52

switch (sbget(fileno(fp), &fs, UFS_STDSB, UFS_NOCSUM)) {

usr.sbin/fstyp/ufs.c

54

strlcpy(label, fs->fs_volname, labelsize);

usr.sbin/fstyp/ufs.c

55

free(fs);

usr.sbin/fwcontrol/fwdv.c

192

system = ciph->fdf.dv.fs;

usr.sbin/makefs/ffs.c

1158

struct fs *fs;

usr.sbin/makefs/ffs.c

1171

fs = (struct fs *)fsopts->superblock;

usr.sbin/makefs/ffs.c

1172

cg = ino_to_cg(fs, ino);

usr.sbin/makefs/ffs.c

1173

cgino = ino % fs->fs_ipg;

usr.sbin/makefs/ffs.c

1178

ffs_rdfs(fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize, &sbbuf,

usr.sbin/makefs/ffs.c

1186

buf = emalloc(fs->fs_bsize);

usr.sbin/makefs/ffs.c

1190

if (fs->fs_cstotal.cs_nifree == 0)

usr.sbin/makefs/ffs.c

1193

if (fs->fs_cs(fs, cg).cs_nifree == 0)

usr.sbin/makefs/ffs.c

1199

fs->fs_cstotal.cs_nifree--;

usr.sbin/makefs/ffs.c

1200

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

usr.sbin/makefs/ffs.c

1203

fs->fs_cstotal.cs_ndir++;

usr.sbin/makefs/ffs.c

1204

fs->fs_cs(fs, cg).cs_ndir++;

usr.sbin/makefs/ffs.c

1211

while (ffs_opts->version == 2 && cgino + INOPB(fs) > initediblk &&

usr.sbin/makefs/ffs.c

1213

memset(buf, 0, fs->fs_bsize);

usr.sbin/makefs/ffs.c

1215

for (i = 0; i < INOPB(fs); i++) {

usr.sbin/makefs/ffs.c

1219

ffs_wtfs(fsbtodb(fs, ino_to_fsba(fs,

usr.sbin/makefs/ffs.c

1220

cg * fs->fs_ipg + initediblk)),

usr.sbin/makefs/ffs.c

1221

fs->fs_bsize, buf, fsopts);

usr.sbin/makefs/ffs.c

1222

initediblk += INOPB(fs);

usr.sbin/makefs/ffs.c

1227

ffs_wtfs(fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize, &sbbuf,

usr.sbin/makefs/ffs.c

1231

d = fsbtodb(fs, ino_to_fsba(fs, ino));

usr.sbin/makefs/ffs.c

1232

ffs_rdfs(d, fs->fs_bsize, buf, fsopts);

usr.sbin/makefs/ffs.c

1236

&dp1[ino_to_fsbo(fs, ino)]);

usr.sbin/makefs/ffs.c

1239

&dp2[ino_to_fsbo(fs, ino)]);

usr.sbin/makefs/ffs.c

1242

dp1[ino_to_fsbo(fs, ino)] = dp->dp1;

usr.sbin/makefs/ffs.c

1244

dp2[ino_to_fsbo(fs, ino)] = dp->dp2;

usr.sbin/makefs/ffs.c

1246

ffs_wtfs(d, fs->fs_bsize, buf, fsopts);

usr.sbin/makefs/ffs.c

254

struct fs *superblock;

usr.sbin/makefs/ffs.c

457

ffs_opt_t *fs = f->fs_specific;

usr.sbin/makefs/ffs.c

473

fs->bsize, fs->fsize, fs->cpg, fs->density);

usr.sbin/makefs/ffs.c

475

fs->nsectors, fs->rpm, fs->minfree);

usr.sbin/makefs/ffs.c

477

fs->maxcontig, fs->maxbpg);

usr.sbin/makefs/ffs.c

479

fs->optimization == FS_OPTSPACE ? "space" : "time");

usr.sbin/makefs/ffs.c

489

struct fs *fs;

usr.sbin/makefs/ffs.c

568

fs = ffs_mkfs(image, fsopts, tstamp);

usr.sbin/makefs/ffs.c

569

fsopts->superblock = (void *)fs;

usr.sbin/makefs/ffs.c

573

t = (time_t)((struct fs *)fsopts->superblock)->fs_time;

usr.sbin/makefs/ffs.c

577

(long long)fs->fs_cstotal.cs_nbfree,

usr.sbin/makefs/ffs.c

578

(long long)fs->fs_cstotal.cs_nffree,

usr.sbin/makefs/ffs.c

579

(long long)fs->fs_cstotal.cs_nifree,

usr.sbin/makefs/ffs.c

580

(long long)fs->fs_cstotal.cs_ndir);

usr.sbin/makefs/ffs.c

583

if (fs->fs_cstotal.cs_nifree + (off_t)UFS_ROOTINO < fsopts->inodes) {

usr.sbin/makefs/ffs.c

587

(long long)(fs->fs_cstotal.cs_nifree + UFS_ROOTINO),

usr.sbin/makefs/ffs.c

984

in.i_fs = (struct fs *)fsopts->superblock;

usr.sbin/makefs/ffs/buf.c

129

fsinfo_t *fs = bp->b_fs;

usr.sbin/makefs/ffs/buf.c

132

offset = (off_t)bp->b_blkno * fs->sectorsize + fs->offset;

usr.sbin/makefs/ffs/buf.c

206

bp->b_fs = vp->fs;

usr.sbin/makefs/ffs/buf.c

62

fsinfo_t *fs = vp->fs;

usr.sbin/makefs/ffs/buf.c

70

offset = (off_t)(*bpp)->b_blkno * fs->sectorsize + fs->offset;

usr.sbin/makefs/ffs/buf.h

51

struct makefs_fsinfo *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

100

if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)

usr.sbin/makefs/ffs/ffs_alloc.c

102

if (bpref >= fs->fs_size)

usr.sbin/makefs/ffs/ffs_alloc.c

105

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

usr.sbin/makefs/ffs/ffs_alloc.c

107

cg = dtog(fs, bpref);

usr.sbin/makefs/ffs/ffs_alloc.c

151

struct fs *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

155

fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

156

if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {

usr.sbin/makefs/ffs/ffs_alloc.c

157

if (lbn < UFS_NDADDR + NINDIR(fs)) {

usr.sbin/makefs/ffs/ffs_alloc.c

158

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

usr.sbin/makefs/ffs/ffs_alloc.c

159

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

167

ino_to_cg(fs, ip->i_number) + lbn / fs->fs_maxbpg;

usr.sbin/makefs/ffs/ffs_alloc.c

169

startcg = dtog(fs,

usr.sbin/makefs/ffs/ffs_alloc.c

170

ufs_rw32(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + 1);

usr.sbin/makefs/ffs/ffs_alloc.c

171

startcg %= fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

172

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

173

for (cg = startcg; cg < fs->fs_ncg; cg++)

usr.sbin/makefs/ffs/ffs_alloc.c

174

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree)

usr.sbin/makefs/ffs/ffs_alloc.c

175

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

177

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree)

usr.sbin/makefs/ffs/ffs_alloc.c

178

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

184

return ufs_rw32(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + fs->fs_frag;

usr.sbin/makefs/ffs/ffs_alloc.c

190

struct fs *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

194

fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

195

if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {

usr.sbin/makefs/ffs/ffs_alloc.c

196

if (lbn < UFS_NDADDR + NINDIR(fs)) {

usr.sbin/makefs/ffs/ffs_alloc.c

197

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

usr.sbin/makefs/ffs/ffs_alloc.c

198

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

206

ino_to_cg(fs, ip->i_number) + lbn / fs->fs_maxbpg;

usr.sbin/makefs/ffs/ffs_alloc.c

208

startcg = dtog(fs,

usr.sbin/makefs/ffs/ffs_alloc.c

209

ufs_rw64(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + 1);

usr.sbin/makefs/ffs/ffs_alloc.c

210

startcg %= fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

211

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

212

for (cg = startcg; cg < fs->fs_ncg; cg++)

usr.sbin/makefs/ffs/ffs_alloc.c

213

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

usr.sbin/makefs/ffs/ffs_alloc.c

214

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

217

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

usr.sbin/makefs/ffs/ffs_alloc.c

218

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

225

return ufs_rw64(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + fs->fs_frag;

usr.sbin/makefs/ffs/ffs_alloc.c

243

struct fs *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

247

fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

257

for (i = 1; i < fs->fs_ncg; i *= 2) {

usr.sbin/makefs/ffs/ffs_alloc.c

259

if (cg >= fs->fs_ncg)

usr.sbin/makefs/ffs/ffs_alloc.c

260

cg -= fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

270

cg = (icg + 2) % fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

271

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

usr.sbin/makefs/ffs/ffs_alloc.c

276

if (cg == fs->fs_ncg)

usr.sbin/makefs/ffs/ffs_alloc.c

295

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

296

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

298

if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)

usr.sbin/makefs/ffs/ffs_alloc.c

300

error = bread((void *)ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),

usr.sbin/makefs/ffs/ffs_alloc.c

301

(int)fs->fs_cgsize, NULL, &bp);

usr.sbin/makefs/ffs/ffs_alloc.c

307

(cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize)) {

usr.sbin/makefs/ffs/ffs_alloc.c

311

if (size == fs->fs_bsize) {

usr.sbin/makefs/ffs/ffs_alloc.c

321

frags = numfrags(fs, size);

usr.sbin/makefs/ffs/ffs_alloc.c

322

for (allocsiz = frags; allocsiz < fs->fs_frag; allocsiz++)

usr.sbin/makefs/ffs/ffs_alloc.c

325

if (allocsiz == fs->fs_frag) {

usr.sbin/makefs/ffs/ffs_alloc.c

335

bpref = dtogd(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

336

for (i = frags; i < fs->fs_frag; i++)

usr.sbin/makefs/ffs/ffs_alloc.c

338

i = fs->fs_frag - frags;

usr.sbin/makefs/ffs/ffs_alloc.c

340

fs->fs_cstotal.cs_nffree += i;

usr.sbin/makefs/ffs/ffs_alloc.c

341

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

usr.sbin/makefs/ffs/ffs_alloc.c

342

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

347

bno = ffs_mapsearch(fs, cgp, bpref, allocsiz);

usr.sbin/makefs/ffs/ffs_alloc.c

351

fs->fs_cstotal.cs_nffree -= frags;

usr.sbin/makefs/ffs/ffs_alloc.c

352

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

usr.sbin/makefs/ffs/ffs_alloc.c

353

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

357

blkno = cg * fs->fs_fpg + bno;

usr.sbin/makefs/ffs/ffs_alloc.c

379

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

380

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

385

if (bpref == 0 || (uint32_t)dtog(fs, bpref) != ufs_rw32(cgp->cg_cgx, needswap)) {

usr.sbin/makefs/ffs/ffs_alloc.c

388

bpref = blknum(fs, bpref);

usr.sbin/makefs/ffs/ffs_alloc.c

389

bno = dtogd(fs, bpref);

usr.sbin/makefs/ffs/ffs_alloc.c

393

if (ffs_isblock(fs, blksfree_swap, fragstoblks(fs, bno)))

usr.sbin/makefs/ffs/ffs_alloc.c

399

bno = ffs_mapsearch(fs, cgp, bpref, (int)fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

404

blkno = fragstoblks(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

405

ffs_clrblock(fs, blksfree_swap, (long)blkno);

usr.sbin/makefs/ffs/ffs_alloc.c

406

ffs_clusteracct(fs, cgp, blkno, -1);

usr.sbin/makefs/ffs/ffs_alloc.c

408

fs->fs_cstotal.cs_nbfree--;

usr.sbin/makefs/ffs/ffs_alloc.c

409

fs->fs_cs(fs, ufs_rw32(cgp->cg_cgx, needswap)).cs_nbfree--;

usr.sbin/makefs/ffs/ffs_alloc.c

410

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

411

blkno = ufs_rw32(cgp->cg_cgx, needswap) * fs->fs_fpg + bno;

usr.sbin/makefs/ffs/ffs_alloc.c

429

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

430

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

432

if (size > fs->fs_bsize || fragoff(fs, size) != 0 ||

usr.sbin/makefs/ffs/ffs_alloc.c

433

fragnum(fs, bno) + numfrags(fs, size) > fs->fs_frag) {

usr.sbin/makefs/ffs/ffs_alloc.c

435

(long long)bno, fs->fs_bsize, size);

usr.sbin/makefs/ffs/ffs_alloc.c

437

cg = dtog(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

438

if (bno >= fs->fs_size) {

usr.sbin/makefs/ffs/ffs_alloc.c

443

error = bread((void *)ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),

usr.sbin/makefs/ffs/ffs_alloc.c

444

(int)fs->fs_cgsize, NULL, &bp);

usr.sbin/makefs/ffs/ffs_alloc.c

453

cgbno = dtogd(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

454

if (size == fs->fs_bsize) {

usr.sbin/makefs/ffs/ffs_alloc.c

455

fragno = fragstoblks(fs, cgbno);

usr.sbin/makefs/ffs/ffs_alloc.c

456

if (!ffs_isfreeblock(fs, cg_blksfree_swap(cgp, needswap), fragno)) {

usr.sbin/makefs/ffs/ffs_alloc.c

460

ffs_setblock(fs, cg_blksfree_swap(cgp, needswap), fragno);

usr.sbin/makefs/ffs/ffs_alloc.c

461

ffs_clusteracct(fs, cgp, fragno, 1);

usr.sbin/makefs/ffs/ffs_alloc.c

463

fs->fs_cstotal.cs_nbfree++;

usr.sbin/makefs/ffs/ffs_alloc.c

464

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

usr.sbin/makefs/ffs/ffs_alloc.c

466

bbase = cgbno - fragnum(fs, cgbno);

usr.sbin/makefs/ffs/ffs_alloc.c

470

blk = blkmap(fs, cg_blksfree_swap(cgp, needswap), bbase);

usr.sbin/makefs/ffs/ffs_alloc.c

471

ffs_fragacct_swap(fs, blk, cgp->cg_frsum, -1, needswap);

usr.sbin/makefs/ffs/ffs_alloc.c

475

frags = numfrags(fs, size);

usr.sbin/makefs/ffs/ffs_alloc.c

484

fs->fs_cstotal.cs_nffree += i;

usr.sbin/makefs/ffs/ffs_alloc.c

485

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

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

fragno = fragstoblks(fs, bbase);

usr.sbin/makefs/ffs/ffs_alloc.c

495

if (ffs_isblock(fs, cg_blksfree_swap(cgp, needswap), fragno)) {

usr.sbin/makefs/ffs/ffs_alloc.c

496

ufs_add32(cgp->cg_cs.cs_nffree, -fs->fs_frag, needswap);

usr.sbin/makefs/ffs/ffs_alloc.c

497

fs->fs_cstotal.cs_nffree -= fs->fs_frag;

usr.sbin/makefs/ffs/ffs_alloc.c

498

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

usr.sbin/makefs/ffs/ffs_alloc.c

499

ffs_clusteracct(fs, cgp, fragno, 1);

usr.sbin/makefs/ffs/ffs_alloc.c

501

fs->fs_cstotal.cs_nbfree++;

usr.sbin/makefs/ffs/ffs_alloc.c

502

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

usr.sbin/makefs/ffs/ffs_alloc.c

505

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

527

ffs_mapsearch(struct fs *fs, struct cg *cgp, daddr_t bpref, int allocsiz)

usr.sbin/makefs/ffs/ffs_alloc.c

533

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

540

start = dtogd(fs, bpref) / NBBY;

usr.sbin/makefs/ffs/ffs_alloc.c

543

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

usr.sbin/makefs/ffs/ffs_alloc.c

548

(const u_char *)fragtbl[fs->fs_frag],

usr.sbin/makefs/ffs/ffs_alloc.c

549

(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

usr.sbin/makefs/ffs/ffs_alloc.c

555

(const u_char *)fragtbl[fs->fs_frag],

usr.sbin/makefs/ffs/ffs_alloc.c

556

(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

usr.sbin/makefs/ffs/ffs_alloc.c

572

for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {

usr.sbin/makefs/ffs/ffs_alloc.c

573

blk = blkmap(fs, cg_blksfree_swap(cgp, needswap), bno);

usr.sbin/makefs/ffs/ffs_alloc.c

577

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

usr.sbin/makefs/ffs/ffs_alloc.c

594

ffs_clusteracct(struct fs *fs, struct cg *cgp, int32_t blkno, int cnt)

usr.sbin/makefs/ffs/ffs_alloc.c

600

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

602

if (fs->fs_contigsumsize <= 0)

usr.sbin/makefs/ffs/ffs_alloc.c

617

end = start + fs->fs_contigsumsize;

usr.sbin/makefs/ffs/ffs_alloc.c

638

end = start - fs->fs_contigsumsize;

usr.sbin/makefs/ffs/ffs_alloc.c

66

static int32_t ffs_mapsearch(struct fs *, struct cg *, daddr_t, int);

usr.sbin/makefs/ffs/ffs_alloc.c

660

if (i > fs->fs_contigsumsize)

usr.sbin/makefs/ffs/ffs_alloc.c

661

i = fs->fs_contigsumsize;

usr.sbin/makefs/ffs/ffs_alloc.c

671

lp = &sump[fs->fs_contigsumsize];

usr.sbin/makefs/ffs/ffs_alloc.c

672

for (i = fs->fs_contigsumsize; i > 0; i--)

usr.sbin/makefs/ffs/ffs_alloc.c

675

fs->fs_maxcluster[ufs_rw32(cgp->cg_cgx, needswap)] = i;

usr.sbin/makefs/ffs/ffs_alloc.c

91

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

96

if (size > fs->fs_bsize || fragoff(fs, size) != 0) {

usr.sbin/makefs/ffs/ffs_alloc.c

98

fs->fs_bsize, size);

usr.sbin/makefs/ffs/ffs_balloc.c

107

lastlbn = lblkno(fs, ip->i_ffs1_size);

usr.sbin/makefs/ffs/ffs_balloc.c

110

osize = blksize(fs, ip, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

111

if (osize < fs->fs_bsize && osize > 0) {

usr.sbin/makefs/ffs/ffs_balloc.c

124

(uint64_t)lblktosize(fs, lbn + 1)) {

usr.sbin/makefs/ffs/ffs_balloc.c

135

fs->fs_bsize, NULL, bpp);

usr.sbin/makefs/ffs/ffs_balloc.c

149

osize = fragroundup(fs, blkoff(fs, ip->i_ffs1_size));

usr.sbin/makefs/ffs/ffs_balloc.c

150

nsize = fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

179

if (ip->i_ffs1_size < (uint64_t)lblktosize(fs, lbn + 1))

usr.sbin/makefs/ffs/ffs_balloc.c

180

nsize = fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

182

nsize = fs->fs_bsize;

usr.sbin/makefs/ffs/ffs_balloc.c

192

bp->b_blkno = fsbtodb(fs, newb);

usr.sbin/makefs/ffs/ffs_balloc.c

224

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

230

fs->fs_bsize, 0, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

231

bp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

249

fs->fs_bsize, NULL, &bp);

usr.sbin/makefs/ffs/ffs_balloc.c

265

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

273

fs->fs_bsize, 0, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

274

nbp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

296

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

304

nbp = getblk((void *)ip->i_devvp, lbn, fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

306

nbp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

321

error = bread((void *)ip->i_devvp, lbn, (int)fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

339

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_balloc.c

346

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_balloc.c

348

lbn = lblkno(fs, offset);

usr.sbin/makefs/ffs/ffs_balloc.c

349

size = blkoff(fs, offset) + bufsize;

usr.sbin/makefs/ffs/ffs_balloc.c

354

assert(size <= fs->fs_bsize);

usr.sbin/makefs/ffs/ffs_balloc.c

364

lastlbn = lblkno(fs, ip->i_ffs2_size);

usr.sbin/makefs/ffs/ffs_balloc.c

367

osize = blksize(fs, ip, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

368

if (osize < fs->fs_bsize && osize > 0) {

usr.sbin/makefs/ffs/ffs_balloc.c

381

(uint64_t)lblktosize(fs, lbn + 1)) {

usr.sbin/makefs/ffs/ffs_balloc.c

392

fs->fs_bsize, NULL, bpp);

usr.sbin/makefs/ffs/ffs_balloc.c

406

osize = fragroundup(fs, blkoff(fs, ip->i_ffs2_size));

usr.sbin/makefs/ffs/ffs_balloc.c

407

nsize = fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

436

if (ip->i_ffs2_size < (uint64_t)lblktosize(fs, lbn + 1))

usr.sbin/makefs/ffs/ffs_balloc.c

437

nsize = fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

439

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

487

fs->fs_bsize, 0, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

488

bp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

506

fs->fs_bsize, NULL, &bp);

usr.sbin/makefs/ffs/ffs_balloc.c

522

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

530

fs->fs_bsize, 0, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

531

nbp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

553

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

561

nbp = getblk((void *)ip->i_devvp, lbn, fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

563

nbp->b_blkno = fsbtodb(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

578

error = bread((void *)ip->i_devvp, lbn, (int)fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

82

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_balloc.c

89

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_balloc.c

91

lbn = lblkno(fs, offset);

usr.sbin/makefs/ffs/ffs_balloc.c

92

size = blkoff(fs, offset) + bufsize;

usr.sbin/makefs/ffs/ffs_balloc.c

97

assert(size <= fs->fs_bsize);

usr.sbin/makefs/ffs/ffs_bswap.c

195

ffs_cg_swap(struct cg *o, struct cg *n, struct fs *fs)

usr.sbin/makefs/ffs/ffs_bswap.c

231

if (fs->fs_magic == FS_UFS2_MAGIC)

usr.sbin/makefs/ffs/ffs_bswap.c

248

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

usr.sbin/makefs/ffs/ffs_bswap.c

251

for (i = 0; i < fs->fs_old_cpg * fs->fs_old_nrpos; i++)

usr.sbin/makefs/ffs/ffs_bswap.c

256

for (i = 1; i < fs->fs_contigsumsize + 1; i++)

usr.sbin/makefs/ffs/ffs_bswap.c

63

ffs_sb_swap(struct fs *o, struct fs *n)

usr.sbin/makefs/ffs/ffs_bswap.c

75

for (i = 0; i < offsetof(struct fs, fs_fmod) / sizeof(u_int32_t); i++)

usr.sbin/makefs/ffs/ffs_extern.h

56

void ffs_clusteracct(struct fs *, struct cg *, int32_t, int);

usr.sbin/makefs/ffs/ffs_extern.h

62

void ffs_sb_swap(struct fs*, struct fs *);

usr.sbin/makefs/ffs/ffs_extern.h

66

void ffs_cg_swap(struct cg *, struct cg *, struct fs *);

usr.sbin/makefs/ffs/ffs_extern.h

69

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

usr.sbin/makefs/ffs/ffs_extern.h

70

int ffs_isblock(struct fs *, u_char *, int32_t);

usr.sbin/makefs/ffs/ffs_extern.h

71

int ffs_isfreeblock(struct fs *, u_char *, int32_t);

usr.sbin/makefs/ffs/ffs_extern.h

72

void ffs_clrblock(struct fs *, u_char *, int32_t);

usr.sbin/makefs/ffs/ffs_extern.h

73

void ffs_setblock(struct fs *, u_char *, int32_t);

usr.sbin/makefs/ffs/ffs_subr.c

101

(int)fs->fs_fragshift);

usr.sbin/makefs/ffs/ffs_subr.c

111

ffs_isfreeblock(struct fs *fs, u_char *cp, int32_t h)

usr.sbin/makefs/ffs/ffs_subr.c

114

switch ((int)fs->fs_fragshift) {

usr.sbin/makefs/ffs/ffs_subr.c

125

(int)fs->fs_fragshift);

usr.sbin/makefs/ffs/ffs_subr.c

133

ffs_clrblock(struct fs *fs, u_char *cp, int32_t h)

usr.sbin/makefs/ffs/ffs_subr.c

136

switch ((int)fs->fs_fragshift) {

usr.sbin/makefs/ffs/ffs_subr.c

151

(int)fs->fs_fragshift);

usr.sbin/makefs/ffs/ffs_subr.c

159

ffs_setblock(struct fs *fs, u_char *cp, int32_t h)

usr.sbin/makefs/ffs/ffs_subr.c

162

switch ((int)fs->fs_fragshift) {

usr.sbin/makefs/ffs/ffs_subr.c

177

(int)fs->fs_fragshift);

usr.sbin/makefs/ffs/ffs_subr.c

47

ffs_fragacct_swap(struct fs *fs, int fragmap, uint32_t fraglist[], int cnt, int needswap)

usr.sbin/makefs/ffs/ffs_subr.c

53

inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1;

usr.sbin/makefs/ffs/ffs_subr.c

55

for (siz = 1; siz < fs->fs_frag; siz++) {

usr.sbin/makefs/ffs/ffs_subr.c

56

if ((inblk & (1 << (siz + (fs->fs_frag & (NBBY - 1))))) == 0)

usr.sbin/makefs/ffs/ffs_subr.c

60

for (pos = siz; pos <= fs->fs_frag; pos++) {

usr.sbin/makefs/ffs/ffs_subr.c

83

ffs_isblock(struct fs *fs, u_char *cp, int32_t h)

usr.sbin/makefs/ffs/ffs_subr.c

87

switch ((int)fs->fs_fragshift) {

usr.sbin/makefs/ffs/mkfs.c

101

#define sblock fsun.fs

usr.sbin/makefs/ffs/mkfs.c

131

struct fs *

usr.sbin/makefs/ffs/mkfs.c

456

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

usr.sbin/makefs/ffs/mkfs.c

541

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

usr.sbin/makefs/ffs/mkfs.c

578

ffs_write_superblock(struct fs *fs, const fsinfo_t *fsopts)

usr.sbin/makefs/ffs/mkfs.c

585

saveflag = fs->fs_flags & FS_INTERNAL;

usr.sbin/makefs/ffs/mkfs.c

586

fs->fs_flags &= ~FS_INTERNAL;

usr.sbin/makefs/ffs/mkfs.c

592

info = fs->fs_si;

usr.sbin/makefs/ffs/mkfs.c

593

fs->fs_si = NULL;

usr.sbin/makefs/ffs/mkfs.c

594

memcpy(writebuf, fs, sbsize);

usr.sbin/makefs/ffs/mkfs.c

595

fs->fs_si = info;

usr.sbin/makefs/ffs/mkfs.c

598

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

usr.sbin/makefs/ffs/mkfs.c

599

ffs_wtfs(fs->fs_sblockloc / sectorsize, sbsize, writebuf, fsopts);

usr.sbin/makefs/ffs/mkfs.c

602

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

usr.sbin/makefs/ffs/mkfs.c

603

ffs_wtfs(fsbtodb(fs, cgsblock(fs, cylno)),

usr.sbin/makefs/ffs/mkfs.c

607

size = fs->fs_cssize;

usr.sbin/makefs/ffs/mkfs.c

608

blks = howmany(size, fs->fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

609

space = (void *)fs->fs_csp;

usr.sbin/makefs/ffs/mkfs.c

611

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

usr.sbin/makefs/ffs/mkfs.c

612

size = fs->fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

613

if (i + fs->fs_frag > blks)

usr.sbin/makefs/ffs/mkfs.c

614

size = (blks - i) * fs->fs_fsize;

usr.sbin/makefs/ffs/mkfs.c

620

ffs_wtfs(fsbtodb(fs, fs->fs_csaddr + i), size, wrbuf, fsopts);

usr.sbin/makefs/ffs/mkfs.c

624

fs->fs_flags |= saveflag;

usr.sbin/makefs/ffs/mkfs.c

98

struct fs fs;

usr.sbin/makefs/ffs/newfs_extern.h

31

struct fs *ffs_mkfs(const char *, const fsinfo_t *, time_t);

usr.sbin/makefs/ffs/newfs_extern.h

32

void ffs_write_superblock(struct fs *, const fsinfo_t *);

usr.sbin/makefs/ffs/ufs_bswap.h

43

#define UFS_FSNEEDSWAP(fs) ((fs)->fs_flags & FS_SWAPPED)

usr.sbin/makefs/ffs/ufs_bswap.h

47

#define UFS_FSNEEDSWAP(fs) (0)

usr.sbin/makefs/ffs/ufs_inode.h

43

struct fs *i_fs; /* File system */

usr.sbin/makefs/makefs.h

196

#define DECLARE_FUN(fs) \

usr.sbin/makefs/makefs.h

197

void fs ## _prep_opts(fsinfo_t *); \

usr.sbin/makefs/makefs.h

198

int fs ## _parse_opts(const char *, fsinfo_t *); \

usr.sbin/makefs/makefs.h

199

void fs ## _cleanup_opts(fsinfo_t *); \

usr.sbin/makefs/makefs.h

200

void fs ## _makefs(const char *, const char *, fsnode *, fsinfo_t *)

usr.sbin/makefs/makefs.h

320

struct fs;

usr.sbin/makefs/makefs.h

321

void ffs_fragacct_swap(struct fs *, int, uint32_t [], int, int);

usr.sbin/makefs/msdos.c

181

vp.fs = fsopts;

usr.sbin/makefs/zfs/fs.c

1003

memset(&fs, 0, sizeof(fs));

usr.sbin/makefs/zfs/fs.c

1004

fs.os = os;

usr.sbin/makefs/zfs/fs.c

1010

saobjid = fs_set_zpl_attrs(zfs, &fs);

usr.sbin/makefs/zfs/fs.c

1025

arg.fs = &fs;

usr.sbin/makefs/zfs/fs.c

1068

free(fs.saoffs);

usr.sbin/makefs/zfs/fs.c

160

zfs_fs_t *fs; /* owning filesystem */

usr.sbin/makefs/zfs/fs.c

234

fs_populate_attr(zfs_fs_t *fs, char *attrbuf, const void *val, uint16_t ind,

usr.sbin/makefs/zfs/fs.c

237

assert(ind < fs->sacnt);

usr.sbin/makefs/zfs/fs.c

238

assert(fs->saoffs[ind] != 0xffff);

usr.sbin/makefs/zfs/fs.c

240

memcpy(attrbuf + fs->saoffs[ind], val, fs->satab[ind].size);

usr.sbin/makefs/zfs/fs.c

241

*szp += fs->satab[ind].size;

usr.sbin/makefs/zfs/fs.c

245

fs_populate_varszattr(zfs_fs_t *fs, char *attrbuf, const void *val,

usr.sbin/makefs/zfs/fs.c

248

assert(ind < fs->sacnt);

usr.sbin/makefs/zfs/fs.c

249

assert(fs->saoffs[ind] != 0xffff);

usr.sbin/makefs/zfs/fs.c

250

assert(fs->satab[ind].size == 0);

usr.sbin/makefs/zfs/fs.c

252

memcpy(attrbuf + fs->saoffs[ind] + varoff, val, valsz);

usr.sbin/makefs/zfs/fs.c

341

fs_populate_time(zfs_fs_t *fs, char *attrbuf, struct timespec *ts,

usr.sbin/makefs/zfs/fs.c

346

assert(ind < fs->sacnt);

usr.sbin/makefs/zfs/fs.c

347

assert(fs->saoffs[ind] != 0xffff);

usr.sbin/makefs/zfs/fs.c

348

assert(fs->satab[ind].size == sizeof(timebuf));

usr.sbin/makefs/zfs/fs.c

352

fs_populate_attr(fs, attrbuf, timebuf, ind, szp);

usr.sbin/makefs/zfs/fs.c

360

zfs_fs_t *fs;

usr.sbin/makefs/zfs/fs.c

372

fs = arg->fs;

usr.sbin/makefs/zfs/fs.c

496

fs_populate_attr(fs, attrbuf, &daclcount, ZPL_DACL_COUNT, &bonussz);

usr.sbin/makefs/zfs/fs.c

497

fs_populate_attr(fs, attrbuf, &flags, ZPL_FLAGS, &bonussz);

usr.sbin/makefs/zfs/fs.c

498

fs_populate_attr(fs, attrbuf, &gen, ZPL_GEN, &bonussz);

usr.sbin/makefs/zfs/fs.c

499

fs_populate_attr(fs, attrbuf, &gid, ZPL_GID, &bonussz);

usr.sbin/makefs/zfs/fs.c

500

fs_populate_attr(fs, attrbuf, &links, ZPL_LINKS, &bonussz);

usr.sbin/makefs/zfs/fs.c

501

fs_populate_attr(fs, attrbuf, &mode, ZPL_MODE, &bonussz);

usr.sbin/makefs/zfs/fs.c

502

fs_populate_attr(fs, attrbuf, &parent, ZPL_PARENT, &bonussz);

usr.sbin/makefs/zfs/fs.c

503

fs_populate_attr(fs, attrbuf, &objsize, ZPL_SIZE, &bonussz);

usr.sbin/makefs/zfs/fs.c

504

fs_populate_attr(fs, attrbuf, &uid, ZPL_UID, &bonussz);

usr.sbin/makefs/zfs/fs.c

510

fs_populate_time(fs, attrbuf, &sb->st_mtim, ZPL_ATIME, &bonussz);

usr.sbin/makefs/zfs/fs.c

511

fs_populate_time(fs, attrbuf, &sb->st_ctim, ZPL_CTIME, &bonussz);

usr.sbin/makefs/zfs/fs.c

512

fs_populate_time(fs, attrbuf, &sb->st_mtim, ZPL_MTIME, &bonussz);

usr.sbin/makefs/zfs/fs.c

515

fs_populate_time(fs, attrbuf, &sb->st_ctim, ZPL_CRTIME, &bonussz);

usr.sbin/makefs/zfs/fs.c

517

fs_populate_time(fs, attrbuf, &sb->st_birthtim, ZPL_CRTIME, &bonussz);

usr.sbin/makefs/zfs/fs.c

520

fs_populate_varszattr(fs, attrbuf, aces, sizeof(aces), 0,

usr.sbin/makefs/zfs/fs.c

528

fs_populate_varszattr(fs, attrbuf, target, objsize,

usr.sbin/makefs/zfs/fs.c

566

dnode = objset_dnode_bonus_alloc(arg->fs->os,

usr.sbin/makefs/zfs/fs.c

576

c = dnode_cursor_init(zfs, arg->fs->os, dnode, size, 0);

usr.sbin/makefs/zfs/fs.c

599

loc = objset_space_alloc(zfs, arg->fs->os, &reqbytes);

usr.sbin/makefs/zfs/fs.c

621

os = arg->fs->os;

usr.sbin/makefs/zfs/fs.c

675

dnode = objset_dnode_bonus_alloc(arg->fs->os,

usr.sbin/makefs/zfs/fs.c

763

fs_set_zpl_attrs(zfs_opt_t *zfs, zfs_fs_t *fs)

usr.sbin/makefs/zfs/fs.c

771

os = fs->os;

usr.sbin/makefs/zfs/fs.c

827

fs->sacnt = nitems(zpl_attrs);

usr.sbin/makefs/zfs/fs.c

828

fs->saoffs = ecalloc(fs->sacnt, sizeof(*fs->saoffs));

usr.sbin/makefs/zfs/fs.c

829

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

usr.sbin/makefs/zfs/fs.c

830

fs->saoffs[i] = 0xffff;

usr.sbin/makefs/zfs/fs.c

835

assert(zpl_attr_layout[i] < fs->sacnt);

usr.sbin/makefs/zfs/fs.c

837

fs->saoffs[zpl_attr_layout[i]] = offset;

usr.sbin/makefs/zfs/fs.c

841

fs->satab = zpl_attrs;

usr.sbin/makefs/zfs/fs.c

965

zfs_fs_t fs;

usr.sbin/mountd/mountd.c

2190

struct statfs fs, ofs;

usr.sbin/mountd/mountd.c

2237

if (statfs(ep->ex_fsdir, &fs) < 0)

usr.sbin/mountd/mountd.c

2239

delete_export(iov, iovlen, &fs, errmsg);

usr.sbin/mountd/mountd.c

2240

ret = do_export_mount(ep, &fs);

usr.sbin/mountd/mountd.c

2249

if (statfs(ep->ex_fsdir, &fs) < 0)

usr.sbin/mountd/mountd.c

2251

ret = do_export_mount(ep, &fs);

usr.sbin/mountd/mountd.c

2290

v4root_dirpath, strlen(v4root_dirpath), &fs,

usr.sbin/quot/quot.c

100

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

usr.sbin/quot/quot.c

104

get_inode(int fd, struct fs *super, ino_t ino)

usr.sbin/quot/quot.c

154

isfree(struct fs *super, union dinode *dp)

usr.sbin/quot/quot.c

307

dofsizes(int fd, struct fs *super)

usr.sbin/quot/quot.c

355

douser(int fd, struct fs *super)

usr.sbin/quot/quot.c

392

donames(int fd, struct fs *super)

usr.sbin/quot/quot.c

444

struct fs *fs;

usr.sbin/quot/quot.c

454

switch (errno = sbget(fd, &fs, UFS_STDSB, UFS_NOCSUM)) {

usr.sbin/quot/quot.c

470

(*func)(fd, fs);

usr.sbin/quot/quot.c

471

free(fs);

usr.sbin/quot/quot.c

62

static void (*func)(int, struct fs *);

usr.sbin/quot/quot.c

67

static union dinode *get_inode(int, struct fs *, ino_t);

usr.sbin/quot/quot.c

68

static int isfree(struct fs *, union dinode *);

usr.sbin/quot/quot.c

75

static void dofsizes(int, struct fs *);

usr.sbin/quot/quot.c

76

static void douser(int, struct fs *);

usr.sbin/quot/quot.c

77

static void donames(int, struct fs *);

usr.sbin/quot/quot.c

94

#define INOCNT(fs) ((fs)->fs_ipg)

usr.sbin/quot/quot.c

95

#define INOSZ(fs) \

usr.sbin/quot/quot.c

96

(((fs)->fs_magic == FS_UFS1_MAGIC ? sizeof(struct ufs1_dinode) : \

usr.sbin/quot/quot.c

97

sizeof(struct ufs2_dinode)) * INOCNT(fs))

usr.sbin/quot/quot.c

99

#define DIP(fs, dp, field) \

usr.sbin/quotaon/quotaon.c

101

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

usr.sbin/quotaon/quotaon.c

102

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

usr.sbin/quotaon/quotaon.c

103

strcmp(fs->fs_type, FSTAB_RW))

usr.sbin/quotaon/quotaon.c

107

errs += quotaonoff(fs, offmode, GRPQUOTA);

usr.sbin/quotaon/quotaon.c

109

errs += quotaonoff(fs, offmode, USRQUOTA);

usr.sbin/quotaon/quotaon.c

112

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

usr.sbin/quotaon/quotaon.c

113

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

usr.sbin/quotaon/quotaon.c

116

errs += quotaonoff(fs, offmode, GRPQUOTA);

usr.sbin/quotaon/quotaon.c

118

errs += quotaonoff(fs, offmode, USRQUOTA);

usr.sbin/quotaon/quotaon.c

141

quotaonoff(struct fstab *fs, int offmode, int type)

usr.sbin/quotaon/quotaon.c

145

if ((qf = quota_open(fs, type, O_RDONLY)) == NULL)

usr.sbin/quotaon/quotaon.c

58

static int quotaonoff(struct fstab *fs, int, int);

usr.sbin/quotaon/quotaon.c

64

struct fstab *fs;

usr.sbin/repquota/repquota.c

150

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

usr.sbin/repquota/repquota.c

151

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

usr.sbin/repquota/repquota.c

155

errs += repquota(fs, GRPQUOTA);

usr.sbin/repquota/repquota.c

157

errs += repquota(fs, USRQUOTA);

usr.sbin/repquota/repquota.c

160

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

usr.sbin/repquota/repquota.c

161

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

usr.sbin/repquota/repquota.c

164

errs += repquota(fs, GRPQUOTA);

usr.sbin/repquota/repquota.c

166

errs += repquota(fs, USRQUOTA);

usr.sbin/repquota/repquota.c

186

repquota(struct fstab *fs, int type)

usr.sbin/repquota/repquota.c

194

if ((qf = quota_open(fs, type, O_RDONLY)) == NULL) {

usr.sbin/repquota/repquota.c

199

qfextension[type], fs->fs_file, fs->fs_spec);

usr.sbin/repquota/repquota.c

208

qfextension[type], fs->fs_file, fs->fs_spec);

usr.sbin/repquota/repquota.c

98

struct fstab *fs;