bin/cp/utils.c

102

struct stat to_stat, *fs;

bin/cp/utils.c

123

fs = entp->fts_statp;

bin/cp/utils.c

161

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

bin/cp/utils.c

170

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

bin/cp/utils.c

185

bool need_copy = S_ISREG(fs->st_mode) || fs->st_size > 0;

bin/cp/utils.c

191

fi.size = fs->st_size;

bin/cp/utils.c

198

if (S_ISREG(fs->st_mode) && fs->st_size && fs->st_size <= MMAP_MAX_SIZE) {

bin/cp/utils.c

199

size_t fsize = (size_t)fs->st_size;

bin/cp/utils.c

207

(void) madvise(p, (size_t)fs->st_size, MADV_SEQUENTIAL);

bin/cp/utils.c

273

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

bin/cp/utils.c

282

&& fs->st_mode & (S_ISUID | S_ISGID) && fs->st_uid == myuid) {

bin/cp/utils.c

286

} else if (fs->st_gid == to_stat.st_gid &&

bin/cp/utils.c

287

fchmod(to_fd, fs->st_mode & RETAINBITS & ~myumask)) {

bin/cp/utils.c

297

if (pflag && set_utimes(to.p_path, fs)) {

bin/cp/utils.c

364

setfile(struct stat *fs, int fd)

bin/cp/utils.c

369

islink = S_ISLNK(fs->st_mode);

bin/cp/utils.c

370

fs->st_mode &= S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;

bin/cp/utils.c

378

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

bin/cp/utils.c

379

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

bin/cp/utils.c

384

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

bin/cp/utils.c

386

if (fd ? fchmod(fd, fs->st_mode) : lchmod(to.p_path, fs->st_mode)) {

bin/cp/utils.c

392

unsigned long fflags = fs->st_flags;

bin/cp/utils.c

404

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

bin/cp/utils.c

410

if (fd == 0 && set_utimes(to.p_path, fs))

bin/cp/utils.c

469

preserve_dir_acls(struct stat *fs, char *source_dir, char *dest_dir)

bin/cp/utils.c

503

if (S_ISLNK(fs->st_mode)) {

bin/cp/utils.c

67

set_utimes(const char *file, struct stat *fs)

bin/cp/utils.c

71

ts[0] = fs->st_atimespec;

bin/cp/utils.c

72

ts[1] = fs->st_mtimespec;

bin/ksh/var.c

374

char *fs = NULL;

bin/ksh/var.c

396

s = fs = formatstr(vq, s);

bin/ksh/var.c

409

if (fs)

bin/ksh/var.c

410

afree(fs, ATEMP);

games/backgammon/common_source/save.c

62

char *fs;

games/backgammon/common_source/save.c

78

fs = fname;

games/backgammon/common_source/save.c

79

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

games/backgammon/common_source/save.c

80

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

games/backgammon/common_source/save.c

81

if (fs > fname) {

games/backgammon/common_source/save.c

82

fs--;

games/backgammon/common_source/save.c

86

writec(*fs);

games/backgammon/common_source/save.c

91

writec(*fs++);

games/backgammon/common_source/save.c

93

*fs = '\0';

games/sail/extern.h

195

char fs;

games/sail/game.c

61

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

games/sail/game.c

74

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

games/sail/game.c

76

Move = ship->specs->fs;

lib/libp2k/p2k.c

287

PUFFSOP_SET(pops, p2k, fs, statvfs);

lib/libp2k/p2k.c

288

PUFFSOP_SET(pops, p2k, fs, unmount);

lib/libp2k/p2k.c

289

PUFFSOP_SET(pops, p2k, fs, sync);

lib/libp2k/p2k.c

290

PUFFSOP_SET(pops, p2k, fs, fhtonode);

lib/libp2k/p2k.c

291

PUFFSOP_SET(pops, p2k, fs, nodetofh);

lib/libp2k/p2k.c

292

PUFFSOP_SET(pops, p2k, fs, extattrctl);

lib/libp2k/p2k.c

604

struct ukfs *fs = p2m->p2m_ukfs;

lib/libp2k/p2k.c

609

if (fs) {

lib/libp2k/p2k.c

610

if (ukfs_release(fs, 0) != 0) {

lib/libp2k/p2k.c

618

ukfs_release(fs, UKFS_RELFLAG_FORCE);

lib/libpam/modules/pam_login_access/login_access.c

108

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

lib/libpam/modules/pam_login_access/login_access.c

109

|| !(users = strtok((char *) 0, fs))

lib/libpam/modules/pam_login_access/login_access.c

110

|| !(froms = strtok((char *) 0, fs))

lib/libpam/modules/pam_login_access/login_access.c

111

|| strtok((char *) 0, fs)) {

lib/libpam/modules/pam_login_access/login_access.c

42

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

lib/libperfuse/perfuse.c

493

PUFFSOP_SET(pops, perfuse, fs, unmount);

lib/libperfuse/perfuse.c

494

PUFFSOP_SET(pops, perfuse, fs, statvfs);

lib/libperfuse/perfuse.c

495

PUFFSOP_SET(pops, perfuse, fs, sync);

lib/libpuffs/null.c

167

PUFFSOP_SET(pops, puffs_null, fs, statvfs);

lib/libpuffs/null.c

170

PUFFSOP_SET(pops, puffs_null, fs, fhtonode);

lib/libpuffs/null.c

171

PUFFSOP_SET(pops, puffs_null, fs, nodetofh);

lib/libquota/quota_oldfiles.c

122

__quota_oldfiles_fill_fstabentry(const struct fstab *fs,

lib/libquota/quota_oldfiles.c

143

strlcpy(buf, fs->fs_mntops, sizeof(buf));

lib/libquota/quota_oldfiles.c

173

ofe->ofe_mountpoint = strdup(fs->fs_file);

lib/libquota/quota_oldfiles.c

200

struct fstab *fs;

lib/libquota/quota_oldfiles.c

220

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

lib/libquota/quota_oldfiles.c

221

if (!strcmp(fs->fs_vfstype, "ffs") ||

lib/libquota/quota_oldfiles.c

222

!strcmp(fs->fs_vfstype, "lfs")) {

lib/libquota/quota_oldfiles.c

223

result = __quota_oldfiles_fill_fstabentry(fs, &ofe);

lib/librefuse/fuse.h

294

#include <refuse/fs.h>

lib/librefuse/fuse_internal.h

52

struct fuse_fs *fs; /* The base filesystem layer. */

lib/librefuse/refuse.c

1016

ret = fuse_fs_statfs(fuse->fs, PNPATH(puffs_getroot(pu)), &sb);

lib/librefuse/refuse.c

1211

fuse->fs = __fuse_fs_new(op, op_version, user_data);

lib/librefuse/refuse.c

1223

PUFFSOP_SET(pops, puffs_fuse, fs, sync);

lib/librefuse/refuse.c

1224

PUFFSOP_SET(pops, puffs_fuse, fs, statvfs);

lib/librefuse/refuse.c

1225

PUFFSOP_SET(pops, puffs_fuse, fs, unmount);

lib/librefuse/refuse.c

1279

fuse_fs_init_v30(fuse->fs, &conn, &cfg);

lib/librefuse/refuse.c

320

ret = fuse_fs_getattr_v30(fuse->fs, path, &st, fi);

lib/librefuse/refuse.c

350

ret = fuse_fs_chmod_v30(fuse->fs, path, mode, fi);

lib/librefuse/refuse.c

355

ret = fuse_fs_chown_v30(fuse->fs, path, uid, gid, fi);

lib/librefuse/refuse.c

369

ret = fuse_fs_utimens_v30(fuse->fs, path, tv, fi);

lib/librefuse/refuse.c

374

ret = fuse_fs_truncate_v30(fuse->fs, path, (off_t)va->va_size, fi);

lib/librefuse/refuse.c

401

fuse_fs_rmdir(fuse->fs, path);

lib/librefuse/refuse.c

403

fuse_fs_unlink(fuse->fs, path);

lib/librefuse/refuse.c

441

ret = fuse_fs_getattr_v30(fuse->fs, path, &st, NULL);

lib/librefuse/refuse.c

497

ret = fuse_fs_readlink(fuse->fs, path, linkname, *linklen);

lib/librefuse/refuse.c

528

ret = fuse_fs_mknod(fuse->fs, path, mode, va->va_rdev);

lib/librefuse/refuse.c

554

ret = fuse_fs_mkdir(fuse->fs, path, mode);

lib/librefuse/refuse.c

602

ret = fuse_fs_create(fuse->fs, path, mode | S_IFREG, &fi);

lib/librefuse/refuse.c

607

ret = fuse_fs_mknod(fuse->fs, path, mode | S_IFREG, 0);

lib/librefuse/refuse.c

618

(void)fuse_fs_release(fuse->fs, path, &rn->file_info);

lib/librefuse/refuse.c

641

ret = fuse_fs_unlink(fuse->fs, path);

lib/librefuse/refuse.c

662

ret = fuse_fs_rmdir(fuse->fs, path);

lib/librefuse/refuse.c

683

ret = fuse_fs_symlink(fuse->fs, link_target, path);

lib/librefuse/refuse.c

708

ret = fuse_fs_rename_v30(fuse->fs, path_src, path_dest, 0);

lib/librefuse/refuse.c

728

ret = fuse_fs_link(fuse->fs, PNPATH(pn), PCNPATH(pcn));

lib/librefuse/refuse.c

793

ret = fuse_fs_opendir(fuse->fs, path, fi);

lib/librefuse/refuse.c

795

ret = fuse_fs_open(fuse->fs, path, fi);

lib/librefuse/refuse.c

826

ret = fuse_fs_releasedir(fuse->fs, path, fi);

lib/librefuse/refuse.c

828

ret = fuse_fs_release(fuse->fs, path, fi);

lib/librefuse/refuse.c

863

ret = fuse_fs_read(fuse->fs, path, (char *)buf, maxread, offset,

lib/librefuse/refuse.c

894

ret = fuse_fs_write(fuse->fs, path, (char *)buf, *resid, offset,

lib/librefuse/refuse.c

944

fuse->fs, path, dirh, puffs_fuse_fill_dir,

lib/librefuse/refuse.c

989

fuse_fs_destroy(fuse->fs);

lib/librefuse/refuse/fs.c

1000

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1001

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1011

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->create) \

lib/librefuse/refuse/fs.c

1012

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->create(path, mode, fi); \

lib/librefuse/refuse/fs.c

1025

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1030

fuse_fs_lock(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi,

lib/librefuse/refuse/fs.c

1032

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1034

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

104

fs->op = clone_op(op, op_version);

lib/librefuse/refuse/fs.c

1044

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->lock) \

lib/librefuse/refuse/fs.c

1045

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->lock(path, fi, cmd, lock); \

lib/librefuse/refuse/fs.c

105

if (!fs->op)

lib/librefuse/refuse/fs.c

1057

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1062

fuse_fs_flock(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi, int op) {

lib/librefuse/refuse/fs.c

1063

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1065

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1077

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->flock) \

lib/librefuse/refuse/fs.c

1078

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->flock(path, fi, op); \

lib/librefuse/refuse/fs.c

108

fs->op_version = op_version;

lib/librefuse/refuse/fs.c

1088

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

109

fs->user_data = user_data;

lib/librefuse/refuse/fs.c

1093

fuse_fs_chmod_v27(struct fuse_fs *fs, const char *path, mode_t mode) {

lib/librefuse/refuse/fs.c

1094

return fuse_fs_chmod_v30(fs, path, mode, NULL);

lib/librefuse/refuse/fs.c

1098

fuse_fs_chmod_v30(struct fuse_fs* fs, const char* path,

lib/librefuse/refuse/fs.c

1100

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1101

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1104

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chmod) \

lib/librefuse/refuse/fs.c

1105

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chmod(path, mode); \

lib/librefuse/refuse/fs.c

111

return fs;

lib/librefuse/refuse/fs.c

1120

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chmod) \

lib/librefuse/refuse/fs.c

1121

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chmod(path, mode, fi); \

lib/librefuse/refuse/fs.c

1130

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1134

int fuse_fs_chown_v27(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid) {

lib/librefuse/refuse/fs.c

1135

return fuse_fs_chown_v30(fs, path, uid, gid, NULL);

lib/librefuse/refuse/fs.c

1139

fuse_fs_chown_v30(struct fuse_fs* fs, const char* path,

lib/librefuse/refuse/fs.c

1141

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1142

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1145

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chown) \

lib/librefuse/refuse/fs.c

1146

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chown(path, uid, gid); \

lib/librefuse/refuse/fs.c

1161

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chown) \

lib/librefuse/refuse/fs.c

1162

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chown(path, uid, gid, fi); \

lib/librefuse/refuse/fs.c

1171

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1175

int fuse_fs_truncate_v27(struct fuse_fs *fs, const char *path, off_t size) {

lib/librefuse/refuse/fs.c

1176

return fuse_fs_truncate_v30(fs, path, size, NULL);

lib/librefuse/refuse/fs.c

118

clobber_context_user_data(struct fuse_fs* fs) {

lib/librefuse/refuse/fs.c

1180

fuse_fs_truncate_v30(struct fuse_fs* fs, const char* path, off_t size, struct fuse_file_info* fi) {

lib/librefuse/refuse/fs.c

1181

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1182

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1185

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate) \

lib/librefuse/refuse/fs.c

1186

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate(path, size); \

lib/librefuse/refuse/fs.c

119

fuse_get_context()->private_data = fs->user_data;

lib/librefuse/refuse/fs.c

1201

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate) \

lib/librefuse/refuse/fs.c

1202

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate(path, size, fi); \

lib/librefuse/refuse/fs.c

1211

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1216

fuse_fs_ftruncate(struct fuse_fs* fs, const char* path, off_t size, struct fuse_file_info* fi) {

lib/librefuse/refuse/fs.c

1217

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1218

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1223

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate) \

lib/librefuse/refuse/fs.c

1224

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate(path, size); \

lib/librefuse/refuse/fs.c

1238

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ftruncate) \

lib/librefuse/refuse/fs.c

1239

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ftruncate(path, size, fi); \

lib/librefuse/refuse/fs.c

124

fuse_fs_getattr_v27(struct fuse_fs *fs, const char *path, struct stat *buf) {

lib/librefuse/refuse/fs.c

1240

else if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate) \

lib/librefuse/refuse/fs.c

1241

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate(path, size); \

lib/librefuse/refuse/fs.c

125

return fuse_fs_getattr_v30(fs, path, buf, NULL);

lib/librefuse/refuse/fs.c

1254

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate) \

lib/librefuse/refuse/fs.c

1255

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate(path, size, fi); \

lib/librefuse/refuse/fs.c

1264

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1269

fuse_fs_utimens_v27(struct fuse_fs *fs, const char *path, const struct timespec tv[2]) {

lib/librefuse/refuse/fs.c

1270

return fuse_fs_utimens_v30(fs, path, tv, NULL);

lib/librefuse/refuse/fs.c

1274

fuse_fs_utimens_v30(struct fuse_fs* fs, const char* path,

lib/librefuse/refuse/fs.c

1281

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1283

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1288

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utime) \

lib/librefuse/refuse/fs.c

1289

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utime(path, &timbuf); \

lib/librefuse/refuse/fs.c

129

fuse_fs_getattr_v30(struct fuse_fs* fs, const char* path,

lib/librefuse/refuse/fs.c

1303

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utimens) \

lib/librefuse/refuse/fs.c

1304

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utimens(path, tv); \

lib/librefuse/refuse/fs.c

1305

else if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utime) \

lib/librefuse/refuse/fs.c

1306

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utime(path, &timbuf); \

lib/librefuse/refuse/fs.c

131

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1317

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utimens) \

lib/librefuse/refuse/fs.c

1318

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utimens(path, tv, fi); \

lib/librefuse/refuse/fs.c

132

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1327

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1332

fuse_fs_access(struct fuse_fs* fs, const char* path, int mask) {

lib/librefuse/refuse/fs.c

1333

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1335

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1343

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->access) \

lib/librefuse/refuse/fs.c

1344

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->access(path, mask); \

lib/librefuse/refuse/fs.c

135

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr) \

lib/librefuse/refuse/fs.c

1357

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

136

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr(path, buf); \

lib/librefuse/refuse/fs.c

1362

fuse_fs_readlink(struct fuse_fs* fs, const char* path, char* buf, size_t len) {

lib/librefuse/refuse/fs.c

1363

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1364

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1367

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readlink) \

lib/librefuse/refuse/fs.c

1368

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readlink(path, buf, len); \

lib/librefuse/refuse/fs.c

1385

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1390

fuse_fs_mknod(struct fuse_fs* fs, const char* path, mode_t mode, dev_t rdev) {

lib/librefuse/refuse/fs.c

1391

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1392

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1395

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->mknod) \

lib/librefuse/refuse/fs.c

1396

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->mknod(path, mode, rdev); \

lib/librefuse/refuse/fs.c

1413

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1418

fuse_fs_mkdir(struct fuse_fs* fs, const char* path, mode_t mode) {

lib/librefuse/refuse/fs.c

1419

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1420

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1423

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->mkdir) \

lib/librefuse/refuse/fs.c

1424

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->mkdir(path, mode); \

lib/librefuse/refuse/fs.c

1441

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1445

int fuse_fs_setxattr(struct fuse_fs* fs, const char* path, const char* name,

lib/librefuse/refuse/fs.c

1447

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1449

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1454

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->setxattr) \

lib/librefuse/refuse/fs.c

1455

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->setxattr(path, name, value, size, flags); \

lib/librefuse/refuse/fs.c

1471

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1476

fuse_fs_getxattr(struct fuse_fs* fs, const char* path, const char* name,

lib/librefuse/refuse/fs.c

1478

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1480

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1485

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getxattr) \

lib/librefuse/refuse/fs.c

1486

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getxattr(path, name, value, size); \

lib/librefuse/refuse/fs.c

1502

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1506

int fuse_fs_listxattr(struct fuse_fs* fs, const char* path, char* list, size_t size) {

lib/librefuse/refuse/fs.c

1507

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1509

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

151

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr) \

lib/librefuse/refuse/fs.c

1514

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->listxattr) \

lib/librefuse/refuse/fs.c

1515

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->listxattr(path, list, size); \

lib/librefuse/refuse/fs.c

152

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr(path, buf, fi); \

lib/librefuse/refuse/fs.c

1531

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1536

fuse_fs_removexattr(struct fuse_fs* fs, const char* path, const char* name) {

lib/librefuse/refuse/fs.c

1537

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1539

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1544

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->removexattr) \

lib/librefuse/refuse/fs.c

1545

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->removexattr(path, name); \

lib/librefuse/refuse/fs.c

1561

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1566

fuse_fs_bmap(struct fuse_fs* fs, const char* path, size_t blocksize, uint64_t *idx) {

lib/librefuse/refuse/fs.c

1567

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1569

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1577

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->bmap) \

lib/librefuse/refuse/fs.c

1578

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->bmap(path, blocksize, idx); \

lib/librefuse/refuse/fs.c

1590

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1594

int fuse_fs_ioctl_v28(struct fuse_fs* fs, const char* path, int cmd, void* arg,

lib/librefuse/refuse/fs.c

1596

return fuse_fs_ioctl_v35(fs, path, (unsigned int)cmd, arg, fi, flags, data);

lib/librefuse/refuse/fs.c

1599

int fuse_fs_ioctl_v35(struct fuse_fs* fs, const char* path, unsigned int cmd, void* arg,

lib/librefuse/refuse/fs.c

1601

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1602

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

161

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1612

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ioctl) \

lib/librefuse/refuse/fs.c

1613

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ioctl(path, (int)cmd, arg, fi, flags, data); \

lib/librefuse/refuse/fs.c

1625

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ioctl) \

lib/librefuse/refuse/fs.c

1626

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ioctl(path, cmd, arg, fi, flags, data); \

lib/librefuse/refuse/fs.c

1633

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1638

fuse_fs_poll(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi,

lib/librefuse/refuse/fs.c

1640

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1642

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1651

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->poll) \

lib/librefuse/refuse/fs.c

1652

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->poll(path, fi, ph, reventsp); \

lib/librefuse/refuse/fs.c

166

fuse_fs_fgetattr(struct fuse_fs* fs, const char* path, struct stat* buf,

lib/librefuse/refuse/fs.c

1663

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1668

fuse_fs_fallocate(struct fuse_fs* fs, const char* path, int mode, off_t offset,

lib/librefuse/refuse/fs.c

1670

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1672

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

168

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1682

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fallocate) \

lib/librefuse/refuse/fs.c

1683

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fallocate(path, mode, offset, length, fi); \

lib/librefuse/refuse/fs.c

1693

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1698

fuse_fs_copy_file_range(struct fuse_fs *fs,

lib/librefuse/refuse/fs.c

1702

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1704

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

171

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1716

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->copy_file_range) \

lib/librefuse/refuse/fs.c

1717

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->copy_file_range(path_in, fi_in, off_in, path_out, fi_out, off_out, len, flags); \

lib/librefuse/refuse/fs.c

1725

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1730

fuse_fs_lseek(struct fuse_fs* fs, const char* path, off_t off, int whence,

lib/librefuse/refuse/fs.c

1732

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1734

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1748

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->lseek) \

lib/librefuse/refuse/fs.c

1749

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->lseek(path, off, whence, fi); \

lib/librefuse/refuse/fs.c

1755

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

176

return fuse_fs_getattr_v30(fs, path, buf, fi);

lib/librefuse/refuse/fs.c

1760

fuse_fs_init_v27(struct fuse_fs *fs, struct fuse_conn_info *conn) {

lib/librefuse/refuse/fs.c

1761

fuse_fs_init_v30(fs, conn, NULL);

lib/librefuse/refuse/fs.c

1765

fuse_fs_init_v30(struct fuse_fs* fs, struct fuse_conn_info* conn,

lib/librefuse/refuse/fs.c

1767

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1768

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

1777

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init) \

lib/librefuse/refuse/fs.c

1778

fs->user_data = ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init(); \

lib/librefuse/refuse/fs.c

1788

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init) \

lib/librefuse/refuse/fs.c

1789

fs->user_data = ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init(conn); \

lib/librefuse/refuse/fs.c

180

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fgetattr) \

lib/librefuse/refuse/fs.c

1800

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init) \

lib/librefuse/refuse/fs.c

1801

fs->user_data = ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init(conn, cfg); \

lib/librefuse/refuse/fs.c

1809

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

181

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fgetattr(path, buf, fi); \

lib/librefuse/refuse/fs.c

1814

fuse_fs_destroy(struct fuse_fs *fs) {

lib/librefuse/refuse/fs.c

1815

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

1816

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

182

else if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr) \

lib/librefuse/refuse/fs.c

1825

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->destroy) \

lib/librefuse/refuse/fs.c

1826

((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->destroy(fs->user_data); \

lib/librefuse/refuse/fs.c

183

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr(path, buf); \

lib/librefuse/refuse/fs.c

1839

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

1843

free(fs->op);

lib/librefuse/refuse/fs.c

1844

free(fs);

lib/librefuse/refuse/fs.c

196

return fuse_fs_getattr_v30(fs, path, buf, fi);

lib/librefuse/refuse/fs.c

198

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

203

fuse_fs_rename_v27(struct fuse_fs* fs, const char* oldpath, const char* newpath) {

lib/librefuse/refuse/fs.c

204

return fuse_fs_rename_v30(fs, oldpath, newpath, 0);

lib/librefuse/refuse/fs.c

208

fuse_fs_rename_v30(struct fuse_fs* fs, const char* oldpath,

lib/librefuse/refuse/fs.c

210

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

211

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

214

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rename) \

lib/librefuse/refuse/fs.c

215

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rename(oldpath, newpath); \

lib/librefuse/refuse/fs.c

230

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rename) \

lib/librefuse/refuse/fs.c

231

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rename(oldpath, newpath, flags); \

lib/librefuse/refuse/fs.c

240

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

245

fuse_fs_unlink(struct fuse_fs* fs, const char* path) {

lib/librefuse/refuse/fs.c

246

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

247

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

250

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->unlink) \

lib/librefuse/refuse/fs.c

251

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->unlink(path); \

lib/librefuse/refuse/fs.c

268

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

273

fuse_fs_rmdir(struct fuse_fs* fs, const char* path) {

lib/librefuse/refuse/fs.c

274

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

275

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

278

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rmdir) \

lib/librefuse/refuse/fs.c

279

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rmdir(path); \

lib/librefuse/refuse/fs.c

296

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

301

fuse_fs_symlink(struct fuse_fs* fs, const char* linkname, const char* path) {

lib/librefuse/refuse/fs.c

302

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

303

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

306

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->symlink) \

lib/librefuse/refuse/fs.c

307

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->symlink(linkname, path); \

lib/librefuse/refuse/fs.c

324

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

329

fuse_fs_link(struct fuse_fs* fs, const char* oldpath, const char* newpath) {

lib/librefuse/refuse/fs.c

330

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

331

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

334

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->link) \

lib/librefuse/refuse/fs.c

335

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->link(oldpath, newpath); \

lib/librefuse/refuse/fs.c

352

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

357

fuse_fs_release(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi) {

lib/librefuse/refuse/fs.c

358

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

359

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

362

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->release) \

lib/librefuse/refuse/fs.c

363

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->release(path, fi->flags); \

lib/librefuse/refuse/fs.c

372

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->release) \

lib/librefuse/refuse/fs.c

373

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->release(path, fi); \

lib/librefuse/refuse/fs.c

388

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

393

fuse_fs_open(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi) {

lib/librefuse/refuse/fs.c

394

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

395

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

398

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->open) \

lib/librefuse/refuse/fs.c

399

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->open(path, fi->flags); \

lib/librefuse/refuse/fs.c

408

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->open) \

lib/librefuse/refuse/fs.c

409

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->open(path, fi); \

lib/librefuse/refuse/fs.c

424

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

429

fuse_fs_read(struct fuse_fs* fs, const char* path, char* buf,

lib/librefuse/refuse/fs.c

431

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

432

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

435

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read) \

lib/librefuse/refuse/fs.c

436

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read(path, buf, size, off); \

lib/librefuse/refuse/fs.c

445

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read) \

lib/librefuse/refuse/fs.c

446

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read(path, buf, size, off, fi); \

lib/librefuse/refuse/fs.c

461

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

466

fuse_fs_read_buf(struct fuse_fs* fs, const char* path,

lib/librefuse/refuse/fs.c

469

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

470

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

482

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read_buf) \

lib/librefuse/refuse/fs.c

483

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read_buf(path, bufp, size, off, fi); \

lib/librefuse/refuse/fs.c

493

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

498

fuse_fs_write(struct fuse_fs* fs, const char* path, const char* buf,

lib/librefuse/refuse/fs.c

500

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

501

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

504

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write) \

lib/librefuse/refuse/fs.c

505

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write(path, buf, size, off); \

lib/librefuse/refuse/fs.c

514

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write) \

lib/librefuse/refuse/fs.c

515

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write(path, buf, size, off, fi); \

lib/librefuse/refuse/fs.c

530

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

535

fuse_fs_write_buf(struct fuse_fs* fs, const char* path,

lib/librefuse/refuse/fs.c

538

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

539

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

551

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write_buf) \

lib/librefuse/refuse/fs.c

552

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write_buf(path, bufp, off, fi); \

lib/librefuse/refuse/fs.c

562

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

567

fuse_fs_fsync(struct fuse_fs* fs, const char* path, int datasync, struct fuse_file_info* fi) {

lib/librefuse/refuse/fs.c

568

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

569

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

572

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsync) \

lib/librefuse/refuse/fs.c

573

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsync(path, datasync); \

lib/librefuse/refuse/fs.c

582

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsync) \

lib/librefuse/refuse/fs.c

583

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsync(path, datasync, fi); \

lib/librefuse/refuse/fs.c

598

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

603

fuse_fs_flush(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi) {

lib/librefuse/refuse/fs.c

604

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

607

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

611

if (((const struct fuse_operations_v21 *)fs->op)->flush)

lib/librefuse/refuse/fs.c

612

return ((const struct fuse_operations_v21 *)fs->op)->flush(path);

lib/librefuse/refuse/fs.c

618

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->flush) \

lib/librefuse/refuse/fs.c

619

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->flush(path, fi); \

lib/librefuse/refuse/fs.c

634

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

670

fuse_fs_statfs(struct fuse_fs* fs, const char* path, struct statvfs* buf) {

lib/librefuse/refuse/fs.c

671

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

675

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

678

if (((const struct fuse_operations_v11*)fs->op)->statfs) {

lib/librefuse/refuse/fs.c

682

ret = ((const struct fuse_operations_v11*)fs->op)->statfs(path, &statfs_v11);

lib/librefuse/refuse/fs.c

695

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->statfs) { \

lib/librefuse/refuse/fs.c

699

ret = ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->statfs(path, &statfs_v22); \

lib/librefuse/refuse/fs.c

714

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->statfs) \

lib/librefuse/refuse/fs.c

715

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->statfs(path, buf); \

lib/librefuse/refuse/fs.c

728

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

733

fuse_fs_opendir(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi) {

lib/librefuse/refuse/fs.c

734

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

735

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

745

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->opendir) \

lib/librefuse/refuse/fs.c

746

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->opendir(path, fi); \

lib/librefuse/refuse/fs.c

760

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

841

fuse_fs_readdir_v27(struct fuse_fs* fs, const char* path, void* buf,

lib/librefuse/refuse/fs.c

850

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

852

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

856

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getdir) \

lib/librefuse/refuse/fs.c

857

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getdir(path, &v23_shim, fuse_dirfil_v11_to_fill_dir_v23); \

lib/librefuse/refuse/fs.c

867

if (((const struct fuse_operations_v22*)fs->op)->getdir)

lib/librefuse/refuse/fs.c

868

return ((const struct fuse_operations_v22*)fs->op)->getdir(path, &v23_shim, fuse_dirfil_v22_to_fill_dir_v23);

lib/librefuse/refuse/fs.c

878

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readdir) \

lib/librefuse/refuse/fs.c

879

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readdir(path, buf, filler, off, fi); \

lib/librefuse/refuse/fs.c

880

else if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getdir) \

lib/librefuse/refuse/fs.c

881

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getdir(path, &v23_shim, fuse_dirfil_v22_to_fill_dir_v23); \

lib/librefuse/refuse/fs.c

894

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

899

fuse_fs_readdir_v30(struct fuse_fs* fs, const char* path, void* buf,

lib/librefuse/refuse/fs.c

902

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

904

if (fs->op_version < 30) {

lib/librefuse/refuse/fs.c

910

return fuse_fs_readdir_v27(fs, path, &v30_shim, fuse_fill_dir_v23_to_v30, off, fi);

lib/librefuse/refuse/fs.c

913

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

916

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readdir) \

lib/librefuse/refuse/fs.c

917

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readdir(path, buf, filler, off, fi, flags); \

lib/librefuse/refuse/fs.c

926

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

936

fuse_fs_fsyncdir(struct fuse_fs* fs, const char* path, int datasync, struct fuse_file_info* fi) {

lib/librefuse/refuse/fs.c

937

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

939

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

947

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsyncdir) \

lib/librefuse/refuse/fs.c

948

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsyncdir(path, datasync, fi); \

lib/librefuse/refuse/fs.c

95

struct fuse_fs* fs;

lib/librefuse/refuse/fs.c

962

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

967

fuse_fs_releasedir(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi) {

lib/librefuse/refuse/fs.c

968

clobber_context_user_data(fs);

lib/librefuse/refuse/fs.c

969

switch (fs->op_version) {

lib/librefuse/refuse/fs.c

97

fs = malloc(sizeof(struct fuse_fs));

lib/librefuse/refuse/fs.c

979

if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->releasedir) \

lib/librefuse/refuse/fs.c

98

if (!fs)

lib/librefuse/refuse/fs.c

980

return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->releasedir(path, fi); \

lib/librefuse/refuse/fs.c

994

UNKNOWN_VERSION(fs->op_version);

lib/librefuse/refuse/fs.c

999

fuse_fs_create(struct fuse_fs* fs, const char* path, mode_t mode, struct fuse_file_info* fi) {

lib/librefuse/refuse/fs.h

100

int fuse_fs_listxattr(struct fuse_fs* fs, const char* path, char* list, size_t size);

lib/librefuse/refuse/fs.h

101

int fuse_fs_removexattr(struct fuse_fs* fs, const char* path, const char* name);

lib/librefuse/refuse/fs.h

102

int fuse_fs_bmap(struct fuse_fs* fs, const char* path, size_t blocksize, uint64_t *idx);

lib/librefuse/refuse/fs.h

103

int fuse_fs_ioctl_v28(struct fuse_fs* fs, const char* path, int cmd, void* arg, struct fuse_file_info* fi, unsigned int flags, void* data);

lib/librefuse/refuse/fs.h

104

int fuse_fs_ioctl_v35(struct fuse_fs* fs, const char* path, unsigned int cmd, void* arg, struct fuse_file_info* fi, unsigned int flags, void* data);

lib/librefuse/refuse/fs.h

105

int fuse_fs_poll(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi, struct fuse_pollhandle* ph, unsigned* reventsp);

lib/librefuse/refuse/fs.h

106

int fuse_fs_fallocate(struct fuse_fs* fs, const char* path, int mode, off_t offset, off_t length, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

107

ssize_t fuse_fs_copy_file_range(struct fuse_fs* fs,

lib/librefuse/refuse/fs.h

111

off_t fuse_fs_lseek(struct fuse_fs* fs, const char* path, off_t off, int whence, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

112

void fuse_fs_init_v27(struct fuse_fs* fs, struct fuse_conn_info* conn);

lib/librefuse/refuse/fs.h

113

void fuse_fs_init_v30(struct fuse_fs* fs, struct fuse_conn_info* conn, struct fuse_config* cfg);

lib/librefuse/refuse/fs.h

114

void fuse_fs_destroy(struct fuse_fs* fs);

lib/librefuse/refuse/fs.h

59

int fuse_fs_getattr_v27(struct fuse_fs *fs, const char *path, struct stat *buf);

lib/librefuse/refuse/fs.h

60

int fuse_fs_getattr_v30(struct fuse_fs* fs, const char* path, struct stat* buf, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

61

int fuse_fs_fgetattr(struct fuse_fs* fs, const char* path, struct stat* buf, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

62

int fuse_fs_rename_v27(struct fuse_fs* fs, const char* oldpath, const char* newpath);

lib/librefuse/refuse/fs.h

63

int fuse_fs_rename_v30(struct fuse_fs* fs, const char* oldpath, const char* newpath, unsigned int flags);

lib/librefuse/refuse/fs.h

64

int fuse_fs_unlink(struct fuse_fs* fs, const char* path);

lib/librefuse/refuse/fs.h

65

int fuse_fs_rmdir(struct fuse_fs* fs, const char* path);

lib/librefuse/refuse/fs.h

66

int fuse_fs_symlink(struct fuse_fs* fs, const char* linkname, const char* path);

lib/librefuse/refuse/fs.h

67

int fuse_fs_link(struct fuse_fs* fs, const char* oldpath, const char* newpath);

lib/librefuse/refuse/fs.h

68

int fuse_fs_release(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

69

int fuse_fs_open(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

70

int fuse_fs_read(struct fuse_fs* fs, const char* path, char* buf, size_t size, off_t off, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

71

int fuse_fs_read_buf(struct fuse_fs* fs, const char* path, struct fuse_bufvec** bufp, size_t size, off_t off, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

72

int fuse_fs_write(struct fuse_fs* fs, const char* path, const char* buf, size_t size, off_t off, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

73

int fuse_fs_write_buf(struct fuse_fs* fs, const char* path, struct fuse_bufvec *buf, off_t off, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

74

int fuse_fs_fsync(struct fuse_fs* fs, const char* path, int datasync, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

75

int fuse_fs_flush(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

76

int fuse_fs_statfs(struct fuse_fs* fs, const char* path, struct statvfs* buf);

lib/librefuse/refuse/fs.h

77

int fuse_fs_opendir(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

78

int fuse_fs_readdir_v27(struct fuse_fs* fs, const char* path, void* buf, fuse_fill_dir_t_v23 filler, off_t off, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

79

int fuse_fs_readdir_v30(struct fuse_fs* fs, const char* path, void* buf, fuse_fill_dir_t_v30 filler, off_t off, struct fuse_file_info* fi, enum fuse_readdir_flags flags);

lib/librefuse/refuse/fs.h

80

int fuse_fs_fsyncdir(struct fuse_fs* fs, const char* path, int datasync, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

81

int fuse_fs_releasedir(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

82

int fuse_fs_create(struct fuse_fs* fs, const char* path, mode_t mode, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

83

int fuse_fs_lock(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi, int cmd, struct flock* lock);

lib/librefuse/refuse/fs.h

84

int fuse_fs_flock(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi, int op);

lib/librefuse/refuse/fs.h

85

int fuse_fs_chmod_v27(struct fuse_fs *fs, const char *path, mode_t mode);

lib/librefuse/refuse/fs.h

86

int fuse_fs_chmod_v30(struct fuse_fs* fs, const char* path, mode_t mode, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

87

int fuse_fs_chown_v27(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid);

lib/librefuse/refuse/fs.h

88

int fuse_fs_chown_v30(struct fuse_fs* fs, const char* path, uid_t uid, gid_t gid, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

89

int fuse_fs_truncate_v27(struct fuse_fs *fs, const char *path, off_t size);

lib/librefuse/refuse/fs.h

90

int fuse_fs_truncate_v30(struct fuse_fs* fs, const char* path, off_t size, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

91

int fuse_fs_ftruncate(struct fuse_fs* fs, const char* path, off_t size, struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

92

int fuse_fs_utimens_v27(struct fuse_fs *fs, const char *path, const struct timespec tv[2]);

lib/librefuse/refuse/fs.h

93

int fuse_fs_utimens_v30(struct fuse_fs* fs, const char* path, const struct timespec tv[2], struct fuse_file_info* fi);

lib/librefuse/refuse/fs.h

94

int fuse_fs_access(struct fuse_fs* fs, const char* path, int mask);

lib/librefuse/refuse/fs.h

95

int fuse_fs_readlink(struct fuse_fs* fs, const char* path, char* buf, size_t len);

lib/librefuse/refuse/fs.h

96

int fuse_fs_mknod(struct fuse_fs* fs, const char* path, mode_t mode, dev_t rdev);

lib/librefuse/refuse/fs.h

97

int fuse_fs_mkdir(struct fuse_fs* fs, const char* path, mode_t mode);

lib/librefuse/refuse/fs.h

98

int fuse_fs_setxattr(struct fuse_fs* fs, const char* path, const char* name, const char* value, size_t size, int flags);

lib/librefuse/refuse/fs.h

99

int fuse_fs_getxattr(struct fuse_fs* fs, const char* path, const char* name, char* value, size_t size);

lib/libukfs/ukfs.c

1322

int (*mkdirfn)(struct ukfs *, const char *, mode_t), struct ukfs *fs)

lib/libukfs/ukfs.c

1348

rv = mkdirfn(fs, f1, mode & ~mask);

lib/libukfs/ukfs.c

534

struct ukfs *fs = NULL;

lib/libukfs/ukfs.c

549

fs = malloc(sizeof(struct ukfs));

lib/libukfs/ukfs.c

550

if (fs == NULL) {

lib/libukfs/ukfs.c

554

memset(fs, 0, sizeof(struct ukfs));

lib/libukfs/ukfs.c

619

rv = rump_pub_vfs_getmp(mountpath, &fs->ukfs_mp);

lib/libukfs/ukfs.c

625

fs->ukfs_devpath = strdup(devpath);

lib/libukfs/ukfs.c

627

fs->ukfs_mountpath = strdup(mountpath);

lib/libukfs/ukfs.c

628

pthread_spin_init(&fs->ukfs_spin, PTHREAD_PROCESS_SHARED);

lib/libukfs/ukfs.c

629

fs->ukfs_devfd = devfd;

lib/libukfs/ukfs.c

630

fs->ukfs_part = part;

lib/libukfs/ukfs.c

635

fs->ukfs_lwp = rump_pub_lwproc_curlwp();

lib/libukfs/ukfs.c

636

fs->ukfs_cwd = strdup("/");

lib/libukfs/ukfs.c

641

if (fs) {

lib/libukfs/ukfs.c

642

free(fs);

lib/libukfs/ukfs.c

643

fs = NULL;

lib/libukfs/ukfs.c

657

return fs;

lib/libukfs/ukfs.c

680

ukfs_release(struct ukfs *fs, int flags)

lib/libukfs/ukfs.c

685

rump_pub_lwproc_switch(fs->ukfs_lwp);

lib/libukfs/ukfs.c

695

rv = rump_sys_unmount(fs->ukfs_mountpath, mntflag);

lib/libukfs/ukfs.c

706

if (fs->ukfs_devpath) {

lib/libukfs/ukfs.c

707

rump_pub_etfs_remove(fs->ukfs_devpath);

lib/libukfs/ukfs.c

708

free(fs->ukfs_devpath);

lib/libukfs/ukfs.c

710

free(fs->ukfs_mountpath);

lib/libukfs/ukfs.c

711

free(fs->ukfs_cwd);

lib/libukfs/ukfs.c

715

rump_pub_lwproc_switch(fs->ukfs_lwp);

lib/libukfs/ukfs.c

718

pthread_spin_destroy(&fs->ukfs_spin);

lib/libukfs/ukfs.c

719

if (fs->ukfs_devfd != -1) {

lib/libukfs/ukfs.c

720

unlockdev(fs->ukfs_devfd, fs->ukfs_part);

lib/libukfs/ukfs.c

721

close(fs->ukfs_devfd);

lib/libukfs/ukfs.c

723

ukfs_part_release(fs->ukfs_part);

lib/libukfs/ukfs.c

724

free(fs);

libexec/lfs_cleanerd/coalesce.c

101

if (kops.ko_fcntl(fs->clfs_ifilefd, LFCNREWRITEFILE, liap) < 0) {

libexec/lfs_cleanerd/coalesce.c

103

lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/coalesce.c

120

int clean_all_inodes(struct clfs *fs)

libexec/lfs_cleanerd/coalesce.c

134

blocksperseg = lfs_sb_getssize(fs) / lfs_sb_getbsize(fs);

libexec/lfs_cleanerd/coalesce.c

136

fstat(fs->clfs_ifilefd, &st);

libexec/lfs_cleanerd/coalesce.c

137

maxino = lfs_sb_getifpb(fs) * (st.st_size >> lfs_sb_getbshift(fs)) -

libexec/lfs_cleanerd/coalesce.c

138

lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs);

libexec/lfs_cleanerd/coalesce.c

146

if (kops.ko_fcntl(fs->clfs_ifilefd, LFCNFILESTATS, &lfr) < 0) {

libexec/lfs_cleanerd/coalesce.c

148

lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/coalesce.c

164

flush(fs, &lia, totals);

libexec/lfs_cleanerd/coalesce.c

168

flush(fs, &lia, totals);

libexec/lfs_cleanerd/coalesce.c

182

fork_coalesce(struct clfs *fs)

libexec/lfs_cleanerd/coalesce.c

206

syslog(LOG_ERR, "%s: fork to coaleasce: %m", lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/coalesce.c

210

lfs_sb_getfsmnt(fs), getpid());

libexec/lfs_cleanerd/coalesce.c

211

num = clean_all_inodes(fs);

libexec/lfs_cleanerd/coalesce.c

213

lfs_sb_getfsmnt(fs), num);

libexec/lfs_cleanerd/coalesce.c

97

static void flush(struct clfs *fs, struct lfs_inode_array *liap, int *totals)

libexec/lfs_cleanerd/fdfs.c

101

free(fs->fd_bufp[i].buf);

libexec/lfs_cleanerd/fdfs.c

102

free(fs->fd_bufp);

libexec/lfs_cleanerd/fdfs.c

104

free(fs);

libexec/lfs_cleanerd/fdfs.c

109

vp->v_fs = fs;

libexec/lfs_cleanerd/fdfs.c

129

struct fdfs *fs;

libexec/lfs_cleanerd/fdfs.c

140

fs = (struct fdfs *)vp->v_fs;

libexec/lfs_cleanerd/fdfs.c

141

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

libexec/lfs_cleanerd/fdfs.c

142

free(fs->fd_bufp[i].buf);

libexec/lfs_cleanerd/fdfs.c

143

free(fs->fd_bufp);

libexec/lfs_cleanerd/fdfs.c

144

free(fs);

libexec/lfs_cleanerd/fdfs.c

174

struct fdfs *fs = (struct fdfs *)vp->v_fs;

libexec/lfs_cleanerd/fdfs.c

179

if (fs->fd_bufi == fs->fd_bufc) {

libexec/lfs_cleanerd/fdfs.c

180

++fs->fd_bufc;

libexec/lfs_cleanerd/fdfs.c

182

fs->fd_bufc);

libexec/lfs_cleanerd/fdfs.c

183

t = realloc(fs->fd_bufp, fs->fd_bufc * sizeof(struct fd_buf));

libexec/lfs_cleanerd/fdfs.c

186

fs->fd_bufc);

libexec/lfs_cleanerd/fdfs.c

189

fs->fd_bufp = t;

libexec/lfs_cleanerd/fdfs.c

190

fs->fd_bufp[fs->fd_bufi].start = 0x0;

libexec/lfs_cleanerd/fdfs.c

191

fs->fd_bufp[fs->fd_bufi].end = 0x0;

libexec/lfs_cleanerd/fdfs.c

192

fs->fd_bufp[fs->fd_bufi].buf = malloc(fs->fd_ssize);

libexec/lfs_cleanerd/fdfs.c

193

if (fs->fd_bufp[fs->fd_bufi].buf == NULL) {

libexec/lfs_cleanerd/fdfs.c

195

fs->fd_bufc);

libexec/lfs_cleanerd/fdfs.c

196

--fs->fd_bufc;

libexec/lfs_cleanerd/fdfs.c

202

fs->fd_bufp[fs->fd_bufi].start = start;

libexec/lfs_cleanerd/fdfs.c

203

fs->fd_bufp[fs->fd_bufi].end = start + fs->fd_ssize / fs->fd_bsize;

libexec/lfs_cleanerd/fdfs.c

205

if ((r = kops.ko_pread(fs->fd_fd, fs->fd_bufp[fs->fd_bufi].buf,

libexec/lfs_cleanerd/fdfs.c

206

(size_t)fs->fd_ssize, start * fs->fd_bsize)) < 0) {

libexec/lfs_cleanerd/fdfs.c

207

syslog(LOG_ERR, "preload to segment buffer %d", fs->fd_bufi);

libexec/lfs_cleanerd/fdfs.c

211

fs->fd_bufi = fs->fd_bufi + 1;

libexec/lfs_cleanerd/fdfs.c

223

struct fdfs *fs;

libexec/lfs_cleanerd/fdfs.c

225

fs = (struct fdfs *)vp->v_fs;

libexec/lfs_cleanerd/fdfs.c

226

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

libexec/lfs_cleanerd/fdfs.c

227

if (bn >= fs->fd_bufp[i].start && bn < fs->fd_bufp[i].end) {

libexec/lfs_cleanerd/fdfs.c

228

return fs->fd_bufp[i].buf +

libexec/lfs_cleanerd/fdfs.c

229

(bn - fs->fd_bufp[i].start) * fs->fd_bsize;

libexec/lfs_cleanerd/fdfs.c

241

struct fdfs *fs;

libexec/lfs_cleanerd/fdfs.c

245

fs = (struct fdfs *)bp->b_vp->v_fs;

libexec/lfs_cleanerd/fdfs.c

254

bp->b_blkno * fs->fd_bsize);

libexec/lfs_cleanerd/fdfs.c

259

bp->b_blkno * fs->fd_bsize);

libexec/lfs_cleanerd/fdfs.c

63

struct fdfs *fs;

libexec/lfs_cleanerd/fdfs.c

67

fs = malloc(sizeof(*fs));

libexec/lfs_cleanerd/fdfs.c

68

if (fs == NULL)

libexec/lfs_cleanerd/fdfs.c

71

fs->fd_bufp = malloc(nseg * sizeof(struct fd_buf));

libexec/lfs_cleanerd/fdfs.c

72

if (fs->fd_bufp == NULL) {

libexec/lfs_cleanerd/fdfs.c

73

free(fs);

libexec/lfs_cleanerd/fdfs.c

77

fs->fd_bufp[i].start = 0x0;

libexec/lfs_cleanerd/fdfs.c

78

fs->fd_bufp[i].end = 0x0;

libexec/lfs_cleanerd/fdfs.c

79

fs->fd_bufp[i].buf = malloc(segsize);

libexec/lfs_cleanerd/fdfs.c

80

if (fs->fd_bufp[i].buf == NULL) {

libexec/lfs_cleanerd/fdfs.c

82

free(fs->fd_bufp[i].buf);

libexec/lfs_cleanerd/fdfs.c

83

free(fs->fd_bufp);

libexec/lfs_cleanerd/fdfs.c

84

free(fs);

libexec/lfs_cleanerd/fdfs.c

89

fs->fd_bufp = NULL;

libexec/lfs_cleanerd/fdfs.c

91

fs->fd_fd = fd;

libexec/lfs_cleanerd/fdfs.c

92

fs->fd_bufc = nseg;

libexec/lfs_cleanerd/fdfs.c

93

fs->fd_bufi = 0;

libexec/lfs_cleanerd/fdfs.c

94

fs->fd_bsize = bsize;

libexec/lfs_cleanerd/fdfs.c

95

fs->fd_ssize = segsize;

libexec/lfs_cleanerd/fdfs.c

99

if (fs->fd_bufp) {

libexec/lfs_cleanerd/lfs_cleanerd.c

136

reinit_fs(struct clfs *fs)

libexec/lfs_cleanerd/lfs_cleanerd.c

140

memcpy(fsname, lfs_sb_getfsmnt(fs), sizeof(fsname));

libexec/lfs_cleanerd/lfs_cleanerd.c

143

kops.ko_close(fs->clfs_ifilefd);

libexec/lfs_cleanerd/lfs_cleanerd.c

144

kops.ko_close(fs->clfs_devfd);

libexec/lfs_cleanerd/lfs_cleanerd.c

145

free(fs->clfs_dev);

libexec/lfs_cleanerd/lfs_cleanerd.c

146

free(fs->clfs_segtab);

libexec/lfs_cleanerd/lfs_cleanerd.c

147

free(fs->clfs_segtabp);

libexec/lfs_cleanerd/lfs_cleanerd.c

149

return init_fs(fs, fsname);

libexec/lfs_cleanerd/lfs_cleanerd.c

163

init_fs(struct clfs *fs, char *fsname)

libexec/lfs_cleanerd/lfs_cleanerd.c

173

fs->clfs_dev = strndup(do_asdevice,strlen(do_asdevice) + 2);

libexec/lfs_cleanerd/lfs_cleanerd.c

174

if (fs->clfs_dev == NULL) {

libexec/lfs_cleanerd/lfs_cleanerd.c

187

fs->clfs_dev = malloc(mlen);

libexec/lfs_cleanerd/lfs_cleanerd.c

188

if (fs->clfs_dev == NULL) {

libexec/lfs_cleanerd/lfs_cleanerd.c

192

if (getdiskrawname(fs->clfs_dev, mlen, sf.f_mntfromname) == NULL) {

libexec/lfs_cleanerd/lfs_cleanerd.c

198

if ((fs->clfs_devfd = kops.ko_open(fs->clfs_dev, O_RDONLY, 0)) < 0) {

libexec/lfs_cleanerd/lfs_cleanerd.c

200

fs->clfs_dev);

libexec/lfs_cleanerd/lfs_cleanerd.c

207

if (kops.ko_fcntl(rootfd, LFCNIFILEFH, &fs->clfs_ifilefh) < 0)

libexec/lfs_cleanerd/lfs_cleanerd.c

209

if ((fs->clfs_ifilefd = kops.ko_fhopen(&fs->clfs_ifilefh,

libexec/lfs_cleanerd/lfs_cleanerd.c

210

sizeof(fs->clfs_ifilefh), O_RDONLY)) < 0)

libexec/lfs_cleanerd/lfs_cleanerd.c

221

if (kops.ko_pread(fs->clfs_devfd, sbuf, LFS_SBPAD, LFS_LABELPAD) < 0) {

libexec/lfs_cleanerd/lfs_cleanerd.c

227

memcpy(&fs->lfs_dlfs_u, sbuf, sizeof(struct dlfs));

libexec/lfs_cleanerd/lfs_cleanerd.c

231

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

libexec/lfs_cleanerd/lfs_cleanerd.c

233

fs->lfs_is64 = false;

libexec/lfs_cleanerd/lfs_cleanerd.c

234

fs->lfs_dobyteswap = false;

libexec/lfs_cleanerd/lfs_cleanerd.c

237

fs->lfs_is64 = false;

libexec/lfs_cleanerd/lfs_cleanerd.c

238

fs->lfs_dobyteswap = true;

libexec/lfs_cleanerd/lfs_cleanerd.c

241

fs->lfs_is64 = true;

libexec/lfs_cleanerd/lfs_cleanerd.c

242

fs->lfs_dobyteswap = false;

libexec/lfs_cleanerd/lfs_cleanerd.c

245

fs->lfs_is64 = true;

libexec/lfs_cleanerd/lfs_cleanerd.c

246

fs->lfs_dobyteswap = true;

libexec/lfs_cleanerd/lfs_cleanerd.c

253

fs->lfs_hasolddirfmt = 0;

libexec/lfs_cleanerd/lfs_cleanerd.c

256

if (lfs_sb_getversion(fs) != 2) {

libexec/lfs_cleanerd/lfs_cleanerd.c

264

lfs_sb_setfsmnt(fs, mnttmp);

libexec/lfs_cleanerd/lfs_cleanerd.c

267

fs->clfs_segtab = (struct clfs_seguse *)malloc(lfs_sb_getnseg(fs) *

libexec/lfs_cleanerd/lfs_cleanerd.c

268

sizeof(*fs->clfs_segtab));

libexec/lfs_cleanerd/lfs_cleanerd.c

269

fs->clfs_segtabp = (struct clfs_seguse **)malloc(lfs_sb_getnseg(fs) *

libexec/lfs_cleanerd/lfs_cleanerd.c

270

sizeof(*fs->clfs_segtabp));

libexec/lfs_cleanerd/lfs_cleanerd.c

271

if (fs->clfs_segtab == NULL || fs->clfs_segtabp == NULL) {

libexec/lfs_cleanerd/lfs_cleanerd.c

273

fs->clfs_dev);

libexec/lfs_cleanerd/lfs_cleanerd.c

277

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

libexec/lfs_cleanerd/lfs_cleanerd.c

278

fs->clfs_segtabp[i] = &(fs->clfs_segtab[i]);

libexec/lfs_cleanerd/lfs_cleanerd.c

279

fs->clfs_segtab[i].flags = 0x0;

libexec/lfs_cleanerd/lfs_cleanerd.c

287

calc_cb(struct clfs *fs, int sn, struct clfs_seguse *t)

libexec/lfs_cleanerd/lfs_cleanerd.c

318

if (t->nbytes > lfs_sb_getssize(fs)) {

libexec/lfs_cleanerd/lfs_cleanerd.c

335

benefit = (int64_t)lfs_sb_getssize(fs) - t->nbytes -

libexec/lfs_cleanerd/lfs_cleanerd.c

336

(t->nsums + 1) * lfs_sb_getfsize(fs);

libexec/lfs_cleanerd/lfs_cleanerd.c

337

if (lfs_sb_getbsize(fs) > lfs_sb_getfsize(fs)) /* fragmentation */

libexec/lfs_cleanerd/lfs_cleanerd.c

338

benefit -= (lfs_sb_getbsize(fs) / 2);

libexec/lfs_cleanerd/lfs_cleanerd.c

344

cost = lfs_sb_getssize(fs) + t->nbytes;

libexec/lfs_cleanerd/lfs_cleanerd.c

373

invalidate_segment(struct clfs *fs, int sn)

libexec/lfs_cleanerd/lfs_cleanerd.c

378

dlog("%s: inval seg %d", lfs_sb_getfsmnt(fs), sn);

libexec/lfs_cleanerd/lfs_cleanerd.c

385

if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNREWRITESEGS, &lsa)) < 0) {

libexec/lfs_cleanerd/lfs_cleanerd.c

387

"for seg %d", lfs_sb_getfsmnt(fs), r, sn);

libexec/lfs_cleanerd/lfs_cleanerd.c

397

if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNINVAL, &sn)) < 0) {

libexec/lfs_cleanerd/lfs_cleanerd.c

399

"for seg %d", lfs_sb_getfsmnt(fs), r, sn);

libexec/lfs_cleanerd/lfs_cleanerd.c

416

clean_fs(struct clfs *fs, const CLEANERINFO64 *cip)

libexec/lfs_cleanerd/lfs_cleanerd.c

434

for (i = 0; i < lfs_sb_getnseg(fs); i+= LFS_SEGUSE_MAXCNT) {

libexec/lfs_cleanerd/lfs_cleanerd.c

436

if (fcntl(fs->clfs_ifilefd, LFCNSEGUSE, &sua) < 0) {

libexec/lfs_cleanerd/lfs_cleanerd.c

437

dlog("%s: fcntl returned %d", lfs_sb_getfsmnt(fs),

libexec/lfs_cleanerd/lfs_cleanerd.c

442

for (j = 0; j < LFS_SEGUSE_MAXCNT && i + j < lfs_sb_getnseg(fs); j++) {

libexec/lfs_cleanerd/lfs_cleanerd.c

444

fs->clfs_segtab[i + j].nbytes = sup->su_nbytes;

libexec/lfs_cleanerd/lfs_cleanerd.c

445

fs->clfs_segtab[i + j].nsums = sup->su_nsums;

libexec/lfs_cleanerd/lfs_cleanerd.c

446

fs->clfs_segtab[i + j].lastmod = sup->su_lastmod;

libexec/lfs_cleanerd/lfs_cleanerd.c

448

fs->clfs_segtab[i + j].flags &= SEGUSE_ERROR;

libexec/lfs_cleanerd/lfs_cleanerd.c

449

fs->clfs_segtab[i + j].flags |= sup->su_flags;

libexec/lfs_cleanerd/lfs_cleanerd.c

452

calc_cb(fs, i + j, fs->clfs_segtab + i + j);

libexec/lfs_cleanerd/lfs_cleanerd.c

453

if (fs->clfs_segtab[i + j].priority > 0)

libexec/lfs_cleanerd/lfs_cleanerd.c

460

fs->clfs_segtab[recent[i]].priority /= 2;

libexec/lfs_cleanerd/lfs_cleanerd.c

463

heapsort(fs->clfs_segtabp, lfs_sb_getnseg(fs), sizeof(struct clfs_seguse *),

libexec/lfs_cleanerd/lfs_cleanerd.c

467

if (fs->clfs_segtabp[0]->priority == 0) {

libexec/lfs_cleanerd/lfs_cleanerd.c

468

dlog("%s: no segment cleanable", lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

474

fs->clfs_nactive = 0;

libexec/lfs_cleanerd/lfs_cleanerd.c

480

goal = lfs_sb_getssize(fs) * atatime;

libexec/lfs_cleanerd/lfs_cleanerd.c

481

if (goal > (cip->clean - 1) * lfs_sb_getssize(fs) / 2)

libexec/lfs_cleanerd/lfs_cleanerd.c

482

goal = MAX((cip->clean - 1) * lfs_sb_getssize(fs),

libexec/lfs_cleanerd/lfs_cleanerd.c

483

lfs_sb_getssize(fs)) / 2;

libexec/lfs_cleanerd/lfs_cleanerd.c

487

lfs_sb_getfsmnt(fs), goal, cip->clean, npos);

libexec/lfs_cleanerd/lfs_cleanerd.c

490

lfs_sb_getfsmnt(fs), goal, cip->clean, npos);

libexec/lfs_cleanerd/lfs_cleanerd.c

492

for (i = 0; i < lfs_sb_getnseg(fs) && totbytes < goal; i++) {

libexec/lfs_cleanerd/lfs_cleanerd.c

493

if (fs->clfs_segtabp[i]->priority == 0)

libexec/lfs_cleanerd/lfs_cleanerd.c

496

if (ngood * lfs_sb_getssize(fs) > 4 * goal)

libexec/lfs_cleanerd/lfs_cleanerd.c

498

sn = (fs->clfs_segtabp[i] - fs->clfs_segtab);

libexec/lfs_cleanerd/lfs_cleanerd.c

501

lfs_sb_getfsmnt(fs), sn, fs->clfs_segtabp[i]->priority,

libexec/lfs_cleanerd/lfs_cleanerd.c

502

fs->clfs_segtabp[i]->nbytes);

libexec/lfs_cleanerd/lfs_cleanerd.c

506

totbytes += fs->clfs_segtabp[i]->nbytes;

libexec/lfs_cleanerd/lfs_cleanerd.c

516

lfs_sb_getfsmnt(fs), (int)goal, cip->clean, npos);

libexec/lfs_cleanerd/lfs_cleanerd.c

517

for (i = 0; i < lfs_sb_getnseg(fs) && ngood < goal; i++) {

libexec/lfs_cleanerd/lfs_cleanerd.c

518

if (fs->clfs_segtabp[i]->priority == 0)

libexec/lfs_cleanerd/lfs_cleanerd.c

520

sn = (fs->clfs_segtabp[i] - fs->clfs_segtab);

libexec/lfs_cleanerd/lfs_cleanerd.c

522

lfs_sb_getfsmnt(fs), sn, fs->clfs_segtabp[i]->priority);

libexec/lfs_cleanerd/lfs_cleanerd.c

533

lfs_sb_getfsmnt(fs), (int)ngood);

libexec/lfs_cleanerd/lfs_cleanerd.c

540

util = ((double)nb) / (fs->clfs_nactive * lfs_sb_getssize(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

548

if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNREWRITESEGS, &sna)) < 0) {

libexec/lfs_cleanerd/lfs_cleanerd.c

551

lfs_sb_getfsmnt(fs), r, errno);

libexec/lfs_cleanerd/lfs_cleanerd.c

554

lfs_sb_getfsmnt(fs), oerrno);

libexec/lfs_cleanerd/lfs_cleanerd.c

559

lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

571

if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNRECLAIM, &reclaim_stats)) < 0)

libexec/lfs_cleanerd/lfs_cleanerd.c

573

lfs_sb_getfsmnt(fs), errno);

libexec/lfs_cleanerd/lfs_cleanerd.c

579

* lfs_sb_getfsize(fs);

libexec/lfs_cleanerd/lfs_cleanerd.c

580

double revenue = sna.len * lfs_sb_getssize(fs);

libexec/lfs_cleanerd/lfs_cleanerd.c

583

lfs_sb_getfsmnt(fs), sna.stats.direct, sna.stats.offset,

libexec/lfs_cleanerd/lfs_cleanerd.c

588

lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

599

needs_cleaning(struct clfs *fs, CLEANERINFO64 *cip)

libexec/lfs_cleanerd/lfs_cleanerd.c

607

if (fs->clfs_onhold) {

libexec/lfs_cleanerd/lfs_cleanerd.c

626

if (fcntl(fs->clfs_ifilefd, LFCNCLEANERINFO, cip) < 0) {

libexec/lfs_cleanerd/lfs_cleanerd.c

627

syslog(LOG_ERR, "%s: failed to read cleaner info", lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

641

if (lfs_sb_getnseg(fs) != cip->clean + cip->dirty) {

libexec/lfs_cleanerd/lfs_cleanerd.c

642

if (reinit_fs(fs) < 0) {

libexec/lfs_cleanerd/lfs_cleanerd.c

644

syslog(LOG_NOTICE, "%s: filesystem unmounted", lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

647

syslog(LOG_NOTICE, "%s: nsegs changed", lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

651

fsb_per_seg = lfs_segtod(fs, 1);

libexec/lfs_cleanerd/lfs_cleanerd.c

652

max_free_segs = MAX(cip->bfree, 0) / fsb_per_seg + lfs_sb_getminfreeseg(fs);

libexec/lfs_cleanerd/lfs_cleanerd.c

655

lfs_sb_getfsmnt(fs), cip->bfree, cip->avail, cip->clean,

libexec/lfs_cleanerd/lfs_cleanerd.c

656

lfs_sb_getnseg(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

659

if (cip->clean <= lfs_sb_getminfreeseg(fs) ||

libexec/lfs_cleanerd/lfs_cleanerd.c

661

dlog("%s: must clean", lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

668

dlog("%s: enough clean", lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

675

dlog("%s: dire straits", lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

681

dlog("%s: busy clean", lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

689

if (fstat(fs->clfs_ifilefd, &st) < 0) {

libexec/lfs_cleanerd/lfs_cleanerd.c

691

lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

697

lfs_sb_getfsmnt(fs), (int)(now - st.st_mtime));

libexec/lfs_cleanerd/lfs_cleanerd.c

704

lfs_sb_getfsmnt(fs));

libexec/lfs_cleanerd/lfs_cleanerd.c

710

lfs_sb_getfsmnt(fs), loadavg);

libexec/lfs_cleanerd/lfs_cleanerd.c

715

dlog("%s: default no clean", lfs_sb_getfsmnt(fs));

sbin/badsect/badsect.c

146

fs = &sblock;

sbin/badsect/badsect.c

151

rdfs(sblock_try[i], SBLOCKSIZE, fs);

sbin/badsect/badsect.c

152

switch (fs->fs_magic) {

sbin/badsect/badsect.c

165

ffs_sb_swap(fs, fs);

sbin/badsect/badsect.c

172

if (is_ufs2 || fs->fs_old_flags & FS_FLAGS_UPDATED) {

sbin/badsect/badsect.c

173

if (fs->fs_sblockloc != sblock_try[i])

sbin/badsect/badsect.c

182

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

sbin/badsect/badsect.c

188

(dev_t)FFS_DBTOFSB(fs, number)) == -1) {

sbin/badsect/badsect.c

209

fsbn = FFS_DBTOFSB(fs, blkno);

sbin/badsect/badsect.c

211

if (fsbe > fs->fs_size) {

sbin/badsect/badsect.c

217

cg = (int)dtog(fs, fsbn);

sbin/badsect/badsect.c

218

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

sbin/badsect/badsect.c

219

if (cg == 0 || fsbe > cgsblock(fs, cg)) {

sbin/badsect/badsect.c

225

if (fsbe > cgbase(fs, cg + 1)) {

sbin/badsect/badsect.c

232

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

sbin/badsect/badsect.c

240

bn = dtogd(fs, fsbn);

sbin/badsect/badsect.c

74

struct fs fs;

sbin/badsect/badsect.c

77

#define sblock ufs.fs

sbin/badsect/badsect.c

83

static struct fs *fs;

sbin/cgdconfig/cgdconfig.c

1306

struct fs fs;

sbin/cgdconfig/cgdconfig.c

1318

switch (u.fs.fs_magic) {

sbin/clri/clri.c

103

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

sbin/clri/clri.c

105

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

sbin/clri/clri.c

107

sbp = (struct fs *)sblock;

sbin/clri/clri.c

149

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

sbin/clri/clri.c

151

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

sbin/clri/clri.c

179

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

sbin/clri/clri.c

181

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

sbin/clri/clri.c

202

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

sbin/clri/clri.c

204

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

sbin/clri/clri.c

75

struct fs *sbp;

sbin/clri/clri.c

84

char *fs, sblock[SBLOCKSIZE];

sbin/clri/clri.c

94

fs = *++argv;

sbin/clri/clri.c

98

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

sbin/clri/clri.c

99

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

sbin/dump/ffs_inode.c

63

static struct fs *sblock;

sbin/dump/ffs_inode.c

79

sblock = (struct fs *)superblock;

sbin/dump/optr.c

339

allocfsent(const struct fstab *fs)

sbin/dump/optr.c

343

new = xmalloc(sizeof (*fs));

sbin/dump/optr.c

344

new->fs_file = xstrdup(fs->fs_file);

sbin/dump/optr.c

345

new->fs_type = xstrdup(fs->fs_type);

sbin/dump/optr.c

347

if (getfsspecname(new->fs_spec, FILENAME_MAX, fs->fs_spec) == NULL) {

sbin/dump/optr.c

351

new->fs_passno = fs->fs_passno;

sbin/dump/optr.c

352

new->fs_freq = fs->fs_freq;

sbin/dump/optr.c

366

struct fstab *fs;

sbin/dump/optr.c

374

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

sbin/dump/optr.c

375

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

sbin/dump/optr.c

376

strcmp(fs->fs_type, FSTAB_RO) &&

sbin/dump/optr.c

377

strcmp(fs->fs_type, FSTAB_RQ))

sbin/dump/optr.c

380

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

sbin/dump/optr.c

383

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

sbin/dump/optr.c

384

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

sbin/dump/optr.c

387

fs = allocfsent(fs);

sbin/dump/optr.c

388

if (fs == NULL)

sbin/dump/optr.c

392

pf->pf_fstab = fs;

sbin/dump/optr.c

413

struct fstab *fs;

sbin/dump/optr.c

418

fs = pf->pf_fstab;

sbin/dump/optr.c

419

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

sbin/dump/optr.c

420

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

sbin/dump/optr.c

421

return (fs);

sbin/dump/optr.c

422

rn = getdiskrawname(buf, sizeof(buf), fs->fs_spec);

sbin/dump/optr.c

424

return (fs);

sbin/dump/optr.c

426

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

sbin/dump/optr.c

427

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

sbin/dump/optr.c

428

return (fs);

sbin/dump/optr.c

429

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

sbin/dump/optr.c

430

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

sbin/dump/optr.c

431

return (fs);

sbin/dump/optr.c

450

struct statvfs *mntbuf, *fs;

sbin/dump/optr.c

456

for (fs = mntbuf, i = 0; i < mntbufc; i++, fs++) {

sbin/dump/optr.c

458

if (strcmp(fs->f_fstypename, "lfs") != 0)

sbin/dump/optr.c

461

if (strcmp(fs->f_fstypename, "ufs") != 0 &&

sbin/dump/optr.c

462

strcmp(fs->f_fstypename, "ffs") != 0)

sbin/dump/optr.c

465

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

sbin/dump/optr.c

466

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

sbin/dump/optr.c

467

return (fs);

sbin/dump/optr.c

468

rn = getdiskrawname(buf, sizeof(buf), fs->f_mntfromname);

sbin/dump/optr.c

470

return (fs);

sbin/dump/snapshot.c

65

struct statvfs *mntbuf, *fs, fsb;

sbin/dump/snapshot.c

86

for (fs = mntbuf, i = 0; i < n; i++, fs++) {

sbin/dump/snapshot.c

87

if (strcmp(fs->f_mntfromname, path) == 0) {

sbin/dump/snapshot.c

88

fss.fss_mount = fs->f_mntonname;

sbin/dump_lfs/lfs_inode.c

220

#define BASE_DINDIR (ULFS_NDADDR+LFS_NINDIR(fs))

sbin/dump_lfs/lfs_inode.c

221

#define BASE_TINDIR (ULFS_NDADDR+LFS_NINDIR(fs)+LFS_NINDIR(fs)*LFS_NINDIR(fs))

sbin/dump_lfs/lfs_inode.c

223

#define D_UNITS (LFS_NINDIR(fs))

sbin/dump_lfs/lfs_inode.c

224

#define T_UNITS (LFS_NINDIR(fs)*LFS_NINDIR(fs))

sbin/dump_lfs/lfs_inode.c

227

lfs_bmap(struct lfs *fs, union lfs_dinode *idinode, daddr_t lbn)

sbin/dump_lfs/lfs_inode.c

235

if(lbn > 0 && lbn > lfs_lblkno(fs, lfs_dino_getsize(fs, idinode))) {

sbin/dump_lfs/lfs_inode.c

248

return lfs_dino_getib(fs, idinode, 0); /* single indirect */

sbin/dump_lfs/lfs_inode.c

251

return lfs_dino_getib(fs, idinode, 1); /* double indirect */

sbin/dump_lfs/lfs_inode.c

254

return lfs_dino_getib(fs, idinode, 2); /* triple indirect */

sbin/dump_lfs/lfs_inode.c

261

residue = (lbn-ULFS_NDADDR) % LFS_NINDIR(fs);

sbin/dump_lfs/lfs_inode.c

264

up = lfs_dino_getib(fs, idinode, 2);

sbin/dump_lfs/lfs_inode.c

265

off = (lbn-2-BASE_TINDIR)/(LFS_NINDIR(fs)*LFS_NINDIR(fs));

sbin/dump_lfs/lfs_inode.c

270

return lfs_iblock_get(fs, bp, off);

sbin/dump_lfs/lfs_inode.c

290

return lfs_dino_getdb(fs, idinode, lbn);

sbin/dump_lfs/lfs_inode.c

298

up = lfs_bmap(fs,idinode,up);

sbin/dump_lfs/lfs_inode.c

302

return lfs_iblock_get(fs, bp, off);

sbin/dump_lfs/lfs_inode.c

340

lfs_ifind(struct lfs *fs, ino_t ino, void *block)

sbin/dump_lfs/lfs_inode.c

345

num = LFS_INOPB(fs);

sbin/dump_lfs/lfs_inode.c

347

dip = DINO_IN_BLOCK(fs, block, i);

sbin/dump_lfs/lfs_inode.c

348

if (lfs_dino_getinumber(fs, dip) == ino)

sbin/fsck/fsck.c

214

fs = getfsfile(spec);

sbin/fsck/fsck.c

215

if (fs == NULL)

sbin/fsck/fsck.c

216

fs = getfsspec(spec);

sbin/fsck/fsck.c

217

if (fs == NULL && spec != spec2) {

sbin/fsck/fsck.c

218

fs = getfsspec(spec2);

sbin/fsck/fsck.c

222

if (fs) {

sbin/fsck/fsck.c

223

spec = getfsspecname(buf, sizeof(buf), fs->fs_spec);

sbin/fsck/fsck.c

226

type = fs->fs_vfstype;

sbin/fsck/fsck.c

227

if (BADTYPE(fs->fs_type))

sbin/fsck/fsck.c

247

isok(struct fstab *fs)

sbin/fsck/fsck.c

250

if (fs->fs_passno == 0)

sbin/fsck/fsck.c

253

if (BADTYPE(fs->fs_type))

sbin/fsck/fsck.c

256

if (!selected(fs->fs_vfstype))

sbin/fsck/fsck.c

259

if (omitted(fs->fs_file))

sbin/fsck/fsck.c

262

return fs;

sbin/fsck/fsck.c

98

struct fstab *fs;

sbin/fsck/openspecial.c

57

struct fstab *fs;

sbin/fsck/openspecial.c

59

fs = getfsfile(special);

sbin/fsck/openspecial.c

60

if (fs)

sbin/fsck/openspecial.c

61

special = fs->fs_spec;

sbin/fsck/preen.c

115

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

sbin/fsck/preen.c

118

if ((auxarg = (*docheck)(fs)) == NULL)

sbin/fsck/preen.c

120

fsspec = getfsspecname(buf, sizeof(buf), fs->fs_spec);

sbin/fsck/preen.c

130

(passno == 1 && fs->fs_passno == 1)) {

sbin/fsck/preen.c

137

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

sbin/fsck/preen.c

138

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

sbin/fsck/preen.c

146

} else if (passno == 2 && fs->fs_passno > 1) {

sbin/fsck/preen.c

153

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

sbin/fsck/preen.c

97

struct fstab *fs;

sbin/fsck_ext2fs/inode.c

89

#define fsck_ino_to_fsba(fs, x) \

sbin/fsck_ext2fs/inode.c

90

(fs2h32((fs)->e2fs_gd[ino_to_cg(fs, x)].ext2bgd_i_tables) + \

sbin/fsck_ext2fs/inode.c

91

(((x)-1) % (fs)->e2fs.e2fs_ipg)/(fs)->e2fs_ipb)

sbin/fsck_ext2fs/pass5.c

100

ibmap = malloc(fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

101

bbmap = malloc(fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

106

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

sbin/fsck_ext2fs/pass5.c

112

nifree = fs->e2fs.e2fs_ipg;

sbin/fsck_ext2fs/pass5.c

116

blk_bitmap = getdatablk(fs2h32(fs->e2fs_gd[c].ext2bgd_b_bitmap),

sbin/fsck_ext2fs/pass5.c

117

fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

119

getblk(blk_bitmap, fs2h32(fs->e2fs_gd[c].ext2bgd_b_bitmap),

sbin/fsck_ext2fs/pass5.c

120

fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

123

ino_bitmap = getdatablk(fs2h32(fs->e2fs_gd[c].ext2bgd_i_bitmap),

sbin/fsck_ext2fs/pass5.c

124

fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

126

getblk(ino_bitmap, fs2h32(fs->e2fs_gd[c].ext2bgd_i_bitmap),

sbin/fsck_ext2fs/pass5.c

127

fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

129

memset(bbmap, 0, fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

130

memset(ibmap, 0, fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

136

j = fs->e2fs.e2fs_ipg * c + 1;

sbin/fsck_ext2fs/pass5.c

138

for (i = 0; i < fs->e2fs.e2fs_ipg; j++, i++) {

sbin/fsck_ext2fs/pass5.c

144

if (j > fs->e2fs.e2fs_icount) {

sbin/fsck_ext2fs/pass5.c

172

for (i = fs->e2fs.e2fs_ipg / NBBY; i < (uint32_t)fs->e2fs_bsize; i++)

sbin/fsck_ext2fs/pass5.c

195

if (debug && (fs2h16(fs->e2fs_gd[c].ext2bgd_nbfree) != nbfree ||

sbin/fsck_ext2fs/pass5.c

196

fs2h16(fs->e2fs_gd[c].ext2bgd_nifree) != nifree ||

sbin/fsck_ext2fs/pass5.c

197

fs2h16(fs->e2fs_gd[c].ext2bgd_ndirs) != ndirs)) {

sbin/fsck_ext2fs/pass5.c

200

fs2h16(fs->e2fs_gd[c].ext2bgd_nbfree),

sbin/fsck_ext2fs/pass5.c

201

fs2h16(fs->e2fs_gd[c].ext2bgd_nifree),

sbin/fsck_ext2fs/pass5.c

202

fs2h16(fs->e2fs_gd[c].ext2bgd_ndirs),

sbin/fsck_ext2fs/pass5.c

209

if ((fs2h16(fs->e2fs_gd[c].ext2bgd_nbfree) != nbfree ||

sbin/fsck_ext2fs/pass5.c

210

fs2h16(fs->e2fs_gd[c].ext2bgd_nifree) != nifree ||

sbin/fsck_ext2fs/pass5.c

211

fs2h16(fs->e2fs_gd[c].ext2bgd_ndirs) != ndirs) &&

sbin/fsck_ext2fs/pass5.c

213

fs->e2fs_gd[c].ext2bgd_nbfree = h2fs16(nbfree);

sbin/fsck_ext2fs/pass5.c

214

fs->e2fs_gd[c].ext2bgd_nifree = h2fs16(nifree);

sbin/fsck_ext2fs/pass5.c

215

fs->e2fs_gd[c].ext2bgd_ndirs = h2fs16(ndirs);

sbin/fsck_ext2fs/pass5.c

219

if (debug && memcmp(blk_bitmap->b_un.b_buf, bbmap, fs->e2fs_bsize)) {

sbin/fsck_ext2fs/pass5.c

221

print_bmap(blk_bitmap->b_un.b_buf, fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

223

print_bmap(bbmap, fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

228

if (memcmp(blk_bitmap->b_un.b_buf, bbmap, fs->e2fs_bsize) &&

sbin/fsck_ext2fs/pass5.c

230

memcpy(blk_bitmap->b_un.b_buf, bbmap, fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

233

if (debug && memcmp(ino_bitmap->b_un.b_buf, ibmap, fs->e2fs_bsize)) {

sbin/fsck_ext2fs/pass5.c

235

print_bmap(ino_bitmap->b_un.b_buf, fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

237

print_bmap(ibmap, fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

241

if (memcmp(ino_bitmap->b_un.b_buf, ibmap, fs->e2fs_bsize) &&

sbin/fsck_ext2fs/pass5.c

243

memcpy(ino_bitmap->b_un.b_buf, ibmap, fs->e2fs_bsize);

sbin/fsck_ext2fs/pass5.c

248

if (debug && (fs->e2fs.e2fs_fbcount != cs_nbfree ||

sbin/fsck_ext2fs/pass5.c

249

fs->e2fs.e2fs_ficount != cs_nifree)) {

sbin/fsck_ext2fs/pass5.c

251

fs->e2fs.e2fs_fbcount, fs->e2fs.e2fs_ficount,

sbin/fsck_ext2fs/pass5.c

254

if ((fs->e2fs.e2fs_fbcount != cs_nbfree ||

sbin/fsck_ext2fs/pass5.c

255

fs->e2fs.e2fs_ficount != cs_nifree)

sbin/fsck_ext2fs/pass5.c

257

fs->e2fs.e2fs_fbcount = cs_nbfree;

sbin/fsck_ext2fs/pass5.c

258

fs->e2fs.e2fs_ficount = cs_nifree;

sbin/fsck_ext2fs/pass5.c

86

struct m_ext2fs *fs = &sblock;

sbin/fsck_ext2fs/setup.c

503

calcsb(const char *dev, int devfd, struct m_ext2fs *fs)

sbin/fsck_ext2fs/setup.c

515

memset(fs, 0, sizeof(struct m_ext2fs));

sbin/fsck_ext2fs/setup.c

518

fs->e2fs_bsize = S_DFL_BSIZE;

sbin/fsck_ext2fs/setup.c

520

fs->e2fs_bsize = M_DFL_BSIZE;

sbin/fsck_ext2fs/setup.c

522

fs->e2fs_bsize = L_DFL_BSIZE;

sbin/fsck_ext2fs/setup.c

524

fs->e2fs.e2fs_log_bsize = ilog2(fs->e2fs_bsize / 1024);

sbin/fsck_ext2fs/setup.c

525

fs->e2fs.e2fs_bcount = (fs->e2fs_bsize * DEV_BSIZE) / fs->e2fs_bsize;

sbin/fsck_ext2fs/setup.c

526

fs->e2fs.e2fs_first_dblock = (fs->e2fs.e2fs_log_bsize == 0) ? 1 : 0;

sbin/fsck_ext2fs/setup.c

527

fs->e2fs.e2fs_bpg = fs->e2fs_bsize * NBBY;

sbin/fsck_ext2fs/setup.c

528

fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize;

sbin/fsck_ext2fs/setup.c

529

fs->e2fs_qbmask = fs->e2fs_bsize - 1;

sbin/fsck_ext2fs/setup.c

530

fs->e2fs_bmask = ~fs->e2fs_qbmask;

sbin/fsck_ext2fs/setup.c

531

fs->e2fs_ncg =

sbin/fsck_ext2fs/setup.c

532

howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,

sbin/fsck_ext2fs/setup.c

533

fs->e2fs.e2fs_bpg);

sbin/fsck_ext2fs/setup.c

534

fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + 1;

sbin/fsck_ext2fs/setup.c

535

fs->e2fs_ngdb = howmany(fs->e2fs_ncg,

sbin/fsck_ext2fs/setup.c

536

fs->e2fs_bsize / sizeof(struct ext2_gd));

sbin/fsck_ffs/extern.h

106

void sb_oldfscompat_write(struct fs *, struct fs *);

sbin/fsck_ffs/extern.h

107

void sb_oldfscompat_read(struct fs *, struct fs **);

sbin/fsck_ffs/extern.h

42

int cmpsblks(const struct fs *, struct fs *);

sbin/fsck_ffs/extern.h

43

int cmpsblks42(const struct fs *, struct fs *);

sbin/fsck_ffs/extern.h

44

int cmpsblks44(const struct fs *, struct fs *);

sbin/fsck_ffs/extern.h

45

void cvt_magic(struct fs *);

sbin/fsck_ffs/extern.h

97

void quota2_create_inode(struct fs *, int);

sbin/fsck_ffs/fsck.h

118

struct fs *b_fs; /* super block */

sbin/fsck_ffs/fsck.h

158

extern struct fs *sblock;

sbin/fsck_ffs/fsck.h

159

extern struct fs *altsblock;

sbin/fsck_ffs/fsck.h

161

extern struct fs *sblocksave;

sbin/fsck_ffs/inode.c

766

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

sbin/fsck_ffs/inode.c

866

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

sbin/fsck_ffs/main.c

81

struct fs *sblock;

sbin/fsck_ffs/main.c

82

struct fs *altsblock;

sbin/fsck_ffs/main.c

84

struct fs *sblocksave;

sbin/fsck_ffs/pass4.c

206

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

sbin/fsck_ffs/pass4.c

214

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

sbin/fsck_ffs/pass5.c

100

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

sbin/fsck_ffs/pass5.c

101

fs->fs_contigsumsize < FS_MAXCONTIG) {

sbin/fsck_ffs/pass5.c

105

i = fs->fs_contigsumsize;

sbin/fsck_ffs/pass5.c

106

fs->fs_contigsumsize =

sbin/fsck_ffs/pass5.c

107

MIN(fs->fs_maxcontig, FS_MAXCONTIG);

sbin/fsck_ffs/pass5.c

108

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

sbin/fsck_ffs/pass5.c

110

fs->fs_contigsumsize = i;

sbin/fsck_ffs/pass5.c

116

ncgsize = ffs_fragroundup(fs, CGSIZE(fs));

sbin/fsck_ffs/pass5.c

122

fs->fs_cgsize = ncgsize;

sbin/fsck_ffs/pass5.c

143

fs->fs_old_cpg * sizeof(int32_t);

sbin/fsck_ffs/pass5.c

145

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

sbin/fsck_ffs/pass5.c

148

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

sbin/fsck_ffs/pass5.c

150

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

sbin/fsck_ffs/pass5.c

152

if (fs->fs_contigsumsize > 0) {

sbin/fsck_ffs/pass5.c

165

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

sbin/fsck_ffs/pass5.c

167

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

sbin/fsck_ffs/pass5.c

171

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

sbin/fsck_ffs/pass5.c

172

switch ((int)fs->fs_old_postblformat) {

sbin/fsck_ffs/pass5.c

178

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

sbin/fsck_ffs/pass5.c

180

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

sbin/fsck_ffs/pass5.c

192

fs->fs_old_postblformat);

sbin/fsck_ffs/pass5.c

202

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

sbin/fsck_ffs/pass5.c

203

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

sbin/fsck_ffs/pass5.c

205

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

sbin/fsck_ffs/pass5.c

209

cdevname(), c, fs->fs_ncg,

sbin/fsck_ffs/pass5.c

210

c * 100 / fs->fs_ncg);

sbin/fsck_ffs/pass5.c

215

c, fs->fs_ncg);

sbin/fsck_ffs/pass5.c

217

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

sbin/fsck_ffs/pass5.c

218

memcpy(cg, cgblk.b_un.b_cg, fs->fs_cgsize);

sbin/fsck_ffs/pass5.c

267

dbase = cgbase(fs, c);

sbin/fsck_ffs/pass5.c

268

dmax = dbase + fs->fs_fpg;

sbin/fsck_ffs/pass5.c

269

if (dmax > fs->fs_size)

sbin/fsck_ffs/pass5.c

270

dmax = fs->fs_size;

sbin/fsck_ffs/pass5.c

271

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

sbin/fsck_ffs/pass5.c

277

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

sbin/fsck_ffs/pass5.c

281

if ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0)

sbin/fsck_ffs/pass5.c

282

newcg->cg_old_ncyl = fs->fs_old_ncyl % fs->fs_old_cpg;

sbin/fsck_ffs/pass5.c

285

fs->fs_fpg / fs->fs_old_cpg);

sbin/fsck_ffs/pass5.c

287

newcg->cg_old_ncyl = fs->fs_old_cpg;

sbin/fsck_ffs/pass5.c

288

newcg->cg_old_niblk = fs->fs_ipg;

sbin/fsck_ffs/pass5.c

291

if (fs->fs_contigsumsize > 0)

sbin/fsck_ffs/pass5.c

292

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

sbin/fsck_ffs/pass5.c

296

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

sbin/fsck_ffs/pass5.c

305

if (cg->cg_irotor < fs->fs_ipg)

sbin/fsck_ffs/pass5.c

312

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

sbin/fsck_ffs/pass5.c

313

newcg->cg_initediblk = fs->fs_ipg;

sbin/fsck_ffs/pass5.c

320

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

sbin/fsck_ffs/pass5.c

321

fs->fs_old_postblformat == FS_42POSTBLFMT)

sbin/fsck_ffs/pass5.c

323

inum = fs->fs_ipg * c;

sbin/fsck_ffs/pass5.c

324

for (i = 0; i < fs->fs_ipg; inum++, i++) {

sbin/fsck_ffs/pass5.c

357

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

sbin/fsck_ffs/pass5.c

359

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

sbin/fsck_ffs/pass5.c

365

if (frags == fs->fs_frag) {

sbin/fsck_ffs/pass5.c

368

j = old_cbtocylno(fs, i);

sbin/fsck_ffs/pass5.c

370

old_cg_blks(fs, newcg, j, 0)[old_cbtorpos(fs, i)]++;

sbin/fsck_ffs/pass5.c

372

if (fs->fs_contigsumsize > 0)

sbin/fsck_ffs/pass5.c

374

ffs_fragstoblks(fs, i));

sbin/fsck_ffs/pass5.c

377

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

sbin/fsck_ffs/pass5.c

378

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

sbin/fsck_ffs/pass5.c

381

if (fs->fs_contigsumsize > 0) {

sbin/fsck_ffs/pass5.c

392

if (run > fs->fs_contigsumsize)

sbin/fsck_ffs/pass5.c

393

run = fs->fs_contigsumsize;

sbin/fsck_ffs/pass5.c

405

if (run > fs->fs_contigsumsize)

sbin/fsck_ffs/pass5.c

406

run = fs->fs_contigsumsize;

sbin/fsck_ffs/pass5.c

414

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

sbin/fsck_ffs/pass5.c

431

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

sbin/fsck_ffs/pass5.c

458

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

sbin/fsck_ffs/pass5.c

472

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

sbin/fsck_ffs/pass5.c

483

if (memcmp(&cstotal, &fs->fs_cstotal, cssize) != 0) {

sbin/fsck_ffs/pass5.c

487

(long long int)fs->fs_cstotal.cs_nffree,

sbin/fsck_ffs/pass5.c

489

(long long int)fs->fs_cstotal.cs_nbfree,

sbin/fsck_ffs/pass5.c

491

(long long int)fs->fs_cstotal.cs_nifree,

sbin/fsck_ffs/pass5.c

493

(long long int)fs->fs_cstotal.cs_ndir,

sbin/fsck_ffs/pass5.c

497

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

sbin/fsck_ffs/pass5.c

498

fs->fs_ronly = 0;

sbin/fsck_ffs/pass5.c

499

fs->fs_fmod = 0;

sbin/fsck_ffs/pass5.c

65

struct fs *fs = sblock;

sbin/fsck_ffs/pass5.c

83

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

sbin/fsck_ffs/pass5.c

84

newcg->cg_niblk = fs->fs_ipg;

sbin/fsck_ffs/pass5.c

86

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

sbin/fsck_ffs/pass5.c

90

fs->fs_contigsumsize = 0;

sbin/fsck_ffs/pass5.c

95

if (fs->fs_maxcontig > 1) {

sbin/fsck_ffs/pass5.c

98

if (fs->fs_contigsumsize < 1) {

sbin/fsck_ffs/quota2.c

50

quota2_create_inode(struct fs *fs, int type)

sbin/fsck_ffs/setup.c

1082

calcsb(const char *dev, int devfd, struct fs *fs)

sbin/fsck_ffs/setup.c

1123

memcpy(fs, sblk.b_un.b_fs, sizeof(struct fs));

sbin/fsck_ffs/setup.c

1124

nspf = fs->fs_fsize / geo.dg_secsize;

sbin/fsck_ffs/setup.c

1125

fs->fs_old_nspf = nspf;

sbin/fsck_ffs/setup.c

1126

for (fs->fs_fsbtodb = 0, i = nspf; i > 1; i >>= 1)

sbin/fsck_ffs/setup.c

1127

fs->fs_fsbtodb++;

sbin/fsck_ffs/setup.c

1129

if (fs->fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/setup.c

1130

fs->fs_ncg = howmany(fs->fs_size, fs->fs_fpg);

sbin/fsck_ffs/setup.c

1132

fs->fs_old_cgmask = 0xffffffff;

sbin/fsck_ffs/setup.c

1134

fs->fs_old_cgmask <<= 1;

sbin/fsck_ffs/setup.c

1136

fs->fs_old_cgmask <<= 1;

sbin/fsck_ffs/setup.c

1137

fs->fs_old_cgoffset = roundup(

sbin/fsck_ffs/setup.c

1138

howmany(geo.dg_nsectors, nspf), fs->fs_frag);

sbin/fsck_ffs/setup.c

1139

fs->fs_fpg = (fs->fs_old_cpg * geo.dg_secpercyl) / nspf;

sbin/fsck_ffs/setup.c

1140

fs->fs_ncg = howmany(fs->fs_size / geo.dg_secpercyl,

sbin/fsck_ffs/setup.c

1141

fs->fs_old_cpg);

sbin/fsck_ffs/setup.c

716

detect_byteorder(struct fs *fs, int sblockoff)

sbin/fsck_ffs/setup.c

718

if (sblockoff == SBLOCK_UFS2 && (fs->fs_magic == FS_UFS1_MAGIC ||

sbin/fsck_ffs/setup.c

719

fs->fs_magic == FS_UFS1_MAGIC_SWAPPED))

sbin/fsck_ffs/setup.c

72

static int calcsb(const char *, int, struct fs *);

sbin/fsck_ffs/setup.c

722

if (fs->fs_magic == FS_UFS1_MAGIC || fs->fs_magic == FS_UFS2_MAGIC ||

sbin/fsck_ffs/setup.c

723

fs->fs_magic == FS_UFS2EA_MAGIC) {

sbin/fsck_ffs/setup.c

736

else if (fs->fs_magic == FS_UFS1_MAGIC_SWAPPED ||

sbin/fsck_ffs/setup.c

737

fs->fs_magic == FS_UFS2_MAGIC_SWAPPED ||

sbin/fsck_ffs/setup.c

738

fs->fs_magic == FS_UFS2EA_MAGIC_SWAPPED) {

sbin/fsck_ffs/setup.c

754

cvt_magic(struct fs *fs)

sbin/fsck_ffs/setup.c

758

if (fs->fs_magic == FS_UFS2_MAGIC) {

sbin/fsck_ffs/setup.c

759

fs->fs_magic = FS_UFS2EA_MAGIC;

sbin/fsck_ffs/setup.c

761

if (fs->fs_magic == FS_UFS2_MAGIC_SWAPPED) {

sbin/fsck_ffs/setup.c

762

fs->fs_magic = FS_UFS2EA_MAGIC_SWAPPED;

sbin/fsck_ffs/setup.c

766

if (fs->fs_magic == FS_UFS2EA_MAGIC) {

sbin/fsck_ffs/setup.c

767

fs->fs_magic = FS_UFS2_MAGIC;

sbin/fsck_ffs/setup.c

769

if (fs->fs_magic == FS_UFS2EA_MAGIC_SWAPPED) {

sbin/fsck_ffs/setup.c

770

fs->fs_magic = FS_UFS2_MAGIC_SWAPPED;

sbin/fsck_ffs/setup.c

787

struct fs *fs;

sbin/fsck_ffs/setup.c

795

fs = sblk.b_un.b_fs;

sbin/fsck_ffs/setup.c

796

if (detect_byteorder(fs, -1) < 0) {

sbin/fsck_ffs/setup.c

806

fs = sblk.b_un.b_fs;

sbin/fsck_ffs/setup.c

807

if (detect_byteorder(fs, sblock_try[i]) == 0)

sbin/fsck_ffs/setup.c

847

cvt_magic(fs);

sbin/fsck_ffs/setup.c

922

cmpsblks(const struct fs *sb, struct fs *asb)

sbin/fsck_ffs/setup.c

96

struct fs proto;

sbin/fsck_ffs/setup.c

963

cmpsblks42(const struct fs *sb, struct fs *asb)

sbin/fsck_ffs/setup.c

999

cmpsblks44(const struct fs *sb, struct fs *asb)

sbin/fsck_ffs/utilities.c

442

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

sbin/fsck_ffs/utilities.c

448

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

sbin/fsck_ffs/utilities.c

606

sb_oldfscompat_read(struct fs *fs, struct fs **fssave)

sbin/fsck_ffs/utilities.c

608

if ((fs->fs_magic != FS_UFS1_MAGIC) ||

sbin/fsck_ffs/utilities.c

609

(fs->fs_old_flags & FS_FLAGS_UPDATED))

sbin/fsck_ffs/utilities.c

615

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

sbin/fsck_ffs/utilities.c

618

memmove(*fssave, fs, sizeof(struct fs));

sbin/fsck_ffs/utilities.c

627

if (fs->fs_old_postblformat == FS_42POSTBLFMT)

sbin/fsck_ffs/utilities.c

661

fs->fs_cstotal.cs_ndir =

sbin/fsck_ffs/utilities.c

662

fs->fs_old_cstotal.cs_ndir;

sbin/fsck_ffs/utilities.c

663

fs->fs_cstotal.cs_nbfree =

sbin/fsck_ffs/utilities.c

664

fs->fs_old_cstotal.cs_nbfree;

sbin/fsck_ffs/utilities.c

665

fs->fs_cstotal.cs_nifree =

sbin/fsck_ffs/utilities.c

666

fs->fs_old_cstotal.cs_nifree;

sbin/fsck_ffs/utilities.c

667

fs->fs_cstotal.cs_nffree =

sbin/fsck_ffs/utilities.c

668

fs->fs_old_cstotal.cs_nffree;

sbin/fsck_ffs/utilities.c

670

fs->fs_maxbsize = fs->fs_bsize;

sbin/fsck_ffs/utilities.c

671

fs->fs_time = fs->fs_old_time;

sbin/fsck_ffs/utilities.c

672

fs->fs_size = fs->fs_old_size;

sbin/fsck_ffs/utilities.c

673

fs->fs_dsize = fs->fs_old_dsize;

sbin/fsck_ffs/utilities.c

674

fs->fs_csaddr = fs->fs_old_csaddr;

sbin/fsck_ffs/utilities.c

675

fs->fs_sblockloc = SBLOCK_UFS1;

sbin/fsck_ffs/utilities.c

677

fs->fs_flags = fs->fs_old_flags;

sbin/fsck_ffs/utilities.c

679

if (fs->fs_old_postblformat == FS_42POSTBLFMT) {

sbin/fsck_ffs/utilities.c

680

fs->fs_old_nrpos = 8;

sbin/fsck_ffs/utilities.c

681

fs->fs_old_npsect = fs->fs_old_nsect;

sbin/fsck_ffs/utilities.c

682

fs->fs_old_interleave = 1;

sbin/fsck_ffs/utilities.c

683

fs->fs_old_trackskew = 0;

sbin/fsck_ffs/utilities.c

688

sb_oldfscompat_write(struct fs *fs, struct fs *fssave)

sbin/fsck_ffs/utilities.c

690

if ((fs->fs_magic != FS_UFS1_MAGIC) ||

sbin/fsck_ffs/utilities.c

691

(fs->fs_old_flags & FS_FLAGS_UPDATED))

sbin/fsck_ffs/utilities.c

694

fs->fs_old_flags = fs->fs_flags;

sbin/fsck_ffs/utilities.c

695

fs->fs_old_time = fs->fs_time;

sbin/fsck_ffs/utilities.c

696

fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;

sbin/fsck_ffs/utilities.c

697

fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;

sbin/fsck_ffs/utilities.c

698

fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;

sbin/fsck_ffs/utilities.c

699

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

sbin/fsck_ffs/utilities.c

701

fs->fs_flags = fssave->fs_flags;

sbin/fsck_ffs/utilities.c

703

if (fs->fs_old_postblformat == FS_42POSTBLFMT) {

sbin/fsck_ffs/utilities.c

704

fs->fs_old_nrpos = fssave->fs_old_nrpos;

sbin/fsck_ffs/utilities.c

705

fs->fs_old_npsect = fssave->fs_old_npsect;

sbin/fsck_ffs/utilities.c

706

fs->fs_old_interleave = fssave->fs_old_interleave;

sbin/fsck_ffs/utilities.c

707

fs->fs_old_trackskew = fssave->fs_old_trackskew;

sbin/fsck_ffs/utilities.c

710

memmove(&fs->fs_old_postbl_start, &fssave->fs_old_postbl_start,

sbin/fsck_ffs/utilities.c

711

((fs->fs_old_postblformat == FS_42POSTBLFMT) ?

sbin/fsck_lfs/dir.c

145

blksiz = idesc->id_numfrags * lfs_sb_getfsize(fs);

sbin/fsck_lfs/dir.c

152

vp = vget(fs, idesc->id_number);

sbin/fsck_lfs/dir.c

155

dsize = lfs_dir_getreclen(fs, dp);

sbin/fsck_lfs/dir.c

181

blksiz = idesc->id_numfrags * lfs_sb_getfsize(fs);

sbin/fsck_lfs/dir.c

194

lfs_dir_setino(fs, dp, 0);

sbin/fsck_lfs/dir.c

195

lfs_dir_settype(fs, dp, LFS_DT_UNKNOWN);

sbin/fsck_lfs/dir.c

196

lfs_dir_setnamlen(fs, dp, 0);

sbin/fsck_lfs/dir.c

197

lfs_dir_setreclen(fs, dp, LFS_DIRBLKSIZ);

sbin/fsck_lfs/dir.c

200

lfs_dir_nameptr(fs, dp)[0] = '\0';

sbin/fsck_lfs/dir.c

216

idesc->id_loc += lfs_dir_getreclen(fs, dp);

sbin/fsck_lfs/dir.c

217

idesc->id_filesize -= lfs_dir_getreclen(fs, dp);

sbin/fsck_lfs/dir.c

234

lfs_dir_setreclen(fs, dp, lfs_dir_getreclen(fs, dp) + size);

sbin/fsck_lfs/dir.c

258

if (lfs_dir_getino(fs, dp) >= maxino ||

sbin/fsck_lfs/dir.c

259

lfs_dir_getreclen(fs, dp) == 0 ||

sbin/fsck_lfs/dir.c

260

lfs_dir_getreclen(fs, dp) > spaceleft ||

sbin/fsck_lfs/dir.c

261

(lfs_dir_getreclen(fs, dp) & 0x3) != 0) {

sbin/fsck_lfs/dir.c

264

(uintmax_t)lfs_dir_getino(fs, dp),

sbin/fsck_lfs/dir.c

265

lfs_dir_getreclen(fs, dp));

sbin/fsck_lfs/dir.c

270

if (lfs_dir_getino(fs, dp) == 0)

sbin/fsck_lfs/dir.c

272

size = LFS_DIRSIZ(fs, dp);

sbin/fsck_lfs/dir.c

273

namlen = lfs_dir_getnamlen(fs, dp);

sbin/fsck_lfs/dir.c

274

type = lfs_dir_gettype(fs, dp);

sbin/fsck_lfs/dir.c

275

if (lfs_dir_getreclen(fs, dp) < size ||

sbin/fsck_lfs/dir.c

282

cp = lfs_dir_nameptr(fs, dp);

sbin/fsck_lfs/dir.c

317

vp = vget(fs, ino);

sbin/fsck_lfs/dir.c

323

(lfs_dino_getmode(fs, VTOI(vp)->i_din) & LFS_IFMT) == LFS_IFDIR ?

sbin/fsck_lfs/dir.c

342

vp = vget(fs, idesc->id_number);

sbin/fsck_lfs/dir.c

344

if (lfs_dino_getnlink(fs, dp) == lcnt) {

sbin/fsck_lfs/dir.c

349

((lfs_dino_getmode(fs, dp) & LFS_IFMT) == LFS_IFDIR ? "DIR" : "FILE"));

sbin/fsck_lfs/dir.c

352

lfs_dino_getnlink(fs, dp), lfs_dino_getnlink(fs, dp) - lcnt);

sbin/fsck_lfs/dir.c

361

lfs_dino_setnlink(fs, dp,

sbin/fsck_lfs/dir.c

362

lfs_dino_getnlink(fs, dp) - lcnt);

sbin/fsck_lfs/dir.c

377

newreclen = LFS_DIRECTSIZ(fs, namlen);

sbin/fsck_lfs/dir.c

380

if (lfs_dir_getino(fs, dirp) != 0)

sbin/fsck_lfs/dir.c

381

oldreclen = LFS_DIRSIZ(fs, dirp);

sbin/fsck_lfs/dir.c

386

if (lfs_dir_getreclen(fs, dirp) - oldreclen < newreclen)

sbin/fsck_lfs/dir.c

390

newreclen = lfs_dir_getreclen(fs, dirp) - oldreclen;

sbin/fsck_lfs/dir.c

391

lfs_dir_setreclen(fs, dirp, oldreclen);

sbin/fsck_lfs/dir.c

394

dirp = LFS_NEXTDIR(fs, dirp);

sbin/fsck_lfs/dir.c

397

lfs_dir_setino(fs, dirp, idesc->id_parent);

sbin/fsck_lfs/dir.c

398

lfs_dir_setreclen(fs, dirp, newreclen);

sbin/fsck_lfs/dir.c

399

lfs_dir_settype(fs, dirp, typemap[idesc->id_parent]);

sbin/fsck_lfs/dir.c

400

lfs_dir_setnamlen(fs, dirp, namlen);

sbin/fsck_lfs/dir.c

401

lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), idesc->id_name,

sbin/fsck_lfs/dir.c

413

namlen = lfs_dir_getnamlen(fs, dirp);

sbin/fsck_lfs/dir.c

414

if (memcmp(lfs_dir_nameptr(fs, dirp), idesc->id_name, namlen + 1))

sbin/fsck_lfs/dir.c

416

lfs_dir_setino(fs, dirp, idesc->id_parent);

sbin/fsck_lfs/dir.c

417

lfs_dir_settype(fs, dirp, typemap[idesc->id_parent]);

sbin/fsck_lfs/dir.c

432

vp = vget(fs, orphan);

sbin/fsck_lfs/dir.c

434

lostdir = (lfs_dino_getmode(fs, dp) & LFS_IFMT) == LFS_IFDIR;

sbin/fsck_lfs/dir.c

437

if (preen && lfs_dino_getsize(fs, dp) == 0)

sbin/fsck_lfs/dir.c

474

vp = vget(fs, lfdir);

sbin/fsck_lfs/dir.c

476

if ((lfs_dino_getmode(fs, dp) & LFS_IFMT) != LFS_IFDIR) {

sbin/fsck_lfs/dir.c

495

vp = vget(fs, lfdir);

sbin/fsck_lfs/dir.c

513

vp = vget(fs, lfdir);

sbin/fsck_lfs/dir.c

514

lfs_dino_setnlink(fs, VTOI(vp)->i_din,

sbin/fsck_lfs/dir.c

515

lfs_dino_getnlink(fs, VTOI(vp)->i_din) + 1);

sbin/fsck_lfs/dir.c

569

vp = vget(fs, parent);

sbin/fsck_lfs/dir.c

571

size = lfs_dino_getsize(fs, dp);

sbin/fsck_lfs/dir.c

574

lfs_dino_setsize(fs, dp, size);

sbin/fsck_lfs/dir.c

580

vp = vget(fs, parent);

sbin/fsck_lfs/dir.c

597

lfs_dir_setino(fs, dirp, 0);

sbin/fsck_lfs/dir.c

598

lfs_dir_setreclen(fs, dirp, LFS_DIRBLKSIZ);

sbin/fsck_lfs/dir.c

599

lfs_dir_settype(fs, dirp, LFS_DT_UNKNOWN);

sbin/fsck_lfs/dir.c

600

lfs_dir_setnamlen(fs, dirp, 0);

sbin/fsck_lfs/dir.c

601

lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), "", 0,

sbin/fsck_lfs/dir.c

615

lastbn = lfs_lblkno(fs, lfs_dino_getsize(fs, dp));

sbin/fsck_lfs/dir.c

616

if (lastbn >= ULFS_NDADDR - 1 || lfs_dino_getdb(fs, dp, lastbn) == 0 ||

sbin/fsck_lfs/dir.c

617

lfs_dino_getsize(fs, dp) == 0)

sbin/fsck_lfs/dir.c

619

lfs_dino_setdb(fs, dp, lastbn + 1, lfs_dino_getdb(fs, dp, lastbn));

sbin/fsck_lfs/dir.c

620

lfs_dino_setdb(fs, dp, lastbn, 0);

sbin/fsck_lfs/dir.c

621

bp = getblk(vp, lastbn, lfs_sb_getbsize(fs));

sbin/fsck_lfs/dir.c

623

lfs_dino_setsize(fs, dp,

sbin/fsck_lfs/dir.c

624

lfs_dino_getsize(fs, dp) + lfs_sb_getbsize(fs));

sbin/fsck_lfs/dir.c

625

lfs_dino_setblocks(fs, dp,

sbin/fsck_lfs/dir.c

626

lfs_dino_getblocks(fs, dp) + lfs_btofsb(fs, lfs_sb_getbsize(fs)));

sbin/fsck_lfs/dir.c

627

bread(vp, lfs_dino_getdb(fs, dp, lastbn + 1),

sbin/fsck_lfs/dir.c

628

(long) lfs_dblksize(fs, dp, lastbn + 1), 0, &bp);

sbin/fsck_lfs/dir.c

632

bread(vp, lastbn, lfs_sb_getbsize(fs), 0, &bp);

sbin/fsck_lfs/dir.c

637

cp < &bp->b_data[lfs_sb_getbsize(fs)];

sbin/fsck_lfs/dir.c

641

bread(vp, lfs_dino_getdb(fs, dp, lastbn + 1),

sbin/fsck_lfs/dir.c

642

(long) lfs_dblksize(fs, dp, lastbn + 1), 0, &bp);

sbin/fsck_lfs/dir.c

655

lfs_dino_setdb(fs, dp, lastbn, lfs_dino_getdb(fs, dp, lastbn + 1));

sbin/fsck_lfs/dir.c

656

lfs_dino_setdb(fs, dp, lastbn + 1, 0);

sbin/fsck_lfs/dir.c

657

lfs_dino_setsize(fs, dp,

sbin/fsck_lfs/dir.c

658

lfs_dino_getsize(fs, dp) - lfs_sb_getbsize(fs));

sbin/fsck_lfs/dir.c

659

lfs_dino_setblocks(fs, dp,

sbin/fsck_lfs/dir.c

660

lfs_dino_getblocks(fs, dp) - lfs_btofsb(fs, lfs_sb_getbsize(fs)));

sbin/fsck_lfs/dir.c

678

vp = vget(fs, ino);

sbin/fsck_lfs/dir.c

680

bread(vp, lfs_dino_getdb(fs, dp, 0), lfs_sb_getfsize(fs), 0, &bp);

sbin/fsck_lfs/dir.c

688

lfs_dir_setino(fs, dirp, ino);

sbin/fsck_lfs/dir.c

689

lfs_dir_setreclen(fs, dirp, LFS_DIRECTSIZ(fs, 1));

sbin/fsck_lfs/dir.c

690

lfs_dir_settype(fs, dirp, LFS_DT_DIR);

sbin/fsck_lfs/dir.c

691

lfs_dir_setnamlen(fs, dirp, 1);

sbin/fsck_lfs/dir.c

692

lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), ".", 1,

sbin/fsck_lfs/dir.c

693

LFS_DIRECTSIZ(fs, 1));

sbin/fsck_lfs/dir.c

695

dirp = LFS_NEXTDIR(fs, dirp);

sbin/fsck_lfs/dir.c

696

lfs_dir_setino(fs, dirp, parent);

sbin/fsck_lfs/dir.c

697

lfs_dir_setreclen(fs, dirp, LFS_DIRBLKSIZ - LFS_DIRECTSIZ(fs, 1));

sbin/fsck_lfs/dir.c

698

lfs_dir_settype(fs, dirp, LFS_DT_DIR);

sbin/fsck_lfs/dir.c

699

lfs_dir_setnamlen(fs, dirp, 2);

sbin/fsck_lfs/dir.c

700

lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), "..", 2,

sbin/fsck_lfs/dir.c

701

LFS_DIRBLKSIZ - LFS_DIRECTSIZ(fs, 1));

sbin/fsck_lfs/dir.c

703

cp < &bp->b_data[lfs_sb_getfsize(fs)];

sbin/fsck_lfs/dir.c

708

lfs_dino_setnlink(fs, dp, 2);

sbin/fsck_lfs/dir.c

711

lncntp[ino] = lfs_dino_getnlink(fs, dp);

sbin/fsck_lfs/dir.c

722

lncntp[ino] = lfs_dino_getnlink(fs, dp);

sbin/fsck_lfs/dir.c

725

vp = vget(fs, parent);

sbin/fsck_lfs/dir.c

727

lfs_dino_setnlink(fs, dp, lfs_dino_getnlink(fs, dp) + 1);

sbin/fsck_lfs/dir.c

741

vp = vget(fs, parent);

sbin/fsck_lfs/dir.c

742

lfs_dino_setnlink(fs, VTOI(vp)->i_din,

sbin/fsck_lfs/dir.c

743

lfs_dino_getnlink(fs, VTOI(vp)->i_din) - 1);

sbin/fsck_lfs/fsck_vars.h

39

extern struct lfs *fs;

sbin/fsck_lfs/inode.c

106

vp = vget(fs, ino);

sbin/fsck_lfs/inode.c

111

LFS_IENTRY(ifp, fs, ino, bp);

sbin/fsck_lfs/inode.c

112

daddr = lfs_if_getdaddr(fs, ifp);

sbin/fsck_lfs/inode.c

113

segno = lfs_dtosn(fs, daddr);

sbin/fsck_lfs/inode.c

115

seg_table[segno].su_nbytes += DINOSIZE(fs);

sbin/fsck_lfs/inode.c

138

idesc->id_filesize = lfs_dino_getsize(fs, dp);

sbin/fsck_lfs/inode.c

139

mode = lfs_dino_getmode(fs, dp) & LFS_IFMT;

sbin/fsck_lfs/inode.c

141

(mode == LFS_IFLNK && (lfs_dino_getsize(fs, dp) < lfs_sb_getmaxsymlinklen(fs) ||

sbin/fsck_lfs/inode.c

142

(lfs_sb_getmaxsymlinklen(fs) == 0 &&

sbin/fsck_lfs/inode.c

143

lfs_dino_getblocks(fs, dp) == 0))))

sbin/fsck_lfs/inode.c

147

ndb = howmany(lfs_dino_getsize(fs, &dino), lfs_sb_getbsize(fs));

sbin/fsck_lfs/inode.c

149

thisvp = vget(fs, idesc->id_number);

sbin/fsck_lfs/inode.c

151

pbn = lfs_dino_getdb(fs, &dino, lbn);

sbin/fsck_lfs/inode.c

154

lfs_numfrags(fs, VTOI(thisvp)->i_lfs_fragsize[lbn]);

sbin/fsck_lfs/inode.c

156

if (--ndb == 0 && (offset = lfs_blkoff(fs, lfs_dino_getsize(fs, &dino))) != 0) {

sbin/fsck_lfs/inode.c

158

lfs_numfrags(fs, lfs_fragroundup(fs, offset));

sbin/fsck_lfs/inode.c

160

idesc->id_numfrags = lfs_sb_getfrag(fs);

sbin/fsck_lfs/inode.c

170

vp = vget(fs, idesc->id_number);

sbin/fsck_lfs/inode.c

172

lfs_dino_setsize(fs, dp,

sbin/fsck_lfs/inode.c

173

lbn * lfs_sb_getbsize(fs));

sbin/fsck_lfs/inode.c

192

idesc->id_numfrags = lfs_sb_getfrag(fs);

sbin/fsck_lfs/inode.c

193

remsize = lfs_dino_getsize(fs, &dino) - lfs_sb_getbsize(fs) * ULFS_NDADDR;

sbin/fsck_lfs/inode.c

194

sizepb = lfs_sb_getbsize(fs);

sbin/fsck_lfs/inode.c

196

pbn = lfs_dino_getib(fs, &dino, n-1);

sbin/fsck_lfs/inode.c

210

vp = vget(fs, idesc->id_number);

sbin/fsck_lfs/inode.c

212

lfs_dino_setsize(fs, dp,

sbin/fsck_lfs/inode.c

213

lfs_dino_getsize(fs, dp) - remsize);

sbin/fsck_lfs/inode.c

224

sizepb *= LFS_NINDIR(fs);

sbin/fsck_lfs/inode.c

252

devvp = fs->lfs_devvp;

sbin/fsck_lfs/inode.c

253

bread(devvp, LFS_FSBTODB(fs, idesc->id_blkno), lfs_sb_getbsize(fs),

sbin/fsck_lfs/inode.c

256

for (sizepb = lfs_sb_getbsize(fs), i = 0; i < ilevel; i++)

sbin/fsck_lfs/inode.c

257

sizepb *= LFS_NINDIR(fs);

sbin/fsck_lfs/inode.c

258

if (isize > sizepb * LFS_NINDIR(fs))

sbin/fsck_lfs/inode.c

259

nif = LFS_NINDIR(fs);

sbin/fsck_lfs/inode.c

262

if (idesc->id_func == pass1check && nif < LFS_NINDIR(fs)) {

sbin/fsck_lfs/inode.c

263

maxindir = LFS_NINDIR(fs);

sbin/fsck_lfs/inode.c

265

found = lfs_iblock_get(fs, bp->b_data, j);

sbin/fsck_lfs/inode.c

272

lfs_iblock_set(fs, bp->b_data, j, 0);

sbin/fsck_lfs/inode.c

279

found = lfs_iblock_get(fs, bp->b_data, j);

sbin/fsck_lfs/inode.c

306

vp = vget(fs, idesc->id_number);

sbin/fsck_lfs/inode.c

307

lfs_dino_setsize(fs, VTOI(vp)->i_din,

sbin/fsck_lfs/inode.c

308

lfs_dino_getsize(fs,

sbin/fsck_lfs/inode.c

340

if (blk < lfs_sntod(fs, 0)) {

sbin/fsck_lfs/inode.c

346

if (blk + cnt < lfs_sntod(fs, 0)) {

sbin/fsck_lfs/inode.c

369

blks = howmany(lfs_dino_getsize(fs, dp), lfs_sb_getbsize(fs));

sbin/fsck_lfs/inode.c

383

inp->i_isize = lfs_dino_getsize(fs, dp);

sbin/fsck_lfs/inode.c

387

inp->i_blks[i] = lfs_dino_getdb(fs, dp, i);

sbin/fsck_lfs/inode.c

390

inp->i_blks[i] = lfs_dino_getib(fs, dp, i - ULFS_NDADDR);

sbin/fsck_lfs/inode.c

446

vp = vget(fs, idesc->id_number);

sbin/fsck_lfs/inode.c

449

(lfs_dino_getmode(fs, VTOI(vp)->i_din) & LFS_IFMT) == LFS_IFDIR ? "DIR" : "FILE");

sbin/fsck_lfs/inode.c

474

LFS_IENTRY(ifp, fs, inumber, bp);

sbin/fsck_lfs/inode.c

475

daddr = lfs_if_getdaddr(fs, ifp);

sbin/fsck_lfs/inode.c

480

lfs_if_setdaddr(fs, ifp, LFS_UNUSED_DADDR);

sbin/fsck_lfs/inode.c

481

lfs_if_setnextfree(fs, ifp, lfs_sb_getfreehd(fs));

sbin/fsck_lfs/inode.c

482

lfs_sb_setfreehd(fs, inumber);

sbin/fsck_lfs/inode.c

491

u_int32_t oldsn = lfs_dtosn(fs, daddr);

sbin/fsck_lfs/inode.c

493

seg_table[oldsn].su_nbytes -= DINOSIZE(fs);

sbin/fsck_lfs/inode.c

494

LFS_SEGENTRY(sup, fs, oldsn, bp);

sbin/fsck_lfs/inode.c

495

sup->su_nbytes -= DINOSIZE(fs);

sbin/fsck_lfs/inode.c

496

LFS_WRITESEGENTRY(sup, fs, oldsn, bp); /* Ifile */

sbin/fsck_lfs/inode.c

507

if (lfs_dir_getino(fs, dirp) != idesc->id_parent)

sbin/fsck_lfs/inode.c

509

len = lfs_dir_getnamlen(fs, dirp) + 1;

sbin/fsck_lfs/inode.c

517

(void)memcpy(buf, lfs_dir_nameptr(fs, dirp), len);

sbin/fsck_lfs/inode.c

527

ino = lfs_dir_getino(fs, dirp);

sbin/fsck_lfs/inode.c

530

if (strcmp(lfs_dir_nameptr(fs, dirp), idesc->id_name) == 0 &&

sbin/fsck_lfs/inode.c

551

if (Uflag && (pw = getpwuid(lfs_dino_getuid(fs, dp))) != 0)

sbin/fsck_lfs/inode.c

555

printf("%u ", (unsigned)lfs_dino_getuid(fs, dp));

sbin/fsck_lfs/inode.c

556

printf("MODE=%o\n", lfs_dino_getmode(fs, dp));

sbin/fsck_lfs/inode.c

559

printf("SIZE=%ju ", (uintmax_t) lfs_dino_getsize(fs, dp));

sbin/fsck_lfs/inode.c

560

printf("MTIME=%s ", print_mtime(lfs_dino_getmtime(fs, dp)));

sbin/fsck_lfs/inode.c

613

extend_ifile(fs);

sbin/fsck_lfs/inode.c

626

vp = lfs_valloc(fs, ino);

sbin/fsck_lfs/inode.c

630

bp = getblk(vp, 0, lfs_sb_getfsize(fs));

sbin/fsck_lfs/inode.c

632

lfs_dino_setmode(fs, dp, type);

sbin/fsck_lfs/inode.c

634

lfs_dino_setatime(fs, dp, t);

sbin/fsck_lfs/inode.c

635

lfs_dino_setctime(fs, dp, t);

sbin/fsck_lfs/inode.c

636

lfs_dino_setmtime(fs, dp, t);

sbin/fsck_lfs/inode.c

637

lfs_dino_setsize(fs, dp, lfs_sb_getfsize(fs));

sbin/fsck_lfs/inode.c

638

lfs_dino_setblocks(fs, dp, lfs_btofsb(fs, lfs_sb_getfsize(fs)));

sbin/fsck_lfs/inode.c

658

vp = vget(fs, ino);

sbin/fsck_lfs/lfs.c

1003

reset_maxino(((lfs_dino_getsize(fs, ip->i_din) >> lfs_sb_getbshift(fs))

sbin/fsck_lfs/lfs.c

1004

- lfs_sb_getsegtabsz(fs)

sbin/fsck_lfs/lfs.c

1005

- lfs_sb_getcleansz(fs)) * lfs_sb_getifpb(fs));

sbin/fsck_lfs/lfs.c

1030

struct lfs *fs;

sbin/fsck_lfs/lfs.c

1037

fs = ip->i_lfs;

sbin/fsck_lfs/lfs.c

1038

offset = lfs_blkoff(fs, startoffset);

sbin/fsck_lfs/lfs.c

1039

lbn = lfs_lblkno(fs, startoffset);

sbin/fsck_lfs/lfs.c

1061

lastblock = lfs_lblkno(fs, lfs_dino_getsize(fs, ip->i_din));

sbin/fsck_lfs/lfs.c

1063

osize = lfs_blksize(fs, ip, lastblock);

sbin/fsck_lfs/lfs.c

1064

if (osize < lfs_sb_getbsize(fs) && osize > 0) {

sbin/fsck_lfs/lfs.c

1065

if ((error = lfs_fragextend(vp, osize, lfs_sb_getbsize(fs),

sbin/fsck_lfs/lfs.c

1069

lfs_dino_setsize(fs, ip->i_din, (lastblock + 1) * lfs_sb_getbsize(fs));

sbin/fsck_lfs/lfs.c

1084

if (lbn < ULFS_NDADDR && lfs_lblkno(fs, lfs_dino_getsize(fs, ip->i_din)) <= lbn) {

sbin/fsck_lfs/lfs.c

1085

osize = lfs_blksize(fs, ip, lbn);

sbin/fsck_lfs/lfs.c

1086

nsize = lfs_fragroundup(fs, offset + iosize);

sbin/fsck_lfs/lfs.c

1087

if (lfs_lblktosize(fs, lbn) >= lfs_dino_getsize(fs, ip->i_din)) {

sbin/fsck_lfs/lfs.c

1089

frags = lfs_numfrags(fs, nsize);

sbin/fsck_lfs/lfs.c

1095

lfs_sb_subbfree(fs, frags);

sbin/fsck_lfs/lfs.c

1096

lfs_dino_setdb(fs, ip->i_din, lbn, UNWRITTEN);

sbin/fsck_lfs/lfs.c

1116

error = ulfs_bmaparray(fs, vp, lbn, &daddr, &indirs[0], &num);

sbin/fsck_lfs/lfs.c

1124

frags = LFS_FSBTODB(fs, 1); /* frags = VFSTOULFS(vp->v_mount)->um_seqinc; */

sbin/fsck_lfs/lfs.c

1134

lfs_sb_subbfree(fs, bcount);

sbin/fsck_lfs/lfs.c

1138

if (num > 0 && lfs_dino_getib(fs, ip->i_din, indirs[0].in_off) == 0) {

sbin/fsck_lfs/lfs.c

1139

lfs_dino_setib(fs, ip->i_din, indirs[0].in_off,

sbin/fsck_lfs/lfs.c

1147

idaddr = lfs_dino_getib(fs, ip->i_din, indirs[0].in_off);

sbin/fsck_lfs/lfs.c

1150

lfs_sb_getbsize(fs));

sbin/fsck_lfs/lfs.c

1155

ibp->b_blkno = LFS_FSBTODB(fs, idaddr);

sbin/fsck_lfs/lfs.c

1164

if (lfs_iblock_get(fs, ibp->b_data,

sbin/fsck_lfs/lfs.c

1166

lfs_iblock_set(fs, ibp->b_data,

sbin/fsck_lfs/lfs.c

1168

idaddr = lfs_iblock_get(fs, ibp->b_data,

sbin/fsck_lfs/lfs.c

1181

*bpp = bp = getblk(vp, lbn, lfs_blksize(fs, ip, lbn));

sbin/fsck_lfs/lfs.c

1199

lfs_dino_setdb(fs, ip->i_din, lbn, UNWRITTEN);

sbin/fsck_lfs/lfs.c

1202

lfs_dino_setib(fs, ip->i_din, indirs[0].in_off,

sbin/fsck_lfs/lfs.c

1207

if (bread(vp, idp->in_lbn, lfs_sb_getbsize(fs), 0, &ibp))

sbin/fsck_lfs/lfs.c

1210

lfs_iblock_set(fs, ibp->b_data, idp->in_off,

sbin/fsck_lfs/lfs.c

1219

if (iosize == lfs_sb_getbsize(fs))

sbin/fsck_lfs/lfs.c

1242

struct lfs *fs;

sbin/fsck_lfs/lfs.c

1247

fs = ip->i_lfs;

sbin/fsck_lfs/lfs.c

1248

frags = (long)lfs_numfrags(fs, nsize - osize);

sbin/fsck_lfs/lfs.c

1262

lfs_sb_subbfree(fs, frags);

sbin/fsck_lfs/lfs.c

136

struct lfs *fs;

sbin/fsck_lfs/lfs.c

138

fs = bp->b_vp->v_fs;

sbin/fsck_lfs/lfs.c

140

lfs_sb_subavail(fs, lfs_btofsb(fs, bp->b_bcount));

sbin/fsck_lfs/lfs.c

155

ulfs_bmaparray(struct lfs * fs, struct uvnode * vp, daddr_t bn, daddr_t * bnp, struct indir * ap, int *nump)

sbin/fsck_lfs/lfs.c

169

*bnp = LFS_FSBTODB(fs, lfs_dino_getdb(fs, ip->i_din, bn));

sbin/fsck_lfs/lfs.c

177

if ((error = ulfs_getlbns(fs, vp, bn, xap, nump)) != 0)

sbin/fsck_lfs/lfs.c

183

daddr = lfs_dino_getib(fs, ip->i_din, xap->in_off);

sbin/fsck_lfs/lfs.c

201

bp = getblk(vp, metalbn, lfs_sb_getbsize(fs));

sbin/fsck_lfs/lfs.c

204

bp->b_blkno = LFS_FSBTODB(fs, daddr);

sbin/fsck_lfs/lfs.c

208

daddr = lfs_iblock_get(fs, bp->b_data, xap->in_off);

sbin/fsck_lfs/lfs.c

213

daddr = LFS_FSBTODB(fs, daddr);

sbin/fsck_lfs/lfs.c

228

ulfs_getlbns(struct lfs * fs, struct uvnode * vp, daddr_t bn, struct indir * ap, int *nump)

sbin/fsck_lfs/lfs.c

246

for (indir = lfs_sb_getnindir(fs); indir; indir >>= 1)

sbin/fsck_lfs/lfs.c

284

off = (bn >> lbc) & (lfs_sb_getnindir(fs) - 1);

sbin/fsck_lfs/lfs.c

307

lfs_ifind(struct lfs *fs, ino_t ino, struct ubuf *bp)

sbin/fsck_lfs/lfs.c

312

num = LFS_INOPB(fs);

sbin/fsck_lfs/lfs.c

320

ldip = DINO_IN_BLOCK(fs, bp->b_data, i);

sbin/fsck_lfs/lfs.c

321

if (lfs_dino_getinumber(fs, ldip) == ino)

sbin/fsck_lfs/lfs.c

332

lfs_raw_vget(struct lfs * fs, ino_t ino, int fd, daddr_t daddr)

sbin/fsck_lfs/lfs.c

342

vp->v_fs = fs;

sbin/fsck_lfs/lfs.c

363

bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs),

sbin/fsck_lfs/lfs.c

366

dip = lfs_ifind(fs, ino, bp);

sbin/fsck_lfs/lfs.c

375

lfs_copy_dinode(fs, ip->i_din, dip);

sbin/fsck_lfs/lfs.c

380

ip->i_lfs = fs;

sbin/fsck_lfs/lfs.c

382

ip->i_lfs_effnblks = lfs_dino_getblocks(fs, ip->i_din);

sbin/fsck_lfs/lfs.c

383

ip->i_lfs_osize = lfs_dino_getsize(fs, ip->i_din);

sbin/fsck_lfs/lfs.c

385

if (lfs_sb_getversion(fs) > 1) {

sbin/fsck_lfs/lfs.c

386

lfs_dino_setatime(fs, ip->i_din, ts.tv_sec);

sbin/fsck_lfs/lfs.c

387

lfs_dino_setatimensec(fs, ip->i_din, ts.tv_nsec);

sbin/fsck_lfs/lfs.c

393

if (lfs_dino_getdb(fs, ip->i_din, i) != 0)

sbin/fsck_lfs/lfs.c

394

ip->i_lfs_fragsize[i] = lfs_blksize(fs, ip, i);

sbin/fsck_lfs/lfs.c

397

hash = ((int)(intptr_t)fs + ino) & (VNODE_HASH_MAX - 1);

sbin/fsck_lfs/lfs.c

407

struct lfs *fs = (struct lfs *)vfs;

sbin/fsck_lfs/lfs.c

412

LFS_IENTRY(ifp, fs, ino, bp);

sbin/fsck_lfs/lfs.c

413

daddr = lfs_if_getdaddr(fs, ifp);

sbin/fsck_lfs/lfs.c

415

if (daddr <= 0 || lfs_dtosn(fs, daddr) >= lfs_sb_getnseg(fs))

sbin/fsck_lfs/lfs.c

417

return lfs_raw_vget(fs, ino, fs->lfs_ivnode->v_fd, daddr);

sbin/fsck_lfs/lfs.c

425

check_sb(struct lfs *fs)

sbin/fsck_lfs/lfs.c

431

magic = fs->lfs_dlfs_u.u_32.dlfs_magic;

sbin/fsck_lfs/lfs.c

435

fs->lfs_is64 = false;

sbin/fsck_lfs/lfs.c

436

fs->lfs_dobyteswap = false;

sbin/fsck_lfs/lfs.c

439

fs->lfs_is64 = false;

sbin/fsck_lfs/lfs.c

440

fs->lfs_dobyteswap = true;

sbin/fsck_lfs/lfs.c

443

fs->lfs_is64 = true;

sbin/fsck_lfs/lfs.c

444

fs->lfs_dobyteswap = false;

sbin/fsck_lfs/lfs.c

447

fs->lfs_is64 = true;

sbin/fsck_lfs/lfs.c

448

fs->lfs_dobyteswap = true;

sbin/fsck_lfs/lfs.c

462

checksum = lfs_sb_cksum(fs);

sbin/fsck_lfs/lfs.c

463

if (lfs_sb_getcksum(fs) != checksum) {

sbin/fsck_lfs/lfs.c

465

(unsigned long) lfs_sb_getcksum(fs), (unsigned long) checksum);

sbin/fsck_lfs/lfs.c

478

struct lfs *fs, *altfs;

sbin/fsck_lfs/lfs.c

495

fs = ecalloc(1, sizeof(*fs));

sbin/fsck_lfs/lfs.c

496

fs->lfs_devvp = devvp;

sbin/fsck_lfs/lfs.c

508

fs = ecalloc(1, sizeof(*fs));

sbin/fsck_lfs/lfs.c

510

memcpy(&fs->lfs_dlfs_u, bp->b_data, sizeof(struct dlfs));

sbin/fsck_lfs/lfs.c

511

fs->lfs_devvp = devvp;

sbin/fsck_lfs/lfs.c

521

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

sbin/fsck_lfs/lfs.c

528

fs->lfs_is64 = true;

sbin/fsck_lfs/lfs.c

536

dev_bsize = lfs_sb_getfsize(fs) >> lfs_sb_getfsbtodb(fs);

sbin/fsck_lfs/lfs.c

539

(void)bread(devvp, LFS_FSBTODB(fs, lfs_sb_getsboff(fs, 1)),

sbin/fsck_lfs/lfs.c

548

if (check_sb(fs) || lfs_sb_getidaddr(fs) <= 0) {

sbin/fsck_lfs/lfs.c

551

free(fs);

sbin/fsck_lfs/lfs.c

552

fs = altfs;

sbin/fsck_lfs/lfs.c

560

if (lfs_verify(fs, altfs, devvp, debug) == fs) {

sbin/fsck_lfs/lfs.c

563

free(fs);

sbin/fsck_lfs/lfs.c

564

fs = altfs;

sbin/fsck_lfs/lfs.c

569

if (check_sb(fs)) {

sbin/fsck_lfs/lfs.c

570

free(fs);

sbin/fsck_lfs/lfs.c

576

if (lfs_sb_getversion(fs) < 2) {

sbin/fsck_lfs/lfs.c

577

lfs_sb_setsumsize(fs, LFS_V1_SUMMARY_SIZE);

sbin/fsck_lfs/lfs.c

578

lfs_sb_setibsize(fs, lfs_sb_getbsize(fs));

sbin/fsck_lfs/lfs.c

579

lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 0));

sbin/fsck_lfs/lfs.c

580

lfs_sb_settstamp(fs, lfs_sb_getotstamp(fs));

sbin/fsck_lfs/lfs.c

581

lfs_sb_setfsbtodb(fs, 0);

sbin/fsck_lfs/lfs.c

585

idaddr = lfs_sb_getidaddr(fs);

sbin/fsck_lfs/lfs.c

587

lfs_sb_setidaddr(fs, idaddr);

sbin/fsck_lfs/lfs.c

589

fs->lfs_ivnode = lfs_raw_vget(fs, LFS_IFILE_INUM,

sbin/fsck_lfs/lfs.c

591

if (fs->lfs_ivnode == NULL)

sbin/fsck_lfs/lfs.c

594

register_vget((void *)fs, lfs_vget);

sbin/fsck_lfs/lfs.c

596

return fs;

sbin/fsck_lfs/lfs.c

784

check_summary(struct lfs *fs, SEGSUM *sp, daddr_t pseg_addr, int debug,

sbin/fsck_lfs/lfs.c

800

nblocks = howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs));

sbin/fsck_lfs/lfs.c

801

bc = nblocks << (lfs_sb_getversion(fs) > 1 ? lfs_sb_getffshift(fs) : lfs_sb_getbshift(fs));

sbin/fsck_lfs/lfs.c

804

fp = SEGSUM_FINFOBASE(fs, sp);

sbin/fsck_lfs/lfs.c

805

for (i = 0; i < lfs_ss_getnfinfo(fs, sp); i++) {

sbin/fsck_lfs/lfs.c

806

nblocks += lfs_fi_getnblocks(fs, fp);

sbin/fsck_lfs/lfs.c

807

bc += lfs_fi_getlastlength(fs, fp) + ((lfs_fi_getnblocks(fs, fp) - 1)

sbin/fsck_lfs/lfs.c

808

<< lfs_sb_getbshift(fs));

sbin/fsck_lfs/lfs.c

810

fp = NEXT_FINFO(fs, fp);

sbin/fsck_lfs/lfs.c

811

if (((char *)fp) - (char *)sp > lfs_sb_getsumsize(fs))

sbin/fsck_lfs/lfs.c

817

iibase = SEGSUM_IINFOSTART(fs, sp);

sbin/fsck_lfs/lfs.c

820

daddr = pseg_addr + lfs_btofsb(fs, lfs_sb_getsumsize(fs));

sbin/fsck_lfs/lfs.c

821

fp = SEGSUM_FINFOBASE(fs, sp);

sbin/fsck_lfs/lfs.c

823

i < lfs_ss_getnfinfo(fs, sp) || j < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)); i++) {

sbin/fsck_lfs/lfs.c

824

if (i >= lfs_ss_getnfinfo(fs, sp) && lfs_ii_getblock(fs, iip) != daddr) {

sbin/fsck_lfs/lfs.c

827

pseg_addr, j, howmany(lfs_ss_getninos(fs, sp),

sbin/fsck_lfs/lfs.c

828

LFS_INOPB(fs)));

sbin/fsck_lfs/lfs.c

831

(uintmax_t)lfs_ii_getblock(fs, iip),

sbin/fsck_lfs/lfs.c

835

while (j < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)) && lfs_ii_getblock(fs, iip) == daddr) {

sbin/fsck_lfs/lfs.c

836

bread(devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs),

sbin/fsck_lfs/lfs.c

842

daddr += lfs_btofsb(fs, lfs_sb_getibsize(fs));

sbin/fsck_lfs/lfs.c

843

iip = NEXTLOWER_IINFO(fs, iip);

sbin/fsck_lfs/lfs.c

845

if (i < lfs_ss_getnfinfo(fs, sp)) {

sbin/fsck_lfs/lfs.c

848

for (k = 0; k < lfs_fi_getnblocks(fs, fp); k++) {

sbin/fsck_lfs/lfs.c

849

len = (k == lfs_fi_getnblocks(fs, fp) - 1 ?

sbin/fsck_lfs/lfs.c

850

lfs_fi_getlastlength(fs, fp)

sbin/fsck_lfs/lfs.c

851

: lfs_sb_getbsize(fs));

sbin/fsck_lfs/lfs.c

852

bread(devvp, LFS_FSBTODB(fs, daddr), len,

sbin/fsck_lfs/lfs.c

856

daddr += lfs_btofsb(fs, len);

sbin/fsck_lfs/lfs.c

858

fp = NEXT_FINFO(fs, fp);

sbin/fsck_lfs/lfs.c

868

if (ccksum != lfs_ss_getdatasum(fs, sp)) {

sbin/fsck_lfs/lfs.c

871

(uintmax_t)pseg_addr, lfs_ss_getdatasum(fs, sp), ccksum);

sbin/fsck_lfs/lfs.c

900

lfs_valloc(struct lfs *fs, ino_t ino)

sbin/fsck_lfs/lfs.c

909

LFS_GET_HEADFREE(fs, cip, cbp, &new_ino);

sbin/fsck_lfs/lfs.c

915

LFS_IENTRY(ifp, fs, new_ino, bp);

sbin/fsck_lfs/lfs.c

916

if (lfs_if_getdaddr(fs, ifp) != LFS_UNUSED_DADDR)

sbin/fsck_lfs/lfs.c

918

LFS_PUT_HEADFREE(fs, cip, cbp, lfs_if_getnextfree(fs, ifp));

sbin/fsck_lfs/lfs.c

923

if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {

sbin/fsck_lfs/lfs.c

924

if ((error = extend_ifile(fs)) != 0) {

sbin/fsck_lfs/lfs.c

925

LFS_PUT_HEADFREE(fs, cip, cbp, new_ino);

sbin/fsck_lfs/lfs.c

932

lfs_sb_addnfiles(fs, 1);

sbin/fsck_lfs/lfs.c

934

return lfs_raw_vget(fs, ino, fs->lfs_devvp->v_fd, 0x0);

sbin/fsck_lfs/lfs.c

945

extend_ifile(struct lfs *fs)

sbin/fsck_lfs/lfs.c

957

vp = fs->lfs_ivnode;

sbin/fsck_lfs/lfs.c

959

blkno = lfs_lblkno(fs, lfs_dino_getsize(fs, ip->i_din));

sbin/fsck_lfs/lfs.c

961

lfs_balloc(vp, lfs_dino_getsize(fs, ip->i_din), lfs_sb_getbsize(fs), &bp);

sbin/fsck_lfs/lfs.c

962

lfs_dino_setsize(fs, ip->i_din,

sbin/fsck_lfs/lfs.c

963

lfs_dino_getsize(fs, ip->i_din) + lfs_sb_getbsize(fs));

sbin/fsck_lfs/lfs.c

966

i = (blkno - lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs)) *

sbin/fsck_lfs/lfs.c

967

lfs_sb_getifpb(fs);

sbin/fsck_lfs/lfs.c

968

LFS_GET_HEADFREE(fs, cip, cbp, &oldlast);

sbin/fsck_lfs/lfs.c

969

LFS_PUT_HEADFREE(fs, cip, cbp, i);

sbin/fsck_lfs/lfs.c

970

max = i + lfs_sb_getifpb(fs);

sbin/fsck_lfs/lfs.c

971

lfs_sb_subbfree(fs, lfs_btofsb(fs, lfs_sb_getbsize(fs)));

sbin/fsck_lfs/lfs.c

973

if (fs->lfs_is64) {

sbin/fsck_lfs/lfs.c

981

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

sbin/fsck_lfs/lfs.c

998

LFS_PUT_TAILFREE(fs, cip, cbp, max - 1);

sbin/fsck_lfs/main.c

233

printf("** Last Mounted on %s\n", lfs_sb_getfsmnt(fs));

sbin/fsck_lfs/main.c

319

(intmax_t) lfs_sb_getbfree(fs));

sbin/fsck_lfs/pass0.c

115

LFS_CLEANERINFO(cip, fs, cbp);

sbin/fsck_lfs/pass0.c

116

freehd = ino = lfs_ci_getfree_head(fs, cip);

sbin/fsck_lfs/pass0.c

132

LFS_IENTRY(ifp, fs, plastino, bp);

sbin/fsck_lfs/pass0.c

133

lfs_if_setnextfree(fs, ifp, 0);

sbin/fsck_lfs/pass0.c

139

LFS_IENTRY(ifp, fs, ino, bp);

sbin/fsck_lfs/pass0.c

140

nextino = lfs_if_getnextfree(fs, ifp);

sbin/fsck_lfs/pass0.c

141

daddr = lfs_if_getdaddr(fs, ifp);

sbin/fsck_lfs/pass0.c

151

LFS_IENTRY(ifp, fs, plastino, bp);

sbin/fsck_lfs/pass0.c

152

lfs_if_setnextfree(fs, ifp, nextino);

sbin/fsck_lfs/pass0.c

171

LFS_IENTRY(ifp, fs, ino, bp);

sbin/fsck_lfs/pass0.c

172

if (lfs_if_getdaddr(fs, ifp)) {

sbin/fsck_lfs/pass0.c

180

lfs_if_setnextfree(fs, ifp, freehd);

sbin/fsck_lfs/pass0.c

193

LFS_CLEANERINFO(cip, fs, cbp);

sbin/fsck_lfs/pass0.c

194

if (lfs_ci_getfree_head(fs, cip) != freehd) {

sbin/fsck_lfs/pass0.c

196

lfs_ci_setfree_head(fs, cip, freehd);

sbin/fsck_lfs/pass0.c

199

if (freehd != lfs_sb_getfreehd(fs)) {

sbin/fsck_lfs/pass0.c

201

(uintmax_t)freehd, (uintmax_t)lfs_sb_getfreehd(fs));

sbin/fsck_lfs/pass0.c

203

lfs_sb_setfreehd(fs, freehd);

sbin/fsck_lfs/pass0.c

207

if (lfs_ci_getfree_tail(fs, cip) != plastino) {

sbin/fsck_lfs/pass0.c

210

(unsigned long long)lfs_ci_getfree_tail(fs, cip));

sbin/fsck_lfs/pass0.c

212

lfs_ci_setfree_tail(fs, cip, plastino);

sbin/fsck_lfs/pass0.c

218

LFS_SYNC_CLEANERINFO(cip, fs, cbp, writeit);

sbin/fsck_lfs/pass0.c

222

if (lfs_sb_getfreehd(fs) == 0) {

sbin/fsck_lfs/pass0.c

225

extend_ifile(fs);

sbin/fsck_lfs/pass0.c

95

#define dbshift (fs->lfs_bshift - fs->lfs_blktodb)

sbin/fsck_lfs/pass1.c

112

dins[i]->daddr = lfs_sb_getidaddr(fs);

sbin/fsck_lfs/pass1.c

114

LFS_IENTRY(ifp, fs, i, bp);

sbin/fsck_lfs/pass1.c

115

dins[i]->daddr = lfs_if_getdaddr(fs, ifp);

sbin/fsck_lfs/pass1.c

130

if (tinode && (lfs_dino_getmode(fs, tinode) & LFS_IFMT) == LFS_IFDIR)

sbin/fsck_lfs/pass1.c

164

if (lfs_dino_getdb(fs, dip, i) != 0) {

sbin/fsck_lfs/pass1.c

177

if (lfs_dino_getib(fs, dip, i) != 0) {

sbin/fsck_lfs/pass1.c

195

vp = vget(fs, inumber);

sbin/fsck_lfs/pass1.c

205

mode = lfs_dino_getmode(fs, dp) & LFS_IFMT;

sbin/fsck_lfs/pass1.c

210

lfs_dino_getmode(fs, dp) || lfs_dino_getsize(fs, dp)) {

sbin/fsck_lfs/pass1.c

211

pwarn("mode=o%o, ifmt=o%o\n", lfs_dino_getmode(fs, dp), mode);

sbin/fsck_lfs/pass1.c

215

vp = vget(fs, inumber);

sbin/fsck_lfs/pass1.c

225

lfs_dino_getsize(fs, dp) + lfs_sb_getbsize(fs) - 1 < lfs_dino_getsize(fs, dp)) {

sbin/fsck_lfs/pass1.c

228

(uintmax_t)lfs_dino_getsize(fs, dp));

sbin/fsck_lfs/pass1.c

232

vp = vget(fs, inumber);

sbin/fsck_lfs/pass1.c

234

lfs_dino_setsize(fs, dp, lfs_sb_getfsize(fs));

sbin/fsck_lfs/pass1.c

235

lfs_dino_setmode(fs, dp, LFS_IFREG | 0600);

sbin/fsck_lfs/pass1.c

238

ndb = howmany(lfs_dino_getsize(fs, dp), lfs_sb_getbsize(fs));

sbin/fsck_lfs/pass1.c

242

(uintmax_t)lfs_dino_getsize(fs, dp), (intmax_t)ndb);

sbin/fsck_lfs/pass1.c

252

if (lfs_dino_getsize(fs, dp) < lfs_sb_getmaxsymlinklen(fs) ||

sbin/fsck_lfs/pass1.c

253

(lfs_sb_getmaxsymlinklen(fs) == 0 && lfs_dino_getblocks(fs, dp) == 0)) {

sbin/fsck_lfs/pass1.c

254

ndb = howmany(lfs_dino_getsize(fs, dp), LFS_BLKPTRSIZE(fs));

sbin/fsck_lfs/pass1.c

258

ndb *= LFS_NINDIR(fs);

sbin/fsck_lfs/pass1.c

264

if (lfs_dino_getdb(fs, dp, j) != 0) {

sbin/fsck_lfs/pass1.c

267

(uintmax_t)lfs_dino_getsize(fs, dp),

sbin/fsck_lfs/pass1.c

269

(intmax_t)lfs_dino_getdb(fs, dp, j));

sbin/fsck_lfs/pass1.c

273

ndb /= LFS_NINDIR(fs);

sbin/fsck_lfs/pass1.c

275

if (lfs_dino_getib(fs, dp, j) != 0) {

sbin/fsck_lfs/pass1.c

278

(uintmax_t)lfs_dino_getsize(fs, dp),

sbin/fsck_lfs/pass1.c

280

(intmax_t)lfs_dino_getib(fs, dp, j));

sbin/fsck_lfs/pass1.c

286

lncntp[inumber] = lfs_dino_getnlink(fs, dp);

sbin/fsck_lfs/pass1.c

287

if (lfs_dino_getnlink(fs, dp) <= 0) {

sbin/fsck_lfs/pass1.c

294

if (lfs_dino_getsize(fs, dp) == 0)

sbin/fsck_lfs/pass1.c

307

if (lfs_dino_getnlink(fs, dp) <= 0) {

sbin/fsck_lfs/pass1.c

308

LFS_IENTRY(ifp, fs, inumber, bp);

sbin/fsck_lfs/pass1.c

309

if (lfs_if_getnextfree(fs, ifp) == LFS_ORPHAN_NEXTFREE(fs)) {

sbin/fsck_lfs/pass1.c

326

if (lfs_dino_getblocks(fs, dp) != idesc->id_entryno) {

sbin/fsck_lfs/pass1.c

328

(unsigned long long)inumber, lfs_dino_getblocks(fs, dp),

sbin/fsck_lfs/pass1.c

334

lfs_dino_setblocks(fs, VTOD(vp), idesc->id_entryno);

sbin/fsck_lfs/pass1.c

343

vp = vget(fs, inumber);

sbin/fsck_lfs/pass1.c

370

seg_table[lfs_dtosn(fs, blkno)].su_nbytes += idesc->id_numfrags * lfs_sb_getfsize(fs);

sbin/fsck_lfs/pass2.c

107

vp = vget(fs, ULFS_ROOTINO);

sbin/fsck_lfs/pass2.c

109

mode = lfs_dino_getmode(fs, dp);

sbin/fsck_lfs/pass2.c

112

lfs_dino_setmode(fs, dp, mode);

sbin/fsck_lfs/pass2.c

139

if (inp->i_isize < MINDIRSIZE(fs)) {

sbin/fsck_lfs/pass2.c

141

inp->i_isize = roundup(MINDIRSIZE(fs), LFS_DIRBLKSIZ);

sbin/fsck_lfs/pass2.c

143

vp = vget(fs, inp->i_number);

sbin/fsck_lfs/pass2.c

145

lfs_dino_setsize(fs, dp, inp->i_isize);

sbin/fsck_lfs/pass2.c

157

vp = vget(fs, inp->i_number);

sbin/fsck_lfs/pass2.c

159

lfs_dino_setsize(fs, dp, inp->i_isize);

sbin/fsck_lfs/pass2.c

164

lfs_dino_setmode(fs, &dino, LFS_IFDIR);

sbin/fsck_lfs/pass2.c

165

lfs_dino_setsize(fs, &dino, inp->i_isize);

sbin/fsck_lfs/pass2.c

168

lfs_dino_setdb(fs, &dino, ii, inp->i_blks[ii]);

sbin/fsck_lfs/pass2.c

171

lfs_dino_setib(fs, &dino, ii - ULFS_NDADDR,

sbin/fsck_lfs/pass2.c

230

if (lfs_dir_getino(fs, dirp) != 0 && strcmp(lfs_dir_nameptr(fs, dirp), ".") == 0) {

sbin/fsck_lfs/pass2.c

231

if (lfs_dir_getino(fs, dirp) != idesc->id_number) {

sbin/fsck_lfs/pass2.c

234

lfs_dir_setino(fs, dirp, idesc->id_number);

sbin/fsck_lfs/pass2.c

238

if (lfs_dir_gettype(fs, dirp) != LFS_DT_DIR) {

sbin/fsck_lfs/pass2.c

241

lfs_dir_settype(fs, dirp, LFS_DT_DIR);

sbin/fsck_lfs/pass2.c

248

lfs_dir_setino(fs, &proto, idesc->id_number);

sbin/fsck_lfs/pass2.c

249

lfs_dir_settype(fs, &proto, LFS_DT_DIR);

sbin/fsck_lfs/pass2.c

250

lfs_dir_setnamlen(fs, &proto, 1);

sbin/fsck_lfs/pass2.c

251

entrysize = LFS_DIRECTSIZ(fs, 1);

sbin/fsck_lfs/pass2.c

252

lfs_dir_setreclen(fs, &proto, entrysize);

sbin/fsck_lfs/pass2.c

253

if (lfs_dir_getino(fs, dirp) != 0 && strcmp(lfs_dir_nameptr(fs, dirp), "..") != 0) {

sbin/fsck_lfs/pass2.c

255

lfs_dir_nameptr(fs, dirp));

sbin/fsck_lfs/pass2.c

256

} else if (lfs_dir_getreclen(fs, dirp) < entrysize) {

sbin/fsck_lfs/pass2.c

258

} else if (lfs_dir_getreclen(fs, dirp) < 2 * entrysize) {

sbin/fsck_lfs/pass2.c

260

lfs_dir_setreclen(fs, &proto, lfs_dir_getreclen(fs, dirp));

sbin/fsck_lfs/pass2.c

262

lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), ".", 1,

sbin/fsck_lfs/pass2.c

263

lfs_dir_getreclen(fs, dirp));

sbin/fsck_lfs/pass2.c

268

n = lfs_dir_getreclen(fs, dirp) - entrysize;

sbin/fsck_lfs/pass2.c

270

lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), ".", 1,

sbin/fsck_lfs/pass2.c

271

lfs_dir_getreclen(fs, dirp));

sbin/fsck_lfs/pass2.c

273

lncntp[lfs_dir_getino(fs, dirp)]--;

sbin/fsck_lfs/pass2.c

274

dirp = LFS_NEXTDIR(fs, dirp);

sbin/fsck_lfs/pass2.c

276

lfs_dir_setreclen(fs, dirp, n);

sbin/fsck_lfs/pass2.c

284

lfs_dir_setino(fs, &proto, inp->i_parent);

sbin/fsck_lfs/pass2.c

285

lfs_dir_settype(fs, &proto, LFS_DT_DIR);

sbin/fsck_lfs/pass2.c

286

lfs_dir_setnamlen(fs, &proto, 2);

sbin/fsck_lfs/pass2.c

287

entrysize = LFS_DIRECTSIZ(fs, 2);

sbin/fsck_lfs/pass2.c

288

lfs_dir_setreclen(fs, &proto, entrysize);

sbin/fsck_lfs/pass2.c

290

n = LFS_DIRSIZ(fs, dirp);

sbin/fsck_lfs/pass2.c

291

if (lfs_dir_getreclen(fs, dirp) < n + entrysize)

sbin/fsck_lfs/pass2.c

293

lfs_dir_setreclen(fs, &proto, lfs_dir_getreclen(fs, dirp) - n);

sbin/fsck_lfs/pass2.c

294

lfs_dir_setreclen(fs, dirp, n);

sbin/fsck_lfs/pass2.c

296

lncntp[lfs_dir_getino(fs, dirp)]--;

sbin/fsck_lfs/pass2.c

298

memset(dirp, 0, lfs_dir_getreclen(fs, &proto));

sbin/fsck_lfs/pass2.c

299

lfs_dir_setreclen(fs, dirp, lfs_dir_getreclen(fs, &proto));

sbin/fsck_lfs/pass2.c

301

if (lfs_dir_getino(fs, dirp) != 0 && strcmp(lfs_dir_nameptr(fs, dirp), "..") == 0) {

sbin/fsck_lfs/pass2.c

302

inp->i_dotdot = lfs_dir_getino(fs, dirp);

sbin/fsck_lfs/pass2.c

303

if (lfs_dir_gettype(fs, dirp) != LFS_DT_DIR) {

sbin/fsck_lfs/pass2.c

305

lfs_dir_settype(fs, dirp, LFS_DT_DIR);

sbin/fsck_lfs/pass2.c

311

if (lfs_dir_getino(fs, dirp) != 0 && strcmp(lfs_dir_nameptr(fs, dirp), ".") != 0) {

sbin/fsck_lfs/pass2.c

314

lfs_dir_nameptr(fs, dirp));

sbin/fsck_lfs/pass2.c

316

} else if (lfs_dir_getreclen(fs, dirp) < entrysize) {

sbin/fsck_lfs/pass2.c

326

lfs_dir_setreclen(fs, &proto, lfs_dir_getreclen(fs, dirp));

sbin/fsck_lfs/pass2.c

328

lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), "..", 2,

sbin/fsck_lfs/pass2.c

329

lfs_dir_getreclen(fs, dirp));

sbin/fsck_lfs/pass2.c

334

if (lfs_dir_getino(fs, dirp) != 0)

sbin/fsck_lfs/pass2.c

335

lncntp[lfs_dir_getino(fs, dirp)]--;

sbin/fsck_lfs/pass2.c

338

if (lfs_dir_getino(fs, dirp) == 0)

sbin/fsck_lfs/pass2.c

340

if (lfs_dir_getnamlen(fs, dirp) <= 2 &&

sbin/fsck_lfs/pass2.c

341

lfs_dir_nameptr(fs, dirp)[0] == '.' &&

sbin/fsck_lfs/pass2.c

343

if (lfs_dir_getnamlen(fs, dirp) == 1) {

sbin/fsck_lfs/pass2.c

346

lfs_dir_setino(fs, dirp, 0);

sbin/fsck_lfs/pass2.c

351

if (lfs_dir_nameptr(fs, dirp)[1] == '.') {

sbin/fsck_lfs/pass2.c

354

lfs_dir_setino(fs, dirp, 0);

sbin/fsck_lfs/pass2.c

362

if (lfs_dir_getino(fs, dirp) >= maxino) {

sbin/fsck_lfs/pass2.c

363

fileerror(idesc->id_number, lfs_dir_getino(fs, dirp), "I OUT OF RANGE");

sbin/fsck_lfs/pass2.c

372

} else if (lfs_dir_getino(fs, dirp) == LFS_IFILE_INUM &&

sbin/fsck_lfs/pass2.c

374

if (lfs_dir_gettype(fs, dirp) != LFS_DT_REG) {

sbin/fsck_lfs/pass2.c

375

fileerror(idesc->id_number, lfs_dir_getino(fs, dirp),

sbin/fsck_lfs/pass2.c

378

lfs_dir_settype(fs, dirp, LFS_DT_REG);

sbin/fsck_lfs/pass2.c

383

} else if (((lfs_dir_getino(fs, dirp) == ULFS_WINO && lfs_dir_gettype(fs, dirp) != LFS_DT_WHT) ||

sbin/fsck_lfs/pass2.c

384

(lfs_dir_getino(fs, dirp) != ULFS_WINO && lfs_dir_gettype(fs, dirp) == LFS_DT_WHT))) {

sbin/fsck_lfs/pass2.c

385

fileerror(idesc->id_number, lfs_dir_getino(fs, dirp), "BAD WHITEOUT ENTRY");

sbin/fsck_lfs/pass2.c

387

lfs_dir_setino(fs, dirp, ULFS_WINO);

sbin/fsck_lfs/pass2.c

388

lfs_dir_settype(fs, dirp, LFS_DT_WHT);

sbin/fsck_lfs/pass2.c

393

switch (statemap[lfs_dir_getino(fs, dirp)]) {

sbin/fsck_lfs/pass2.c

397

fileerror(idesc->id_number, lfs_dir_getino(fs, dirp),

sbin/fsck_lfs/pass2.c

406

if (statemap[lfs_dir_getino(fs, dirp)] == FCLEAR)

sbin/fsck_lfs/pass2.c

414

fileerror(idesc->id_number, lfs_dir_getino(fs, dirp), errmsg);

sbin/fsck_lfs/pass2.c

417

dp = ginode(lfs_dir_getino(fs, dirp));

sbin/fsck_lfs/pass2.c

418

statemap[lfs_dir_getino(fs, dirp)] =

sbin/fsck_lfs/pass2.c

419

(lfs_dino_getmode(fs, dp) & LFS_IFMT) == LFS_IFDIR ? DSTATE : FSTATE;

sbin/fsck_lfs/pass2.c

420

lncntp[lfs_dir_getino(fs, dirp)] = lfs_dino_getnlink(fs, dp);

sbin/fsck_lfs/pass2.c

425

inp = getinoinfo(lfs_dir_getino(fs, dirp));

sbin/fsck_lfs/pass2.c

430

lfs_dir_getino(fs, dirp),

sbin/fsck_lfs/pass2.c

431

lfs_dir_getino(fs, dirp));

sbin/fsck_lfs/pass2.c

445

if (lfs_dir_gettype(fs, dirp) != typemap[lfs_dir_getino(fs, dirp)]) {

sbin/fsck_lfs/pass2.c

447

lfs_dir_getino(fs, dirp),

sbin/fsck_lfs/pass2.c

451

lfs_dir_gettype(fs, dirp), typemap[lfs_dir_getino(fs, dirp)]);

sbin/fsck_lfs/pass2.c

452

lfs_dir_settype(fs, dirp, typemap[lfs_dir_getino(fs, dirp)]);

sbin/fsck_lfs/pass2.c

456

lncntp[lfs_dir_getino(fs, dirp)]--;

sbin/fsck_lfs/pass2.c

461

statemap[lfs_dir_getino(fs, dirp)],

sbin/fsck_lfs/pass2.c

462

(uintmax_t)lfs_dir_getino(fs, dirp));

sbin/fsck_lfs/pass2.c

467

lfs_dir_setino(fs, dirp, 0);

sbin/fsck_lfs/pass2.c

54

#define MINDIRSIZE(fs) \

sbin/fsck_lfs/pass2.c

55

((fs)->lfs_is64 ? sizeof(struct lfs_dirtemplate64) : \

sbin/fsck_lfs/pass4.c

119

if (lfs_dino_getsize(fs, dp) == 0) {

sbin/fsck_lfs/pass4.c

154

sn = lfs_dtosn(fs, blkno);

sbin/fsck_lfs/pass4.c

170

LFS_SEGENTRY(sup, fs, sn, bp);

sbin/fsck_lfs/pass4.c

171

sup->su_nbytes -= lfs_fsbtob(fs, 1);

sbin/fsck_lfs/pass4.c

173

seg_table[sn].su_nbytes -= lfs_fsbtob(fs, 1);

sbin/fsck_lfs/pass4.c

174

lfs_sb_addbfree(fs, 1);

sbin/fsck_lfs/pass5.c

109

bb += lfs_btofsb(fs, su->su_nbytes +

sbin/fsck_lfs/pass5.c

110

su->su_nsums * lfs_sb_getsumsize(fs));

sbin/fsck_lfs/pass5.c

111

ubb += lfs_btofsb(fs, su->su_nbytes +

sbin/fsck_lfs/pass5.c

112

su->su_nsums * lfs_sb_getsumsize(fs) +

sbin/fsck_lfs/pass5.c

113

su->su_ninos * lfs_sb_getibsize(fs));

sbin/fsck_lfs/pass5.c

114

dmeta += lfs_btofsb(fs,

sbin/fsck_lfs/pass5.c

115

lfs_sb_getsumsize(fs) * su->su_nsums);

sbin/fsck_lfs/pass5.c

116

dmeta += lfs_btofsb(fs,

sbin/fsck_lfs/pass5.c

117

lfs_sb_getibsize(fs) * su->su_ninos);

sbin/fsck_lfs/pass5.c

120

avail += lfs_segtod(fs, 1);

sbin/fsck_lfs/pass5.c

123

if (i == 0 && lfs_sb_getversion(fs) > 1 &&

sbin/fsck_lfs/pass5.c

124

lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))

sbin/fsck_lfs/pass5.c

125

labelcorrect = lfs_btofsb(fs, LFS_LABELPAD) -

sbin/fsck_lfs/pass5.c

126

lfs_sb_gets0addr(fs);

sbin/fsck_lfs/pass5.c

135

i = lfs_dtosn(fs, lfs_sb_getoffset(fs));

sbin/fsck_lfs/pass5.c

136

curr = lfs_sntod(fs, i + 1) - lfs_sb_getoffset(fs);

sbin/fsck_lfs/pass5.c

138

mfs = lfs_segtod(fs, (lfs_sb_getminfreeseg(fs) -

sbin/fsck_lfs/pass5.c

139

(lfs_sb_getminfreeseg(fs) / 2)));

sbin/fsck_lfs/pass5.c

141

avail = nclean * lfs_segtod(fs, 1);

sbin/fsck_lfs/pass5.c

142

avail -= nsb * lfs_btofsb(fs, LFS_SBPAD);

sbin/fsck_lfs/pass5.c

148

avail -= lfs_btofsb(fs, locked_queue_bytes);

sbin/fsck_lfs/pass5.c

154

(intmax_t)lfs_segtod(fs, 1),

sbin/fsck_lfs/pass5.c

156

(intmax_t)lfs_btofsb(fs, LFS_SBPAD),

sbin/fsck_lfs/pass5.c

160

(intmax_t)lfs_btofsb(fs, locked_queue_bytes),

sbin/fsck_lfs/pass5.c

166

if (dmeta != lfs_sb_getdmeta(fs)) {

sbin/fsck_lfs/pass5.c

168

lfs_sb_getdmeta(fs), dmeta);

sbin/fsck_lfs/pass5.c

170

lfs_sb_setdmeta(fs, dmeta);

sbin/fsck_lfs/pass5.c

174

if (avail != lfs_sb_getavail(fs) && !aflag) {

sbin/fsck_lfs/pass5.c

176

(intmax_t)lfs_sb_getavail(fs), (intmax_t)avail);

sbin/fsck_lfs/pass5.c

178

lfs_sb_setavail(fs, avail);

sbin/fsck_lfs/pass5.c

182

if (nclean != lfs_sb_getnclean(fs)) {

sbin/fsck_lfs/pass5.c

183

pwarn("NCLEAN GIVEN AS %d, SHOULD BE %d\n", lfs_sb_getnclean(fs),

sbin/fsck_lfs/pass5.c

186

lfs_sb_setnclean(fs, nclean);

sbin/fsck_lfs/pass5.c

192

if (lfs_sb_getversion(fs) > 1 &&

sbin/fsck_lfs/pass5.c

193

lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))

sbin/fsck_lfs/pass5.c

194

labelskew = lfs_btofsb(fs, LFS_LABELPAD);

sbin/fsck_lfs/pass5.c

195

bfree_ub = lfs_sb_getdsize(fs) - bb - labelskew;

sbin/fsck_lfs/pass5.c

196

bfree_lb = lfs_sb_getdsize(fs) - ubb - labelskew;

sbin/fsck_lfs/pass5.c

197

bfree_observed = (daddr_t)lfs_sb_getbfree(fs);

sbin/fsck_lfs/pass5.c

204

lfs_sb_setbfree(fs, (bfree_lb + bfree_ub) / 2);

sbin/fsck_lfs/pass5.c

81

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

sbin/fsck_lfs/pass5.c

83

LFS_SEGENTRY(su, fs, i, bp);

sbin/fsck_lfs/pass6.c

101

lfs_dino_setblocks(fs, ip->i_din,

sbin/fsck_lfs/pass6.c

102

lfs_dino_getblocks(fs, ip->i_din) + frags);

sbin/fsck_lfs/pass6.c

105

ofrags = lfs_numfrags(fs, ip->i_lfs_fragsize[lbn]);

sbin/fsck_lfs/pass6.c

106

lfs_dino_setblocks(fs, ip->i_din,

sbin/fsck_lfs/pass6.c

107

lfs_dino_getblocks(fs, ip->i_din) + (frags - ofrags));

sbin/fsck_lfs/pass6.c

109

lfs_dino_setdb(fs, ip->i_din, lbn, ndaddr);

sbin/fsck_lfs/pass6.c

112

ooff = lfs_dino_getib(fs, ip->i_din, a[0].in_off);

sbin/fsck_lfs/pass6.c

114

lfs_dino_setblocks(fs, ip->i_din,

sbin/fsck_lfs/pass6.c

115

lfs_dino_getblocks(fs, ip->i_din) + frags);

sbin/fsck_lfs/pass6.c

116

lfs_dino_setib(fs, ip->i_din, a[0].in_off, ndaddr);

sbin/fsck_lfs/pass6.c

120

if (bread(vp, ap->in_lbn, lfs_sb_getbsize(fs), 0, &bp))

sbin/fsck_lfs/pass6.c

124

ooff = lfs_iblock_get(fs, bp->b_data, ap->in_off);

sbin/fsck_lfs/pass6.c

126

lfs_dino_setblocks(fs, ip->i_din,

sbin/fsck_lfs/pass6.c

127

lfs_dino_getblocks(fs, ip->i_din) + frags);

sbin/fsck_lfs/pass6.c

128

lfs_iblock_set(fs, bp->b_data, ap->in_off, ndaddr);

sbin/fsck_lfs/pass6.c

137

oldsn = lfs_dtosn(fs, daddr);

sbin/fsck_lfs/pass6.c

141

osize = lfs_sb_getbsize(fs);

sbin/fsck_lfs/pass6.c

142

LFS_SEGENTRY(sup, fs, oldsn, bp);

sbin/fsck_lfs/pass6.c

146

fs->lfs_flags |= LFS_IFDIRTY;

sbin/fsck_lfs/pass6.c

147

LFS_WRITESEGENTRY(sup, fs, oldsn, bp);

sbin/fsck_lfs/pass6.c

148

for (i = 0; i < lfs_btofsb(fs, osize); i++)

sbin/fsck_lfs/pass6.c

153

if (lbn >= 0 && lfs_dino_getsize(fs, ip->i_din) <= (lbn << lfs_sb_getbshift(fs))) {

sbin/fsck_lfs/pass6.c

154

lfs_dino_setsize(fs, ip->i_din, (lbn << lfs_sb_getbshift(fs)) + 1);

sbin/fsck_lfs/pass6.c

161

minsize = (lbn << lfs_sb_getbshift(fs));

sbin/fsck_lfs/pass6.c

162

minsize += (size - lfs_sb_getfsize(fs)) + 1;

sbin/fsck_lfs/pass6.c

163

if (lfs_dino_getsize(fs, ip->i_din) < minsize)

sbin/fsck_lfs/pass6.c

164

lfs_dino_setsize(fs, ip->i_din, minsize);

sbin/fsck_lfs/pass6.c

171

sn = lfs_dtosn(fs, ndaddr);

sbin/fsck_lfs/pass6.c

172

LFS_SEGENTRY(sup, fs, sn, bp);

sbin/fsck_lfs/pass6.c

176

fs->lfs_flags |= LFS_IFDIRTY;

sbin/fsck_lfs/pass6.c

177

LFS_WRITESEGENTRY(sup, fs, sn, bp);

sbin/fsck_lfs/pass6.c

178

for (i = 0; i < lfs_btofsb(fs, size); i++)

sbin/fsck_lfs/pass6.c

187

lfs_sb_subbfree(fs, lfs_btofsb(fs, size));

sbin/fsck_lfs/pass6.c

189

lfs_sb_subbfree(fs, frags - ofrags);

sbin/fsck_lfs/pass6.c

220

LFS_IENTRY(ifp, fs, ino, bp);

sbin/fsck_lfs/pass6.c

221

daddr = lfs_if_getdaddr(fs, ifp);

sbin/fsck_lfs/pass6.c

223

lfs_if_setdaddr(fs, ifp, 0);

sbin/fsck_lfs/pass6.c

225

LFS_GET_HEADFREE(fs, cip, cbp, &nextfree);

sbin/fsck_lfs/pass6.c

226

lfs_if_setnextfree(fs, ifp, nextfree);

sbin/fsck_lfs/pass6.c

228

LFS_PUT_HEADFREE(fs, cip, cbp, ino);

sbin/fsck_lfs/pass6.c

232

vp = lfs_raw_vget(fs, ino, fs->lfs_ivnode->v_fd, daddr);

sbin/fsck_lfs/pass6.c

234

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), sbp);

sbin/fsck_lfs/pass6.c

235

sup->su_nbytes -= DINOSIZE(fs);

sbin/fsck_lfs/pass6.c

237

seg_table[lfs_dtosn(fs, daddr)].su_nbytes -= DINOSIZE(fs);

sbin/fsck_lfs/pass6.c

262

vp = vget(fs, lfs_fi_getino(fs, fip));

sbin/fsck_lfs/pass6.c

263

if (vp && vp != fs->lfs_ivnode &&

sbin/fsck_lfs/pass6.c

264

lfs_dino_getgen(fs, VTOI(vp)->i_din) == lfs_fi_getversion(fs, fip)) {

sbin/fsck_lfs/pass6.c

265

for (i = 0; i < lfs_fi_getnblocks(fs, fip); i++) {

sbin/fsck_lfs/pass6.c

266

size = (i == lfs_fi_getnblocks(fs, fip) - 1 ?

sbin/fsck_lfs/pass6.c

267

lfs_fi_getlastlength(fs, fip) : lfs_sb_getbsize(fs));

sbin/fsck_lfs/pass6.c

270

(uintmax_t)lfs_fi_getino(fs, fip),

sbin/fsck_lfs/pass6.c

271

(intmax_t)lfs_fi_getblock(fs, fip, i),

sbin/fsck_lfs/pass6.c

273

rfw_update_single(vp, lfs_fi_getblock(fs, fip, i), daddr, size);

sbin/fsck_lfs/pass6.c

274

daddr += lfs_btofsb(fs, size);

sbin/fsck_lfs/pass6.c

294

sn = lfs_dtosn(fs, idesc->id_blkno + i);

sbin/fsck_lfs/pass6.c

295

if (sn < 0 || sn >= lfs_sb_getnseg(fs) ||

sbin/fsck_lfs/pass6.c

301

if (sn != lfs_dtosn(fs, lfs_sb_getoffset(fs)) ||

sbin/fsck_lfs/pass6.c

302

idesc->id_blkno > lfs_sb_getoffset(fs)) {

sbin/fsck_lfs/pass6.c

309

seg_table[sn].su_nbytes -= lfs_fsbtob(fs, 1);

sbin/fsck_lfs/pass6.c

339

bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getbsize(fs), 0, &bp);

sbin/fsck_lfs/pass6.c

340

buf = emalloc(lfs_sb_getbsize(fs));

sbin/fsck_lfs/pass6.c

341

memcpy(buf, bp->b_data, lfs_sb_getbsize(fs));

sbin/fsck_lfs/pass6.c

344

obuf = emalloc(lfs_sb_getbsize(fs));

sbin/fsck_lfs/pass6.c

346

bread(vp, ilbn, lfs_sb_getbsize(fs), 0, &bp);

sbin/fsck_lfs/pass6.c

347

memcpy(obuf, bp->b_data, lfs_sb_getbsize(fs));

sbin/fsck_lfs/pass6.c

350

memset(obuf, 0, lfs_sb_getbsize(fs));

sbin/fsck_lfs/pass6.c

353

dap < (int32_t *)((char *)buf + lfs_sb_getbsize(fs));

sbin/fsck_lfs/pass6.c

356

rfw_update_single(vp, lbn, *dap, lfs_dblksize(fs, dp, lbn));

sbin/fsck_lfs/pass6.c

363

lbn -= LFS_NINDIR(fs);

sbin/fsck_lfs/pass6.c

365

lbn -= LFS_NINDIR(fs) * LFS_NINDIR(fs);

sbin/fsck_lfs/pass6.c

383

vp = vget(fs, lfs_dino_getinumber(fs, dp));

sbin/fsck_lfs/pass6.c

388

odaddr = (ip ? lfs_dino_getdb(fs, ip->i_din, i) : 0x0);

sbin/fsck_lfs/pass6.c

389

if (lfs_dino_getdb(fs, dp, i) > 0 && lfs_dino_getdb(fs, dp, i) != odaddr)

sbin/fsck_lfs/pass6.c

390

rfw_update_single(vp, i, lfs_dino_getdb(fs, dp, i),

sbin/fsck_lfs/pass6.c

391

lfs_dblksize(fs, dp, i));

sbin/fsck_lfs/pass6.c

397

odaddr = (ip ? lfs_dino_getib(fs, ip->i_din, i) : 0x0);

sbin/fsck_lfs/pass6.c

398

if (lfs_dino_getib(fs, dp, i) > 0 && lfs_dino_getib(fs, dp, i) != odaddr) {

sbin/fsck_lfs/pass6.c

400

rfw_update_single(vp, i, lfs_dino_getib(fs, dp, i), lfs_sb_getbsize(fs));

sbin/fsck_lfs/pass6.c

401

account_indir(vp, dp, lbn, lfs_dino_getib(fs, dp, i), i);

sbin/fsck_lfs/pass6.c

404

off = LFS_NINDIR(fs);

sbin/fsck_lfs/pass6.c

406

off *= LFS_NINDIR(fs);

sbin/fsck_lfs/pass6.c

425

ino_t thisino = lfs_dino_getinumber(fs, dp);

sbin/fsck_lfs/pass6.c

432

LFS_IENTRY(ifp, fs, thisino, bp);

sbin/fsck_lfs/pass6.c

433

odaddr = lfs_if_getdaddr(fs, ifp);

sbin/fsck_lfs/pass6.c

435

lfs_if_setdaddr(fs, ifp, daddr);

sbin/fsck_lfs/pass6.c

440

(uintmax_t)lfs_dino_getinumber(fs, dp),

sbin/fsck_lfs/pass6.c

443

(int)lfs_dino_getmode(fs, dp),

sbin/fsck_lfs/pass6.c

444

(int)lfs_dino_getnlink(fs, dp));

sbin/fsck_lfs/pass6.c

447

vp = vget(fs, thisino);

sbin/fsck_lfs/pass6.c

448

lfs_copy_dinode(fs, VTOI(vp)->i_din, dp);

sbin/fsck_lfs/pass6.c

451

sn = lfs_dtosn(fs, odaddr);

sbin/fsck_lfs/pass6.c

452

LFS_SEGENTRY(sup, fs, sn, bp);

sbin/fsck_lfs/pass6.c

453

sup->su_nbytes -= DINOSIZE(fs);

sbin/fsck_lfs/pass6.c

455

seg_table[sn].su_nbytes -= DINOSIZE(fs);

sbin/fsck_lfs/pass6.c

457

sn = lfs_dtosn(fs, daddr);

sbin/fsck_lfs/pass6.c

458

LFS_SEGENTRY(sup, fs, sn, bp);

sbin/fsck_lfs/pass6.c

459

sup->su_nbytes += DINOSIZE(fs);

sbin/fsck_lfs/pass6.c

461

seg_table[sn].su_nbytes += DINOSIZE(fs);

sbin/fsck_lfs/pass6.c

480

extend_ifile(fs);

sbin/fsck_lfs/pass6.c

483

LFS_IENTRY(ifp, fs, thisino, bp);

sbin/fsck_lfs/pass6.c

484

if (lfs_if_getdaddr(fs, ifp) != 0) {

sbin/fsck_lfs/pass6.c

488

nextfree = lfs_if_getnextfree(fs, ifp);

sbin/fsck_lfs/pass6.c

489

lfs_if_setnextfree(fs, ifp, 0);

sbin/fsck_lfs/pass6.c

490

lfs_if_setdaddr(fs, ifp, daddr);

sbin/fsck_lfs/pass6.c

493

LFS_GET_HEADFREE(fs, cip, cbp, &oldhead);

sbin/fsck_lfs/pass6.c

495

LFS_PUT_HEADFREE(fs, cip, cbp, nextfree);

sbin/fsck_lfs/pass6.c

498

extend_ifile(fs);

sbin/fsck_lfs/pass6.c

504

LFS_IENTRY(ifp, fs, ino, bp);

sbin/fsck_lfs/pass6.c

505

assert(lfs_if_getnextfree(fs, ifp) != ino);

sbin/fsck_lfs/pass6.c

506

if (lfs_if_getnextfree(fs, ifp) == thisino) {

sbin/fsck_lfs/pass6.c

507

lfs_if_setnextfree(fs, ifp, nextfree);

sbin/fsck_lfs/pass6.c

510

LFS_PUT_TAILFREE(fs, cip, cbp, ino);

sbin/fsck_lfs/pass6.c

513

ino = lfs_if_getnextfree(fs, ifp);

sbin/fsck_lfs/pass6.c

519

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), bp);

sbin/fsck_lfs/pass6.c

520

sup->su_nbytes += DINOSIZE(fs);

sbin/fsck_lfs/pass6.c

522

seg_table[lfs_dtosn(fs, daddr)].su_nbytes += DINOSIZE(fs);

sbin/fsck_lfs/pass6.c

561

devvp = fs->lfs_devvp;

sbin/fsck_lfs/pass6.c

571

lastgood = try_verify(fs, devvp, 0, debug);

sbin/fsck_lfs/pass6.c

572

if (lastgood == lfs_sb_getoffset(fs)) {

sbin/fsck_lfs/pass6.c

580

(uintmax_t)lfs_sb_getoffset(fs), (uintmax_t)lastgood);

sbin/fsck_lfs/pass6.c

589

ibbuf = emalloc(lfs_sb_getibsize(fs));

sbin/fsck_lfs/pass6.c

591

daddr = lfs_sb_getoffset(fs);

sbin/fsck_lfs/pass6.c

595

seg_table[lfs_dtosn(fs, daddr)].su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE;

sbin/fsck_lfs/pass6.c

596

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), sbp);

sbin/fsck_lfs/pass6.c

601

if (lfs_sntod(fs, lfs_dtosn(fs, daddr)) == daddr) {

sbin/fsck_lfs/pass6.c

602

if (daddr == lfs_sb_gets0addr(fs)) {

sbin/fsck_lfs/pass6.c

604

daddr += lfs_btofsb(fs, LFS_LABELPAD);

sbin/fsck_lfs/pass6.c

607

if (daddr == lfs_sb_getsboff(fs, i)) {

sbin/fsck_lfs/pass6.c

609

daddr += lfs_btofsb(fs, LFS_SBPAD);

sbin/fsck_lfs/pass6.c

611

if (daddr < lfs_sb_getsboff(fs, i))

sbin/fsck_lfs/pass6.c

618

bread(devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getsumsize(fs), 0, &bp);

sbin/fsck_lfs/pass6.c

622

(intmax_t)daddr, (int)lfs_ss_getninos(fs, sp),

sbin/fsck_lfs/pass6.c

623

(int)lfs_ss_getnfinfo(fs, sp));

sbin/fsck_lfs/pass6.c

626

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), sbp);

sbin/fsck_lfs/pass6.c

629

lfs_sb_subbfree(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));

sbin/fsck_lfs/pass6.c

630

lfs_sb_adddmeta(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));

sbin/fsck_lfs/pass6.c

632

if (lfs_sntod(fs, lfs_dtosn(fs, daddr)) == daddr +

sbin/fsck_lfs/pass6.c

633

hassuper * lfs_btofsb(fs, LFS_SBPAD) &&

sbin/fsck_lfs/pass6.c

634

lfs_dtosn(fs, daddr) != lfs_dtosn(fs, lfs_sb_getoffset(fs))) {

sbin/fsck_lfs/pass6.c

635

lfs_sb_subnclean(fs, 1);

sbin/fsck_lfs/pass6.c

640

if (lfs_ss_getninos(fs, sp)) {

sbin/fsck_lfs/pass6.c

641

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), sbp);

sbin/fsck_lfs/pass6.c

642

sup->su_ninos += howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs));

sbin/fsck_lfs/pass6.c

644

lfs_sb_adddmeta(fs, lfs_btofsb(fs, howmany(lfs_ss_getninos(fs, sp),

sbin/fsck_lfs/pass6.c

645

LFS_INOPB(fs)) *

sbin/fsck_lfs/pass6.c

646

lfs_sb_getibsize(fs)));

sbin/fsck_lfs/pass6.c

648

iip = SEGSUM_IINFOSTART(fs, bp->b_data);

sbin/fsck_lfs/pass6.c

649

for (i = 0; i < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)); i++) {

sbin/fsck_lfs/pass6.c

652

inums = ecalloc(LFS_INOPB(fs) + 1, sizeof(*inums));

sbin/fsck_lfs/pass6.c

653

ibdaddr = lfs_ii_getblock(fs, iip);

sbin/fsck_lfs/pass6.c

654

iip = NEXTLOWER_IINFO(fs, iip);

sbin/fsck_lfs/pass6.c

655

lfs_sb_subbfree(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));

sbin/fsck_lfs/pass6.c

657

bread(devvp, LFS_FSBTODB(fs, ibdaddr),

sbin/fsck_lfs/pass6.c

658

lfs_sb_getibsize(fs), 0, &ibp);

sbin/fsck_lfs/pass6.c

659

memcpy(ibbuf, ibp->b_data, lfs_sb_getibsize(fs));

sbin/fsck_lfs/pass6.c

663

for (k = 0; k < LFS_INOPB(fs); k++) {

sbin/fsck_lfs/pass6.c

664

dp = DINO_IN_BLOCK(fs, ibbuf, k);

sbin/fsck_lfs/pass6.c

665

if (lfs_dino_getinumber(fs, dp) == 0 ||

sbin/fsck_lfs/pass6.c

666

lfs_dino_getinumber(fs, dp) == LFS_IFILE_INUM)

sbin/fsck_lfs/pass6.c

669

if (lfs_dino_getnlink(fs, dp) < 0

sbin/fsck_lfs/pass6.c

671

|| lfs_dino_getinumber(fs, dp) < 0

sbin/fsck_lfs/pass6.c

672

|| lfs_dino_getsize(fs, dp) < 0

sbin/fsck_lfs/pass6.c

682

vp = vget(fs, lfs_dino_getinumber(fs, dp));

sbin/fsck_lfs/pass6.c

689

if (lfs_dino_getnlink(fs, dp) == 0) {

sbin/fsck_lfs/pass6.c

690

remove_ino(vp, lfs_dino_getinumber(fs, dp));

sbin/fsck_lfs/pass6.c

701

if (!(lfs_ss_getflags(fs, sp) & SS_DIROP))

sbin/fsck_lfs/pass6.c

704

inums[j++] = lfs_dino_getinumber(fs, dp);

sbin/fsck_lfs/pass6.c

715

lfs_dino_getgen(fs, VTOI(vp)->i_din)

sbin/fsck_lfs/pass6.c

716

< lfs_dino_getgen(fs, dp)) {

sbin/fsck_lfs/pass6.c

717

remove_ino(vp, lfs_dino_getinumber(fs, dp));

sbin/fsck_lfs/pass6.c

718

if (!(lfs_ss_getflags(fs, sp) & SS_DIROP))

sbin/fsck_lfs/pass6.c

721

inums[j++] = lfs_dino_getinumber(fs, dp);

sbin/fsck_lfs/pass6.c

735

lfs_dino_getgen(fs, VTOI(vp)->i_din)

sbin/fsck_lfs/pass6.c

736

== lfs_dino_getgen(fs, dp)) {

sbin/fsck_lfs/pass6.c

741

lfs_dino_setmode(fs, VTOD(vp), lfs_dino_getmode(fs, dp));

sbin/fsck_lfs/pass6.c

742

lfs_dino_setnlink(fs, VTOD(vp), lfs_dino_getmode(fs, dp));

sbin/fsck_lfs/pass6.c

744

lfs_dino_setsize(fs, VTOD(vp), lfs_dino_getsize(fs, dp));

sbin/fsck_lfs/pass6.c

745

lfs_dino_setatime(fs, VTOD(vp), lfs_dino_getatime(fs, dp));

sbin/fsck_lfs/pass6.c

746

lfs_dino_setatimensec(fs, VTOD(vp), lfs_dino_getatimensec(fs, dp));

sbin/fsck_lfs/pass6.c

747

lfs_dino_setmtime(fs, VTOD(vp), lfs_dino_getmtime(fs, dp));

sbin/fsck_lfs/pass6.c

748

lfs_dino_setmtimensec(fs, VTOD(vp), lfs_dino_getmtimensec(fs, dp));

sbin/fsck_lfs/pass6.c

749

lfs_dino_setctime(fs, VTOD(vp), lfs_dino_getctime(fs, dp));

sbin/fsck_lfs/pass6.c

750

lfs_dino_setctimensec(fs, VTOD(vp), lfs_dino_getctimensec(fs, dp));

sbin/fsck_lfs/pass6.c

751

lfs_dino_setflags(fs, VTOD(vp), lfs_dino_getflags(fs, dp));

sbin/fsck_lfs/pass6.c

752

lfs_dino_setuid(fs, VTOD(vp), lfs_dino_getuid(fs, dp));

sbin/fsck_lfs/pass6.c

753

lfs_dino_setgid(fs, VTOD(vp), lfs_dino_getgid(fs, dp));

sbin/fsck_lfs/pass6.c

759

vp = lfs_raw_vget(fs, inums[j],

sbin/fsck_lfs/pass6.c

764

(int)inums[j], lfs_dino_getnlink(fs, VTOD(vp)));

sbin/fsck_lfs/pass6.c

767

lfs_dino_setdb(fs, VTOD(vp), k, 0);

sbin/fsck_lfs/pass6.c

770

lfs_dino_setib(fs, VTOD(vp), k, 0);

sbin/fsck_lfs/pass6.c

772

lfs_dino_setblocks(fs, VTOD(vp), 0);

sbin/fsck_lfs/pass6.c

780

bc = check_summary(fs, sp, daddr, debug, devvp, NULL);

sbin/fsck_lfs/pass6.c

783

(intmax_t)daddr, (uintmax_t)lfs_ss_getserial(fs, sp));

sbin/fsck_lfs/pass6.c

789

(intmax_t)daddr, (uintmax_t)lfs_ss_getserial(fs, sp));

sbin/fsck_lfs/pass6.c

790

lastserial = lfs_ss_getserial(fs, sp);

sbin/fsck_lfs/pass6.c

793

daddr += lfs_btofsb(fs, lfs_sb_getsumsize(fs) + bc);

sbin/fsck_lfs/pass6.c

794

if (lfs_dtosn(fs, odaddr) != lfs_dtosn(fs, daddr) ||

sbin/fsck_lfs/pass6.c

795

lfs_dtosn(fs, daddr) != lfs_dtosn(fs, daddr +

sbin/fsck_lfs/pass6.c

796

lfs_btofsb(fs, lfs_sb_getsumsize(fs) + lfs_sb_getbsize(fs)) - 1)) {

sbin/fsck_lfs/pass6.c

797

daddr = lfs_ss_getnext(fs, sp);

sbin/fsck_lfs/pass6.c

806

lfs_sb_setserial(fs, lastserial + 1);

sbin/fsck_lfs/pass6.c

830

daddr = lfs_sb_getoffset(fs);

sbin/fsck_lfs/pass6.c

832

if (!(seg_table[lfs_dtosn(fs, daddr)].su_flags & SEGUSE_DIRTY)) {

sbin/fsck_lfs/pass6.c

833

seg_table[lfs_dtosn(fs, daddr)].su_flags |= SEGUSE_DIRTY;

sbin/fsck_lfs/pass6.c

834

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), sbp);

sbin/fsck_lfs/pass6.c

840

if (lfs_sntod(fs, lfs_dtosn(fs, daddr)) == daddr) {

sbin/fsck_lfs/pass6.c

841

if (daddr == lfs_sb_gets0addr(fs))

sbin/fsck_lfs/pass6.c

842

daddr += lfs_btofsb(fs, LFS_LABELPAD);

sbin/fsck_lfs/pass6.c

844

if (daddr == lfs_sb_getsboff(fs, i)) {

sbin/fsck_lfs/pass6.c

845

daddr += lfs_btofsb(fs, LFS_SBPAD);

sbin/fsck_lfs/pass6.c

847

if (daddr < lfs_sb_getsboff(fs, i))

sbin/fsck_lfs/pass6.c

853

bread(devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getsumsize(fs), 0, &bp);

sbin/fsck_lfs/pass6.c

855

bc = check_summary(fs, sp, daddr, debug, devvp, pass6harvest);

sbin/fsck_lfs/pass6.c

858

(intmax_t)daddr, (uintmax_t)lfs_ss_getserial(fs, sp));

sbin/fsck_lfs/pass6.c

863

daddr += lfs_btofsb(fs, lfs_sb_getsumsize(fs) + bc);

sbin/fsck_lfs/pass6.c

864

lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs) + bc));

sbin/fsck_lfs/pass6.c

865

if (lfs_dtosn(fs, odaddr) != lfs_dtosn(fs, daddr) ||

sbin/fsck_lfs/pass6.c

866

lfs_dtosn(fs, daddr) != lfs_dtosn(fs, daddr +

sbin/fsck_lfs/pass6.c

867

lfs_btofsb(fs, lfs_sb_getsumsize(fs) + lfs_sb_getbsize(fs)) - 1)) {

sbin/fsck_lfs/pass6.c

868

lfs_sb_subavail(fs, lfs_sntod(fs, lfs_dtosn(fs, daddr) + 1) - daddr);

sbin/fsck_lfs/pass6.c

869

daddr = lfs_ss_getnext(fs, sp);

sbin/fsck_lfs/pass6.c

871

LFS_CLEANERINFO(cip, fs, cbp);

sbin/fsck_lfs/pass6.c

872

LFS_SYNC_CLEANERINFO(cip, fs, cbp, 0);

sbin/fsck_lfs/pass6.c

878

if (lfs_sntod(fs, lfs_dtosn(fs, lastgood)) == lastgood) {

sbin/fsck_lfs/pass6.c

879

if (lastgood == lfs_sb_gets0addr(fs))

sbin/fsck_lfs/pass6.c

880

lastgood += lfs_btofsb(fs, LFS_LABELPAD);

sbin/fsck_lfs/pass6.c

882

if (lastgood == lfs_sb_getsboff(fs, i))

sbin/fsck_lfs/pass6.c

883

lastgood += lfs_btofsb(fs, LFS_SBPAD);

sbin/fsck_lfs/pass6.c

884

if (lastgood < lfs_sb_getsboff(fs, i))

sbin/fsck_lfs/pass6.c

89

error = ulfs_bmaparray(fs, vp, lbn, &daddr, a, &num);

sbin/fsck_lfs/pass6.c

890

lfs_sb_setoffset(fs, lastgood);

sbin/fsck_lfs/pass6.c

891

lfs_sb_setcurseg(fs, lfs_sntod(fs, lfs_dtosn(fs, lastgood)));

sbin/fsck_lfs/pass6.c

892

for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs));;) {

sbin/fsck_lfs/pass6.c

893

sn = (sn + 1) % lfs_sb_getnseg(fs);

sbin/fsck_lfs/pass6.c

896

LFS_SEGENTRY(sup, fs, sn, bp);

sbin/fsck_lfs/pass6.c

904

lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));

sbin/fsck_lfs/pass6.c

94

daddr = LFS_DBTOFSB(fs, daddr);

sbin/fsck_lfs/pass6.c

96

frags = lfs_numfrags(fs, size);

sbin/fsck_lfs/pass6.c

99

ooff = lfs_dino_getdb(fs, ip->i_din, lbn);

sbin/fsck_lfs/segwrite.c

1003

lfs_writevnodes(struct lfs *fs, struct segment *sp, int op)

sbin/fsck_lfs/segwrite.c

1024

lfs_writefile(fs, sp, vp);

sbin/fsck_lfs/segwrite.c

1025

(void) lfs_writeinode(fs, sp, ip);

sbin/fsck_lfs/segwrite.c

1033

lfs_writesuper(struct lfs *fs, daddr_t daddr)

sbin/fsck_lfs/segwrite.c

1038

if (lfs_sb_getversion(fs) == 1)

sbin/fsck_lfs/segwrite.c

1039

lfs_sb_setotstamp(fs, write_time);

sbin/fsck_lfs/segwrite.c

1040

lfs_sb_settstamp(fs, write_time);

sbin/fsck_lfs/segwrite.c

1045

lfs_sb_setcksum(fs, lfs_sb_cksum(fs));

sbin/fsck_lfs/segwrite.c

1047

bp = getblk(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), LFS_SBPAD);

sbin/fsck_lfs/segwrite.c

1048

memcpy(bp->b_data, &fs->lfs_dlfs_u, sizeof(struct dlfs));

sbin/fsck_lfs/segwrite.c

111

lfs_match_data(struct lfs * fs, struct ubuf * bp)

sbin/fsck_lfs/segwrite.c

117

lfs_match_indir(struct lfs * fs, struct ubuf * bp)

sbin/fsck_lfs/segwrite.c

122

return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 0);

sbin/fsck_lfs/segwrite.c

126

lfs_match_dindir(struct lfs * fs, struct ubuf * bp)

sbin/fsck_lfs/segwrite.c

131

return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 1);

sbin/fsck_lfs/segwrite.c

135

lfs_match_tindir(struct lfs * fs, struct ubuf * bp)

sbin/fsck_lfs/segwrite.c

140

return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 2);

sbin/fsck_lfs/segwrite.c

147

lfs_segwrite(struct lfs * fs, int flags)

sbin/fsck_lfs/segwrite.c

155

lfs_seglock(fs, flags | SEGM_CKP);

sbin/fsck_lfs/segwrite.c

156

sp = fs->lfs_sp;

sbin/fsck_lfs/segwrite.c

158

lfs_writevnodes(fs, sp, VN_REG);

sbin/fsck_lfs/segwrite.c

159

lfs_writevnodes(fs, sp, VN_DIROP);

sbin/fsck_lfs/segwrite.c

161

lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) & ~(SS_CONT));

sbin/fsck_lfs/segwrite.c

164

vp = fs->lfs_ivnode;

sbin/fsck_lfs/segwrite.c

165

fs->lfs_flags &= ~LFS_IFDIRTY;

sbin/fsck_lfs/segwrite.c

167

if (LIST_FIRST(&vp->v_dirtyblkhd) != NULL || lfs_sb_getidaddr(fs) <= 0)

sbin/fsck_lfs/segwrite.c

168

lfs_writefile(fs, sp, vp);

sbin/fsck_lfs/segwrite.c

170

redo = lfs_writeinode(fs, sp, ip);

sbin/fsck_lfs/segwrite.c

171

redo += lfs_writeseg(fs, sp);

sbin/fsck_lfs/segwrite.c

172

redo += (fs->lfs_flags & LFS_IFDIRTY);

sbin/fsck_lfs/segwrite.c

175

lfs_segunlock(fs);

sbin/fsck_lfs/segwrite.c

178

written_bytes, (ulfs_daddr_t)lfs_btofsb(fs, written_bytes));

sbin/fsck_lfs/segwrite.c

180

written_data, (ulfs_daddr_t)lfs_btofsb(fs, written_data));

sbin/fsck_lfs/segwrite.c

182

written_indir, (ulfs_daddr_t)lfs_btofsb(fs, written_indir));

sbin/fsck_lfs/segwrite.c

184

written_dev, (ulfs_daddr_t)lfs_btofsb(fs, written_dev));

sbin/fsck_lfs/segwrite.c

186

written_inodes, lfs_btofsb(fs, written_inodes * fs->lfs_ibsize));

sbin/fsck_lfs/segwrite.c

195

lfs_writefile(struct lfs * fs, struct segment * sp, struct uvnode * vp)

sbin/fsck_lfs/segwrite.c

205

if (sp->seg_bytes_left < lfs_sb_getbsize(fs) ||

sbin/fsck_lfs/segwrite.c

206

sp->sum_bytes_left < FINFOSIZE(fs) + LFS_BLKPTRSIZE(fs))

sbin/fsck_lfs/segwrite.c

207

(void) lfs_writeseg(fs, sp);

sbin/fsck_lfs/segwrite.c

209

sp->sum_bytes_left -= FINFOSIZE(fs);

sbin/fsck_lfs/segwrite.c

211

lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) + 1);

sbin/fsck_lfs/segwrite.c

214

lfs_ss_setflags(fs, ssp,

sbin/fsck_lfs/segwrite.c

215

lfs_ss_getflags(fs, ssp) | (SS_DIROP | SS_CONT));

sbin/fsck_lfs/segwrite.c

219

lfs_fi_setnblocks(fs, fip, 0);

sbin/fsck_lfs/segwrite.c

220

lfs_fi_setino(fs, fip, ip->i_number);

sbin/fsck_lfs/segwrite.c

221

LFS_IENTRY(ifp, fs, lfs_fi_getino(fs, fip), bp);

sbin/fsck_lfs/segwrite.c

222

lfs_fi_setversion(fs, fip, lfs_if_getversion(fs, ifp));

sbin/fsck_lfs/segwrite.c

225

lfs_gather(fs, sp, vp, lfs_match_data);

sbin/fsck_lfs/segwrite.c

226

lfs_gather(fs, sp, vp, lfs_match_indir);

sbin/fsck_lfs/segwrite.c

227

lfs_gather(fs, sp, vp, lfs_match_dindir);

sbin/fsck_lfs/segwrite.c

228

lfs_gather(fs, sp, vp, lfs_match_tindir);

sbin/fsck_lfs/segwrite.c

231

if (lfs_fi_getnblocks(fs, fip) != 0) {

sbin/fsck_lfs/segwrite.c

232

sp->fip = NEXT_FINFO(fs, fip);

sbin/fsck_lfs/segwrite.c

233

lfs_blocks_fromfinfo(fs, &sp->start_lbp, sp->fip);

sbin/fsck_lfs/segwrite.c

236

sp->sum_bytes_left += FINFOSIZE(fs);

sbin/fsck_lfs/segwrite.c

237

lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) - 1);

sbin/fsck_lfs/segwrite.c

242

lfs_writeinode(struct lfs * fs, struct segment * sp, struct inode * ip)

sbin/fsck_lfs/segwrite.c

261

if (sp->seg_bytes_left < lfs_sb_getibsize(fs) ||

sbin/fsck_lfs/segwrite.c

262

sp->sum_bytes_left < LFS_BLKPTRSIZE(fs))

sbin/fsck_lfs/segwrite.c

263

(void) lfs_writeseg(fs, sp);

sbin/fsck_lfs/segwrite.c

266

daddr = lfs_sb_getoffset(fs);

sbin/fsck_lfs/segwrite.c

267

lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));

sbin/fsck_lfs/segwrite.c

269

getblk(fs->lfs_devvp, LFS_FSBTODB(fs, daddr),

sbin/fsck_lfs/segwrite.c

270

lfs_sb_getibsize(fs));

sbin/fsck_lfs/segwrite.c

275

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

sbin/fsck_lfs/segwrite.c

278

tmpdip = DINO_IN_BLOCK(fs, sp->ibp->b_data, i);

sbin/fsck_lfs/segwrite.c

279

lfs_dino_setinumber(fs, tmpdip, 0);

sbin/fsck_lfs/segwrite.c

283

lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));

sbin/fsck_lfs/segwrite.c

285

sp->seg_bytes_left -= lfs_sb_getibsize(fs);

sbin/fsck_lfs/segwrite.c

286

sp->sum_bytes_left -= LFS_BLKPTRSIZE(fs);

sbin/fsck_lfs/segwrite.c

289

iip = NTH_IINFO(fs, sp->segsum, sp->ninodes / LFS_INOPB(fs));

sbin/fsck_lfs/segwrite.c

290

lfs_ii_setblock(fs, iip, daddr);

sbin/fsck_lfs/segwrite.c

308

lfs_copy_dinode(fs, sp->idp, ip->i_din);

sbin/fsck_lfs/segwrite.c

309

ip->i_lfs_osize = lfs_dino_getsize(fs, ip->i_din);

sbin/fsck_lfs/segwrite.c

313

cdp = DINO_IN_BLOCK(fs, bp->b_data, sp->ninodes % LFS_INOPB(fs));

sbin/fsck_lfs/segwrite.c

314

lfs_copy_dinode(fs, cdp, ip->i_din);

sbin/fsck_lfs/segwrite.c

317

ip->i_lfs_osize = lfs_dino_getsize(fs, ip->i_din);

sbin/fsck_lfs/segwrite.c

320

sp->idp = DINO_IN_BLOCK(fs, bp->b_data, sp->ninodes % LFS_INOPB(fs));

sbin/fsck_lfs/segwrite.c

328

lfs_ss_setninos(fs, ssp, lfs_ss_getninos(fs, ssp) + 1);

sbin/fsck_lfs/segwrite.c

331

if (++sp->ninodes % LFS_INOPB(fs) == 0)

sbin/fsck_lfs/segwrite.c

340

daddr = lfs_sb_getidaddr(fs);

sbin/fsck_lfs/segwrite.c

341

lfs_sb_setidaddr(fs, LFS_DBTOFSB(fs, bp->b_blkno));

sbin/fsck_lfs/segwrite.c

344

LFS_IENTRY(ifp, fs, ino, ibp);

sbin/fsck_lfs/segwrite.c

345

daddr = lfs_if_getdaddr(fs, ifp);

sbin/fsck_lfs/segwrite.c

346

lfs_if_setdaddr(fs, ifp, LFS_DBTOFSB(fs, bp->b_blkno) + fsb);

sbin/fsck_lfs/segwrite.c

356

u_int32_t oldsn = lfs_dtosn(fs, daddr);

sbin/fsck_lfs/segwrite.c

357

LFS_SEGENTRY(sup, fs, oldsn, bp);

sbin/fsck_lfs/segwrite.c

358

sup->su_nbytes -= DINOSIZE(fs);

sbin/fsck_lfs/segwrite.c

362

fs->lfs_flags |= LFS_IFDIRTY;

sbin/fsck_lfs/segwrite.c

363

LFS_WRITESEGENTRY(sup, fs, oldsn, bp); /* Ifile */

sbin/fsck_lfs/segwrite.c

371

struct lfs *fs;

sbin/fsck_lfs/segwrite.c

380

fs = sp->fs;

sbin/fsck_lfs/segwrite.c

381

blksinblk = howmany(bp->b_bcount, lfs_sb_getbsize(fs));

sbin/fsck_lfs/segwrite.c

382

if (sp->sum_bytes_left < LFS_BLKPTRSIZE(fs) * blksinblk ||

sbin/fsck_lfs/segwrite.c

386

version = lfs_fi_getversion(fs, sp->fip);

sbin/fsck_lfs/segwrite.c

387

(void) lfs_writeseg(fs, sp);

sbin/fsck_lfs/segwrite.c

389

lfs_fi_setversion(fs, sp->fip, version);

sbin/fsck_lfs/segwrite.c

390

lfs_fi_setino(fs, sp->fip, VTOI(sp->vp)->i_number);

sbin/fsck_lfs/segwrite.c

393

lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) + 1);

sbin/fsck_lfs/segwrite.c

394

sp->sum_bytes_left -= FINFOSIZE(fs);

sbin/fsck_lfs/segwrite.c

406

bn = lfs_fi_getnblocks(fs, sp->fip);

sbin/fsck_lfs/segwrite.c

407

lfs_fi_setnblocks(fs, sp->fip, bn + 1);

sbin/fsck_lfs/segwrite.c

408

lfs_fi_setblock(fs, sp->fip, bn, bp->b_lblkno + j);

sbin/fsck_lfs/segwrite.c

411

sp->sum_bytes_left -= LFS_BLKPTRSIZE(fs) * blksinblk;

sbin/fsck_lfs/segwrite.c

417

lfs_gather(struct lfs * fs, struct segment * sp, struct uvnode * vp, int (*match) (struct lfs *, struct ubuf *))

sbin/fsck_lfs/segwrite.c

428

if ((bp->b_flags & (B_BUSY | B_GATHERED)) || !match(fs, bp)) {

sbin/fsck_lfs/segwrite.c

450

lfs_update_single(struct lfs * fs, struct segment * sp, daddr_t lbn,

sbin/fsck_lfs/segwrite.c

466

error = ulfs_bmaparray(fs, vp, lbn, &daddr, a, &num);

sbin/fsck_lfs/segwrite.c

471

daddr = LFS_DBTOFSB(fs, daddr);

sbin/fsck_lfs/segwrite.c

473

frags = lfs_numfrags(fs, size);

sbin/fsck_lfs/segwrite.c

476

ooff = lfs_dino_getdb(fs, ip->i_din, lbn);

sbin/fsck_lfs/segwrite.c

478

lfs_dino_setblocks(fs, ip->i_din,

sbin/fsck_lfs/segwrite.c

479

lfs_dino_getblocks(fs, ip->i_din) + frags);

sbin/fsck_lfs/segwrite.c

482

ofrags = lfs_btofsb(fs, ip->i_lfs_fragsize[lbn]);

sbin/fsck_lfs/segwrite.c

483

lfs_dino_setblocks(fs, ip->i_din,

sbin/fsck_lfs/segwrite.c

484

lfs_dino_getblocks(fs, ip->i_din) + (frags - ofrags));

sbin/fsck_lfs/segwrite.c

486

lfs_dino_setdb(fs, ip->i_din, lbn, ndaddr);

sbin/fsck_lfs/segwrite.c

489

ooff = lfs_dino_getib(fs, ip->i_din, a[0].in_off);

sbin/fsck_lfs/segwrite.c

491

lfs_dino_setblocks(fs, ip->i_din,

sbin/fsck_lfs/segwrite.c

492

lfs_dino_getblocks(fs, ip->i_din) + frags);

sbin/fsck_lfs/segwrite.c

493

lfs_dino_setib(fs, ip->i_din, a[0].in_off, ndaddr);

sbin/fsck_lfs/segwrite.c

497

if (bread(vp, ap->in_lbn, lfs_sb_getbsize(fs), 0, &bp))

sbin/fsck_lfs/segwrite.c

501

ooff = lfs_iblock_get(fs, bp->b_data, ap->in_off);

sbin/fsck_lfs/segwrite.c

503

lfs_dino_setblocks(fs, ip->i_din,

sbin/fsck_lfs/segwrite.c

504

lfs_dino_getblocks(fs, ip->i_din) + frags);

sbin/fsck_lfs/segwrite.c

505

lfs_iblock_set(fs, bp->b_data, ap->in_off, ndaddr);

sbin/fsck_lfs/segwrite.c

514

u_int32_t oldsn = lfs_dtosn(fs, daddr);

sbin/fsck_lfs/segwrite.c

518

osize = lfs_sb_getbsize(fs);

sbin/fsck_lfs/segwrite.c

519

LFS_SEGENTRY(sup, fs, oldsn, bp);

sbin/fsck_lfs/segwrite.c

522

fs->lfs_flags |= LFS_IFDIRTY;

sbin/fsck_lfs/segwrite.c

523

LFS_WRITESEGENTRY(sup, fs, oldsn, bp);

sbin/fsck_lfs/segwrite.c

542

struct lfs *fs;

sbin/fsck_lfs/segwrite.c

550

fs = sp->fs;

sbin/fsck_lfs/segwrite.c

560

lfs_blocks_fromvoid(fs, &tmpptr, (void *)NEXT_FINFO(fs, sp->fip));

sbin/fsck_lfs/segwrite.c

561

nblocks = lfs_blocks_sub(fs, &tmpptr, &sp->start_lbp);

sbin/fsck_lfs/segwrite.c

578

num = howmany(sp->start_bpp[i]->b_bcount, lfs_sb_getbsize(fs));

sbin/fsck_lfs/segwrite.c

585

lfs_shellsort(fs, sp->start_bpp, &sp->start_lbp, nblocks, lfs_sb_getbsize(fs));

sbin/fsck_lfs/segwrite.c

593

lfs_fi_setlastlength(fs, sp->fip, ((sp->start_bpp[nblocks - 1]->b_bcount - 1) &

sbin/fsck_lfs/segwrite.c

594

lfs_sb_getbmask(fs)) + 1);

sbin/fsck_lfs/segwrite.c

602

lbn = lfs_blocks_get(fs, &sp->start_lbp, 0);

sbin/fsck_lfs/segwrite.c

604

sbp->b_blkno = LFS_FSBTODB(fs, lfs_sb_getoffset(fs));

sbin/fsck_lfs/segwrite.c

613

if ((sbp->b_bcount & lfs_sb_getbmask(fs)) && i != 0)

sbin/fsck_lfs/segwrite.c

621

bytesleft -= lfs_sb_getbsize(fs)) {

sbin/fsck_lfs/segwrite.c

622

size = MIN(bytesleft, lfs_sb_getbsize(fs));

sbin/fsck_lfs/segwrite.c

623

frags = lfs_numfrags(fs, size);

sbin/fsck_lfs/segwrite.c

624

lbn = lfs_blocks_get(fs, &sp->start_lbp, 0);

sbin/fsck_lfs/segwrite.c

625

lfs_blocks_inc(fs, &sp->start_lbp);

sbin/fsck_lfs/segwrite.c

626

lfs_update_single(fs, sp, lbn, lfs_sb_getoffset(fs), size);

sbin/fsck_lfs/segwrite.c

627

lfs_sb_addoffset(fs, frags);

sbin/fsck_lfs/segwrite.c

637

lfs_initseg(struct lfs * fs)

sbin/fsck_lfs/segwrite.c

645

sp = fs->lfs_sp;

sbin/fsck_lfs/segwrite.c

650

if (!LFS_PARTIAL_FITS(fs)) {

sbin/fsck_lfs/segwrite.c

652

lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) -

sbin/fsck_lfs/segwrite.c

653

lfs_sb_getcurseg(fs)));

sbin/fsck_lfs/segwrite.c

654

lfs_newseg(fs);

sbin/fsck_lfs/segwrite.c

656

lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));

sbin/fsck_lfs/segwrite.c

658

sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));

sbin/fsck_lfs/segwrite.c

659

sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs));

sbin/fsck_lfs/segwrite.c

665

LFS_SEGENTRY(sup, fs, sp->seg_number, bp);

sbin/fsck_lfs/segwrite.c

667

lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_SBPAD));

sbin/fsck_lfs/segwrite.c

672

if (lfs_sb_getversion(fs) > 1 && sp->seg_number == 0 &&

sbin/fsck_lfs/segwrite.c

673

lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD)) {

sbin/fsck_lfs/segwrite.c

674

lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_LABELPAD) - lfs_sb_gets0addr(fs));

sbin/fsck_lfs/segwrite.c

675

sp->seg_bytes_left -= LFS_LABELPAD - lfs_fsbtob(fs, lfs_sb_gets0addr(fs));

sbin/fsck_lfs/segwrite.c

678

sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));

sbin/fsck_lfs/segwrite.c

679

sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs) -

sbin/fsck_lfs/segwrite.c

680

(lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));

sbin/fsck_lfs/segwrite.c

682

lfs_sb_setlastpseg(fs, lfs_sb_getoffset(fs));

sbin/fsck_lfs/segwrite.c

684

sp->fs = fs;

sbin/fsck_lfs/segwrite.c

691

sbp = *sp->cbpp = getblk(fs->lfs_devvp,

sbin/fsck_lfs/segwrite.c

692

LFS_FSBTODB(fs, lfs_sb_getoffset(fs)), lfs_sb_getsumsize(fs));

sbin/fsck_lfs/segwrite.c

694

memset(sp->segsum, 0, lfs_sb_getsumsize(fs));

sbin/fsck_lfs/segwrite.c

696

lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));

sbin/fsck_lfs/segwrite.c

700

lfs_ss_setnext(fs, ssp, lfs_sb_getnextseg(fs));

sbin/fsck_lfs/segwrite.c

701

lfs_ss_setnfinfo(fs, ssp, 0);

sbin/fsck_lfs/segwrite.c

702

lfs_ss_setninos(fs, ssp, 0);

sbin/fsck_lfs/segwrite.c

703

lfs_ss_setmagic(fs, ssp, SS_MAGIC);

sbin/fsck_lfs/segwrite.c

706

sp->fip = SEGSUM_FINFOBASE(fs, ssp);

sbin/fsck_lfs/segwrite.c

707

lfs_fi_setnblocks(fs, sp->fip, 0);

sbin/fsck_lfs/segwrite.c

708

lfs_blocks_fromfinfo(fs, &sp->start_lbp, sp->fip);

sbin/fsck_lfs/segwrite.c

709

lfs_fi_setlastlength(fs, sp->fip, 0);

sbin/fsck_lfs/segwrite.c

711

sp->seg_bytes_left -= lfs_sb_getsumsize(fs);

sbin/fsck_lfs/segwrite.c

712

sp->sum_bytes_left = lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs);

sbin/fsck_lfs/segwrite.c

723

lfs_newseg(struct lfs * fs)

sbin/fsck_lfs/segwrite.c

730

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);

sbin/fsck_lfs/segwrite.c

735

LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);

sbin/fsck_lfs/segwrite.c

737

LFS_CLEANERINFO(cip, fs, bp);

sbin/fsck_lfs/segwrite.c

738

lfs_ci_shiftcleantodirty(fs, cip, 1);

sbin/fsck_lfs/segwrite.c

739

lfs_sb_setnclean(fs, lfs_ci_getclean(fs, cip));

sbin/fsck_lfs/segwrite.c

740

LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);

sbin/fsck_lfs/segwrite.c

742

lfs_sb_setlastseg(fs, lfs_sb_getcurseg(fs));

sbin/fsck_lfs/segwrite.c

743

lfs_sb_setcurseg(fs, lfs_sb_getnextseg(fs));

sbin/fsck_lfs/segwrite.c

744

for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + lfs_sb_getinterleave(fs);;) {

sbin/fsck_lfs/segwrite.c

745

sn = (sn + 1) % lfs_sb_getnseg(fs);

sbin/fsck_lfs/segwrite.c

748

LFS_SEGENTRY(sup, fs, sn, bp);

sbin/fsck_lfs/segwrite.c

756

++fs->lfs_nactive;

sbin/fsck_lfs/segwrite.c

757

lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));

sbin/fsck_lfs/segwrite.c

762

lfs_writeseg(struct lfs * fs, struct segment * sp)

sbin/fsck_lfs/segwrite.c

783

nblocks, (int)LFS_DBTOFSB(fs, (*sp->bpp)->b_blkno));

sbin/fsck_lfs/segwrite.c

788

devvp = fs->lfs_devvp;

sbin/fsck_lfs/segwrite.c

791

LFS_SEGENTRY(sup, fs, sp->seg_number, bp);

sbin/fsck_lfs/segwrite.c

799

assert(lfs_dtosn(fs, LFS_DBTOFSB(fs, (*bpp)->b_blkno)) == sp->seg_number);

sbin/fsck_lfs/segwrite.c

803

lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_RFW);

sbin/fsck_lfs/segwrite.c

805

ninos = (lfs_ss_getninos(fs, ssp) + LFS_INOPB(fs) - 1) / LFS_INOPB(fs);

sbin/fsck_lfs/segwrite.c

806

sup->su_nbytes += lfs_ss_getninos(fs, ssp) * DINOSIZE(fs);

sbin/fsck_lfs/segwrite.c

808

if (lfs_sb_getversion(fs) == 1)

sbin/fsck_lfs/segwrite.c

814

lfs_sb_adddmeta(fs, (lfs_btofsb(fs, lfs_sb_getsumsize(fs)) + lfs_btofsb(fs, ninos *

sbin/fsck_lfs/segwrite.c

815

lfs_sb_getibsize(fs))));

sbin/fsck_lfs/segwrite.c

816

lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));

sbin/fsck_lfs/segwrite.c

819

LFS_WRITESEGENTRY(sup, fs, sp->seg_number, bp); /* Ifile */

sbin/fsck_lfs/segwrite.c

826

if (lfs_sb_getversion(fs) == 1)

sbin/fsck_lfs/segwrite.c

835

byteoffset += lfs_sb_getbsize(fs)) {

sbin/fsck_lfs/segwrite.c

842

if (lfs_sb_getversion(fs) == 1)

sbin/fsck_lfs/segwrite.c

843

lfs_ss_setocreate(fs, ssp, write_time);

sbin/fsck_lfs/segwrite.c

845

lfs_ss_setcreate(fs, ssp, write_time);

sbin/fsck_lfs/segwrite.c

846

lfs_sb_addserial(fs, 1);

sbin/fsck_lfs/segwrite.c

847

lfs_ss_setserial(fs, ssp, lfs_sb_getserial(fs));

sbin/fsck_lfs/segwrite.c

848

lfs_ss_setident(fs, ssp, lfs_sb_getident(fs));

sbin/fsck_lfs/segwrite.c

854

lfs_ss_setdatasum(fs, ssp, cksum(datap, (nblocks - 1) * el_size));

sbin/fsck_lfs/segwrite.c

855

sumstart = lfs_ss_getsumstart(fs);

sbin/fsck_lfs/segwrite.c

856

lfs_ss_setsumsum(fs, ssp,

sbin/fsck_lfs/segwrite.c

857

cksum((char *)ssp + sumstart, lfs_sb_getsumsize(fs) - sumstart));

sbin/fsck_lfs/segwrite.c

860

lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +

sbin/fsck_lfs/segwrite.c

861

lfs_btofsb(fs, lfs_sb_getsumsize(fs))));

sbin/fsck_lfs/segwrite.c

871

if (bp->b_vp != fs->lfs_devvp)

sbin/fsck_lfs/segwrite.c

875

if (bp->b_vp == fs->lfs_devvp)

sbin/fsck_lfs/segwrite.c

890

return (lfs_initseg(fs) || do_again);

sbin/fsck_lfs/segwrite.c

897

lfs_shellsort(struct lfs *fs,

sbin/fsck_lfs/segwrite.c

920

lfs_blocks_set(fs, lb_array, incr++,

sbin/fsck_lfs/segwrite.c

932

lfs_seglock(struct lfs * fs, unsigned long flags)

sbin/fsck_lfs/segwrite.c

937

if (fs->lfs_seglock) {

sbin/fsck_lfs/segwrite.c

938

++fs->lfs_seglock;

sbin/fsck_lfs/segwrite.c

939

fs->lfs_sp->seg_flags |= flags;

sbin/fsck_lfs/segwrite.c

942

fs->lfs_seglock = 1;

sbin/fsck_lfs/segwrite.c

944

sp = fs->lfs_sp = emalloc(sizeof(*sp));

sbin/fsck_lfs/segwrite.c

945

allocsize = lfs_sb_getssize(fs) * sizeof(struct ubuf *);

sbin/fsck_lfs/segwrite.c

952

(void) lfs_initseg(fs);

sbin/fsck_lfs/segwrite.c

962

lfs_segunlock(struct lfs * fs)

sbin/fsck_lfs/segwrite.c

967

sp = fs->lfs_sp;

sbin/fsck_lfs/segwrite.c

969

if (fs->lfs_seglock == 1) {

sbin/fsck_lfs/segwrite.c

972

lfs_sb_suboffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));

sbin/fsck_lfs/segwrite.c

986

fs->lfs_sp = NULL;

sbin/fsck_lfs/segwrite.c

988

fs->lfs_nactive = 0;

sbin/fsck_lfs/segwrite.c

991

lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));

sbin/fsck_lfs/segwrite.c

992

lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));

sbin/fsck_lfs/segwrite.c

994

--fs->lfs_seglock;

sbin/fsck_lfs/segwrite.c

995

} else if (fs->lfs_seglock == 0) {

sbin/fsck_lfs/segwrite.c

998

--fs->lfs_seglock;

sbin/fsck_lfs/segwrite.h

34

#define LFS_PARTIAL_FITS(fs) \

sbin/fsck_lfs/segwrite.h

35

(lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)) > \

sbin/fsck_lfs/segwrite.h

36

lfs_sb_getfrag(fs))

sbin/fsck_lfs/setup.c

124

nptr = (1 << bshift) / LFS_BLKPTRSIZE(fs);

sbin/fsck_lfs/setup.c

211

fs = lfs_init(fsreadfd, bflag, idaddr, 0, debug);

sbin/fsck_lfs/setup.c

212

if (fs == NULL) {

sbin/fsck_lfs/setup.c

219

bufrehash((lfs_sb_getsegtabsz(fs) + maxino / lfs_sb_getifpb(fs)) << 4);

sbin/fsck_lfs/setup.c

221

if (lfs_sb_getpflags(fs) & LFS_PF_CLEAN) {

sbin/fsck_lfs/setup.c

241

tdaddr = lfs_sntod(fs, lfs_dtosn(fs, idaddr));

sbin/fsck_lfs/setup.c

242

if (lfs_sntod(fs, lfs_dtosn(fs, tdaddr)) == tdaddr) {

sbin/fsck_lfs/setup.c

243

if (tdaddr == lfs_sb_gets0addr(fs))

sbin/fsck_lfs/setup.c

244

tdaddr += lfs_btofsb(fs, LFS_LABELPAD);

sbin/fsck_lfs/setup.c

246

if (lfs_sb_getsboff(fs, i) == tdaddr)

sbin/fsck_lfs/setup.c

247

tdaddr += lfs_btofsb(fs, LFS_SBPAD);

sbin/fsck_lfs/setup.c

248

if (lfs_sb_getsboff(fs, i) > tdaddr)

sbin/fsck_lfs/setup.c

252

lfs_sb_setoffset(fs, tdaddr);

sbin/fsck_lfs/setup.c

255

(uintmax_t)lfs_sb_getoffset(fs),

sbin/fsck_lfs/setup.c

256

(intmax_t)lfs_sb_getserial(fs));

sbin/fsck_lfs/setup.c

258

bread(fs->lfs_devvp, LFS_FSBTODB(fs, tdaddr),

sbin/fsck_lfs/setup.c

259

lfs_sb_getsumsize(fs),

sbin/fsck_lfs/setup.c

262

sumstart = lfs_ss_getsumstart(fs);

sbin/fsck_lfs/setup.c

263

if (lfs_ss_getsumsum(fs, sp) !=

sbin/fsck_lfs/setup.c

265

lfs_sb_getsumsize(fs) - sumstart)) {

sbin/fsck_lfs/setup.c

272

fp = SEGSUM_FINFOBASE(fs, sp);

sbin/fsck_lfs/setup.c

273

bc = howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)) <<

sbin/fsck_lfs/setup.c

274

(lfs_sb_getversion(fs) > 1 ? lfs_sb_getffshift(fs) :

sbin/fsck_lfs/setup.c

275

lfs_sb_getbshift(fs));

sbin/fsck_lfs/setup.c

276

for (i = 0; i < lfs_ss_getnfinfo(fs, sp); i++) {

sbin/fsck_lfs/setup.c

277

bc += lfs_fi_getlastlength(fs, fp) + ((lfs_fi_getnblocks(fs, fp) - 1)

sbin/fsck_lfs/setup.c

278

<< lfs_sb_getbshift(fs));

sbin/fsck_lfs/setup.c

279

fp = NEXT_FINFO(fs, fp);

sbin/fsck_lfs/setup.c

282

tdaddr += lfs_btofsb(fs, bc) + 1;

sbin/fsck_lfs/setup.c

283

lfs_sb_setoffset(fs, tdaddr);

sbin/fsck_lfs/setup.c

284

lfs_sb_setserial(fs, lfs_ss_getserial(fs, sp) + 1);

sbin/fsck_lfs/setup.c

292

curseg = lfs_dtosn(fs, lfs_sb_getoffset(fs));

sbin/fsck_lfs/setup.c

293

lfs_sb_setcurseg(fs, lfs_sntod(fs, curseg));

sbin/fsck_lfs/setup.c

294

for (sn = curseg + lfs_sb_getinterleave(fs);;) {

sbin/fsck_lfs/setup.c

295

sn = (sn + 1) % lfs_sb_getnseg(fs);

sbin/fsck_lfs/setup.c

298

LFS_SEGENTRY(sup, fs, sn, bp);

sbin/fsck_lfs/setup.c

308

if (lfs_sb_getoffset(fs) == lfs_sb_getsboff(fs, i))

sbin/fsck_lfs/setup.c

309

lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_SBPAD));

sbin/fsck_lfs/setup.c

311

++fs->lfs_nactive;

sbin/fsck_lfs/setup.c

312

lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));

sbin/fsck_lfs/setup.c

315

lfs_sb_getoffset(fs), lfs_sb_getserial(fs));

sbin/fsck_lfs/setup.c

317

lfs_sb_getcurseg(fs), lfs_sb_getnextseg(fs));

sbin/fsck_lfs/setup.c

321

lfs_sb_setidaddr(fs, idaddr);

sbin/fsck_lfs/setup.c

329

(uintmax_t)lfs_sb_getidaddr(fs));

sbin/fsck_lfs/setup.c

331

pwarn("lfs_bsize = %lu\n", (unsigned long) lfs_sb_getbsize(fs));

sbin/fsck_lfs/setup.c

332

pwarn("lfs_fsize = %lu\n", (unsigned long) lfs_sb_getfsize(fs));

sbin/fsck_lfs/setup.c

333

pwarn("lfs_frag = %lu\n", (unsigned long) lfs_sb_getfrag(fs));

sbin/fsck_lfs/setup.c

334

pwarn("lfs_inopb = %lu\n", (unsigned long) lfs_sb_getinopb(fs));

sbin/fsck_lfs/setup.c

336

if (lfs_sb_getversion(fs) == 1)

sbin/fsck_lfs/setup.c

337

maxfsblock = lfs_blkstofrags(fs, lfs_sb_getsize(fs));

sbin/fsck_lfs/setup.c

339

maxfsblock = lfs_sb_getsize(fs);

sbin/fsck_lfs/setup.c

340

maxfilesize = calcmaxfilesize(lfs_sb_getbshift(fs));

sbin/fsck_lfs/setup.c

341

if (/* lfs_sb_getminfree(fs) < 0 || */ lfs_sb_getminfree(fs) > 99) {

sbin/fsck_lfs/setup.c

343

lfs_sb_getminfree(fs));

sbin/fsck_lfs/setup.c

345

lfs_sb_setminfree(fs, 10);

sbin/fsck_lfs/setup.c

349

if (lfs_sb_getbmask(fs) != lfs_sb_getbsize(fs) - 1) {

sbin/fsck_lfs/setup.c

351

(uintmax_t)lfs_sb_getbmask(fs),

sbin/fsck_lfs/setup.c

352

lfs_sb_getbsize(fs) - 1);

sbin/fsck_lfs/setup.c

353

lfs_sb_setbmask(fs, lfs_sb_getbsize(fs) - 1);

sbin/fsck_lfs/setup.c

360

if (lfs_sb_getffmask(fs) != lfs_sb_getfsize(fs) - 1) {

sbin/fsck_lfs/setup.c

362

(uintmax_t)lfs_sb_getffmask(fs),

sbin/fsck_lfs/setup.c

363

lfs_sb_getfsize(fs) - 1);

sbin/fsck_lfs/setup.c

364

lfs_sb_setffmask(fs, lfs_sb_getfsize(fs) - 1);

sbin/fsck_lfs/setup.c

371

if (lfs_sb_getfbmask(fs) != (1U << lfs_sb_getfbshift(fs)) - 1) {

sbin/fsck_lfs/setup.c

373

(uintmax_t)lfs_sb_getfbmask(fs),

sbin/fsck_lfs/setup.c

374

(1U << lfs_sb_getfbshift(fs)) - 1);

sbin/fsck_lfs/setup.c

375

lfs_sb_setfbmask(fs, (1U << lfs_sb_getfbshift(fs)) - 1);

sbin/fsck_lfs/setup.c

382

if (lfs_sb_getmaxfilesize(fs) != maxfilesize) {

sbin/fsck_lfs/setup.c

385

(uintmax_t) lfs_sb_getmaxfilesize(fs),

sbin/fsck_lfs/setup.c

386

(uintmax_t) maxfilesize, lfs_sb_getbshift(fs));

sbin/fsck_lfs/setup.c

390

lfs_sb_setmaxfilesize(fs, maxfilesize);

sbin/fsck_lfs/setup.c

394

if (lfs_sb_getmaxsymlinklen(fs) != LFS_MAXSYMLINKLEN(fs)) {

sbin/fsck_lfs/setup.c

396

lfs_sb_getmaxsymlinklen(fs), LFS_MAXSYMLINKLEN(fs));

sbin/fsck_lfs/setup.c

397

lfs_sb_setmaxsymlinklen(fs, LFS_MAXSYMLINKLEN(fs));

sbin/fsck_lfs/setup.c

412

ivp = fs->lfs_ivnode;

sbin/fsck_lfs/setup.c

413

maxino = ((lfs_dino_getsize(fs, VTOI(ivp)->i_din) - (lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs))

sbin/fsck_lfs/setup.c

414

* lfs_sb_getbsize(fs)) / lfs_sb_getbsize(fs)) * lfs_sb_getifpb(fs);

sbin/fsck_lfs/setup.c

417

for (i = 0; i < lfs_dino_getsize(fs, VTOI(ivp)->i_din); i += lfs_sb_getbsize(fs)) {

sbin/fsck_lfs/setup.c

418

bread(ivp, i >> lfs_sb_getbshift(fs), lfs_sb_getbsize(fs), 0, &bp);

sbin/fsck_lfs/setup.c

427

seg_table = ecalloc(lfs_sb_getnseg(fs), sizeof(SEGUSE));

sbin/fsck_lfs/setup.c

429

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

sbin/fsck_lfs/setup.c

430

LFS_SEGENTRY(sup, fs, i, bp);

sbin/fsck_lfs/setup.c

438

din_table[LFS_IFILE_INUM] = lfs_sb_getidaddr(fs);

sbin/fsck_lfs/setup.c

439

seg_table[lfs_dtosn(fs, lfs_sb_getidaddr(fs))].su_nbytes += DINOSIZE(fs);

sbin/fsck_lfs/setup.c

452

n_files = lfs_sb_getnfiles(fs);

sbin/fsck_lfs/setup.c

453

n_blks = lfs_sb_getdsize(fs) - lfs_sb_getbfree(fs);

sbin/fsck_lfs/utilities.c

123

(uintmax_t)lfs_sb_getidaddr(fs));

sbin/fsck_lfs/utilities.c

124

lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));

sbin/fsck_lfs/utilities.c

125

lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));

sbin/fsck_lfs/utilities.c

136

lfs_segwrite(fs, SEGM_CKP);

sbin/fsck_lfs/utilities.c

142

if (!nflag && (lfs_sb_getpflags(fs) & LFS_PF_CLEAN) == 0) {

sbin/fsck_lfs/utilities.c

143

lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) | LFS_PF_CLEAN);

sbin/fsck_lfs/utilities.c

160

lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) | LFS_PF_CLEAN);

sbin/fsck_lfs/utilities.c

66

switch (lfs_dino_getmode(fs, dp) & LFS_IFMT) {

sbin/fsck_lfs/utilities.c

79

pwarn("bad file type 0%o\n", lfs_dino_getmode(fs, dp));

sbin/fsck_lfs/vars.c

44

struct lfs *fs;

sbin/fsck_lfs/vnode.c

103

register_vget(void *fs, struct uvnode *func(void *, ino_t))

sbin/fsck_lfs/vnode.c

108

vgr->vgr_fs = fs;

sbin/fsck_lfs/vnode.c

114

VFS_VGET(void *fs, ino_t ino)

sbin/fsck_lfs/vnode.c

119

if (vgr->vgr_fs == fs)

sbin/fsck_lfs/vnode.c

120

return vgr->vgr_func(fs, ino);

sbin/fsck_lfs/vnode.c

158

vget(void *fs, ino_t ino)

sbin/fsck_lfs/vnode.c

165

hash = ((unsigned long)fs + ino) & (VNODE_HASH_MAX - 1);

sbin/fsck_lfs/vnode.c

167

if (vp->v_fs != fs)

sbin/fsck_lfs/vnode.c

189

return VFS_VGET(fs, ino);

sbin/fsck_msdos/fat.c

102

if ((size_t)read(fs, *buffer, boot->FATsecs * boot->BytesPerSec)

sbin/fsck_msdos/fat.c

119

readfat(int fs, struct bootblock *boot, u_int no, struct fatEntry **fp)

sbin/fsck_msdos/fat.c

129

if (!_readfat(fs, boot, no, &buffer))

sbin/fsck_msdos/fat.c

477

writefat(int fs, struct bootblock *boot, struct fatEntry *fat, int correct_fat)

sbin/fsck_msdos/fat.c

527

if (!_readfat(fs, boot, boot->ValidFat >= 0 ? boot->ValidFat :0,

sbin/fsck_msdos/fat.c

573

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

sbin/fsck_msdos/fat.c

574

|| (size_t)write(fs, buffer, fatsz) != fatsz) {

sbin/fsck_msdos/fat.c

83

_readfat(int fs, struct bootblock *boot, u_int no, u_char **buffer)

sbin/fsck_msdos/fat.c

97

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

sbin/fsck_v7fs/datablock.c

103

if ((ret = v7fs_datablock_foreach(fs, p, datablock_subr, ctx)) ==

sbin/fsck_v7fs/datablock.c

111

datablock_vs_freeblock_check(struct v7fs_self *fs)

sbin/fsck_v7fs/datablock.c

113

struct v7fs_superblock *sb = &fs->superblock;

sbin/fsck_v7fs/datablock.c

121

if ((ret = v7fs_ilist_foreach(fs, inode_subr, &(struct loop_context)

sbin/fsck_v7fs/datablock.c

133

datablock_i_j(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz

sbin/fsck_v7fs/datablock.c

142

arg->i, filename(fs, arg->i),

sbin/fsck_v7fs/datablock.c

143

arg->j, filename(fs, arg->j), blk);

sbin/fsck_v7fs/datablock.c

145

datablock_dup_remove(fs, arg->i, arg->j, blk);

sbin/fsck_v7fs/datablock.c

154

loopover_j(struct v7fs_self *fs, void *ctx, struct v7fs_inode *p,

sbin/fsck_v7fs/datablock.c

165

if ((ret = v7fs_datablock_foreach(fs, p, datablock_i_j, ctx)) ==

sbin/fsck_v7fs/datablock.c

173

datablock_i(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk,

sbin/fsck_v7fs/datablock.c

181

if ((ret = v7fs_ilist_foreach(fs, loopover_j, ctx)) ==

sbin/fsck_v7fs/datablock.c

189

loopover_i(struct v7fs_self *fs, void *ctx, struct v7fs_inode *inode,

sbin/fsck_v7fs/datablock.c

197

if ((ret = v7fs_datablock_foreach(fs, inode, datablock_i, ctx)) ==

sbin/fsck_v7fs/datablock.c

206

datablock_vs_datablock_check(struct v7fs_self *fs)

sbin/fsck_v7fs/datablock.c

208

const struct v7fs_superblock *sb = &fs->superblock;

sbin/fsck_v7fs/datablock.c

215

if ((ret = v7fs_ilist_foreach(fs, loopover_i, &(struct loop_context){

sbin/fsck_v7fs/datablock.c

226

copy_block(struct v7fs_self *fs, v7fs_daddr_t dst, v7fs_daddr_t src)

sbin/fsck_v7fs/datablock.c

230

if (!(buf = scratch_read(fs, src)))

sbin/fsck_v7fs/datablock.c

232

fs->io.write(fs->io.cookie, buf, dst);

sbin/fsck_v7fs/datablock.c

233

scratch_free(fs, buf);

sbin/fsck_v7fs/datablock.c

239

replace_block_direct(struct v7fs_self *fs, struct v7fs_inode *p, int dupidx,

sbin/fsck_v7fs/datablock.c

246

v7fs_inode_writeback(fs, p); /* endian conversion done by here. */

sbin/fsck_v7fs/datablock.c

248

copy_block(fs, newblk, oldblk);

sbin/fsck_v7fs/datablock.c

252

prepare_list(struct v7fs_self *fs, v7fs_daddr_t listblk, v7fs_daddr_t *p)

sbin/fsck_v7fs/datablock.c

256

fs->io.read(fs->io.cookie, (void *)p, listblk);

sbin/fsck_v7fs/datablock.c

258

p[i] = V7FS_VAL32(fs, p[i]);

sbin/fsck_v7fs/datablock.c

262

replace_block_indexed(struct v7fs_self *fs, v7fs_daddr_t listblk, int dupidx,

sbin/fsck_v7fs/datablock.c

269

if (!(buf = scratch_read(fs, listblk)))

sbin/fsck_v7fs/datablock.c

272

oldblk = V7FS_VAL32(fs, list[dupidx]);

sbin/fsck_v7fs/datablock.c

273

list[dupidx] = V7FS_VAL32(fs, newblk);

sbin/fsck_v7fs/datablock.c

274

fs->io.write(fs->io.cookie, buf, listblk);

sbin/fsck_v7fs/datablock.c

275

scratch_free(fs, buf);

sbin/fsck_v7fs/datablock.c

277

copy_block(fs, newblk, oldblk);

sbin/fsck_v7fs/datablock.c

282

dupfind_loop1(struct v7fs_self *fs, v7fs_daddr_t listblk, v7fs_daddr_t dupblk,

sbin/fsck_v7fs/datablock.c

288

prepare_list(fs, listblk, list);

sbin/fsck_v7fs/datablock.c

291

replace_block_indexed(fs, listblk, i, newblk);

sbin/fsck_v7fs/datablock.c

300

dupfind_loop2(struct v7fs_self *fs, v7fs_daddr_t listblk, v7fs_daddr_t dupblk,

sbin/fsck_v7fs/datablock.c

307

prepare_list(fs, listblk, list);

sbin/fsck_v7fs/datablock.c

310

replace_block_indexed(fs, listblk, i, newblk);

sbin/fsck_v7fs/datablock.c

313

if (dupfind_loop1(fs, blk, dupblk, newblk))

sbin/fsck_v7fs/datablock.c

321

do_replace(struct v7fs_self *fs, struct v7fs_inode *p, v7fs_daddr_t dupblk,

sbin/fsck_v7fs/datablock.c

331

replace_block_direct(fs, p, i, newblk);

sbin/fsck_v7fs/datablock.c

338

replace_block_direct(fs, p, V7FS_NADDR_INDEX1, newblk);

sbin/fsck_v7fs/datablock.c

341

if (dupfind_loop1(fs, blk, dupblk, newblk))

sbin/fsck_v7fs/datablock.c

346

replace_block_direct(fs, p, V7FS_NADDR_INDEX2, newblk);

sbin/fsck_v7fs/datablock.c

349

if (dupfind_loop2(fs, blk, dupblk, newblk))

sbin/fsck_v7fs/datablock.c

354

replace_block_direct(fs, p, V7FS_NADDR_INDEX3, newblk);

sbin/fsck_v7fs/datablock.c

357

prepare_list(fs, blk, list);

sbin/fsck_v7fs/datablock.c

360

replace_block_indexed(fs, blk, i, newblk);

sbin/fsck_v7fs/datablock.c

363

if (dupfind_loop2(fs, blk2, dupblk, newblk))

sbin/fsck_v7fs/datablock.c

369

datablock_dup_remove(struct v7fs_self *fs, v7fs_ino_t i, v7fs_ino_t j,

sbin/fsck_v7fs/datablock.c

377

pwarn("Is victim %s (%s is preserved)", filename(fs, i),

sbin/fsck_v7fs/datablock.c

378

filename(fs, j));

sbin/fsck_v7fs/datablock.c

383

filename(fs, j), filename(fs, i));

sbin/fsck_v7fs/datablock.c

392

if ((error = v7fs_inode_load(fs, &inode, victim)))

sbin/fsck_v7fs/datablock.c

396

if ((error = v7fs_datablock_allocate(fs, &newblk))) {

sbin/fsck_v7fs/datablock.c

401

do_replace(fs, &inode, dupblk, newblk);

sbin/fsck_v7fs/datablock.c

62

freeblock_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t freeblk)

sbin/fsck_v7fs/datablock.c

69

arg->i, filename(fs, arg->i), freeblk);

sbin/fsck_v7fs/datablock.c

71

freeblock_dup_remove(fs, freeblk);

sbin/fsck_v7fs/datablock.c

80

datablock_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk,

sbin/fsck_v7fs/datablock.c

87

if ((ret = v7fs_freeblock_foreach(fs, freeblock_subr, ctx)) ==

sbin/fsck_v7fs/datablock.c

95

inode_subr(struct v7fs_self *fs, void *ctx, struct v7fs_inode *p,

sbin/fsck_v7fs/freeblock.c

107

ret = v7fs_freeblock_foreach(fs, freeblock_subr_j, ctx);

sbin/fsck_v7fs/freeblock.c

117

freeblock_vs_freeblock_check(struct v7fs_self *fs)

sbin/fsck_v7fs/freeblock.c

119

struct v7fs_superblock *sb = &fs->superblock;

sbin/fsck_v7fs/freeblock.c

125

return v7fs_freeblock_foreach(fs, freeblock_subr_i,

sbin/fsck_v7fs/freeblock.c

133

freeblock_dup_remove(struct v7fs_self *fs, v7fs_daddr_t dupblk)

sbin/fsck_v7fs/freeblock.c

135

struct v7fs_superblock *sb = &fs->superblock;

sbin/fsck_v7fs/freeblock.c

151

v7fs_superblock_writeback(fs);

sbin/fsck_v7fs/freeblock.c

164

buf = scratch_read(fs, blk);

sbin/fsck_v7fs/freeblock.c

166

v7fs_freeblock_endian_convert(fs, fb);

sbin/fsck_v7fs/freeblock.c

176

v7fs_superblock_writeback(fs);

sbin/fsck_v7fs/freeblock.c

193

v7fs_superblock_writeback(fs);

sbin/fsck_v7fs/freeblock.c

195

v7fs_freeblock_endian_convert(fs, fb);

sbin/fsck_v7fs/freeblock.c

196

fs->io.write(fs->io.cookie, buf, blk);

sbin/fsck_v7fs/freeblock.c

200

scratch_free(fs, buf);

sbin/fsck_v7fs/freeblock.c

207

v7fs_freeblock_foreach(struct v7fs_self *fs,

sbin/fsck_v7fs/freeblock.c

210

struct v7fs_superblock *sb = &fs->superblock;

sbin/fsck_v7fs/freeblock.c

221

if ((ret = func(fs, ctx, sb->freeblock[i])))

sbin/fsck_v7fs/freeblock.c

227

if (!datablock_number_sanity(fs, blk)) {

sbin/fsck_v7fs/freeblock.c

234

if (!(buf = scratch_read(fs, blk)))

sbin/fsck_v7fs/freeblock.c

238

if (v7fs_freeblock_endian_convert(fs, fb)) {

sbin/fsck_v7fs/freeblock.c

245

if ((ret = func(fs, ctx, blk)))

sbin/fsck_v7fs/freeblock.c

251

if ((ret = func(fs, ctx, fb->freeblock[i]))) {

sbin/fsck_v7fs/freeblock.c

252

scratch_free(fs, buf);

sbin/fsck_v7fs/freeblock.c

255

scratch_free(fs, buf);

sbin/fsck_v7fs/freeblock.c

262

freeblock_check(struct v7fs_self *fs)

sbin/fsck_v7fs/freeblock.c

264

struct v7fs_superblock *sb = &fs->superblock;

sbin/fsck_v7fs/freeblock.c

274

v7fs_freeblock_foreach(fs, freeblock_subr_cnt, &freeblock_arg);

sbin/fsck_v7fs/freeblock.c

287

v7fs_superblock_writeback(fs);

sbin/fsck_v7fs/freeblock.c

55

freeblock_subr_cnt(struct v7fs_self *fs __unused, void *ctx,

sbin/fsck_v7fs/freeblock.c

65

freeblock_subr_j(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk)

sbin/fsck_v7fs/freeblock.c

69

if (!datablock_number_sanity(fs, blk)) {

sbin/fsck_v7fs/freeblock.c

83

freeblock_dup_remove(fs, blk);

sbin/fsck_v7fs/freeblock.c

94

freeblock_subr_i(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk)

sbin/fsck_v7fs/freeblock.c

99

if (!datablock_number_sanity(fs, blk)) {

sbin/fsck_v7fs/inode.c

108

v7fs_inode_deallocate(fs, ino);

sbin/fsck_v7fs/inode.c

118

ilistcheck_subr(struct v7fs_self *fs, void *ctx, struct v7fs_inode *p,

sbin/fsck_v7fs/inode.c

125

error = v7fs_inode_check(fs, p, ino);

sbin/fsck_v7fs/inode.c

135

ilist_check(struct v7fs_self *fs)

sbin/fsck_v7fs/inode.c

137

struct v7fs_superblock *sb = &fs->superblock;

sbin/fsck_v7fs/inode.c

141

if ((error = v7fs_ilist_foreach(fs, ilistcheck_subr, &arg)))

sbin/fsck_v7fs/inode.c

151

v7fs_superblock_writeback(fs);

sbin/fsck_v7fs/inode.c

152

v7fs_superblock_dump(fs);

sbin/fsck_v7fs/inode.c

53

freeinode_check(struct v7fs_self *fs)

sbin/fsck_v7fs/inode.c

55

struct v7fs_superblock *sb = &fs->superblock;

sbin/fsck_v7fs/inode.c

69

v7fs_superblock_writeback(fs);

sbin/fsck_v7fs/inode.c

87

v7fs_superblock_writeback(fs);

sbin/fsck_v7fs/inode.c

99

v7fs_inode_check(struct v7fs_self *fs, struct v7fs_inode *p, v7fs_ino_t ino)

sbin/fsck_v7fs/main.c

102

if ((error = freeblock_check(fs)))

sbin/fsck_v7fs/main.c

107

if ((error = ilist_check(fs)))

sbin/fsck_v7fs/main.c

112

if ((error = make_lost_and_found(fs, &lost_and_found)))

sbin/fsck_v7fs/main.c

117

if ((error = pathname_check(fs)))

sbin/fsck_v7fs/main.c

123

if ((error = freeblock_vs_freeblock_check(fs)))

sbin/fsck_v7fs/main.c

130

if ((error = datablock_vs_datablock_check(fs)))

sbin/fsck_v7fs/main.c

138

if ((error = datablock_vs_freeblock_check(fs)))

sbin/fsck_v7fs/main.c

223

make_lost_and_found(struct v7fs_self *fs, struct v7fs_inode *p)

sbin/fsck_v7fs/main.c

230

if ((error = v7fs_inode_load(fs, &root_inode, V7FS_ROOT_INODE))) {

sbin/fsck_v7fs/main.c

244

if (!(error = v7fs_file_allocate(fs, &root_inode,

sbin/fsck_v7fs/main.c

246

v7fs_superblock_writeback(fs);

sbin/fsck_v7fs/main.c

257

if ((error = v7fs_inode_load(fs, p, ino))) {

sbin/fsck_v7fs/main.c

60

struct v7fs_self *fs;

sbin/fsck_v7fs/main.c

63

if ((error = v7fs_io_init(&fs, mount, V7FS_BSIZE))) {

sbin/fsck_v7fs/main.c

68

if ((error = v7fs_superblock_load(fs))) {

sbin/fsck_v7fs/main.c

79

error = check_filesystem(fs, flags);

sbin/fsck_v7fs/main.c

82

v7fs_io_fini(fs);

sbin/fsck_v7fs/main.c

89

check_filesystem(struct v7fs_self *fs, int flags)

sbin/fsck_v7fs/main.c

95

v7fs_superblock_dump(fs);

sbin/fsck_v7fs/main.c

97

if ((error = freeinode_check(fs)))

sbin/fsck_v7fs/pathname.c

105

if ((error = v7fs_inode_load(fs, &inode, dir->inode_number)))

sbin/fsck_v7fs/pathname.c

109

v7fs_directory_remove_entry(fs, arg->parent,

sbin/fsck_v7fs/pathname.c

117

scratch_free(fs, buf);

sbin/fsck_v7fs/pathname.c

123

lookup_child_from_dir(struct v7fs_self *fs, struct v7fs_inode *p, bool print)

sbin/fsck_v7fs/pathname.c

128

v7fs_datablock_foreach(fs, p, lookup_child_subr, &arg);

sbin/fsck_v7fs/pathname.c

140

lookup_parent_from_file_subr(struct v7fs_self *fs, void *ctx,

sbin/fsck_v7fs/pathname.c

148

if (v7fs_file_lookup_by_number(fs, p, arg->target_ino, NULL)) {

sbin/fsck_v7fs/pathname.c

158

lookup_parent_from_file(struct v7fs_self *fs, v7fs_ino_t ino)

sbin/fsck_v7fs/pathname.c

162

v7fs_ilist_foreach(fs, lookup_parent_from_file_subr, &arg);

sbin/fsck_v7fs/pathname.c

169

lookup_parent_from_dir_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk,

sbin/fsck_v7fs/pathname.c

176

if (!(buf = scratch_read(fs, blk)))

sbin/fsck_v7fs/pathname.c

180

if (!v7fs_dirent_endian_convert(fs, dir, n)) {

sbin/fsck_v7fs/pathname.c

181

scratch_free(fs, buf);

sbin/fsck_v7fs/pathname.c

194

scratch_free(fs, buf);

sbin/fsck_v7fs/pathname.c

199

lookup_parent_from_dir(struct v7fs_self *fs, struct v7fs_inode *p)

sbin/fsck_v7fs/pathname.c

204

v7fs_datablock_foreach(fs, p, lookup_parent_from_dir_subr, &arg);

sbin/fsck_v7fs/pathname.c

210

pathname_check_file(struct v7fs_self *fs, struct v7fs_inode *p, v7fs_ino_t ino)

sbin/fsck_v7fs/pathname.c

220

if (!(parent_ino = lookup_parent_from_file(fs, ino)) ||

sbin/fsck_v7fs/pathname.c

221

(error = v7fs_inode_load(fs, &parent_inode, parent_ino)) ||

sbin/fsck_v7fs/pathname.c

225

error = connect_lost_and_found(fs, ino);

sbin/fsck_v7fs/pathname.c

232

pathname_check_dir(struct v7fs_self *fs, struct v7fs_inode *p, v7fs_ino_t ino)

sbin/fsck_v7fs/pathname.c

239

if (!(parent_ino = lookup_parent_from_dir(fs, p)) ||

sbin/fsck_v7fs/pathname.c

240

(error = v7fs_inode_load(fs, &parent_inode, parent_ino)) ||

sbin/fsck_v7fs/pathname.c

246

if ((error = connect_lost_and_found(fs, ino)))

sbin/fsck_v7fs/pathname.c

251

int cnt = lookup_child_from_dir(fs, p, false);

sbin/fsck_v7fs/pathname.c

256

lookup_child_from_dir(fs, p, true);

sbin/fsck_v7fs/pathname.c

260

v7fs_inode_writeback(fs, p);

sbin/fsck_v7fs/pathname.c

271

pathname_subr(struct v7fs_self *fs, void *ctx __unused, struct v7fs_inode *p,

sbin/fsck_v7fs/pathname.c

282

error = pathname_check_dir(fs, p, ino);

sbin/fsck_v7fs/pathname.c

284

error = pathname_check_file(fs, p, ino);

sbin/fsck_v7fs/pathname.c

291

pathname_check(struct v7fs_self *fs)

sbin/fsck_v7fs/pathname.c

293

struct v7fs_superblock *sb = &fs->superblock;

sbin/fsck_v7fs/pathname.c

299

return v7fs_ilist_foreach(fs, pathname_subr, 0);

sbin/fsck_v7fs/pathname.c

304

filename(struct v7fs_self *fs, v7fs_ino_t ino)

sbin/fsck_v7fs/pathname.c

314

if ((error = v7fs_inode_load(fs, &inode, ino)))

sbin/fsck_v7fs/pathname.c

319

parent = lookup_parent_from_dir(fs, &inode);

sbin/fsck_v7fs/pathname.c

321

parent = lookup_parent_from_file(fs, ino);

sbin/fsck_v7fs/pathname.c

323

if ((error = v7fs_inode_load(fs, &inode, parent)))

sbin/fsck_v7fs/pathname.c

326

if (!v7fs_file_lookup_by_number(fs, &inode, ino, name))

sbin/fsck_v7fs/pathname.c

335

parent = lookup_parent_from_dir(fs, &inode);

sbin/fsck_v7fs/pathname.c

336

if ((error = v7fs_inode_load(fs, &inode, parent)))

sbin/fsck_v7fs/pathname.c

338

if (!v7fs_file_lookup_by_number(fs, &inode, ino, name))

sbin/fsck_v7fs/pathname.c

58

connect_lost_and_found(struct v7fs_self *fs, v7fs_ino_t ino)

sbin/fsck_v7fs/pathname.c

67

v7fs_directory_add_entry(fs, &lost_and_found, ino, name, strlen(name));

sbin/fsck_v7fs/pathname.c

70

v7fs_inode_writeback(fs, &lost_and_found);

sbin/fsck_v7fs/pathname.c

71

v7fs_superblock_writeback(fs); /* # of freeblocks may change. */

sbin/fsck_v7fs/pathname.c

84

lookup_child_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)

sbin/fsck_v7fs/pathname.c

90

if (!(buf = scratch_read(fs, blk)))

sbin/fsck_v7fs/pathname.c

94

if (!v7fs_dirent_endian_convert(fs, dir, n)) {

sbin/fsdb/fsdb.c

72

struct fs *sblock;

sbin/fsdb/fsdb.c

73

struct fs *altsblock;

sbin/fsdb/fsdb.c

75

struct fs *sblocksave;

sbin/fsirand/fsirand.c

109

ffs_sb_swap(fs, fs);

sbin/fsirand/fsirand.c

120

if (fs->fs_ncg < 1)

sbin/fsirand/fsirand.c

123

if (fs->fs_sbsize > SBLOCKSIZE)

sbin/fsirand/fsirand.c

133

fixinodes(int fd, struct fs *fs, struct disklabel *lab, int pflag, long xorval)

sbin/fsirand/fsirand.c

135

int inopb = FFS_INOPB(fs);

sbin/fsirand/fsirand.c

153

for (ino = 0, imax = fs->fs_ipg * fs->fs_ncg; ino < imax;) {

sbin/fsirand/fsirand.c

155

sp = (off_t) FFS_FSBTODB(fs, ino_to_fsba(fs, ino)) *

sbin/fsirand/fsirand.c

230

struct fs *fs = (struct fs *) buf;

sbin/fsirand/fsirand.c

287

getsblock(fd, special, fs);

sbin/fsirand/fsirand.c

288

fixinodes(fd, fs, &lab, pflag, xorval);

sbin/fsirand/fsirand.c

61

static void getsblock(int, const char *, struct fs *);

sbin/fsirand/fsirand.c

62

static void fixinodes(int, struct fs *, struct disklabel *, int, long);

sbin/fsirand/fsirand.c

86

getsblock(int fd, const char *name, struct fs *fs)

sbin/fsirand/fsirand.c

93

if (pread(fd, fs, SBLOCKSIZE, sblock_try[i]) != SBLOCKSIZE)

sbin/fsirand/fsirand.c

96

switch(fs->fs_magic) {

sbin/mount/mount.c

108

struct fstab *fs;

sbin/mount/mount.c

183

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

sbin/mount/mount.c

184

if (BADTYPE(fs->fs_type))

sbin/mount/mount.c

186

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

sbin/mount/mount.c

188

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

sbin/mount/mount.c

190

if (strcmp(fs->fs_spec, "from_mount") == 0) {

sbin/mount/mount.c

191

if ((mntbuf = getmntpt(fs->fs_file))

sbin/mount/mount.c

195

fs->fs_file);

sbin/mount/mount.c

198

mntfromname = fs->fs_spec;

sbin/mount/mount.c

203

if (mountfs(fs->fs_vfstype, mntfromname,

sbin/mount/mount.c

204

fs->fs_file, init_flags, options,

sbin/mount/mount.c

205

fs->fs_mntops, !forceall, NULL, 0))

sbin/mount/mount.c

246

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

sbin/mount/mount.c

247

if (strcmp(fs->fs_spec, "from_mount") != 0)

sbin/mount/mount.c

248

mntfromname = fs->fs_spec;

sbin/mount/mount.c

250

fs->fs_mntops = NULL;

sbin/mount/mount.c

261

((fs = getfsfile(canonical_path)) == NULL &&

sbin/mount/mount.c

262

(fs = getfsspec(canonical_path)) == NULL))

sbin/mount/mount.c

264

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

sbin/mount/mount.c

265

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

sbin/mount/mount.c

269

if (BADTYPE(fs->fs_type))

sbin/mount/mount.c

273

if (strcmp(fs->fs_spec, "from_mount") == 0) {

sbin/mount/mount.c

281

mntfromname = fs->fs_spec;

sbin/mount/mount.c

282

mntonname = fs->fs_file;

sbin/mount/mount.c

283

fstypename = fs->fs_vfstype;

sbin/mount/mount.c

284

mountopts = fs->fs_mntops;

sbin/newfs/mkfs.c

119

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

sbin/newfs/mkfs.c

120

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

sbin/newfs/mkfs.c

121

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

sbin/newfs/mkfs.c

134

struct fs fs;

sbin/newfs/mkfs.c

137

#define sblock fsun->fs

sbin/newfs/mkfs.c

1476

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

sbin/newfs/mkfs.c

1480

switch (fs->fs_fragshift) {

sbin/newfs/mkfs.c

1494

printf("isblock bad fs_fragshift %d\n", fs->fs_fragshift);

sbin/newfs/mkfs.c

1497

fs->fs_fragshift);

sbin/newfs/mkfs.c

1507

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

sbin/newfs/mkfs.c

1509

switch ((fs)->fs_fragshift) {

sbin/newfs/mkfs.c

1524

printf("clrblock bad fs_fragshift %d\n", fs->fs_fragshift);

sbin/newfs/mkfs.c

1527

fs->fs_fragshift);

sbin/newfs/mkfs.c

1537

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

sbin/newfs/mkfs.c

1539

switch (fs->fs_fragshift) {

sbin/newfs/mkfs.c

1554

printf("setblock bad fs_frag %d\n", fs->fs_fragshift);

sbin/newfs/mkfs.c

1557

fs->fs_fragshift);

sbin/newfs/mkfs.c

1598

{offsetof(struct fs, fs_magic)/4, FS_UFS1_MAGIC, ~0u},

sbin/newfs/mkfs.c

1599

{offsetof(struct fs, fs_magic)/4, FS_UFS2_MAGIC, ~0u},

sbin/newfs/mkfs.c

499

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

sbin/newfs/mkfs.c

664

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

sbin/newfs/mkfs.c

666

memset(iobuf + offsetof(struct fs, fs_old_postbl_start),

sbin/newfs/mkfs.c

749

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

sbin/newfs/mkfs.c

751

((struct fs *)iobuf)->fs_magic = FS_UFS2EA_MAGIC;

sbin/newfs/mkfs.c

753

memset(iobuf + offsetof(struct fs, fs_old_postbl_start),

sbin/newfs_ext2fs/mke2fs.c

158

#define cgbase(fs, c) \

sbin/newfs_ext2fs/mke2fs.c

159

((fs)->e2fs.e2fs_first_dblock + (fs)->e2fs.e2fs_bpg * (c))

sbin/newfs_lfs/make_lfs.c

276

maxfilesize(struct lfs *fs, int bshift)

sbin/newfs_lfs/make_lfs.c

281

nptr = (1 << bshift) / LFS_BLKPTRSIZE(fs);

sbin/newfs_lfs/make_lfs.c

292

make_dinode(ino_t ino, union lfs_dinode *dip, int nfrags, struct lfs *fs)

sbin/newfs_lfs/make_lfs.c

298

nblocks = howmany(nfrags, lfs_sb_getfrag(fs));

sbin/newfs_lfs/make_lfs.c

300

nfrags = roundup(nfrags, lfs_sb_getfrag(fs));

sbin/newfs_lfs/make_lfs.c

302

lfs_dino_setnlink(fs, dip, 1);

sbin/newfs_lfs/make_lfs.c

303

lfs_dino_setblocks(fs, dip, nfrags);

sbin/newfs_lfs/make_lfs.c

305

lfs_dino_setsize(fs, dip, nfrags << lfs_sb_getffshift(fs));

sbin/newfs_lfs/make_lfs.c

306

t = lfs_sb_gettstamp(fs);

sbin/newfs_lfs/make_lfs.c

307

lfs_dino_setatime(fs, dip, t);

sbin/newfs_lfs/make_lfs.c

308

lfs_dino_setmtime(fs, dip, t);

sbin/newfs_lfs/make_lfs.c

309

lfs_dino_setctime(fs, dip, t);

sbin/newfs_lfs/make_lfs.c

310

lfs_dino_setatimensec(fs, dip, 0);

sbin/newfs_lfs/make_lfs.c

311

lfs_dino_setmtimensec(fs, dip, 0);

sbin/newfs_lfs/make_lfs.c

312

lfs_dino_setctimensec(fs, dip, 0);

sbin/newfs_lfs/make_lfs.c

313

lfs_dino_setinumber(fs, dip, ino);

sbin/newfs_lfs/make_lfs.c

314

lfs_dino_setgen(fs, dip, 1);

sbin/newfs_lfs/make_lfs.c

321

bb = howmany(bb, LFS_NINDIR(fs));

sbin/newfs_lfs/make_lfs.c

325

lfs_dino_setblocks(fs, dip,

sbin/newfs_lfs/make_lfs.c

326

lfs_dino_getblocks(fs, dip) + lfs_blkstofrags(fs, ifibc));

sbin/newfs_lfs/make_lfs.c

331

lfs_dino_setdb(fs, dip, i, 0x0);

sbin/newfs_lfs/make_lfs.c

334

lfs_dino_setib(fs, dip, 0, 0x0);

sbin/newfs_lfs/make_lfs.c

335

bb = howmany(nblocks - ULFS_NDADDR, LFS_NINDIR(fs)) - 1;

sbin/newfs_lfs/make_lfs.c

336

factor = LFS_NINDIR(fs);

sbin/newfs_lfs/make_lfs.c

340

lfs_dino_setib(fs, dip, lvl, 0x0);

sbin/newfs_lfs/make_lfs.c

341

bb = howmany(bb, LFS_NINDIR(fs));

sbin/newfs_lfs/make_lfs.c

343

factor *= LFS_NINDIR(fs);

sbin/newfs_lfs/make_lfs.c

355

make_dir(struct lfs *fs, void *bufp,

sbin/newfs_lfs/make_lfs.c

367

reclen = LFS_DIRECTSIZ(fs, namlen);

sbin/newfs_lfs/make_lfs.c

377

lfs_dir_setino(fs, ep, protodir[i].dp_ino);

sbin/newfs_lfs/make_lfs.c

378

lfs_dir_setreclen(fs, ep, reclen);

sbin/newfs_lfs/make_lfs.c

379

lfs_dir_settype(fs, ep, protodir[i].dp_type);

sbin/newfs_lfs/make_lfs.c

380

lfs_dir_setnamlen(fs, ep, namlen);

sbin/newfs_lfs/make_lfs.c

381

lfs_copydirname(fs, lfs_dir_nameptr(fs, ep), protodir[i].dp_name,

sbin/newfs_lfs/make_lfs.c

383

ep = LFS_NEXTDIR(fs, ep);

sbin/newfs_lfs/make_lfs.c

400

struct lfs *fs; /* Superblock */

sbin/newfs_lfs/make_lfs.c

437

fs = lfs_init(devfd, start, 0, 1, 1/* XXX debug*/);

sbin/newfs_lfs/make_lfs.c

438

save_devvp = fs->lfs_devvp;

sbin/newfs_lfs/make_lfs.c

439

vp = fs->lfs_ivnode;

sbin/newfs_lfs/make_lfs.c

441

*fs = lfs_default;

sbin/newfs_lfs/make_lfs.c

443

fs->lfs_dlfs_u.u_64 = dlfs64_default;

sbin/newfs_lfs/make_lfs.c

445

fs->lfs_dlfs_u.u_32 = dlfs32_default;

sbin/newfs_lfs/make_lfs.c

447

fs->lfs_is64 = is64;

sbin/newfs_lfs/make_lfs.c

448

fs->lfs_dobyteswap = dobyteswap;

sbin/newfs_lfs/make_lfs.c

449

fs->lfs_hasolddirfmt = false;

sbin/newfs_lfs/make_lfs.c

450

fs->lfs_ivnode = vp;

sbin/newfs_lfs/make_lfs.c

451

fs->lfs_devvp = save_devvp;

sbin/newfs_lfs/make_lfs.c

455

lfs_sb_setversion(fs, version);

sbin/newfs_lfs/make_lfs.c

517

lfs_sb_setbshift(fs, lfs_log2(bsize));

sbin/newfs_lfs/make_lfs.c

518

if (1 << lfs_sb_getbshift(fs) != bsize)

sbin/newfs_lfs/make_lfs.c

520

lfs_sb_setbsize(fs, bsize);

sbin/newfs_lfs/make_lfs.c

521

lfs_sb_setfsize(fs, fsize);

sbin/newfs_lfs/make_lfs.c

522

lfs_sb_setbmask(fs, bsize - 1);

sbin/newfs_lfs/make_lfs.c

523

lfs_sb_setffmask(fs, fsize - 1);

sbin/newfs_lfs/make_lfs.c

524

lfs_sb_setffshift(fs, lfs_log2(fsize));

sbin/newfs_lfs/make_lfs.c

525

if (1 << lfs_sb_getffshift(fs) != fsize)

sbin/newfs_lfs/make_lfs.c

527

lfs_sb_setfrag(fs, lfs_numfrags(fs, bsize));

sbin/newfs_lfs/make_lfs.c

528

lfs_sb_setfbmask(fs, lfs_sb_getfrag(fs) - 1);

sbin/newfs_lfs/make_lfs.c

529

lfs_sb_setfbshift(fs, lfs_log2(lfs_sb_getfrag(fs)));

sbin/newfs_lfs/make_lfs.c

530

lfs_sb_setifpb(fs, bsize / IFILE_ENTRYSIZE(fs));

sbin/newfs_lfs/make_lfs.c

531

lfs_sb_setnindir(fs, bsize / LFS_BLKPTRSIZE(fs));

sbin/newfs_lfs/make_lfs.c

534

if (lfs_sb_getversion(fs) == 1) {

sbin/newfs_lfs/make_lfs.c

535

lfs_sb_setsumsize(fs, LFS_V1_SUMMARY_SIZE);

sbin/newfs_lfs/make_lfs.c

543

fs->lfs_dlfs_u.u_32.dlfs_segshift = segshift;

sbin/newfs_lfs/make_lfs.c

544

fs->lfs_dlfs_u.u_32.dlfs_segmask = ssize - 1;

sbin/newfs_lfs/make_lfs.c

546

lfs_sb_setifpb(fs, lfs_sb_getbsize(fs) / sizeof(IFILE_V1));

sbin/newfs_lfs/make_lfs.c

547

lfs_sb_setibsize(fs, lfs_sb_getbsize(fs));

sbin/newfs_lfs/make_lfs.c

548

lfs_sb_setsepb(fs, bsize / sizeof(SEGUSE_V1));

sbin/newfs_lfs/make_lfs.c

549

lfs_sb_setssize(fs, ssize >> lfs_sb_getbshift(fs));

sbin/newfs_lfs/make_lfs.c

559

lfs_sb_setsumsize(fs, fsize);

sbin/newfs_lfs/make_lfs.c

562

fs->lfs_dlfs_u.u_32.dlfs_segshift = 0;

sbin/newfs_lfs/make_lfs.c

563

fs->lfs_dlfs_u.u_32.dlfs_segmask = 0;

sbin/newfs_lfs/make_lfs.c

565

lfs_sb_setsepb(fs, bsize / sizeof(SEGUSE));

sbin/newfs_lfs/make_lfs.c

566

lfs_sb_setssize(fs, ssize);

sbin/newfs_lfs/make_lfs.c

567

lfs_sb_setibsize(fs, ibsize);

sbin/newfs_lfs/make_lfs.c

569

lfs_sb_setinopb(fs, lfs_sb_getibsize(fs) / DINOSIZE(fs));

sbin/newfs_lfs/make_lfs.c

570

lfs_sb_setminfree(fs, minfree);

sbin/newfs_lfs/make_lfs.c

573

lfs_sb_setinopf(fs, secsize/DINOSIZE(fs));

sbin/newfs_lfs/make_lfs.c

574

lfs_sb_setinterleave(fs, interleave);

sbin/newfs_lfs/make_lfs.c

577

lfs_sb_setident(fs, roll_id);

sbin/newfs_lfs/make_lfs.c

588

lfs_sb_setblktodb(fs, lfs_log2(db_per_blk));

sbin/newfs_lfs/make_lfs.c

589

lfs_sb_setfsbtodb(fs, lfs_log2(fsize / secsize));

sbin/newfs_lfs/make_lfs.c

591

lfs_sb_setsushift(fs, lfs_log2(lfs_sb_getsepb(fs)));

sbin/newfs_lfs/make_lfs.c

592

lfs_sb_setfsbtodb(fs, 0);

sbin/newfs_lfs/make_lfs.c

593

lfs_sb_setsize(fs, dkw->dkw_size >> lfs_sb_getblktodb(fs));

sbin/newfs_lfs/make_lfs.c

595

label_fsb = lfs_btofsb(fs, roundup(LFS_LABELPAD, fsize));

sbin/newfs_lfs/make_lfs.c

596

sb_fsb = lfs_btofsb(fs, roundup(LFS_SBPAD, fsize));

sbin/newfs_lfs/make_lfs.c

597

lfs_sb_setfsbpseg(fs, LFS_DBTOFSB(fs, ssize / secsize));

sbin/newfs_lfs/make_lfs.c

598

lfs_sb_setsize(fs, dkw->dkw_size >> lfs_sb_getfsbtodb(fs));

sbin/newfs_lfs/make_lfs.c

599

lfs_sb_setdsize(fs, LFS_DBTOFSB(fs, dkw->dkw_size) -

sbin/newfs_lfs/make_lfs.c

600

MAX(label_fsb, LFS_DBTOFSB(fs, start)));

sbin/newfs_lfs/make_lfs.c

601

lfs_sb_setnseg(fs, lfs_sb_getdsize(fs) / lfs_segtod(fs, 1));

sbin/newfs_lfs/make_lfs.c

603

lfs_sb_setnclean(fs, lfs_sb_getnseg(fs) - 1);

sbin/newfs_lfs/make_lfs.c

604

lfs_sb_setmaxfilesize(fs, maxfilesize(fs, lfs_sb_getbshift(fs)));

sbin/newfs_lfs/make_lfs.c

607

lfs_sb_setminfreeseg(fs, lfs_sb_getnseg(fs) / DFL_MIN_FREE_SEGS);

sbin/newfs_lfs/make_lfs.c

609

lfs_sb_setminfreeseg(fs, minfreeseg);

sbin/newfs_lfs/make_lfs.c

610

if (lfs_sb_getminfreeseg(fs) < MIN_FREE_SEGS)

sbin/newfs_lfs/make_lfs.c

611

lfs_sb_setminfreeseg(fs, MIN_FREE_SEGS);

sbin/newfs_lfs/make_lfs.c

614

lfs_sb_setresvseg(fs, lfs_sb_getminfreeseg(fs) / 2 + 1);

sbin/newfs_lfs/make_lfs.c

616

lfs_sb_setresvseg(fs, resvseg);

sbin/newfs_lfs/make_lfs.c

617

if (lfs_sb_getresvseg(fs) < MIN_RESV_SEGS)

sbin/newfs_lfs/make_lfs.c

618

lfs_sb_setresvseg(fs, MIN_RESV_SEGS);

sbin/newfs_lfs/make_lfs.c

620

if(lfs_sb_getnseg(fs) < (4 * lfs_sb_getminfreeseg(fs))

sbin/newfs_lfs/make_lfs.c

621

|| lfs_sb_getnseg(fs) < LFS_MIN_SBINTERVAL + 1)

sbin/newfs_lfs/make_lfs.c

640

"segment size.\n", ssize, lfs_sb_getbsize(fs));

sbin/newfs_lfs/make_lfs.c

649

printf("Creating a version %d LFS%d", lfs_sb_getversion(fs), bitwidth);

sbin/newfs_lfs/make_lfs.c

650

if (lfs_sb_getversion(fs) > 1)

sbin/newfs_lfs/make_lfs.c

651

printf(" with roll-forward ident 0x%x", lfs_sb_getident(fs));

sbin/newfs_lfs/make_lfs.c

658

fssize = (double)lfs_sb_getnseg(fs);

sbin/newfs_lfs/make_lfs.c

662

lfs_sb_getnseg(fs), ssize);

sbin/newfs_lfs/make_lfs.c

672

lfs_sb_setdsize(fs,

sbin/newfs_lfs/make_lfs.c

673

lfs_segtod(fs, lfs_sb_getnseg(fs) - lfs_sb_getminfreeseg(fs)));

sbin/newfs_lfs/make_lfs.c

674

lfs_sb_setbfree(fs, lfs_sb_getdsize(fs));

sbin/newfs_lfs/make_lfs.c

675

lfs_sb_subbfree(fs, LFS_DBTOFSB(fs, ((lfs_sb_getnseg(fs) / 2) <<

sbin/newfs_lfs/make_lfs.c

676

lfs_sb_getblktodb(fs))));

sbin/newfs_lfs/make_lfs.c

678

lfs_sb_setsegtabsz(fs, SEGTABSIZE_SU(fs));

sbin/newfs_lfs/make_lfs.c

679

lfs_sb_setcleansz(fs, CLEANSIZE_SU(fs));

sbin/newfs_lfs/make_lfs.c

682

lfs_sb_settstamp(fs, stamp);

sbin/newfs_lfs/make_lfs.c

684

lfs_sb_setotstamp(fs, stamp);

sbin/newfs_lfs/make_lfs.c

686

if ((sb_interval = lfs_sb_getnseg(fs) / LFS_MAXNUMSB) < LFS_MIN_SBINTERVAL)

sbin/newfs_lfs/make_lfs.c

696

if (LFS_FSBTODB(fs, LFS_DBTOFSB(fs, start)) != start)

sbin/newfs_lfs/make_lfs.c

706

lfs_sb_setsboff(fs, 0, label_fsb);

sbin/newfs_lfs/make_lfs.c

708

lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 0));

sbin/newfs_lfs/make_lfs.c

710

lfs_sb_sets0addr(fs, LFS_DBTOFSB(fs, start));

sbin/newfs_lfs/make_lfs.c

711

lfs_sb_subdsize(fs, sb_fsb);

sbin/newfs_lfs/make_lfs.c

713

sb_addr = ((i * sb_interval) * lfs_segtod(fs, 1))

sbin/newfs_lfs/make_lfs.c

714

+ lfs_sb_getsboff(fs, 0);

sbin/newfs_lfs/make_lfs.c

716

if (lfs_sb_getversion(fs) > 1 && lfs_sb_gets0addr(fs) < label_fsb)

sbin/newfs_lfs/make_lfs.c

719

>= LFS_DBTOFSB(fs, dkw->dkw_size))

sbin/newfs_lfs/make_lfs.c

721

lfs_sb_setsboff(fs, i, sb_addr);

sbin/newfs_lfs/make_lfs.c

722

lfs_sb_subdsize(fs, sb_fsb);

sbin/newfs_lfs/make_lfs.c

726

if (lfs_sb_getsboff(fs, 1) == 0x0) {

sbin/newfs_lfs/make_lfs.c

731

lfs_sb_setlastseg(fs, lfs_sntod(fs, lfs_sb_getnseg(fs) - 2));

sbin/newfs_lfs/make_lfs.c

732

lfs_sb_setcurseg(fs, lfs_sntod(fs, lfs_sb_getnseg(fs) - 1));

sbin/newfs_lfs/make_lfs.c

733

lfs_sb_setoffset(fs, lfs_sntod(fs, lfs_sb_getnseg(fs)));

sbin/newfs_lfs/make_lfs.c

734

lfs_sb_setnextseg(fs, lfs_sntod(fs, 0));

sbin/newfs_lfs/make_lfs.c

748

VTOI(fs->lfs_ivnode)->i_din = dip;

sbin/newfs_lfs/make_lfs.c

750

lfs_dino_setmode(fs, dip, LFS_IFREG | 0600);

sbin/newfs_lfs/make_lfs.c

751

lfs_dino_setflags(fs, dip, SF_IMMUTABLE);

sbin/newfs_lfs/make_lfs.c

753

lfs_blkstofrags(fs, lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs) + 1), fs);

sbin/newfs_lfs/make_lfs.c

754

lfs_dino_setsize(fs, dip, (lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs) + 1) << lfs_sb_getbshift(fs));

sbin/newfs_lfs/make_lfs.c

755

for (i = 0; i < ULFS_NDADDR && i < (lfs_dino_getsize(fs, dip) >> lfs_sb_getbshift(fs)); i++)

sbin/newfs_lfs/make_lfs.c

756

VTOI(fs->lfs_ivnode)->i_lfs_fragsize[i] = lfs_sb_getbsize(fs);

sbin/newfs_lfs/make_lfs.c

761

LFS_CLEANERINFO(cip, fs, bp);

sbin/newfs_lfs/make_lfs.c

762

lfs_ci_setclean(fs, cip, lfs_sb_getnseg(fs));

sbin/newfs_lfs/make_lfs.c

763

lfs_ci_setdirty(fs, cip, 0);

sbin/newfs_lfs/make_lfs.c

765

lfs_ci_setfree_head(fs, cip, HIGHEST_USED_INO + 1);

sbin/newfs_lfs/make_lfs.c

766

lfs_ci_setfree_tail(fs, cip, lfs_sb_getifpb(fs) - 1);

sbin/newfs_lfs/make_lfs.c

768

LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);

sbin/newfs_lfs/make_lfs.c

773

for (i = j = 0; i < lfs_sb_getnseg(fs); i++) {

sbin/newfs_lfs/make_lfs.c

774

LFS_SEGENTRY(segp, fs, i, bp);

sbin/newfs_lfs/make_lfs.c

777

lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD + LFS_SBPAD)) {

sbin/newfs_lfs/make_lfs.c

779

lfs_sb_subbfree(fs, sb_fsb);

sbin/newfs_lfs/make_lfs.c

785

lfs_sb_subbfree(fs, sb_fsb);

sbin/newfs_lfs/make_lfs.c

795

LFS_WRITESEGENTRY(segp, fs, i, bp);

sbin/newfs_lfs/make_lfs.c

799

vp = lfs_raw_vget(fs, ULFS_ROOTINO, devfd, 0x0);

sbin/newfs_lfs/make_lfs.c

801

make_dinode(ULFS_ROOTINO, dip, howmany(LFS_DIRBLKSIZ, lfs_sb_getfsize(fs)), fs);

sbin/newfs_lfs/make_lfs.c

802

lfs_dino_setmode(fs, dip, LFS_IFDIR | UMASK);

sbin/newfs_lfs/make_lfs.c

810

lfs_btofsb(fs, roundup(LFS_DIRBLKSIZ, lfs_sb_getfsize(fs)));

sbin/newfs_lfs/make_lfs.c

811

lfs_dino_setsize(fs, dip, VTOI(vp)->i_lfs_osize);

sbin/newfs_lfs/make_lfs.c

812

lfs_dino_setnlink(fs, dip, VTOI(vp)->i_nlink);

sbin/newfs_lfs/make_lfs.c

813

lfs_dino_setblocks(fs, dip, VTOI(vp)->i_lfs_effnblks);

sbin/newfs_lfs/make_lfs.c

814

for (i = 0; i < ULFS_NDADDR && i < howmany(LFS_DIRBLKSIZ, lfs_sb_getbsize(fs)); i++)

sbin/newfs_lfs/make_lfs.c

815

VTOI(vp)->i_lfs_fragsize[i] = lfs_sb_getbsize(fs);

sbin/newfs_lfs/make_lfs.c

816

if (LFS_DIRBLKSIZ < lfs_sb_getbsize(fs))

sbin/newfs_lfs/make_lfs.c

818

roundup(LFS_DIRBLKSIZ, lfs_sb_getfsize(fs));

sbin/newfs_lfs/make_lfs.c

819

bread(vp, 0, lfs_sb_getfsize(fs), 0, &bp);

sbin/newfs_lfs/make_lfs.c

820

make_dir(fs, bp->b_data, lfs_root_dir, __arraycount(lfs_root_dir));

sbin/newfs_lfs/make_lfs.c

825

vp = lfs_raw_vget(fs, LOSTFOUNDINO, devfd, 0x0);

sbin/newfs_lfs/make_lfs.c

827

make_dinode(LOSTFOUNDINO, dip, howmany(DIRBLKSIZ,fs->lfs_fsize), fs);

sbin/newfs_lfs/make_lfs.c

832

lfs_btofsb(fs, roundup(DIRBLKSIZ,fs->lfs_fsize));

sbin/newfs_lfs/make_lfs.c

833

for (i = 0; i < ULFS_NDADDR && i < howmany(DIRBLKSIZ, lfs_sb_getbsize(fs)); i++)

sbin/newfs_lfs/make_lfs.c

834

VTOI(vp)->i_lfs_fragsize[i] = lfs_sb_getbsize(fs);

sbin/newfs_lfs/make_lfs.c

835

if (DIRBLKSIZ < lfs_sb_getbsize(fs))

sbin/newfs_lfs/make_lfs.c

837

roundup(DIRBLKSIZ,fs->lfs_fsize);

sbin/newfs_lfs/make_lfs.c

838

bread(vp, 0, fs->lfs_fsize, 0, &bp);

sbin/newfs_lfs/make_lfs.c

839

make_dir(fs, bp->b_data, lfs_lf_dir, __arraycount(lfs_lf_dir));

sbin/newfs_lfs/make_lfs.c

844

LFS_IENTRY(ipall, fs, 1, bp);

sbin/newfs_lfs/make_lfs.c

873

i < lfs_sb_getifpb(fs); ++ip64) {

sbin/newfs_lfs/make_lfs.c

882

i < lfs_sb_getifpb(fs); ++ip32) {

sbin/newfs_lfs/make_lfs.c

891

i < lfs_sb_getifpb(fs); ++ip_v1) {

sbin/newfs_lfs/make_lfs.c

903

lfs_segwrite(fs, SEGM_CKP);

sbin/newfs_lfs/make_lfs.c

909

lfs_sb_setavail(fs, 0);

sbin/newfs_lfs/make_lfs.c

911

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

sbin/newfs_lfs/make_lfs.c

912

LFS_SEGENTRY(segp, fs, i, bp);

sbin/newfs_lfs/make_lfs.c

914

bb += lfs_btofsb(fs, segp->su_nbytes +

sbin/newfs_lfs/make_lfs.c

915

segp->su_nsums * lfs_sb_getsumsize(fs));

sbin/newfs_lfs/make_lfs.c

916

ubb += lfs_btofsb(fs, segp->su_nbytes +

sbin/newfs_lfs/make_lfs.c

917

segp->su_nsums * lfs_sb_getsumsize(fs) +

sbin/newfs_lfs/make_lfs.c

918

segp->su_ninos * lfs_sb_getibsize(fs));

sbin/newfs_lfs/make_lfs.c

919

dmeta += lfs_btofsb(fs,

sbin/newfs_lfs/make_lfs.c

920

lfs_sb_getsumsize(fs) * segp->su_nsums);

sbin/newfs_lfs/make_lfs.c

921

dmeta += lfs_btofsb(fs,

sbin/newfs_lfs/make_lfs.c

922

lfs_sb_getibsize(fs) * segp->su_ninos);

sbin/newfs_lfs/make_lfs.c

924

lfs_sb_addavail(fs, lfs_segtod(fs, 1));

sbin/newfs_lfs/make_lfs.c

926

lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_SBPAD));

sbin/newfs_lfs/make_lfs.c

927

if (i == 0 && lfs_sb_getversion(fs) > 1 &&

sbin/newfs_lfs/make_lfs.c

928

lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))

sbin/newfs_lfs/make_lfs.c

929

lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_LABELPAD) -

sbin/newfs_lfs/make_lfs.c

930

lfs_sb_gets0addr(fs));

sbin/newfs_lfs/make_lfs.c

935

i = lfs_dtosn(fs, lfs_sb_getoffset(fs));

sbin/newfs_lfs/make_lfs.c

936

lfs_sb_addavail(fs, lfs_sntod(fs, i + 1) - lfs_sb_getoffset(fs));

sbin/newfs_lfs/make_lfs.c

938

lfs_sb_subavail(fs, lfs_segtod(fs, (lfs_sb_getminfreeseg(fs) - (lfs_sb_getminfreeseg(fs) / 2))));

sbin/newfs_lfs/make_lfs.c

941

if (lfs_sb_getversion(fs) > 1 && lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))

sbin/newfs_lfs/make_lfs.c

942

labelskew = lfs_btofsb(fs, LFS_LABELPAD);

sbin/newfs_lfs/make_lfs.c

943

lfs_sb_setbfree(fs, lfs_sb_getdsize(fs) - labelskew - (ubb + bb) / 2);

sbin/newfs_lfs/make_lfs.c

946

LFS_CLEANERINFO(cip, fs, bp);

sbin/newfs_lfs/make_lfs.c

947

lfs_ci_setbfree(fs, cip, lfs_sb_getbfree(fs));

sbin/newfs_lfs/make_lfs.c

948

lfs_ci_setavail(fs, cip, lfs_sb_getavail(fs));

sbin/newfs_lfs/make_lfs.c

949

LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);

sbin/newfs_lfs/make_lfs.c

951

lfs_segwrite(fs, SEGM_CKP);

sbin/newfs_lfs/make_lfs.c

959

seg_addr = lfs_sb_getsboff(fs, i);

sbin/newfs_lfs/make_lfs.c

966

(long long)LFS_FSBTODB(fs, seg_addr));

sbin/newfs_lfs/make_lfs.c

977

lfs_sb_settstamp(fs, 0);

sbin/newfs_lfs/make_lfs.c

978

lfs_sb_setcksum(fs, lfs_sb_cksum(fs));

sbin/newfs_lfs/make_lfs.c

981

lfs_writesuper(fs, seg_addr);

sbin/newfs_v7fs/main.c

109

v7fs_inode_writeback(fs, &inode);

sbin/newfs_v7fs/main.c

113

if ((error = v7fs_inode_allocate(fs, &ino))) {

sbin/newfs_v7fs/main.c

128

v7fs_datablock_expand(fs, &inode, sizeof(*dir) * 2);

sbin/newfs_v7fs/main.c

131

if (!(buf = scratch_read(fs, blk))) {

sbin/newfs_v7fs/main.c

132

v7fs_inode_deallocate(fs, ino);

sbin/newfs_v7fs/main.c

140

dir[0].inode_number = V7FS_VAL16(fs, ino);

sbin/newfs_v7fs/main.c

142

dir[1].inode_number = V7FS_VAL16(fs, ino);

sbin/newfs_v7fs/main.c

143

if (!fs->io.write(fs->io.cookie, buf, blk)) {/*writeback */

sbin/newfs_v7fs/main.c

144

scratch_free(fs, buf);

sbin/newfs_v7fs/main.c

149

scratch_free(fs, buf);

sbin/newfs_v7fs/main.c

150

v7fs_inode_writeback(fs, &inode);

sbin/newfs_v7fs/main.c

151

if ((error = v7fs_superblock_writeback(fs))) {

sbin/newfs_v7fs/main.c

160

make_freeblocklist(struct v7fs_self *fs, v7fs_daddr_t listblk, uint8_t *buf)

sbin/newfs_v7fs/main.c

162

uint32_t (*val32)(uint32_t) = fs->val.conv32;

sbin/newfs_v7fs/main.c

163

uint16_t (*val16)(uint16_t) = fs->val.conv16;

sbin/newfs_v7fs/main.c

172

if (j == (int32_t)fs->superblock.volume_size)

sbin/newfs_v7fs/main.c

183

fs->io.write(fs->io.cookie, buf, listblk);

sbin/newfs_v7fs/main.c

190

if (!fs->io.write(fs->io.cookie, buf, listblk)) {

sbin/newfs_v7fs/main.c

201

make_filesystem(struct v7fs_self *fs, v7fs_daddr_t volume_size,

sbin/newfs_v7fs/main.c

216

fs->io.write(fs->io.cookie, buf, i);

sbin/newfs_v7fs/main.c

225

sb = &fs->superblock;

sbin/newfs_v7fs/main.c

248

if ((error = v7fs_superblock_writeback(fs))) {

sbin/newfs_v7fs/main.c

259

while ((blk = make_freeblocklist(fs, blk, buf)))

sbin/newfs_v7fs/main.c

273

struct v7fs_self *fs;

sbin/newfs_v7fs/main.c

291

if ((error = v7fs_io_init(&fs, mount, V7FS_BSIZE))) {

sbin/newfs_v7fs/main.c

296

fs->endian = mount->endian;

sbin/newfs_v7fs/main.c

297

v7fs_endian_init(fs);

sbin/newfs_v7fs/main.c

299

if ((error = partition_check(fs))) {

sbin/newfs_v7fs/main.c

304

if ((error = make_filesystem(fs, volume_size, ilist_size))) {

sbin/newfs_v7fs/main.c

309

if ((error = make_root(fs))) {

sbin/newfs_v7fs/main.c

313

v7fs_io_fini(fs);

sbin/newfs_v7fs/main.c

76

partition_check(struct v7fs_self *fs)

sbin/newfs_v7fs/main.c

78

struct v7fs_superblock *sb = &fs->superblock;

sbin/newfs_v7fs/main.c

81

if ((error = v7fs_superblock_load(fs))) {

sbin/newfs_v7fs/main.c

88

if ((error = v7fs_superblock_writeback(fs))) {

sbin/newfs_v7fs/main.c

99

make_root(struct v7fs_self *fs)

sbin/resize_ffs/resize_ffs.c

147

#define dblksize(fs, dip, lbn, filesize) \

sbin/resize_ffs/resize_ffs.c

148

(((lbn) >= UFS_NDADDR || (uint64_t)(filesize) >= ffs_lblktosize(fs, (lbn) + 1)) \

sbin/resize_ffs/resize_ffs.c

149

? (fs)->fs_bsize \

sbin/resize_ffs/resize_ffs.c

150

: (ffs_fragroundup(fs, ffs_blkoff(fs, (filesize)))))

sbin/resize_ffs/resize_ffs.c

156

#define NSPB(fs) (FFS_FSBTODB((fs),1) << (fs)->fs_fragshift)

sbin/resize_ffs/resize_ffs.c

157

#define NSPF(fs) (FFS_FSBTODB((fs),1))

sbin/resize_ffs/resize_ffs.c

2225

oldsb = (struct fs *) & sbbuf;

sbin/resize_ffs/resize_ffs.c

2226

newsb = (struct fs *) (SBLOCKSIZE + (char *) &sbbuf);

sbin/resize_ffs/resize_ffs.c

86

static struct fs *oldsb; /* before we started */

sbin/resize_ffs/resize_ffs.c

87

static struct fs *newsb; /* copy to work with */

sbin/resize_ffs/resize_ffs.c

90

__attribute__((__aligned__(__alignof__(struct fs))));

sbin/resize_lfs/resize_lfs.c

127

fs = (struct lfs *)calloc(sizeof(*fs), 1);

sbin/resize_lfs/resize_lfs.c

131

memcpy(&fs->lfs_dlfs_u, buf, sizeof(struct dlfs));

sbin/resize_lfs/resize_lfs.c

132

if (sboff == LFS_LABELPAD && lfs_fsbtob(fs, 1) > LFS_LABELPAD)

sbin/resize_lfs/resize_lfs.c

133

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

sbin/resize_lfs/resize_lfs.c

140

newnsegs = (newsize * secsize) / lfs_sb_getssize(fs);

sbin/resize_lfs/resize_lfs.c

141

if (newnsegs == lfs_sb_getnseg(fs)) {

sbin/resize_lfs/resize_lfs.c

151

for (i = lfs_sb_getnseg(fs) - 1; i >= newnsegs; --i) {

sbin/resize_lfs/resize_lfs.c

171

fsname, lfs_sb_getnseg(fs), (long long)newnsegs);

sbin/resize_lfs/resize_lfs.c

71

struct lfs *fs;

sbin/scan_ffs/scan_ffs.c

459

sbinfo.ffs = (struct fs *)&buf[n];

sbin/scan_ffs/scan_ffs.c

70

struct fs *ffs;

sbin/tunefs/tunefs.c

100

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

sbin/tunefs/tunefs.c

455

ffs_sb_swap((struct fs*)&buf, (struct fs*)&buf);

sbin/tunefs/tunefs.c

661

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

sbin/tunefs/tunefs.c

668

bread(sblock_try[i] / dev_bsize, (char *)fs, SBLOCKSIZE, file);

sbin/tunefs/tunefs.c

669

switch(fs->fs_magic) {

sbin/tunefs/tunefs.c

687

ffs_sb_swap(fs, fs);

sbin/tunefs/tunefs.c

694

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

sbin/tunefs/tunefs.c

695

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

sbin/tunefs/tunefs.c

700

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

sbin/tunefs/tunefs.c

78

struct fs sb;

share/examples/puffs/pgfs/mount.c

133

PUFFSOP_SET(pops, pgfs, fs, statvfs);

sys/arch/acorn32/podulebus/sbic.c

2317

unsigned int fs;

sys/arch/acorn32/podulebus/sbic.c

2325

GET_SBIC_myid(regs,fs);

sys/arch/acorn32/podulebus/sbic.c

2326

fs = (fs >> 6) + 2; /* DIV */

sys/arch/acorn32/podulebus/sbic.c

2327

fs = (fs * 10000) / (dev->sc_clkfreq << 1); /* Cycle, in ns */

sys/arch/acorn32/podulebus/sbic.c

2330

return (fs * a) >> 2; /* in 4 ns units */

sys/arch/acorn32/podulebus/sbic.c

2336

register unsigned int fs, ret;

sys/arch/acorn32/podulebus/sbic.c

2340

GET_SBIC_myid(regs, fs);

sys/arch/acorn32/podulebus/sbic.c

2341

fs = (fs >> 6) + 2; /* DIV */

sys/arch/acorn32/podulebus/sbic.c

2342

fs = (fs * 10000) / (dev->sc_clkfreq << 1); /* Cycle, in ns */

sys/arch/acorn32/podulebus/sbic.c

2345

ret = ret / fs; /* in Cycles */

sys/arch/amd64/amd64/db_machdep.c

59

{ "fs", dbreg(fs), db_x86_regop, NULL },

sys/arch/amd64/include/frame_regs.h

52

greg(fs, FS, 16) /* tf_fs */ \

sys/arch/amd64/include/frameasm.h

342

movw %fs,TF_FS(%rsp) ; \

sys/arch/amiga/dev/sbic.c

2579

unsigned int fs;

sys/arch/amiga/dev/sbic.c

2587

GET_SBIC_myid(regs,fs);

sys/arch/amiga/dev/sbic.c

2588

fs = (fs >>6) + 2; /* DIV */

sys/arch/amiga/dev/sbic.c

2589

fs = (fs * 10000) / (dev->sc_clkfreq<<1); /* Cycle, in ns */

sys/arch/amiga/dev/sbic.c

2591

return ((fs*a)>>2); /* in 4 ns units */

sys/arch/amiga/dev/sbic.c

2597

register unsigned int fs, ret;

sys/arch/amiga/dev/sbic.c

2601

GET_SBIC_myid(regs,fs);

sys/arch/amiga/dev/sbic.c

2602

fs = (fs >>6) + 2; /* DIV */

sys/arch/amiga/dev/sbic.c

2603

fs = (fs * 10000) / (dev->sc_clkfreq<<1); /* Cycle, in ns */

sys/arch/amiga/dev/sbic.c

2606

ret = ret / fs; /* in Cycles */

sys/arch/arc/arc/minidebug.c

865

i.FRType.fd, i.FRType.fs, i.FRType.ft);

sys/arch/arm/nvidia/tegra_i2c.c

384

const uint32_t fs = I2C_READ(sc, I2C_FIFO_STATUS_REG);

sys/arch/arm/nvidia/tegra_i2c.c

386

__SHIFTOUT(fs, I2C_FIFO_STATUS_TX_FIFO_EMPTY_CNT);

sys/arch/arm/nvidia/tegra_i2c.c

440

const uint32_t fs = I2C_READ(sc, I2C_FIFO_STATUS_REG);

sys/arch/arm/nvidia/tegra_i2c.c

442

__SHIFTOUT(fs, I2C_FIFO_STATUS_RX_FIFO_FULL_CNT);

sys/arch/ews4800mips/stand/common/devopen.c

136

enum fstype fs;

sys/arch/ews4800mips/stand/common/devopen.c

145

fs = FSTYPE_USTARFS;

sys/arch/ews4800mips/stand/common/devopen.c

149

fs = fstype(partition);

sys/arch/ews4800mips/stand/common/devopen.c

155

switch (fs) {

sys/arch/hp300/dev/topcat.c

602

int width, height, cnt, fs;

sys/arch/hp300/dev/topcat.c

648

fs = ri->ri_font->stride;

sys/arch/hp300/dev/topcat.c

653

fr += fs;

sys/arch/hp300/stand/common/rawfs.c

101

struct rawfs_file *fs = (struct rawfs_file *)f->f_fsdata;

sys/arch/hp300/stand/common/rawfs.c

109

printf(" fs=0x%x\n", (u_long)fs);

sys/arch/hp300/stand/common/rawfs.c

114

if (fs->fs_len == 0)

sys/arch/hp300/stand/common/rawfs.c

118

if (fs->fs_len <= 0)

sys/arch/hp300/stand/common/rawfs.c

122

if (csize > fs->fs_len)

sys/arch/hp300/stand/common/rawfs.c

123

csize = fs->fs_len;

sys/arch/hp300/stand/common/rawfs.c

125

memcpy(addr, fs->fs_ptr, csize);

sys/arch/hp300/stand/common/rawfs.c

126

fs->fs_ptr += csize;

sys/arch/hp300/stand/common/rawfs.c

127

fs->fs_len -= csize;

sys/arch/hp300/stand/common/rawfs.c

179

struct rawfs_file *fs;

sys/arch/hp300/stand/common/rawfs.c

183

fs = (struct rawfs_file *)f->f_fsdata;

sys/arch/hp300/stand/common/rawfs.c

184

fs->fs_ptr = fs->fs_buf;

sys/arch/hp300/stand/common/rawfs.c

191

fs->fs_nextblk, RAWFS_BSIZE, fs->fs_buf, &len);

sys/arch/hp300/stand/common/rawfs.c

197

fs->fs_len = len;

sys/arch/hp300/stand/common/rawfs.c

198

fs->fs_nextblk += (RAWFS_BSIZE / DEV_BSIZE);

sys/arch/hp300/stand/common/rawfs.c

61

struct rawfs_file *fs;

sys/arch/hp300/stand/common/rawfs.c

67

fs = alloc(sizeof(struct rawfs_file));

sys/arch/hp300/stand/common/rawfs.c

68

fs->fs_nextblk = 0;

sys/arch/hp300/stand/common/rawfs.c

69

fs->fs_len = 0;

sys/arch/hp300/stand/common/rawfs.c

70

fs->fs_ptr = fs->fs_buf;

sys/arch/hp300/stand/common/rawfs.c

73

printf("rawfs_open: fs=0x%x\n", (u_long)fs);

sys/arch/hp300/stand/common/rawfs.c

76

f->f_fsdata = fs;

sys/arch/hp300/stand/common/rawfs.c

83

struct rawfs_file *fs;

sys/arch/hp300/stand/common/rawfs.c

85

fs = (struct rawfs_file *) f->f_fsdata;

sys/arch/hp300/stand/common/rawfs.c

89

printf("rawfs_close: fs=0x%x\n", (u_long)fs);

sys/arch/hp300/stand/common/rawfs.c

92

if (fs != (struct rawfs_file *)0)

sys/arch/hp300/stand/common/rawfs.c

93

dealloc(fs, sizeof(*fs));

sys/arch/hpc/stand/hpcboot/menu/menu.cpp

116

int fs = pref.rootfs + IDC_MAIN_ROOT_;

sys/arch/hpc/stand/hpcboot/menu/menu.cpp

117

_set_check(fs, TRUE);

sys/arch/hpc/stand/hpcboot/menu/menu.cpp

121

EnableWindow(_edit_md_root, fs == IDC_MAIN_ROOT_MD ? TRUE : FALSE);

sys/arch/hppa/stand/xxboot/readufs.c

152

struct ufs_info *ufsinfo = &fs;

sys/arch/hppa/stand/xxboot/readufs.c

239

p = alloca((disize + fs.bsize - 1) & ~(fs.bsize - 1));

sys/arch/hppa/stand/xxboot/readufs.c

313

p = alloca((disize + fs.bsize - 1) & ~(fs.bsize - 1));

sys/arch/hppa/stand/xxboot/readufs.c

349

p = malloc((disize + fs.bsize - 1) & ~(fs.bsize - 1));

sys/arch/hppa/stand/xxboot/readufs.c

40

struct ufs_info fs;

sys/arch/hppa/stand/xxboot/readufs.c

85

struct ufs_info *ufsinfo = &fs;

sys/arch/hppa/stand/xxboot/readufs_ffs.c

29

struct fs sblk;

sys/arch/i386/i386/db_machdep.c

70

{ "fs", dbreg(fs), db_x86_regop, NULL },

sys/arch/i386/include/asm.h

103

#define CPUVAR(off) %fs:__CONCAT(CPU_INFO_,off)

sys/arch/i386/include/frameasm.h

158

movw %fs,TF_FS(%esp) ; \

sys/arch/i386/include/frameasm.h

173

movl %eax,%fs ; \

sys/arch/luna68k/stand/boot/disklabel.c

116

struct fs *fp = (struct fs *)lbl_buff;

sys/arch/mips/include/mips_opcode.h

120

unsigned fs: 5;

sys/arch/mips/include/mips_opcode.h

76

unsigned fs: 5;

sys/arch/mips/mips/db_disasm.c

717

i.FRType.fd, i.FRType.fs, i.FRType.ft);

sys/arch/mvme68k/dev/sbic.c

2571

unsigned int fs;

sys/arch/mvme68k/dev/sbic.c

2579

GET_SBIC_myid(dev->sc_sbicp, fs);

sys/arch/mvme68k/dev/sbic.c

2581

fs = (fs >> 6) + 2; /* DIV */

sys/arch/mvme68k/dev/sbic.c

2583

fs = (fs * 10000) / (dev->sc_clkfreq << 1); /* Cycle, in ns */

sys/arch/mvme68k/dev/sbic.c

2588

return (fs * a) >> 2; /* in 4 ns units */

sys/arch/mvme68k/dev/sbic.c

2594

unsigned int fs, ret;

sys/arch/mvme68k/dev/sbic.c

2599

GET_SBIC_myid(dev->sc_sbicp, fs);

sys/arch/mvme68k/dev/sbic.c

2601

fs = (fs >> 6) + 2; /* DIV */

sys/arch/mvme68k/dev/sbic.c

2603

fs = (fs * 10000) / (dev->sc_clkfreq << 1); /* Cycle, in ns */

sys/arch/mvme68k/dev/sbic.c

2606

ret = ret / fs; /* in Cycles */

sys/arch/mvme68k/stand/bootst/rawfs.c

101

if (fs->fs_len <= 0)

sys/arch/mvme68k/stand/bootst/rawfs.c

105

if (csize > fs->fs_len)

sys/arch/mvme68k/stand/bootst/rawfs.c

106

csize = fs->fs_len;

sys/arch/mvme68k/stand/bootst/rawfs.c

108

memcpy(addr, fs->fs_ptr, csize);

sys/arch/mvme68k/stand/bootst/rawfs.c

109

fs->fs_ptr += csize;

sys/arch/mvme68k/stand/bootst/rawfs.c

110

fs->fs_len -= csize;

sys/arch/mvme68k/stand/bootst/rawfs.c

134

struct file *fs = (struct file *)f->f_fsdata;

sys/arch/mvme68k/stand/bootst/rawfs.c

147

curblk = (fs->fs_curblk < 0) ? 0 : fs->fs_curblk;

sys/arch/mvme68k/stand/bootst/rawfs.c

159

if (fs->fs_curblk < 0)

sys/arch/mvme68k/stand/bootst/rawfs.c

162

newoff = fs->fs_curblk * RAWFS_BSIZE;

sys/arch/mvme68k/stand/bootst/rawfs.c

163

newoff += RAWFS_BSIZE - fs->fs_len;

sys/arch/mvme68k/stand/bootst/rawfs.c

184

while (fs->fs_curblk != targblk && (err = rawfs_get_block(f)) == 0)

sys/arch/mvme68k/stand/bootst/rawfs.c

196

fs->fs_len = RAWFS_BSIZE - idx;

sys/arch/mvme68k/stand/bootst/rawfs.c

197

fs->fs_ptr = &fs->fs_buf[idx];

sys/arch/mvme68k/stand/bootst/rawfs.c

217

struct file *fs;

sys/arch/mvme68k/stand/bootst/rawfs.c

221

fs = (struct file *)f->f_fsdata;

sys/arch/mvme68k/stand/bootst/rawfs.c

222

fs->fs_ptr = fs->fs_buf;

sys/arch/mvme68k/stand/bootst/rawfs.c

226

fs->fs_nextblk * (RAWFS_BSIZE / DEV_BSIZE),

sys/arch/mvme68k/stand/bootst/rawfs.c

227

RAWFS_BSIZE, fs->fs_buf, &len);

sys/arch/mvme68k/stand/bootst/rawfs.c

230

fs->fs_len = len;

sys/arch/mvme68k/stand/bootst/rawfs.c

231

fs->fs_curblk = fs->fs_nextblk;

sys/arch/mvme68k/stand/bootst/rawfs.c

232

fs->fs_nextblk += 1;

sys/arch/mvme68k/stand/bootst/rawfs.c

59

struct file *fs;

sys/arch/mvme68k/stand/bootst/rawfs.c

65

fs = alloc(sizeof(struct file));

sys/arch/mvme68k/stand/bootst/rawfs.c

66

fs->fs_nextblk = 0;

sys/arch/mvme68k/stand/bootst/rawfs.c

67

fs->fs_curblk = -1;

sys/arch/mvme68k/stand/bootst/rawfs.c

68

fs->fs_len = 0;

sys/arch/mvme68k/stand/bootst/rawfs.c

69

fs->fs_ptr = fs->fs_buf;

sys/arch/mvme68k/stand/bootst/rawfs.c

71

f->f_fsdata = fs;

sys/arch/mvme68k/stand/bootst/rawfs.c

77

struct file *fs;

sys/arch/mvme68k/stand/bootst/rawfs.c

79

fs = (struct file *)f->f_fsdata;

sys/arch/mvme68k/stand/bootst/rawfs.c

82

if (fs != NULL)

sys/arch/mvme68k/stand/bootst/rawfs.c

83

dealloc(fs, sizeof(*fs));

sys/arch/mvme68k/stand/bootst/rawfs.c

90

struct file *fs = (struct file *)f->f_fsdata;

sys/arch/mvme68k/stand/bootst/rawfs.c

97

if (fs->fs_len == 0)

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

243

struct fs *fs;

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

281

fs = (struct fs *)sblock;

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

284

if (fs->fs_magic != FS_UFS1_MAGIC)

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

286

if (fs->fs_inopb <= 0)

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

287

err(1, "Bad inopb=%d in superblock", fs->fs_inopb);

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

290

if ((buf = malloc(fs->fs_bsize)) == NULL)

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

293

blk = FFS_FSBTODB(fs, ino_to_fsba(fs, statbuf.st_ino));

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

294

devread(devfd, buf, blk, fs->fs_bsize, "inode");

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

295

ip = (struct ufs1_dinode *)(buf) + ino_to_fsbo(fs, statbuf.st_ino);

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

300

ndb = howmany(ip->di_size, fs->fs_bsize);

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

304

*block_size_p = fs->fs_bsize;

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

307

ndb, fs->fs_bsize);

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

314

blk = FFS_FSBTODB(fs, *ap);

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

326

blk = FFS_FSBTODB(fs, ip->di_ib[0]);

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

327

devread(devfd, buf, blk, fs->fs_bsize, "indirect block");

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

330

for (; i < FFS_NINDIR(fs) && *ap && ndb; i++, ap++, ndb--) {

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

331

blk = FFS_FSBTODB(fs, *ap);

sys/arch/powerpc/fpu/fpu_emu.c

162

#define FR(reg) (fs->fpreg[reg])

sys/arch/powerpc/fpu/fpu_emu.c

351

struct fpreg *fs;

sys/arch/powerpc/fpu/fpu_emu.c

356

fs = fe->fe_fpstate;

sys/arch/powerpc/fpu/fpu_emu.c

357

fe->fe_fpscr = ((int *)&fs->fpscr)[1];

sys/arch/powerpc/fpu/fpu_emu.c

410

a = (int *)&fs->fpreg[rt];

sys/arch/powerpc/fpu/fpu_emu.c

586

memcpy(&fs->fpreg[rt], &fs->fpreg[rb],

sys/arch/powerpc/fpu/fpu_emu.c

588

a = (int *)&fs->fpreg[rt];

sys/arch/powerpc/fpu/fpu_emu.c

615

memcpy(&fs->fpreg[rt], &fs->fpreg[rb],

sys/arch/powerpc/fpu/fpu_emu.c

630

memcpy(&fs->fpreg[rt], &fs->fpreg[rb],

sys/arch/powerpc/fpu/fpu_emu.c

632

a = (int *)&fs->fpreg[rt];

sys/arch/powerpc/fpu/fpu_emu.c

638

memcpy(&fs->fpreg[rt], &fs->fpreg[rb],

sys/arch/powerpc/fpu/fpu_emu.c

640

a = (int *)&fs->fpreg[rt];

sys/arch/powerpc/fpu/fpu_emu.c

646

memcpy(&fs->fpreg[rt], &fs->fpscr,

sys/arch/powerpc/fpu/fpu_emu.c

647

sizeof(fs->fpscr));

sys/arch/powerpc/fpu/fpu_emu.c

662

a = (int *)&fs->fpreg[rb];

sys/arch/powerpc/fpu/fpu_emu.c

738

memcpy(&fs->fpreg[rt], &fs->fpreg[rc],

sys/arch/powerpc/fpu/fpu_emu.c

871

((int *)&fs->fpscr)[1] = fsr;

sys/arch/powerpc/ibm4xx/dev/emacreg.h

66

#define MR1_RFS(fs) /* Receive FIFO size */ \

sys/arch/powerpc/ibm4xx/dev/emacreg.h

67

(((fs) << 20) & 0x00300000)

sys/arch/powerpc/ibm4xx/dev/emacreg.h

68

#define MR1_TFS(fs) /* Transmit FIFO size */ \

sys/arch/powerpc/ibm4xx/dev/emacreg.h

69

(((fs) << 18) & 0x000c0000)

sys/arch/powerpc/ibm4xx/dev/emacreg.h

70

#define MR1_RFS_GBE(fs) /* GbE's Receive FIFO size */ \

sys/arch/powerpc/ibm4xx/dev/emacreg.h

71

(((fs) << 19) & 0x00380000)

sys/arch/powerpc/ibm4xx/dev/emacreg.h

72

#define MR1_TFS_GBE(fs) /* GbE's Transmit FIFO size */ \

sys/arch/powerpc/ibm4xx/dev/emacreg.h

73

(((fs) << 16) & 0x00070000)

sys/arch/sandpoint/stand/altboot/dsk.c

488

struct fs_ops *fs;

sys/arch/sandpoint/stand/altboot/dsk.c

510

fs = &fs_ffsv2;

sys/arch/sandpoint/stand/altboot/dsk.c

514

fs = &fs_ffsv1;

sys/arch/sandpoint/stand/altboot/dsk.c

521

d->fsops = fs;

sys/arch/sandpoint/stand/altboot/dsk.c

534

struct fs_ops *fs = d->fsops;

sys/arch/sandpoint/stand/altboot/dsk.c

536

(*fs->close)(f);

sys/arch/sparc/fpu/fpu.c

132

struct fpstate *fs

sys/arch/sparc/fpu/fpu.c

134

struct fpstate64 *fs

sys/arch/sparc/fpu/fpu.c

138

int i, fsr = fs->fs_fsr, error;

sys/arch/sparc/fpu/fpu.c

171

if (fs->fs_qsize == 0) {

sys/arch/sparc/fpu/fpu.c

181

if (fs->fs_qsize == 0)

sys/arch/sparc/fpu/fpu.c

203

fe.fe_fpstate = fs;

sys/arch/sparc/fpu/fpu.c

204

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

sys/arch/sparc/fpu/fpu.c

205

instr.i_int = fs->fs_queue[i].fq_instr;

sys/arch/sparc/fpu/fpu.c

216

code = fpu_codes[(fs->fs_fsr & FSR_CX) - 1];

sys/arch/sparc/fpu/fpu.c

235

fs->fs_qsize = 0;

sys/arch/sparc/fpu/fpu.c

247

fpu_emulate(l, tf, fs)

sys/arch/sparc/fpu/fpu.c

251

struct fpstate *fs;

sys/arch/sparc/fpu/fpu.c

253

struct fpstate64 *fs;

sys/arch/sparc/fpu/fpu.c

279

fe.fe_fsr = fs->fs_fsr &= ~FSR_CX;

sys/arch/sparc/fpu/fpu.c

280

error = fpu_execute(&fe, fs, instr);

sys/arch/sparc/fpu/fpu.c

306

struct fpstate *fs;

sys/arch/sparc/fpu/fpu.c

309

struct fpstate64 *fs;

sys/arch/sparc/fpu/fpu.c

348

fs = fe->fe_fpstate;

sys/arch/sparc/fpu/fpu.c

349

fe->fe_fsr = fs->fs_fsr & ~FSR_CX;

sys/arch/sparc/fpu/fpu.c

360

cond = (fs->fs_fsr>>FSR_FCC_SHIFT)&FSR_FCC_MASK;

sys/arch/sparc/fpu/fpu.c

362

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

366

cond = (fs->fs_fsr>>FSR_FCC1_SHIFT)&FSR_FCC_MASK;

sys/arch/sparc/fpu/fpu.c

368

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

372

cond = (fs->fs_fsr>>FSR_FCC2_SHIFT)&FSR_FCC_MASK;

sys/arch/sparc/fpu/fpu.c

374

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

378

cond = (fs->fs_fsr>>FSR_FCC3_SHIFT)&FSR_FCC_MASK;

sys/arch/sparc/fpu/fpu.c

380

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

387

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

394

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

402

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

410

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

418

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

426

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

434

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

442

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

462

rs1 = fs->fs_regs[rs2];

sys/arch/sparc/fpu/fpu.c

467

rs1 = fs->fs_regs[rs2] ^ (1 << 31);

sys/arch/sparc/fpu/fpu.c

472

rs1 = fs->fs_regs[rs2] & ~(1 << 31);

sys/arch/sparc/fpu/fpu.c

475

fs->fs_regs[rd] = rs1;

sys/arch/sparc/fpu/fpu.c

478

fs->fs_regs[rd++] = rs1;

sys/arch/sparc/fpu/fpu.c

480

fs->fs_regs[rd++] = fs->fs_regs[++rs2];

sys/arch/sparc/fpu/fpu.c

482

fs->fs_fsr = fe->fe_fsr;

sys/arch/sparc/fpu/fpu.c

540

fs->fs_fsr = (fsr & ~FSR_FTT) |

sys/arch/sparc/fpu/fpu.c

546

fs->fs_fsr = fsr;

sys/arch/sparc/fpu/fpu.c

613

fs->fs_fsr = (fsr & ~FSR_FTT) |

sys/arch/sparc/fpu/fpu.c

620

fs->fs_fsr = fsr;

sys/arch/sparc/fpu/fpu.c

627

fs->fs_regs[rd] = space[0];

sys/arch/sparc/fpu/fpu.c

629

fs->fs_regs[rd + 1] = space[1];

sys/arch/sparc/fpu/fpu.c

631

fs->fs_regs[rd + 2] = space[2];

sys/arch/sparc/fpu/fpu.c

632

fs->fs_regs[rd + 3] = space[3];

sys/arch/sparc/sparc/machdep.c

348

struct fpstate *fs;

sys/arch/sparc/sparc/machdep.c

362

if ((fs = l->l_md.md_fpstate) != NULL) {

sys/arch/sparc/sparc/machdep.c

376

savefpstate(fs);

sys/arch/sparc/sparc/machdep.c

379

XCALL1(ipi_savefpstate, fs, 1 << cpi->ci_cpuid);

sys/arch/sparc/sparc/machdep.c

385

kmem_free(fs, sizeof(struct fpstate));

sys/arch/sparc/sparc/process_machdep.c

159

struct fpstate *fs;

sys/arch/sparc/sparc/process_machdep.c

161

if ((fs = l->l_md.md_fpstate) == NULL)

sys/arch/sparc/sparc/process_machdep.c

162

fs = &initfpstate;

sys/arch/sparc/sparc/process_machdep.c

164

*regs = fs->fs_reg;

sys/arch/sparc/sparc/process_machdep.c

171

struct fpstate *fs;

sys/arch/sparc/sparc/process_machdep.c

173

if ((fs = l->l_md.md_fpstate) == NULL) {

sys/arch/sparc/sparc/process_machdep.c

174

fs = kmem_zalloc(sizeof(*fs), KM_SLEEP);

sys/arch/sparc/sparc/process_machdep.c

175

l->l_md.md_fpstate = fs;

sys/arch/sparc/sparc/process_machdep.c

178

fs->fs_qsize = 0;

sys/arch/sparc/sparc/process_machdep.c

182

fs->fs_reg = *regs;

sys/arch/sparc/sparc/trap.c

396

struct fpstate *fs = l->l_md.md_fpstate;

sys/arch/sparc/sparc/trap.c

407

if (fs == NULL) {

sys/arch/sparc/sparc/trap.c

408

fs = kmem_alloc(sizeof(struct fpstate), KM_SLEEP);

sys/arch/sparc/sparc/trap.c

409

*fs = initfpstate;

sys/arch/sparc/sparc/trap.c

410

l->l_md.md_fpstate = fs;

sys/arch/sparc/sparc/trap.c

417

fpu_emulate(l, tf, fs);

sys/arch/sparc/sparc/trap.c

432

if (fs->fs_qsize) {

sys/arch/sparc/sparc/trap.c

433

if ((code = fpu_cleanup(l, fs)) != 0) {

sys/arch/sparc/sparc/trap.c

467

XCALL1(ipi_savefpstate, fs, 1 << cpi->ci_cpuid);

sys/arch/sparc/sparc/trap.c

471

loadfpstate(fs);

sys/arch/sparc/sparc/vm_machdep.c

295

struct fpstate *fs;

sys/arch/sparc/sparc/vm_machdep.c

297

if ((fs = l->l_md.md_fpstate) != NULL) {

sys/arch/sparc/sparc/vm_machdep.c

307

savefpstate(fs);

sys/arch/sparc/sparc/vm_machdep.c

310

XCALL1(ipi_savefpstate, fs, 1 << cpi->ci_cpuid);

sys/arch/sparc/sparc/vm_machdep.c

322

struct fpstate *fs;

sys/arch/sparc/sparc/vm_machdep.c

324

if ((fs = l->l_md.md_fpstate) != NULL)

sys/arch/sparc/sparc/vm_machdep.c

325

kmem_free(fs, sizeof(struct fpstate));

sys/arch/sparc64/sparc64/machdep.c

232

struct fpstate64 *fs;

sys/arch/sparc64/sparc64/machdep.c

272

if ((fs = l->l_md.md_fpstate) != NULL) {

sys/arch/sparc64/sparc64/machdep.c

279

pool_cache_put(fpstate_cache, fs);

sys/arch/sparc64/sparc64/netbsd32_machdep.c

107

struct fpstate64 *fs;

sys/arch/sparc64/sparc64/netbsd32_machdep.c

133

if ((fs = l->l_md.md_fpstate) != NULL) {

sys/arch/sparc64/sparc64/netbsd32_machdep.c

140

pool_cache_put(fpstate_cache, fs);

sys/arch/sparc64/sparc64/netbsd32_machdep.c

463

mcp->__fpregs.__fpu_fsr = fs.fs_fsr;

sys/arch/sparc64/sparc64/netbsd32_machdep.c

971

mcp->__fpregs.__fpu_fsr = fs.fs_fsr;

sys/arch/sparc64/sparc64/process_machdep.c

206

const struct fpstate64 *fs;

sys/arch/sparc64/sparc64/process_machdep.c

208

if ((fs = l->l_md.md_fpstate) == NULL)

sys/arch/sparc64/sparc64/process_machdep.c

209

fs = &initfpstate;

sys/arch/sparc64/sparc64/process_machdep.c

213

*regs = fs->fs_reg;

sys/arch/sparc64/sparc64/process_machdep.c

222

regp->fr_regs[i] = fs->fs_regs[i];

sys/arch/sparc64/sparc64/process_machdep.c

223

regp->fr_fsr = fs->fs_fsr;

sys/arch/sparc64/sparc64/process_machdep.c

231

struct fpstate64 *fs;

sys/arch/sparc64/sparc64/process_machdep.c

233

if ((fs = l->l_md.md_fpstate) == NULL) {

sys/arch/sparc64/sparc64/process_machdep.c

234

fs = pool_cache_get(fpstate_cache, PR_WAITOK);

sys/arch/sparc64/sparc64/process_machdep.c

235

memcpy(fs, &initfpstate, sizeof *fs);

sys/arch/sparc64/sparc64/process_machdep.c

236

l->l_md.md_fpstate = fs;

sys/arch/sparc64/sparc64/process_machdep.c

238

fs->fs_qsize = 0;

sys/arch/sparc64/sparc64/process_machdep.c

243

fs->fs_reg = *regs;

sys/arch/sparc64/sparc64/process_machdep.c

251

fs->fs_regs[i] = regp->fr_regs[i];

sys/arch/sparc64/sparc64/process_machdep.c

252

fs->fs_fsr = regp->fr_fsr;

sys/arch/sparc64/sparc64/sunos32_machdep.c

108

struct fpstate64 *fs;

sys/arch/sparc64/sparc64/sunos32_machdep.c

135

if ((fs = l->l_md.md_fpstate) != NULL) {

sys/arch/sparc64/sparc64/sunos32_machdep.c

142

savefpstate(fs);

sys/arch/sparc64/sparc64/sunos32_machdep.c

145

pool_cache_put(fpstate_cache, fs);

sys/arch/sparc64/sparc64/trap.c

667

struct fpstate64 *fs = l->l_md.md_fpstate;

sys/arch/sparc64/sparc64/trap.c

669

if (fs == NULL) {

sys/arch/sparc64/sparc64/trap.c

671

fs = pool_cache_get(fpstate_cache, PR_WAITOK);

sys/arch/sparc64/sparc64/trap.c

672

*fs = initfpstate;

sys/arch/sparc64/sparc64/trap.c

673

l->l_md.md_fpstate = fs;

sys/arch/sparc64/sparc64/trap.c

682

if (fs->fs_qsize) {

sys/arch/sparc64/sparc64/trap.c

683

printf("trap: Warning fs_qsize is %d\n",fs->fs_qsize);

sys/arch/sparc64/sparc64/trap.c

684

fpu_cleanup(l, fs);

sys/arch/sparc64/sparc64/trap.c

695

loadfpstate(fs);

sys/arch/sparc64/sparc64/vm_machdep.c

350

struct fpstate64 *fs;

sys/arch/sparc64/sparc64/vm_machdep.c

352

if ((fs = l->l_md.md_fpstate) != NULL)

sys/arch/sparc64/sparc64/vm_machdep.c

353

pool_cache_put(fpstate_cache, fs);

sys/arch/sun68k/stand/tapeboot/rawfs.c

106

struct file *fs = (struct file *)f->f_fsdata;

sys/arch/sun68k/stand/tapeboot/rawfs.c

112

if (fs->fs_len == 0)

sys/arch/sun68k/stand/tapeboot/rawfs.c

116

if (fs->fs_len <= 0)

sys/arch/sun68k/stand/tapeboot/rawfs.c

120

if (csize > fs->fs_len)

sys/arch/sun68k/stand/tapeboot/rawfs.c

121

csize = fs->fs_len;

sys/arch/sun68k/stand/tapeboot/rawfs.c

123

memcpy(addr, fs->fs_ptr, csize);

sys/arch/sun68k/stand/tapeboot/rawfs.c

124

fs->fs_off += csize;

sys/arch/sun68k/stand/tapeboot/rawfs.c

125

fs->fs_ptr += csize;

sys/arch/sun68k/stand/tapeboot/rawfs.c

126

fs->fs_len -= csize;

sys/arch/sun68k/stand/tapeboot/rawfs.c

147

struct file *fs = (struct file *)f->f_fsdata;

sys/arch/sun68k/stand/tapeboot/rawfs.c

152

offset -= fs->fs_off;

sys/arch/sun68k/stand/tapeboot/rawfs.c

165

if (fs->fs_len == 0)

sys/arch/sun68k/stand/tapeboot/rawfs.c

169

if (fs->fs_len <= 0)

sys/arch/sun68k/stand/tapeboot/rawfs.c

173

if (csize > fs->fs_len)

sys/arch/sun68k/stand/tapeboot/rawfs.c

174

csize = fs->fs_len;

sys/arch/sun68k/stand/tapeboot/rawfs.c

176

fs->fs_off += csize;

sys/arch/sun68k/stand/tapeboot/rawfs.c

177

fs->fs_ptr += csize;

sys/arch/sun68k/stand/tapeboot/rawfs.c

178

fs->fs_len -= csize;

sys/arch/sun68k/stand/tapeboot/rawfs.c

181

return (fs->fs_off);

sys/arch/sun68k/stand/tapeboot/rawfs.c

201

struct file *fs;

sys/arch/sun68k/stand/tapeboot/rawfs.c

205

fs = (struct file *)f->f_fsdata;

sys/arch/sun68k/stand/tapeboot/rawfs.c

206

fs->fs_ptr = fs->fs_buf;

sys/arch/sun68k/stand/tapeboot/rawfs.c

210

fs->fs_nextblk, RAWFS_BSIZE, fs->fs_buf, &len);

sys/arch/sun68k/stand/tapeboot/rawfs.c

213

fs->fs_len = len;

sys/arch/sun68k/stand/tapeboot/rawfs.c

214

fs->fs_nextblk += (RAWFS_BSIZE / DEV_BSIZE);

sys/arch/sun68k/stand/tapeboot/rawfs.c

62

struct file *fs;

sys/arch/sun68k/stand/tapeboot/rawfs.c

68

fs = alloc(sizeof(struct file));

sys/arch/sun68k/stand/tapeboot/rawfs.c

69

fs->fs_nextblk = 0;

sys/arch/sun68k/stand/tapeboot/rawfs.c

70

fs->fs_off = 0;

sys/arch/sun68k/stand/tapeboot/rawfs.c

71

fs->fs_len = 0;

sys/arch/sun68k/stand/tapeboot/rawfs.c

72

fs->fs_ptr = fs->fs_buf;

sys/arch/sun68k/stand/tapeboot/rawfs.c

75

printf("rawfs_open: fs=0x%x\n", fs);

sys/arch/sun68k/stand/tapeboot/rawfs.c

78

f->f_fsdata = fs;

sys/arch/sun68k/stand/tapeboot/rawfs.c

85

struct file *fs;

sys/arch/sun68k/stand/tapeboot/rawfs.c

87

fs = (struct file *) f->f_fsdata;

sys/arch/sun68k/stand/tapeboot/rawfs.c

92

printf("rawfs_close: breakpoint...", fs->fs_buf);

sys/arch/sun68k/stand/tapeboot/rawfs.c

97

if (fs != NULL)

sys/arch/sun68k/stand/tapeboot/rawfs.c

98

dealloc(fs, sizeof(*fs));

sys/arch/x68k/stand/boot/boot.c

139

struct fs_ops *fs;

sys/arch/x68k/stand/boot/boot.c

206

fs = &file_system_nfs[0];

sys/arch/x68k/stand/boot/boot.c

208

fs = &file_system_ustarfs[0];

sys/arch/x68k/stand/boot/boot.c

210

memcpy(&file_system[nfsys - 1], fs, sizeof(*fs));

sys/arch/x68k/stand/boot_ufs/readufs.c

152

struct ufs_info *ufsinfo = &fs;

sys/arch/x68k/stand/boot_ufs/readufs.c

240

p = alloca((disize + fs.bsize - 1) & ~(fs.bsize - 1));

sys/arch/x68k/stand/boot_ufs/readufs.c

242

p = alloca(disize + fs.bsize);

sys/arch/x68k/stand/boot_ufs/readufs.c

317

p = alloca((disize + fs.bsize - 1) & ~(fs.bsize - 1));

sys/arch/x68k/stand/boot_ufs/readufs.c

353

p = malloc((disize + fs.bsize - 1) & ~(fs.bsize - 1));

sys/arch/x68k/stand/boot_ufs/readufs.c

40

struct ufs_info fs;

sys/arch/x68k/stand/boot_ufs/readufs.c

85

struct ufs_info *ufsinfo = &fs;

sys/arch/x68k/stand/boot_ufs/readufs_ffs.c

31

struct fs sblk;

sys/arch/xen/x86/cpu.c

976

initctx->user_regs.fs = GSEL(GDATA_SEL, SEL_KPL);

sys/compat/linux/arch/amd64/linux_machdep.c

211

sigframe.uc.luc_mcontext.fs = tf->tf_fs & 0xFFFF;

sys/compat/linux/arch/amd64/linux_machdep.c

374

mctx->__gregs[_REG_FS] = lsigctx->fs & 0xFFFF;

sys/compat/linux/arch/amd64/linux_machdep.h

82

u_int16_t fs;

sys/compat/sys/mount.h

101

statvfs_to_statfs12(const struct statvfs *fs, struct statfs12 *s12)

sys/compat/sys/mount.h

108

s12->f_oflags = (short)fs->f_flag;

sys/compat/sys/mount.h

111

if (strcmp(__nv[i].name, fs->f_fstypename) == 0) {

sys/compat/sys/mount.h

117

s12->f_bsize = __STATFSCLAMP(fs->f_frsize);

sys/compat/sys/mount.h

118

s12->f_iosize = __STATFSCLAMP(fs->f_iosize);

sys/compat/sys/mount.h

119

s12->f_blocks = __STATFSCLAMP(fs->f_blocks);

sys/compat/sys/mount.h

120

s12->f_bfree = __STATFSCLAMP(fs->f_bfree);

sys/compat/sys/mount.h

121

if (fs->f_bfree > fs->f_bresvd)

sys/compat/sys/mount.h

122

s12->f_bavail = __STATFSCLAMP(fs->f_bfree - fs->f_bresvd);

sys/compat/sys/mount.h

124

s12->f_bavail = -__STATFSCLAMP(fs->f_bresvd - fs->f_bfree);

sys/compat/sys/mount.h

125

s12->f_files = __STATFSCLAMP(fs->f_files);

sys/compat/sys/mount.h

126

s12->f_ffree = __STATFSCLAMP(fs->f_ffree);

sys/compat/sys/mount.h

127

s12->f_fsid = fs->f_fsidx;

sys/compat/sys/mount.h

128

s12->f_owner = fs->f_owner;

sys/compat/sys/mount.h

129

s12->f_flags = (long)fs->f_flag;

sys/compat/sys/mount.h

130

s12->f_syncwrites = __STATFSCLAMP(fs->f_syncwrites);

sys/compat/sys/mount.h

131

s12->f_asyncwrites = __STATFSCLAMP(fs->f_asyncwrites);

sys/compat/sys/mount.h

132

memcpy(s12->f_fstypename, fs->f_fstypename, sizeof(s12->f_fstypename));

sys/compat/sys/mount.h

133

memcpy(s12->f_mntonname, fs->f_mntonname, sizeof(s12->f_mntonname));

sys/compat/sys/mount.h

134

memcpy(s12->f_mntfromname, fs->f_mntfromname,

sys/dev/i2c/zl10353.c

594

fe_status_t fs = 0;

sys/dev/i2c/zl10353.c

600

fs |= FE_HAS_LOCK;

sys/dev/i2c/zl10353.c

603

fs |= FE_HAS_CARRIER;

sys/dev/i2c/zl10353.c

606

fs |= FE_HAS_VITERBI;

sys/dev/i2c/zl10353.c

612

fs |= FE_HAS_SYNC;

sys/dev/i2c/zl10353.c

618

fs |= FE_HAS_SIGNAL;

sys/dev/i2c/zl10353.c

621

return ((fs & lock) != lock) ? fs & ~FE_HAS_LOCK : fs;

sys/dev/ic/ad1848.c

923

u_char fs;

sys/dev/ic/ad1848.c

935

fs = sc->speed_bits | (sc->format_bits << 5);

sys/dev/ic/ad1848.c

938

fs |= FMT_STEREO;

sys/dev/ic/ad1848.c

948

ad_write(sc, SP_CLOCK_DATA_FORMAT, fs);

sys/dev/ic/ad1848.c

967

ad_write(sc, CS_REC_FORMAT, fs);

sys/dev/ic/vga_raster.c

1129

struct vga_raster_font *fs;

sys/dev/ic/vga_raster.c

1137

LIST_FOREACH(fs, &scr->fontset, next) {

sys/dev/ic/vga_raster.c

1138

if ((scr->encoding == fs->font->encoding) &&

sys/dev/ic/vga_raster.c

1139

(c >= fs->font->firstchar) &&

sys/dev/ic/vga_raster.c

1140

(c < fs->font->firstchar + fs->font->numchars) &&

sys/dev/ic/vga_raster.c

1141

(scr->type->fontheight == fs->font->fontheight)) {

sys/dev/ic/vga_raster.c

1143

tmp_ch = c - fs->font->firstchar;

sys/dev/ic/vga_raster.c

1145

attr, fs);

sys/dev/ic/vga_raster.c

1151

scr->mem[off].enc = fs->font->encoding;

sys/dev/ic/vga_raster.c

1153

if (fs->font->stride == 2) {

sys/dev/ic/vga_raster.c

1157

scr->mem[off + 1].enc = fs->font->encoding;

sys/dev/ic/vga_raster.c

1182

struct vga_raster_font *fs)

sys/dev/ic/vga_raster.c

1205

if (fs->font->stride == 1) {

sys/dev/ic/vga_raster.c

1217

pattern = ((u_int8_t *)fs->font->data)[c * fheight + i];

sys/dev/ic/vga_raster.c

1225

} else if (fs->font->stride == 2) {

sys/dev/ic/vga_raster.c

1238

pattern = ((u_int8_t *)fs->font->data)

sys/dev/ic/vga_raster.c

1244

pattern = ((u_int8_t *)fs->font->data)

sys/dev/ieee1394/iec68113.h

85

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

sys/dev/ieee1394/iec68113.h

92

fs:1; /* 50/60 field system

sys/dev/ir/sir.h

71

#define deframe_isclear(fs) ((fs)->fsmstate == FSTATE_END_OF_FRAME)

sys/dev/isa/finsio_isa.c

632

struct finsio_sensor *fs = &sc->sc_finsio_sensors[edata->sensor];

sys/dev/isa/finsio_isa.c

635

data = finsio_readreg(sc->sc_iot, sc->sc_ioh, fs->fs_reg);

sys/dev/isa/finsio_isa.c

645

edata->value_cur = data * fs->fs_rfact;

sys/dev/isa/finsio_isa.c

653

struct finsio_sensor *fs = &sc->sc_finsio_sensors[edata->sensor];

sys/dev/isa/finsio_isa.c

663

data = finsio_readreg(sc->sc_iot, sc->sc_ioh, fs->fs_reg) & 0xFF;

sys/dev/isa/finsio_isa.c

666

llmax = (sc->sc_tempsel & fs->fs_aux) ? 111 : 128;

sys/dev/isa/finsio_isa.c

679

struct finsio_sensor *fs = &sc->sc_finsio_sensors[edata->sensor];

sys/dev/isa/finsio_isa.c

682

data = finsio_readreg(sc->sc_iot, sc->sc_ioh, fs->fs_reg) << 8;

sys/dev/isa/finsio_isa.c

683

data |= finsio_readreg(sc->sc_iot, sc->sc_ioh, fs->fs_reg + 1);

sys/dev/midisyn.c

169

struct midisyn_methods *fs;

sys/dev/midisyn.c

174

fs = ms->mets;

sys/dev/midisyn.c

179

if (fs->close)

sys/dev/midisyn.c

180

fs->close(ms);

sys/dev/midisyn.c

349

struct midisyn_methods *fs;

sys/dev/midisyn.c

355

fs = ms->mets;

sys/dev/midisyn.c

369

fs->releasev(ms, voice, buf[2]);

sys/dev/midisyn.c

382

voice = fs->allocv(ms, chan, buf[1]);

sys/dev/midisyn.c

384

fs->attackv_vel(ms, voice,

sys/dev/midisyn.c

405

if (fs->pgmchg)

sys/dev/midisyn.c

406

fs->pgmchg(ms, chan, buf[1]);

sys/dev/nvmm/x86/nvmm_x86_svm.c

2040

&vmcb->state.fs);

sys/dev/nvmm/x86/nvmm_x86_svm.c

2181

&vmcb->state.fs);

sys/dev/nvmm/x86/nvmm_x86_svm.c

433

struct vmcb_segment fs;

sys/dev/pci/tga.c

1219

int fs, height, width;

sys/dev/pci/tga.c

1231

fs = ri->ri_font->stride;

sys/dev/pci/tga.c

1260

fr += fs;

sys/dev/sbus/zx.c

1016

fs = font->stride;

sys/dev/sbus/zx.c

1031

fb += fs;

sys/dev/sbus/zx.c

1036

fb += fs;

sys/dev/sbus/zx.c

995

int fs, i, ul;

sys/fs/nfs/client/nfs_clvfsops.c

287

struct nfsfsinfo fs;

sys/fs/nfs/client/nfs_clvfsops.c

306

error = nfsrpc_fsinfo(vp, &fs, td->td_ucred, td, &nfsva,

sys/fs/nfs/client/nfs_clvfsops.c

313

error = nfsrpc_statfs(vp, &sb, &fs, td->td_ucred, td, &nfsva,

sys/fs/nfs/client/nfs_clvfsops.c

340

nfscl_loadfsinfo(nmp, &fs);

sys/fs/nfs/client/nfs_clvfsops.c

364

struct nfsfsinfo fs;

sys/fs/nfs/client/nfs_clvfsops.c

368

error = nfsrpc_fsinfo(vp, &fs, cred, td, &nfsva, &attrflag, NULL);

sys/fs/nfs/client/nfs_clvfsops.c

374

nfscl_loadfsinfo(nmp, &fs);

sys/fs/nfs/common/nfs_commonsubs.c

2055

struct statfs fs;

sys/fs/nfs/common/nfs_commonsubs.c

2088

error = VFS_STATFS(mp, &fs);

sys/fs/nfs/common/nfs_commonsubs.c

2264

freenum = fs.f_ffree;

sys/fs/nfs/common/nfs_commonsubs.c

2287

*tl = txdr_unsigned(fs.f_ffree);

sys/fs/nfs/common/nfs_commonsubs.c

2293

*tl = txdr_unsigned(fs.f_files);

sys/fs/nfs/common/nfs_commonsubs.c

2369

freenum = fs.f_bfree;

sys/fs/nfs/common/nfs_commonsubs.c

2371

freenum = fs.f_bavail;

sys/fs/nfs/common/nfs_commonsubs.c

2387

NFSQUOTABLKTOBYTE(uquad, fs.f_bsize);

sys/fs/nfs/common/nfs_commonsubs.c

2393

freenum = fs.f_bfree;

sys/fs/nfs/common/nfs_commonsubs.c

2395

freenum = fs.f_bavail;

sys/fs/nfs/common/nfs_commonsubs.c

2411

NFSQUOTABLKTOBYTE(uquad, fs.f_bsize);

sys/fs/nfs/common/nfs_commonsubs.c

2432

NFSQUOTABLKTOBYTE(uquad, fs.f_bsize);

sys/fs/nfs/common/nfs_commonsubs.c

2445

uquad = (u_int64_t)fs.f_bfree;

sys/fs/nfs/common/nfs_commonsubs.c

2447

uquad = (u_int64_t)fs.f_bavail;

sys/fs/nfs/common/nfs_commonsubs.c

2448

uquad *= fs.f_bsize;

sys/fs/nfs/common/nfs_commonsubs.c

2454

uquad = (u_int64_t)fs.f_bfree;

sys/fs/nfs/common/nfs_commonsubs.c

2455

uquad *= fs.f_bsize;

sys/fs/nfs/common/nfs_commonsubs.c

2461

uquad = (u_int64_t)fs.f_blocks;

sys/fs/nfs/common/nfs_commonsubs.c

2462

uquad *= fs.f_bsize;

sys/fs/nfs/server/nfs_nfsdserv.c

2094

struct nfsfsinfo fs;

sys/fs/nfs/server/nfs_nfsdserv.c

2103

nfsvno_getfs(&fs, isdgram);

sys/fs/nfs/server/nfs_nfsdserv.c

2107

*tl++ = txdr_unsigned(fs.fs_rtmax);

sys/fs/nfs/server/nfs_nfsdserv.c

2108

*tl++ = txdr_unsigned(fs.fs_rtpref);

sys/fs/nfs/server/nfs_nfsdserv.c

2109

*tl++ = txdr_unsigned(fs.fs_rtmult);

sys/fs/nfs/server/nfs_nfsdserv.c

2110

*tl++ = txdr_unsigned(fs.fs_wtmax);

sys/fs/nfs/server/nfs_nfsdserv.c

2111

*tl++ = txdr_unsigned(fs.fs_wtpref);

sys/fs/nfs/server/nfs_nfsdserv.c

2112

*tl++ = txdr_unsigned(fs.fs_wtmult);

sys/fs/nfs/server/nfs_nfsdserv.c

2113

*tl++ = txdr_unsigned(fs.fs_dtpref);

sys/fs/nfs/server/nfs_nfsdserv.c

2114

txdr_hyper(fs.fs_maxfilesize, tl);

sys/fs/nfs/server/nfs_nfsdserv.c

2116

txdr_nfsv3time(&fs.fs_timedelta, tl);

sys/fs/nfs/server/nfs_nfsdserv.c

2118

*tl = txdr_unsigned(fs.fs_properties);

sys/fs/nfs/server/nfs_nfsdserv.c

3608

struct nfsfsinfo fs;

sys/fs/nfs/server/nfs_nfsdserv.c

3617

nfsvno_getfs(&fs, isdgram);

sys/fs/nfs/server/nfs_nfsdserv.c

3619

&sf, NULL, &fs, NULL, 1, &ret, NULL, NULL, p, nd->nd_cred);

sys/fs/v7fs/v7fs_datablock.c

101

struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_datablock.c

106

SUPERB_LOCK(fs);

sys/fs/v7fs/v7fs_datablock.c

110

SUPERB_UNLOCK(fs);

sys/fs/v7fs/v7fs_datablock.c

121

if ((error = v7fs_freeblock_update(fs, blk))) {

sys/fs/v7fs/v7fs_datablock.c

123

SUPERB_UNLOCK(fs);

sys/fs/v7fs/v7fs_datablock.c

129

} while (!datablock_number_sanity(fs, blk)); /* skip bogus block. */

sys/fs/v7fs/v7fs_datablock.c

130

SUPERB_UNLOCK(fs);

sys/fs/v7fs/v7fs_datablock.c

135

if (!(buf = scratch_read(fs, blk)))

sys/fs/v7fs/v7fs_datablock.c

138

if (!fs->io.write(fs->io.cookie, buf, blk))

sys/fs/v7fs/v7fs_datablock.c

140

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_datablock.c

149

v7fs_datablock_deallocate(struct v7fs_self *fs, v7fs_daddr_t blk)

sys/fs/v7fs/v7fs_datablock.c

151

struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_datablock.c

155

if (!datablock_number_sanity(fs, blk))

sys/fs/v7fs/v7fs_datablock.c

159

SUPERB_LOCK(fs);

sys/fs/v7fs/v7fs_datablock.c

165

SUPERB_UNLOCK(fs);

sys/fs/v7fs/v7fs_datablock.c

171

if (!(buf = scratch_read(fs, blk))) {

sys/fs/v7fs/v7fs_datablock.c

172

SUPERB_UNLOCK(fs);

sys/fs/v7fs/v7fs_datablock.c

180

fb->freeblock[i] = V7FS_VAL32(fs, sb->freeblock[i]);

sys/fs/v7fs/v7fs_datablock.c

182

if (!fs->io.write(fs->io.cookie, (uint8_t *)fb, blk)) {

sys/fs/v7fs/v7fs_datablock.c

193

SUPERB_UNLOCK(fs);

sys/fs/v7fs/v7fs_datablock.c

194

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_datablock.c

253

v7fs_datablock_foreach(struct v7fs_self *fs, struct v7fs_inode *p,

sys/fs/v7fs/v7fs_datablock.c

271

if (!datablock_number_sanity(fs, blk)) {

sys/fs/v7fs/v7fs_datablock.c

278

if ((ret = func(fs, ctx, blk, last ? filesize : V7FS_BSIZE)))

sys/fs/v7fs/v7fs_datablock.c

286

if (!datablock_number_sanity(fs, blk))

sys/fs/v7fs/v7fs_datablock.c

289

if ((ret = v7fs_loop1(fs, blk, &filesize, func, ctx)))

sys/fs/v7fs/v7fs_datablock.c

294

if (!datablock_number_sanity(fs, blk))

sys/fs/v7fs/v7fs_datablock.c

297

if ((ret = v7fs_loop2(fs, blk, &filesize, func, ctx)))

sys/fs/v7fs/v7fs_datablock.c

302

if (!datablock_number_sanity(fs, blk))

sys/fs/v7fs/v7fs_datablock.c

306

blk2 = v7fs_link(fs, blk, i);

sys/fs/v7fs/v7fs_datablock.c

307

if (!datablock_number_sanity(fs, blk))

sys/fs/v7fs/v7fs_datablock.c

310

if ((ret = v7fs_loop2(fs, blk2, &filesize, func, ctx)))

sys/fs/v7fs/v7fs_datablock.c

318

v7fs_loop2(struct v7fs_self *fs, v7fs_daddr_t listblk, size_t *filesize,

sys/fs/v7fs/v7fs_datablock.c

326

blk = v7fs_link(fs, listblk, j);

sys/fs/v7fs/v7fs_datablock.c

327

if (!datablock_number_sanity(fs, blk))

sys/fs/v7fs/v7fs_datablock.c

329

if ((ret = v7fs_loop1(fs, blk, filesize, func, ctx)))

sys/fs/v7fs/v7fs_datablock.c

337

v7fs_loop1(struct v7fs_self *fs, v7fs_daddr_t listblk, size_t *filesize,

sys/fs/v7fs/v7fs_datablock.c

346

blk = v7fs_link(fs, listblk, k);

sys/fs/v7fs/v7fs_datablock.c

347

if (!datablock_number_sanity(fs, blk))

sys/fs/v7fs/v7fs_datablock.c

350

if ((ret = func(fs, ctx, blk, last ? *filesize : V7FS_BSIZE)))

sys/fs/v7fs/v7fs_datablock.c

360

v7fs_datablock_last(struct v7fs_self *fs, struct v7fs_inode *inode,

sys/fs/v7fs/v7fs_datablock.c

377

blk = v7fs_link(fs, addr[V7FS_NADDR_INDEX1], map.index[0]);

sys/fs/v7fs/v7fs_datablock.c

380

blk = v7fs_link(fs, v7fs_link(fs,

sys/fs/v7fs/v7fs_datablock.c

384

blk = v7fs_link(fs, v7fs_link(fs, v7fs_link(fs,

sys/fs/v7fs/v7fs_datablock.c

394

v7fs_datablock_expand(struct v7fs_self *fs, struct v7fs_inode *inode, size_t sz)

sys/fs/v7fs/v7fs_datablock.c

406

v7fs_inode_writeback(fs, inode);

sys/fs/v7fs/v7fs_datablock.c

424

if ((error = v7fs_datablock_allocate(fs, &idxblk)))

sys/fs/v7fs/v7fs_datablock.c

431

blk = v7fs_add_leaf(fs, idxblk, 0);

sys/fs/v7fs/v7fs_datablock.c

436

blk = v7fs_add_leaf(fs, v7fs_add_leaf(fs,

sys/fs/v7fs/v7fs_datablock.c

442

blk = v7fs_add_leaf(fs, v7fs_add_leaf(fs,

sys/fs/v7fs/v7fs_datablock.c

443

v7fs_add_leaf(fs, idxblk, 0), 0), 0);

sys/fs/v7fs/v7fs_datablock.c

449

if ((error = v7fs_datablock_allocate(fs, &blk)))

sys/fs/v7fs/v7fs_datablock.c

457

blk = v7fs_add_leaf(fs, idxblk,

sys/fs/v7fs/v7fs_datablock.c

463

v7fs_add_leaf(fs, idxblk,

sys/fs/v7fs/v7fs_datablock.c

466

blk = v7fs_add_leaf(fs, v7fs_link(fs,idxblk,

sys/fs/v7fs/v7fs_datablock.c

473

v7fs_add_leaf(fs, idxblk,

sys/fs/v7fs/v7fs_datablock.c

478

v7fs_add_leaf(fs, v7fs_link(fs, idxblk,

sys/fs/v7fs/v7fs_datablock.c

481

blk = v7fs_add_leaf(fs, v7fs_link(fs,

sys/fs/v7fs/v7fs_datablock.c

482

v7fs_link(fs, idxblk, newmap.index[0]),

sys/fs/v7fs/v7fs_datablock.c

494

v7fs_inode_writeback(fs, inode);

sys/fs/v7fs/v7fs_datablock.c

500

v7fs_link(struct v7fs_self *fs, v7fs_daddr_t listblk, int n)

sys/fs/v7fs/v7fs_datablock.c

506

if (!datablock_number_sanity(fs, listblk))

sys/fs/v7fs/v7fs_datablock.c

508

if (!(buf = scratch_read(fs, listblk)))

sys/fs/v7fs/v7fs_datablock.c

511

blk = V7FS_VAL32(fs, list[n]);

sys/fs/v7fs/v7fs_datablock.c

512

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_datablock.c

514

if (!datablock_number_sanity(fs, blk))

sys/fs/v7fs/v7fs_datablock.c

521

v7fs_add_leaf(struct v7fs_self *fs, v7fs_daddr_t up, int idx)

sys/fs/v7fs/v7fs_datablock.c

530

if (!datablock_number_sanity(fs, up))

sys/fs/v7fs/v7fs_datablock.c

533

if ((error = v7fs_datablock_allocate(fs, &newblk)))

sys/fs/v7fs/v7fs_datablock.c

535

if (!(buf = scratch_read(fs, up)))

sys/fs/v7fs/v7fs_datablock.c

538

daddr_list[idx] = V7FS_VAL32(fs, newblk);

sys/fs/v7fs/v7fs_datablock.c

539

if (!fs->io.write(fs->io.cookie, buf, up))

sys/fs/v7fs/v7fs_datablock.c

541

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_datablock.c

547

v7fs_datablock_contract(struct v7fs_self *fs, struct v7fs_inode *inode,

sys/fs/v7fs/v7fs_datablock.c

560

v7fs_inode_writeback(fs, inode);

sys/fs/v7fs/v7fs_datablock.c

579

error = v7fs_datablock_deallocate(fs,

sys/fs/v7fs/v7fs_datablock.c

580

v7fs_remove_self(fs, idxblk));

sys/fs/v7fs/v7fs_datablock.c

586

error = v7fs_datablock_deallocate(fs,

sys/fs/v7fs/v7fs_datablock.c

587

v7fs_remove_self(fs, v7fs_remove_self(fs,

sys/fs/v7fs/v7fs_datablock.c

594

error = v7fs_datablock_deallocate(fs,

sys/fs/v7fs/v7fs_datablock.c

595

v7fs_remove_self(fs, v7fs_remove_self(fs,

sys/fs/v7fs/v7fs_datablock.c

596

v7fs_remove_self(fs, idxblk))));

sys/fs/v7fs/v7fs_datablock.c

604

error = v7fs_datablock_deallocate(fs, blk);

sys/fs/v7fs/v7fs_datablock.c

609

v7fs_remove_leaf(fs, idxblk, oldmap.index[0]);

sys/fs/v7fs/v7fs_datablock.c

616

v7fs_remove_leaf(fs, v7fs_link(fs, idxblk,

sys/fs/v7fs/v7fs_datablock.c

619

v7fs_remove_leaf(fs, idxblk,

sys/fs/v7fs/v7fs_datablock.c

627

v7fs_remove_leaf(fs, v7fs_link(fs,

sys/fs/v7fs/v7fs_datablock.c

628

v7fs_link(fs, idxblk, oldmap.index[0]),

sys/fs/v7fs/v7fs_datablock.c

632

v7fs_remove_leaf(fs, v7fs_link(fs,

sys/fs/v7fs/v7fs_datablock.c

637

v7fs_remove_leaf(fs, idxblk,

sys/fs/v7fs/v7fs_datablock.c

646

v7fs_inode_writeback(fs, inode);

sys/fs/v7fs/v7fs_datablock.c

652

v7fs_unlink(struct v7fs_self *fs, v7fs_daddr_t idxblk, int n)

sys/fs/v7fs/v7fs_datablock.c

658

if (!(buf = scratch_read(fs, idxblk)))

sys/fs/v7fs/v7fs_datablock.c

661

blk = V7FS_VAL32(fs, daddr_list[n]);

sys/fs/v7fs/v7fs_datablock.c

663

fs->io.write(fs->io.cookie, buf, idxblk);

sys/fs/v7fs/v7fs_datablock.c

664

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_datablock.c

670

v7fs_remove_self(struct v7fs_self *fs, v7fs_daddr_t up)

sys/fs/v7fs/v7fs_datablock.c

674

if (!datablock_number_sanity(fs, up))

sys/fs/v7fs/v7fs_datablock.c

678

down = v7fs_unlink(fs, up, 0);

sys/fs/v7fs/v7fs_datablock.c

681

v7fs_datablock_deallocate(fs, up);

sys/fs/v7fs/v7fs_datablock.c

687

v7fs_remove_leaf(struct v7fs_self *fs, v7fs_daddr_t up, int n)

sys/fs/v7fs/v7fs_datablock.c

691

if (!datablock_number_sanity(fs, up))

sys/fs/v7fs/v7fs_datablock.c

695

down = v7fs_unlink(fs, up, n);

sys/fs/v7fs/v7fs_datablock.c

698

v7fs_datablock_deallocate(fs, down);

sys/fs/v7fs/v7fs_datablock.c

704

v7fs_datablock_size_change(struct v7fs_self *fs, size_t newsz,

sys/fs/v7fs/v7fs_datablock.c

711

error = v7fs_datablock_expand(fs, inode, diff);

sys/fs/v7fs/v7fs_datablock.c

713

error = v7fs_datablock_contract(fs, inode, -diff);

sys/fs/v7fs/v7fs_datablock.c

83

datablock_number_sanity(const struct v7fs_self *fs, v7fs_daddr_t blk)

sys/fs/v7fs/v7fs_datablock.c

85

const struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_datablock.c

99

v7fs_datablock_allocate(struct v7fs_self *fs, v7fs_daddr_t *block_number)

sys/fs/v7fs/v7fs_dirent.c

63

v7fs_dirent_endian_convert(struct v7fs_self *fs, struct v7fs_dirent *dir, int n)

sys/fs/v7fs/v7fs_dirent.c

65

struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_dirent.c

71

ino = V7FS_VAL16(fs, dir->inode_number);

sys/fs/v7fs/v7fs_endian.c

161

v7fs_endian_init(struct v7fs_self *fs)

sys/fs/v7fs/v7fs_endian.c

163

struct endian_conversion_ops *ops = &fs->val;

sys/fs/v7fs/v7fs_endian.c

165

switch (fs->endian)

sys/fs/v7fs/v7fs_file.c

103

if (!(buf = scratch_read(fs, blk)))

sys/fs/v7fs/v7fs_file.c

108

v7fs_dirent_endian_convert(fs, dir, n);

sys/fs/v7fs/v7fs_file.c

123

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file.c

129

v7fs_file_allocate(struct v7fs_self *fs, struct v7fs_inode *parent_dir,

sys/fs/v7fs/v7fs_file.c

138

if (v7fs_file_lookup_by_name(fs, parent_dir, srcname, srclen,

sys/fs/v7fs/v7fs_file.c

145

if ((error = v7fs_inode_allocate(fs, ino)))

sys/fs/v7fs/v7fs_file.c

164

v7fs_inode_deallocate(fs, *ino);

sys/fs/v7fs/v7fs_file.c

184

if ((error = v7fs_datablock_expand(fs, &inode, sizeof(*dir) * 2

sys/fs/v7fs/v7fs_file.c

186

v7fs_inode_deallocate(fs, *ino);

sys/fs/v7fs/v7fs_file.c

191

if (!(buf = scratch_read(fs, blk))) {

sys/fs/v7fs/v7fs_file.c

192

v7fs_inode_deallocate(fs, *ino);

sys/fs/v7fs/v7fs_file.c

197

dir[0].inode_number = V7FS_VAL16(fs, *ino);

sys/fs/v7fs/v7fs_file.c

199

dir[1].inode_number = V7FS_VAL16(fs, parent_dir->inode_number);

sys/fs/v7fs/v7fs_file.c

200

if (!fs->io.write(fs->io.cookie, buf, blk)) {

sys/fs/v7fs/v7fs_file.c

201

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file.c

204

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file.c

208

v7fs_inode_writeback(fs, &inode);

sys/fs/v7fs/v7fs_file.c

211

if ((error = v7fs_directory_add_entry(fs, parent_dir, *ino, srcname,

sys/fs/v7fs/v7fs_file.c

222

v7fs_file_deallocate(struct v7fs_self *fs, struct v7fs_inode *parent_dir,

sys/fs/v7fs/v7fs_file.c

230

if ((error = v7fs_file_lookup_by_name(fs, parent_dir, name, namelen,

sys/fs/v7fs/v7fs_file.c

236

if ((error = v7fs_inode_load(fs, &inode, ino)))

sys/fs/v7fs/v7fs_file.c

253

error = v7fs_datablock_size_change(fs, 0, &inode);

sys/fs/v7fs/v7fs_file.c

264

if ((error = v7fs_directory_remove_entry(fs, parent_dir, name,

sys/fs/v7fs/v7fs_file.c

269

v7fs_inode_writeback(fs, &inode);

sys/fs/v7fs/v7fs_file.c

275

v7fs_directory_add_entry(struct v7fs_self *fs, struct v7fs_inode *parent_dir,

sys/fs/v7fs/v7fs_file.c

290

if ((error = v7fs_inode_load(fs, &inode, ino)))

sys/fs/v7fs/v7fs_file.c

294

if ((error = v7fs_datablock_expand(fs, parent_dir, sizeof(*dir))))

sys/fs/v7fs/v7fs_file.c

298

if (!(blk = v7fs_datablock_last(fs, parent_dir,

sys/fs/v7fs/v7fs_file.c

303

if (!(buf = scratch_read(fs, blk)))

sys/fs/v7fs/v7fs_file.c

311

dir[n].inode_number = V7FS_VAL16(fs, ino);

sys/fs/v7fs/v7fs_file.c

314

if (!fs->io.write(fs->io.cookie, buf, blk))

sys/fs/v7fs/v7fs_file.c

316

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file.c

320

v7fs_inode_writeback(fs, parent_dir);

sys/fs/v7fs/v7fs_file.c

329

v7fs_directory_remove_entry(struct v7fs_self *fs, struct v7fs_inode *parent_dir,

sys/fs/v7fs/v7fs_file.c

345

lastblk = v7fs_datablock_last(fs, parent_dir,

sys/fs/v7fs/v7fs_file.c

350

if (!(buf = scratch_read(fs, lastblk)))

sys/fs/v7fs/v7fs_file.c

353

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file.c

355

V7FS_VAL16(fs, lastdirent.inode_number), lastdirent.name, pos);

sys/fs/v7fs/v7fs_file.c

360

if ((error = v7fs_datablock_foreach(fs, parent_dir, remove_subr,

sys/fs/v7fs/v7fs_file.c

365

v7fs_datablock_contract(fs, parent_dir, sizeof(lastdirent));

sys/fs/v7fs/v7fs_file.c

369

if ((error = v7fs_inode_load(fs, &inode, lookup_arg.inode_number)))

sys/fs/v7fs/v7fs_file.c

374

v7fs_inode_writeback(fs, parent_dir);

sys/fs/v7fs/v7fs_file.c

381

remove_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)

sys/fs/v7fs/v7fs_file.c

390

if (!(buf = scratch_read(fs, blk)))

sys/fs/v7fs/v7fs_file.c

396

DPRINTF("%d\n", V7FS_VAL16(fs, dir->inode_number));

sys/fs/v7fs/v7fs_file.c

399

p->inode_number = V7FS_VAL16(fs, dir->inode_number);

sys/fs/v7fs/v7fs_file.c

403

if (!fs->io.write(fs->io.cookie, buf, blk))

sys/fs/v7fs/v7fs_file.c

410

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file.c

69

v7fs_file_lookup_by_name(struct v7fs_self *fs, struct v7fs_inode *parent_dir,

sys/fs/v7fs/v7fs_file.c

81

if ((error = v7fs_datablock_foreach(fs, parent_dir, lookup_subr,

sys/fs/v7fs/v7fs_file.c

94

lookup_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)

sys/fs/v7fs/v7fs_file_util.c

105

if (!(buf = scratch_read(fs, blk))) {

sys/fs/v7fs/v7fs_file_util.c

110

if (!fs->io.write(fs->io.cookie, buf, blk)) {

sys/fs/v7fs/v7fs_file_util.c

111

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file_util.c

114

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file_util.c

115

v7fs_inode_writeback(fs, p);

sys/fs/v7fs/v7fs_file_util.c

121

v7fs_file_rename(struct v7fs_self *fs, struct v7fs_inode *parent_from,

sys/fs/v7fs/v7fs_file_util.c

131

if ((error = v7fs_file_lookup_by_name(fs, parent_from, from, fromlen,

sys/fs/v7fs/v7fs_file_util.c

136

v7fs_inode_load(fs, &inode, from_ino);

sys/fs/v7fs/v7fs_file_util.c

140

error = v7fs_file_lookup_by_name(fs, parent_to, to, tolen, &to_ino);

sys/fs/v7fs/v7fs_file_util.c

143

if ((error = v7fs_file_deallocate(fs, parent_to, to, tolen))) {

sys/fs/v7fs/v7fs_file_util.c

153

if (dir_move && (error = can_dirmove(fs, from_ino,

sys/fs/v7fs/v7fs_file_util.c

160

if ((error = v7fs_directory_add_entry(fs, parent_to, from_ino, to,

sys/fs/v7fs/v7fs_file_util.c

166

if ((error = v7fs_directory_remove_entry(fs, parent_from, from,

sys/fs/v7fs/v7fs_file_util.c

174

if ((error = v7fs_directory_replace_entry(fs, &inode, "..",

sys/fs/v7fs/v7fs_file_util.c

179

v7fs_inode_writeback(fs, &inode);

sys/fs/v7fs/v7fs_file_util.c

187

v7fs_directory_replace_entry(struct v7fs_self *fs, struct v7fs_inode *self_dir,

sys/fs/v7fs/v7fs_file_util.c

195

if ((error = v7fs_datablock_foreach(fs, self_dir, replace_subr,

sys/fs/v7fs/v7fs_file_util.c

203

replace_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)

sys/fs/v7fs/v7fs_file_util.c

212

if (!(buf = scratch_read(fs, blk)))

sys/fs/v7fs/v7fs_file_util.c

222

dir->inode_number = V7FS_VAL16(fs, p->inode_number);

sys/fs/v7fs/v7fs_file_util.c

224

if (!fs->io.write(fs->io.cookie, buf, blk))

sys/fs/v7fs/v7fs_file_util.c

231

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file_util.c

237

v7fs_file_lookup_by_number(struct v7fs_self *fs, struct v7fs_inode *parent_dir,

sys/fs/v7fs/v7fs_file_util.c

242

ret = v7fs_datablock_foreach(fs, parent_dir, lookup_by_number_subr,

sys/fs/v7fs/v7fs_file_util.c

249

lookup_by_number_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk,

sys/fs/v7fs/v7fs_file_util.c

258

if (!(buf = scratch_read(fs, blk)))

sys/fs/v7fs/v7fs_file_util.c

263

v7fs_dirent_endian_convert(fs, dir, n);

sys/fs/v7fs/v7fs_file_util.c

274

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file_util.c

284

can_dirmove(struct v7fs_self *fs, v7fs_ino_t from_ino, v7fs_ino_t to_ino)

sys/fs/v7fs/v7fs_file_util.c

291

if ((error = v7fs_inode_load(fs, &inode, to_ino)))

sys/fs/v7fs/v7fs_file_util.c

302

v7fs_datablock_foreach(fs, &inode, lookup_parent_from_dir_subr,

sys/fs/v7fs/v7fs_file_util.c

309

if ((error = v7fs_inode_load(fs, &inode, parent)))

sys/fs/v7fs/v7fs_file_util.c

321

lookup_parent_from_dir_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk,

sys/fs/v7fs/v7fs_file_util.c

329

if (!(buf = scratch_read(fs, blk)))

sys/fs/v7fs/v7fs_file_util.c

333

if (!v7fs_dirent_endian_convert(fs, dir, n)) {

sys/fs/v7fs/v7fs_file_util.c

334

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file_util.c

348

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_file_util.c

69

v7fs_file_link(struct v7fs_self *fs, struct v7fs_inode *parent_dir,

sys/fs/v7fs/v7fs_file_util.c

76

if ((error = v7fs_directory_add_entry(fs, parent_dir, p->inode_number,

sys/fs/v7fs/v7fs_file_util.c

82

v7fs_inode_writeback(fs, p);

sys/fs/v7fs/v7fs_file_util.c

88

v7fs_file_symlink(struct v7fs_self *fs, struct v7fs_inode *p,

sys/fs/v7fs/v7fs_file_util.c

99

if ((error = v7fs_datablock_expand(fs, p, len))) {

sys/fs/v7fs/v7fs_inode.c

100

v7fs_inode_allocate(struct v7fs_self *fs, v7fs_ino_t *ino)

sys/fs/v7fs/v7fs_inode.c

102

struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_inode.c

107

SUPERB_LOCK(fs);

sys/fs/v7fs/v7fs_inode.c

114

if (sb->nfreeinode <= 0 && (error = v7fs_freeinode_update(fs))) {

sys/fs/v7fs/v7fs_inode.c

133

SUPERB_UNLOCK(fs);

sys/fs/v7fs/v7fs_inode.c

139

v7fs_inode_deallocate(struct v7fs_self *fs, v7fs_ino_t ino)

sys/fs/v7fs/v7fs_inode.c

141

struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_inode.c

146

v7fs_inode_writeback(fs, &inode);

sys/fs/v7fs/v7fs_inode.c

148

SUPERB_LOCK(fs);

sys/fs/v7fs/v7fs_inode.c

157

SUPERB_UNLOCK(fs);

sys/fs/v7fs/v7fs_inode.c

161

v7fs_inode_setup_memory_image(const struct v7fs_self *fs __unused,

sys/fs/v7fs/v7fs_inode.c

164

#define conv16(m) (mem->m = V7FS_VAL16(fs, (disk->m)))

sys/fs/v7fs/v7fs_inode.c

165

#define conv32(m) (mem->m = V7FS_VAL32(fs, (disk->m)))

sys/fs/v7fs/v7fs_inode.c

182

addr = V7FS_VAL24_READ(fs, &disk->addr[j]);

sys/fs/v7fs/v7fs_inode.c

195

v7fs_inode_setup_disk_image(const struct v7fs_self *fs __unused,

sys/fs/v7fs/v7fs_inode.c

198

#define conv16(m) (disk->m = V7FS_VAL16(fs, (mem->m)))

sys/fs/v7fs/v7fs_inode.c

199

#define conv32(m) (disk->m = V7FS_VAL32(fs, (mem->m)))

sys/fs/v7fs/v7fs_inode.c

213

V7FS_VAL24_WRITE(fs, mem->addr[i], disk->addr + j);

sys/fs/v7fs/v7fs_inode.c

221

v7fs_inode_load(struct v7fs_self *fs, struct v7fs_inode *p, v7fs_ino_t n)

sys/fs/v7fs/v7fs_inode.c

227

if (v7fs_inode_inquire_disk_location(fs, n, &blk, &ofs) != 0)

sys/fs/v7fs/v7fs_inode.c

230

ILIST_LOCK(fs);

sys/fs/v7fs/v7fs_inode.c

231

if (!(buf = scratch_read(fs, blk))) {

sys/fs/v7fs/v7fs_inode.c

232

ILIST_UNLOCK(fs);

sys/fs/v7fs/v7fs_inode.c

235

ILIST_UNLOCK(fs);

sys/fs/v7fs/v7fs_inode.c

239

v7fs_inode_setup_memory_image(fs, p, di + ofs);

sys/fs/v7fs/v7fs_inode.c

242

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_inode.c

249

v7fs_inode_writeback(struct v7fs_self *fs, struct v7fs_inode *mem)

sys/fs/v7fs/v7fs_inode.c

258

if (v7fs_inode_inquire_disk_location(fs, ino, &blk, &ofs) != 0)

sys/fs/v7fs/v7fs_inode.c

261

v7fs_inode_setup_disk_image(fs, mem, &disk);

sys/fs/v7fs/v7fs_inode.c

263

ILIST_LOCK(fs);

sys/fs/v7fs/v7fs_inode.c

264

if (!(buf = scratch_read(fs, blk))) {

sys/fs/v7fs/v7fs_inode.c

265

ILIST_UNLOCK(fs);

sys/fs/v7fs/v7fs_inode.c

270

if (!fs->io.write(fs->io.cookie, buf, blk))

sys/fs/v7fs/v7fs_inode.c

272

ILIST_UNLOCK(fs);

sys/fs/v7fs/v7fs_inode.c

274

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_inode.c

280

v7fs_inode_inquire_disk_location(const struct v7fs_self *fs

sys/fs/v7fs/v7fs_inode.c

286

v7fs_inode_number_sanity(&fs->superblock, n);

sys/fs/v7fs/v7fs_inode.c

296

return v7fs_inode_block_sanity(&fs->superblock, *block);

sys/fs/v7fs/v7fs_inode_util.c

100

struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_inode_util.c

111

if (!(buf = scratch_read(fs, i))) {

sys/fs/v7fs/v7fs_inode_util.c

118

v7fs_inode_setup_memory_image(fs, &inode, di + j);

sys/fs/v7fs/v7fs_inode_util.c

120

if ((ret = func(fs, ctx, &inode, k))) {

sys/fs/v7fs/v7fs_inode_util.c

121

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_inode_util.c

125

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_inode_util.c

96

(struct v7fs_self *fs,

sys/fs/v7fs/v7fs_io.c

107

scratch_remain(const struct v7fs_self *fs)

sys/fs/v7fs/v7fs_io.c

112

MEM_LOCK(fs);

sys/fs/v7fs/v7fs_io.c

114

if (fs->scratch_free & (1 << i)) {

sys/fs/v7fs/v7fs_io.c

118

MEM_UNLOCK(fs);

sys/fs/v7fs/v7fs_io.c

126

scratch_free(struct v7fs_self *fs __unused, void *p)

sys/fs/v7fs/v7fs_io.c

130

MEM_LOCK(fs);

sys/fs/v7fs/v7fs_io.c

132

if (fs->scratch[i] == p) {

sys/fs/v7fs/v7fs_io.c

133

fs->scratch_free |= (1 << i);

sys/fs/v7fs/v7fs_io.c

136

MEM_UNLOCK(fs);

sys/fs/v7fs/v7fs_io.c

64

scratch_read(struct v7fs_self *fs, daddr_t blk)

sys/fs/v7fs/v7fs_io.c

68

MEM_LOCK(fs);

sys/fs/v7fs/v7fs_io.c

70

if (fs->scratch_free & (1 << i)) {

sys/fs/v7fs/v7fs_io.c

71

fs->scratch_free &= ~(1 << i);

sys/fs/v7fs/v7fs_io.c

78

MEM_UNLOCK(fs);

sys/fs/v7fs/v7fs_io.c

82

if (!fs->io.read(fs->io.cookie, fs->scratch[i], blk)) {

sys/fs/v7fs/v7fs_io.c

84

fs->scratch_free |= (1 << i);

sys/fs/v7fs/v7fs_io.c

85

MEM_UNLOCK(fs);

sys/fs/v7fs/v7fs_io.c

88

MEM_UNLOCK(fs);

sys/fs/v7fs/v7fs_io.c

91

if ((n = scratch_remain(fs)) < fs->scratch_remain)

sys/fs/v7fs/v7fs_io.c

92

fs->scratch_remain = n;

sys/fs/v7fs/v7fs_io.c

94

return fs->scratch[i];

sys/fs/v7fs/v7fs_io.c

97

if (!fs->io.read(fs->io.cookie, buf, blk)) {

sys/fs/v7fs/v7fs_io_kern.c

110

*fs = p;

sys/fs/v7fs/v7fs_io_kern.c

129

v7fs_io_fini(struct v7fs_self *fs)

sys/fs/v7fs/v7fs_io_kern.c

131

if (fs->io.cookie) {

sys/fs/v7fs/v7fs_io_kern.c

132

kmem_free(fs->io.cookie, sizeof(struct local_io));

sys/fs/v7fs/v7fs_io_kern.c

134

if (fs->sb_lock.cookie) {

sys/fs/v7fs/v7fs_io_kern.c

135

mutex_destroy(fs->sb_lock.cookie);

sys/fs/v7fs/v7fs_io_kern.c

136

kmem_free(fs->sb_lock.cookie, sizeof(kmutex_t));

sys/fs/v7fs/v7fs_io_kern.c

138

if (fs->ilist_lock.cookie) {

sys/fs/v7fs/v7fs_io_kern.c

139

mutex_destroy(fs->ilist_lock.cookie);

sys/fs/v7fs/v7fs_io_kern.c

140

kmem_free(fs->ilist_lock.cookie, sizeof(kmutex_t));

sys/fs/v7fs/v7fs_io_kern.c

142

if (fs->mem_lock.cookie) {

sys/fs/v7fs/v7fs_io_kern.c

143

mutex_destroy(fs->mem_lock.cookie);

sys/fs/v7fs/v7fs_io_kern.c

144

kmem_free(fs->mem_lock.cookie, sizeof(kmutex_t));

sys/fs/v7fs/v7fs_io_kern.c

146

kmem_free(fs, sizeof(*fs));

sys/fs/v7fs/v7fs_io_kern.c

71

v7fs_io_init(struct v7fs_self **fs,

sys/fs/v7fs/v7fs_io_user.c

101

*fs = p;

sys/fs/v7fs/v7fs_io_user.c

107

v7fs_io_fini(struct v7fs_self *fs)

sys/fs/v7fs/v7fs_io_user.c

109

struct local_io *lio = (struct local_io *)fs->io.cookie;

sys/fs/v7fs/v7fs_io_user.c

117

free(fs);

sys/fs/v7fs/v7fs_io_user.c

71

v7fs_io_init(struct v7fs_self **fs, const struct v7fs_mount_device *mount,

sys/fs/v7fs/v7fs_superblock.c

102

if (!(buf = scratch_read(fs, V7FS_SUPERBLOCK_SECTOR)))

sys/fs/v7fs/v7fs_superblock.c

105

v7fs_superblock_endian_convert(fs, disksb, memsb);

sys/fs/v7fs/v7fs_superblock.c

106

if (!fs->io.write(fs->io.cookie, buf, V7FS_SUPERBLOCK_SECTOR))

sys/fs/v7fs/v7fs_superblock.c

108

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_superblock.c

118

v7fs_superblock_sanity(struct v7fs_self *fs)

sys/fs/v7fs/v7fs_superblock.c

120

const struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_superblock.c

131

(!(buf = scratch_read(fs, sb->volume_size - 1)))) {

sys/fs/v7fs/v7fs_superblock.c

136

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_superblock.c

143

v7fs_freeblock_update(struct v7fs_self *fs, v7fs_daddr_t blk)

sys/fs/v7fs/v7fs_superblock.c

146

struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_superblock.c

152

if (!datablock_number_sanity(fs, blk) || !(buf = scratch_read(fs, blk)))

sys/fs/v7fs/v7fs_superblock.c

157

if ((error = v7fs_freeblock_endian_convert(fs, fb))) {

sys/fs/v7fs/v7fs_superblock.c

158

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_superblock.c

166

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_superblock.c

172

v7fs_freeblock_endian_convert(struct v7fs_self *fs __unused,

sys/fs/v7fs/v7fs_superblock.c

179

nfree = V7FS_VAL16(fs, fb->nfreeblock);

sys/fs/v7fs/v7fs_superblock.c

188

fb->freeblock[i] = V7FS_VAL32(fs, fb->freeblock[i]);

sys/fs/v7fs/v7fs_superblock.c

197

v7fs_freeinode_update(struct v7fs_self *fs)

sys/fs/v7fs/v7fs_superblock.c

200

struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_superblock.c

210

if (!(buf = scratch_read(fs, i))) {

sys/fs/v7fs/v7fs_superblock.c

225

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_superblock.c

233

v7fs_superblock_endian_convert(struct v7fs_self *fs __unused,

sys/fs/v7fs/v7fs_superblock.c

237

#define conv16(m) (to->m = V7FS_VAL16(fs, from->m))

sys/fs/v7fs/v7fs_superblock.c

238

#define conv32(m) (to->m = V7FS_VAL32(fs, from->m))

sys/fs/v7fs/v7fs_superblock.c

247

*dto = V7FS_VAL32(fs, *dfrom);

sys/fs/v7fs/v7fs_superblock.c

253

*ito = V7FS_VAL16(fs, *ifrom);

sys/fs/v7fs/v7fs_superblock.c

72

v7fs_superblock_load(struct v7fs_self *fs)

sys/fs/v7fs/v7fs_superblock.c

78

if (!(buf = scratch_read(fs, V7FS_SUPERBLOCK_SECTOR)))

sys/fs/v7fs/v7fs_superblock.c

81

v7fs_superblock_endian_convert(fs, &fs->superblock, disksb);

sys/fs/v7fs/v7fs_superblock.c

82

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_superblock.c

84

if ((error = v7fs_superblock_sanity(fs)))

sys/fs/v7fs/v7fs_superblock.c

92

v7fs_superblock_writeback(struct v7fs_self *fs)

sys/fs/v7fs/v7fs_superblock.c

94

struct v7fs_superblock *memsb = &fs->superblock;

sys/fs/v7fs/v7fs_superblock_util.c

64

v7fs_superblock_status(struct v7fs_self *fs)

sys/fs/v7fs/v7fs_superblock_util.c

66

struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_superblock_util.c

67

struct v7fs_stat *stat = &fs->stat;

sys/fs/v7fs/v7fs_superblock_util.c

80

v7fs_superblock_dump(const struct v7fs_self *fs)

sys/fs/v7fs/v7fs_superblock_util.c

82

const struct v7fs_superblock *sb = &fs->superblock;

sys/fs/v7fs/v7fs_vfsops.c

269

struct v7fs_self *fs = v7fsmount->core;

sys/fs/v7fs/v7fs_vfsops.c

271

if ((error = v7fs_superblock_load(fs))) {

sys/fs/v7fs/v7fs_vfsops.c

272

v7fs_io_fini(fs);

sys/fs/v7fs/v7fs_vfsops.c

347

struct v7fs_self *fs = v7fsmount->core;

sys/fs/v7fs/v7fs_vfsops.c

349

DPRINTF("scratch remain=%d\n", fs->scratch_remain);

sys/fs/v7fs/v7fs_vfsops.c

351

v7fs_superblock_status(fs);

sys/fs/v7fs/v7fs_vfsops.c

356

f->f_blocks = fs->stat.total_blocks;

sys/fs/v7fs/v7fs_vfsops.c

357

f->f_bfree = fs->stat.free_blocks;

sys/fs/v7fs/v7fs_vfsops.c

358

f->f_bavail = fs->stat.free_blocks;

sys/fs/v7fs/v7fs_vfsops.c

360

f->f_files = fs->stat.total_files;

sys/fs/v7fs/v7fs_vfsops.c

361

f->f_ffree = fs->stat.free_inode;

sys/fs/v7fs/v7fs_vfsops.c

389

struct v7fs_self *fs = v7fsmount->core;

sys/fs/v7fs/v7fs_vfsops.c

396

v7fs_superblock_writeback(fs);

sys/fs/v7fs/v7fs_vfsops.c

432

struct v7fs_self *fs;

sys/fs/v7fs/v7fs_vfsops.c

442

fs = v7fsmount->core;

sys/fs/v7fs/v7fs_vfsops.c

445

if ((error = v7fs_inode_load(fs, &inode, number))) {

sys/fs/v7fs/v7fs_vnops.c

1017

error = v7fs_datablock_foreach(fs, inode, readdir_subr, &arg);

sys/fs/v7fs/v7fs_vnops.c

1061

struct v7fs_self *fs = v7node->v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

1068

v7fs_datablock_size_change(fs, 0, inode);

sys/fs/v7fs/v7fs_vnops.c

1070

v7fs_inode_deallocate(fs, inode->inode_number);

sys/fs/v7fs/v7fs_vnops.c

1095

struct v7fs_self *fs = v7node->v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

1105

if (!(blk = v7fs_datablock_last(fs, inode,

sys/fs/v7fs/v7fs_vnops.c

1237

struct v7fs_self *fs = v7node->v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

1260

v7fs_inode_writeback(fs, inode);

sys/fs/v7fs/v7fs_vnops.c

1277

struct v7fs_self *fs = v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

1300

(fs, &parent_node->inode, to, tolen, &attr, &ino))) {

sys/fs/v7fs/v7fs_vnops.c

1314

v7fs_file_symlink(fs, p, from);

sys/fs/v7fs/v7fs_vnops.c

1339

struct v7fs_self *fs = v7node->v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

1348

if (!(buf = scratch_read(fs, blk))) {

sys/fs/v7fs/v7fs_vnops.c

1356

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_vnops.c

148

if ((error = v7fs_file_lookup_by_name(fs, parent, name, namelen,

sys/fs/v7fs/v7fs_vnops.c

208

struct v7fs_self *fs = v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

227

if ((error = v7fs_file_allocate(fs, &parent_node->inode,

sys/fs/v7fs/v7fs_vnops.c

271

struct v7fs_self *fs = v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

286

if ((error = v7fs_file_allocate(fs, &parent_node->inode,

sys/fs/v7fs/v7fs_vnops.c

466

struct v7fs_self *fs = v7node->v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

507

error = v7fs_datablock_size_change(fs, vap->va_size, inode);

sys/fs/v7fs/v7fs_vnops.c

623

struct v7fs_self *fs = v7node->v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

642

if ((error = v7fs_datablock_expand(fs, inode, expand)))

sys/fs/v7fs/v7fs_vnops.c

701

struct v7fs_self *fs = v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

712

if ((error = v7fs_file_deallocate(fs, &parent_node->inode,

sys/fs/v7fs/v7fs_vnops.c

717

error = v7fs_inode_load(fs, inode, inode->inode_number);

sys/fs/v7fs/v7fs_vnops.c

746

struct v7fs_self *fs = node->v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

761

error = v7fs_file_link(fs, parent, p, cnp->cn_nameptr, cnp->cn_namelen);

sys/fs/v7fs/v7fs_vnops.c

790

struct v7fs_self *fs = v7node->v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

807

error = v7fs_file_rename(fs, &parent_from->inode, from_name, from_len,

sys/fs/v7fs/v7fs_vnops.c

815

error = v7fs_inode_load(fs, inode, inode->inode_number);

sys/fs/v7fs/v7fs_vnops.c

849

struct v7fs_self *fs = v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

861

if ((error = v7fs_file_allocate(fs, &parent_node->inode,

sys/fs/v7fs/v7fs_vnops.c

895

struct v7fs_self *fs = v7fsmount->core;

sys/fs/v7fs/v7fs_vnops.c

903

if ((error = v7fs_file_deallocate(fs, &parent_node->inode,

sys/fs/v7fs/v7fs_vnops.c

908

error = v7fs_inode_load(fs, inode, inode->inode_number);

sys/fs/v7fs/v7fs_vnops.c

930

readdir_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)

sys/fs/v7fs/v7fs_vnops.c

941

if (!(buf = scratch_read(fs, blk)))

sys/fs/v7fs/v7fs_vnops.c

951

if ((error = v7fs_inode_load(fs, &inode, dir->inode_number)))

sys/fs/v7fs/v7fs_vnops.c

969

scratch_free(fs, buf);

sys/fs/v7fs/v7fs_vnops.c

99

struct v7fs_self *fs = parent_node->v7fsmount->core;/* my filesystem */

sys/fs/v7fs/v7fs_vnops.c

992

struct v7fs_self *fs = v7node->v7fsmount->core;

sys/lib/libsa/dosfs.c

121

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

sys/lib/libsa/dosfs.c

122

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

sys/lib/libsa/dosfs.c

123

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

sys/lib/libsa/dosfs.c

124

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

sys/lib/libsa/dosfs.c

127

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

sys/lib/libsa/dosfs.c

130

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

sys/lib/libsa/dosfs.c

138

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

sys/lib/libsa/dosfs.c

180

dos_mount(DOS_FS *fs, struct open_file *fd)

sys/lib/libsa/dosfs.c

184

(void)memset(fs, 0, sizeof(DOS_FS));

sys/lib/libsa/dosfs.c

185

fs->fd = fd;

sys/lib/libsa/dosfs.c

186

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

sys/lib/libsa/dosfs.c

187

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

sys/lib/libsa/dosfs.c

188

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

sys/lib/libsa/dosfs.c

189

(void) dosunmount(fs);

sys/lib/libsa/dosfs.c

200

dos_unmount(DOS_FS *fs)

sys/lib/libsa/dosfs.c

204

if (fs->links)

sys/lib/libsa/dosfs.c

206

if ((err = dosunmount(fs)))

sys/lib/libsa/dosfs.c

216

dosunmount(DOS_FS *fs)

sys/lib/libsa/dosfs.c

218

if (fs->buf)

sys/lib/libsa/dosfs.c

219

dealloc(fs->buf, SECSIZ);

sys/lib/libsa/dosfs.c

220

dealloc(fs, sizeof(DOS_FS));

sys/lib/libsa/dosfs.c

232

DOS_FS *fs;

sys/lib/libsa/dosfs.c

237

fs = alloc(sizeof(DOS_FS));

sys/lib/libsa/dosfs.c

239

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

sys/lib/libsa/dosfs.c

242

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

sys/lib/libsa/dosfs.c

245

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

sys/lib/libsa/dosfs.c

250

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

sys/lib/libsa/dosfs.c

266

f->fs = fs;

sys/lib/libsa/dosfs.c

267

fs->links++;

sys/lib/libsa/dosfs.c

289

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

sys/lib/libsa/dosfs.c

295

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

sys/lib/libsa/dosfs.c

296

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

sys/lib/libsa/dosfs.c

303

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

sys/lib/libsa/dosfs.c

308

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

sys/lib/libsa/dosfs.c

310

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

sys/lib/libsa/dosfs.c

315

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

sys/lib/libsa/dosfs.c

317

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

sys/lib/libsa/dosfs.c

318

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

sys/lib/libsa/dosfs.c

387

DOS_FS *fs = f->fs;

sys/lib/libsa/dosfs.c

389

f->fs->links--;

sys/lib/libsa/dosfs.c

391

dos_unmount(fs);

sys/lib/libsa/dosfs.c

410

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

sys/lib/libsa/dosfs.c

428

parsebs(DOS_FS *fs, DOS_BS *bs)

sys/lib/libsa/dosfs.c

439

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

sys/lib/libsa/dosfs.c

441

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

sys/lib/libsa/dosfs.c

442

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

sys/lib/libsa/dosfs.c

443

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

sys/lib/libsa/dosfs.c

446

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

sys/lib/libsa/dosfs.c

449

if (!(fs->spf = getulong(bs->bpb.bpbBigFATsecs)))

sys/lib/libsa/dosfs.c

453

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

sys/lib/libsa/dosfs.c

456

if (!(fs->lsnfat = getushort(bs->bpb.bpbResSectors)))

sys/lib/libsa/dosfs.c

458

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

sys/lib/libsa/dosfs.c

459

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

sys/lib/libsa/dosfs.c

463

if (fs->lsndta > sc)

sys/lib/libsa/dosfs.c

465

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

sys/lib/libsa/dosfs.c

467

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

sys/lib/libsa/dosfs.c

468

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

sys/lib/libsa/dosfs.c

469

if (fs->xclus > sc)

sys/lib/libsa/dosfs.c

470

fs->xclus = sc;

sys/lib/libsa/dosfs.c

478

namede(DOS_FS *fs, const char *path, const struct direntry **dep)

sys/lib/libsa/dosfs.c

501

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

sys/lib/libsa/dosfs.c

514

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

sys/lib/libsa/dosfs.c

535

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

sys/lib/libsa/dosfs.c

536

clus = fs->rdcl;

sys/lib/libsa/dosfs.c

537

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

sys/lib/libsa/dosfs.c

542

lsec = fs->lsndir;

sys/lib/libsa/dosfs.c

543

else if (okclus(fs, clus))

sys/lib/libsa/dosfs.c

544

lsec = blklsn(fs, clus);

sys/lib/libsa/dosfs.c

550

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

sys/lib/libsa/dosfs.c

601

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

sys/lib/libsa/dosfs.c

603

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

sys/lib/libsa/dosfs.c

677

fsize(DOS_FS *fs, struct direntry *de)

sys/lib/libsa/dosfs.c

686

size = fs->dirents * sizeof(struct direntry);

sys/lib/libsa/dosfs.c

688

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

sys/lib/libsa/dosfs.c

690

size = (size_t)blkbyt(fs, n);

sys/lib/libsa/dosfs.c

700

fatcnt(DOS_FS *fs, u_int c)

sys/lib/libsa/dosfs.c

704

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

sys/lib/libsa/dosfs.c

705

if (fatget(fs, &c))

sys/lib/libsa/dosfs.c

707

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

sys/lib/libsa/dosfs.c

714

fatget(DOS_FS *fs, u_int *c)

sys/lib/libsa/dosfs.c

720

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

sys/lib/libsa/dosfs.c

721

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

sys/lib/libsa/dosfs.c

724

x = fs->fatsz != 32 ? getushort(buf) : getulong(buf);

sys/lib/libsa/dosfs.c

725

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

sys/lib/libsa/dosfs.c

742

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

sys/lib/libsa/dosfs.c

751

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

sys/lib/libsa/dosfs.c

756

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

sys/lib/libsa/dosfs.c

762

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

sys/lib/libsa/dosfs.c

768

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

sys/lib/libsa/dosfs.c

770

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

sys/lib/libsa/dosfs.c

779

iobuf(DOS_FS *fs, u_int lsec)

sys/lib/libsa/dosfs.c

783

if (fs->bufsec != lsec) {

sys/lib/libsa/dosfs.c

784

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

sys/lib/libsa/dosfs.c

786

fs->bufsec = lsec;

sys/lib/libsa/dosfs.c

86

DOS_FS *fs; /* associated filesystem */

sys/lib/libsa/ext2fs.c

1001

fs->e2fs.e2fs_first_ino);

sys/lib/libsa/ext2fs.c

1003

fs->e2fs.e2fs_inode_size);

sys/lib/libsa/ext2fs.c

1005

fs->e2fs.e2fs_features_compat);

sys/lib/libsa/ext2fs.c

1007

fs->e2fs.e2fs_features_incompat);

sys/lib/libsa/ext2fs.c

1009

fs->e2fs.e2fs_features_rocompat);

sys/lib/libsa/ext2fs.c

1011

fs->e2fs.e2fs_reserved_ngdb);

sys/lib/libsa/ext2fs.c

1014

printf("fs->e2fs_bsize = %u\n", fs->e2fs_bsize);

sys/lib/libsa/ext2fs.c

1015

printf("fs->e2fs_fsbtodb = %u\n", fs->e2fs_fsbtodb);

sys/lib/libsa/ext2fs.c

1016

printf("fs->e2fs_ncg = %u\n", fs->e2fs_ncg);

sys/lib/libsa/ext2fs.c

1017

printf("fs->e2fs_ngdb = %u\n", fs->e2fs_ngdb);

sys/lib/libsa/ext2fs.c

1018

printf("fs->e2fs_ipb = %u\n", fs->e2fs_ipb);

sys/lib/libsa/ext2fs.c

1019

printf("fs->e2fs_itpg = %u\n", fs->e2fs_itpg);

sys/lib/libsa/ext2fs.c

119

#define FSBTODB(fs, indp) EXT2_FSBTODB(fs, indp)

sys/lib/libsa/ext2fs.c

168

struct m_ext2fs *fs = fp->f_fs;

sys/lib/libsa/ext2fs.c

175

inode_sector = FSBTODB(fs, ino_to_fsba(fs, inumber));

sys/lib/libsa/ext2fs.c

183

inode_sector, fs->e2fs_bsize, buf, &rsize);

sys/lib/libsa/ext2fs.c

186

if (rsize != (size_t)fs->e2fs_bsize)

sys/lib/libsa/ext2fs.c

190

EXT2_DINODE_SIZE(fs) * ino_to_fsbo(fs, inumber));

sys/lib/libsa/ext2fs.c

191

e2fs_iload(dip, &fp->f_di, EXT2_DINODE_SIZE(fs));

sys/lib/libsa/ext2fs.c

209

struct m_ext2fs *fs = fp->f_fs;

sys/lib/libsa/ext2fs.c

288

FSBTODB(fp->f_fs, ind_block_num), fs->e2fs_bsize,

sys/lib/libsa/ext2fs.c

292

if (rsize != (size_t)fs->e2fs_bsize)

sys/lib/libsa/ext2fs.c

318

struct m_ext2fs *fs = fp->f_fs;

sys/lib/libsa/ext2fs.c

325

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

sys/lib/libsa/ext2fs.c

326

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

sys/lib/libsa/ext2fs.c

327

block_size = fs->e2fs_bsize; /* no fragment */

sys/lib/libsa/ext2fs.c

340

FSBTODB(fs, disk_block),

sys/lib/libsa/ext2fs.c

413

read_sblock(struct open_file *f, struct m_ext2fs *fs)

sys/lib/libsa/ext2fs.c

439

e2fs_sbload((void *)sbbuf, &fs->e2fs);

sys/lib/libsa/ext2fs.c

441

fs->e2fs_ncg =

sys/lib/libsa/ext2fs.c

442

howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,

sys/lib/libsa/ext2fs.c

443

fs->e2fs.e2fs_bpg);

sys/lib/libsa/ext2fs.c

445

fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + 1;

sys/lib/libsa/ext2fs.c

446

fs->e2fs_bsize = MINBSIZE << fs->e2fs.e2fs_log_bsize;

sys/lib/libsa/ext2fs.c

447

fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize;

sys/lib/libsa/ext2fs.c

448

fs->e2fs_qbmask = fs->e2fs_bsize - 1;

sys/lib/libsa/ext2fs.c

449

fs->e2fs_bmask = ~fs->e2fs_qbmask;

sys/lib/libsa/ext2fs.c

450

fs->e2fs_ngdb =

sys/lib/libsa/ext2fs.c

451

howmany(fs->e2fs_ncg, fs->e2fs_bsize / sizeof(struct ext2_gd));

sys/lib/libsa/ext2fs.c

452

fs->e2fs_ipb = fs->e2fs_bsize / ext2fs.e2fs_inode_size;

sys/lib/libsa/ext2fs.c

453

fs->e2fs_itpg = fs->e2fs.e2fs_ipg / fs->e2fs_ipb;

sys/lib/libsa/ext2fs.c

459

read_gdblock(struct open_file *f, struct m_ext2fs *fs)

sys/lib/libsa/ext2fs.c

466

gdpb = fs->e2fs_bsize / sizeof(struct ext2_gd);

sys/lib/libsa/ext2fs.c

468

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

sys/lib/libsa/ext2fs.c

470

FSBTODB(fs, fs->e2fs.e2fs_first_dblock +

sys/lib/libsa/ext2fs.c

472

fs->e2fs_bsize, fp->f_buf, &rsize);

sys/lib/libsa/ext2fs.c

475

if (rsize != (size_t)fs->e2fs_bsize)

sys/lib/libsa/ext2fs.c

479

&fs->e2fs_gd[i * gdpb],

sys/lib/libsa/ext2fs.c

480

(i == (fs->e2fs_ngdb - 1)) ?

sys/lib/libsa/ext2fs.c

481

(fs->e2fs_ncg - gdpb * i) * sizeof(struct ext2_gd):

sys/lib/libsa/ext2fs.c

482

(size_t)fs->e2fs_bsize);

sys/lib/libsa/ext2fs.c

501

struct m_ext2fs *fs;

sys/lib/libsa/ext2fs.c

516

fs = alloc(sizeof(*fs));

sys/lib/libsa/ext2fs.c

517

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

sys/lib/libsa/ext2fs.c

518

fp->f_fs = fs;

sys/lib/libsa/ext2fs.c

521

rc = read_sblock(f, fs);

sys/lib/libsa/ext2fs.c

526

dump_sblock(fs);

sys/lib/libsa/ext2fs.c

530

fp->f_buf = alloc(fs->e2fs_bsize);

sys/lib/libsa/ext2fs.c

533

fs->e2fs_gd = alloc(sizeof(struct ext2_gd) * fs->e2fs_ncg);

sys/lib/libsa/ext2fs.c

534

rc = read_gdblock(f, fs);

sys/lib/libsa/ext2fs.c

551

mult = EXT2_NINDIR(fs);

sys/lib/libsa/ext2fs.c

649

F_READ, FSBTODB(fs, disk_block),

sys/lib/libsa/ext2fs.c

650

fs->e2fs_bsize, buf, &buf_size);

sys/lib/libsa/ext2fs.c

988

dump_sblock(struct m_ext2fs *fs)

sys/lib/libsa/ext2fs.c

991

printf("fs->e2fs.e2fs_bcount = %u\n", fs->e2fs.e2fs_bcount);

sys/lib/libsa/ext2fs.c

992

printf("fs->e2fs.e2fs_first_dblock = %u\n", fs->e2fs.e2fs_first_dblock);

sys/lib/libsa/ext2fs.c

993

printf("fs->e2fs.e2fs_log_bsize = %u\n", fs->e2fs.e2fs_log_bsize);

sys/lib/libsa/ext2fs.c

994

printf("fs->e2fs.e2fs_bpg = %u\n", fs->e2fs.e2fs_bpg);

sys/lib/libsa/ext2fs.c

995

printf("fs->e2fs.e2fs_ipg = %u\n", fs->e2fs.e2fs_ipg);

sys/lib/libsa/ext2fs.c

996

printf("fs->e2fs.e2fs_magic = 0x%x\n", fs->e2fs.e2fs_magic);

sys/lib/libsa/ext2fs.c

997

printf("fs->e2fs.e2fs_rev = %u\n", fs->e2fs.e2fs_rev);

sys/lib/libsa/ext2fs.c

999

if (fs->e2fs.e2fs_rev == E2FS_REV1) {

sys/lib/libsa/ffs_bswap.c

56

ffs_sb_swap(const struct fs *o, struct fs *n)

sys/lib/libsa/ffs_bswap.c

69

for (i = 0; i < offsetof(struct fs, fs_fmod) / sizeof(u_int32_t); i++)

sys/lib/libsa/lfsv1.c

20

#define INOPBx(fs) LFS_INOPB(fs)

sys/lib/libsa/lfsv1.c

26

#define FSBTODB(fs, daddr) (daddr) /* LFSv1 uses sectors for addresses */

sys/lib/libsa/lfsv2.c

21

#define INOPBx(fs) LFS_INOPF(fs)

sys/lib/libsa/lfsv2.c

23

#define INOPBx(fs) LFS_INOPB(fs)

sys/lib/libsa/minixfs3.c

143

#define FSBTODB(fs, indp) MFS_FSBTODB(fs, indp)

sys/lib/libsa/minixfs3.c

187

struct mfs_sblock *fs = fp->f_fs;

sys/lib/libsa/minixfs3.c

194

inode_sector = FSBTODB(fs, ino_to_fsba(fs, inumber));

sys/lib/libsa/minixfs3.c

202

inode_sector, fs->mfs_block_size, buf, &rsize);

sys/lib/libsa/minixfs3.c

205

if (rsize != fs->mfs_block_size)

sys/lib/libsa/minixfs3.c

209

INODE_SIZE * ino_to_fsbo(fs, inumber));

sys/lib/libsa/minixfs3.c

228

struct mfs_sblock *fs = fp->f_fs;

sys/lib/libsa/minixfs3.c

236

int scale = fs->mfs_log_zone_size; /* for block-zone conversion */

sys/lib/libsa/minixfs3.c

310

FSBTODB(fs, ind_block_num), fs->mfs_block_size,

sys/lib/libsa/minixfs3.c

314

if (rsize != fs->mfs_block_size)

sys/lib/libsa/minixfs3.c

342

struct mfs_sblock *fs = fp->f_fs;

sys/lib/libsa/minixfs3.c

349

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

sys/lib/libsa/minixfs3.c

350

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

sys/lib/libsa/minixfs3.c

351

block_size = fs->mfs_block_size;

sys/lib/libsa/minixfs3.c

364

FSBTODB(fs, disk_block),

sys/lib/libsa/minixfs3.c

400

struct mfs_sblock *fs = fp->f_fs;

sys/lib/libsa/minixfs3.c

421

if (buf_size < fs->mfs_block_size)

sys/lib/libsa/minixfs3.c

422

buf_size = fs->mfs_block_size;

sys/lib/libsa/minixfs3.c

424

for (dp = dbuf; dp < &dbuf[NR_DIR_ENTRIES(fs)]; dp++) {

sys/lib/libsa/minixfs3.c

448

read_sblock(struct open_file *f, struct mfs_sblock *fs)

sys/lib/libsa/minixfs3.c

468

mfs_sbload((void *)sbbuf, fs);

sys/lib/libsa/minixfs3.c

470

if (fs->mfs_magic != SUPER_MAGIC)

sys/lib/libsa/minixfs3.c

472

if (fs->mfs_block_size < MINBSIZE)

sys/lib/libsa/minixfs3.c

474

if ((fs->mfs_block_size % 512) != 0)

sys/lib/libsa/minixfs3.c

476

if (SBSIZE > fs->mfs_block_size)

sys/lib/libsa/minixfs3.c

478

if ((fs->mfs_block_size % INODE_SIZE) != 0)

sys/lib/libsa/minixfs3.c

485

if (fs->mfs_firstdatazone_old == 0) {

sys/lib/libsa/minixfs3.c

487

offset = START_BLOCK + fs->mfs_imap_blocks + fs->mfs_zmap_blocks;

sys/lib/libsa/minixfs3.c

488

offset += (fs->mfs_ninodes + fs->mfs_inodes_per_block - 1) /

sys/lib/libsa/minixfs3.c

489

fs->mfs_inodes_per_block;

sys/lib/libsa/minixfs3.c

491

fs->mfs_firstdatazone =

sys/lib/libsa/minixfs3.c

492

(offset + (1 << fs->mfs_log_zone_size) - 1) >>

sys/lib/libsa/minixfs3.c

493

fs->mfs_log_zone_size;

sys/lib/libsa/minixfs3.c

495

fs->mfs_firstdatazone = (zone_t) fs->mfs_firstdatazone_old;

sys/lib/libsa/minixfs3.c

498

if (fs->mfs_imap_blocks < 1 || fs->mfs_zmap_blocks < 1

sys/lib/libsa/minixfs3.c

499

|| fs->mfs_ninodes < 1 || fs->mfs_zones < 1

sys/lib/libsa/minixfs3.c

500

|| fs->mfs_firstdatazone <= 4

sys/lib/libsa/minixfs3.c

501

|| fs->mfs_firstdatazone >= fs->mfs_zones

sys/lib/libsa/minixfs3.c

502

|| (unsigned) fs->mfs_log_zone_size > 4)

sys/lib/libsa/minixfs3.c

506

fs->mfs_inodes_per_block = fs->mfs_block_size / INODE_SIZE;

sys/lib/libsa/minixfs3.c

510

int32_t mult = fs->mfs_block_size >> LOG_MINBSIZE;

sys/lib/libsa/minixfs3.c

516

fs->mfs_bshift = ln2;

sys/lib/libsa/minixfs3.c

518

fs->mfs_fsbtodb = ln2 - LOG_MINBSIZE + 1;

sys/lib/libsa/minixfs3.c

521

fs->mfs_qbmask = fs->mfs_block_size - 1;

sys/lib/libsa/minixfs3.c

522

fs->mfs_bmask = ~fs->mfs_qbmask;

sys/lib/libsa/minixfs3.c

539

struct mfs_sblock *fs;

sys/lib/libsa/minixfs3.c

554

fs = alloc(sizeof(*fs));

sys/lib/libsa/minixfs3.c

555

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

sys/lib/libsa/minixfs3.c

556

fp->f_fs = fs;

sys/lib/libsa/minixfs3.c

559

rc = read_sblock(f, fs);

sys/lib/libsa/minixfs3.c

564

fp->f_buf = alloc(fs->mfs_block_size);

sys/lib/libsa/minixfs3.c

579

mult = MFS_NINDIR(fs);

sys/lib/libsa/minixfs3.c

672

F_READ, FSBTODB(fs, disk_block),

sys/lib/libsa/minixfs3.c

673

fs->mfs_block_size, buf, &buf_size);

sys/lib/libsa/minixfs3.c

830

struct mfs_sblock *fs = fp->f_fs;

sys/lib/libsa/minixfs3.c

847

if (buf_size < fs->mfs_block_size)

sys/lib/libsa/minixfs3.c

848

buf_size = fs->mfs_block_size;

sys/lib/libsa/minixfs3.c

850

for (dp = dbuf; dp < &dbuf[NR_DIR_ENTRIES(fs)]; dp++) {

sys/lib/libsa/minixfs3.h

107

#define NR_DIR_ENTRIES(fs) ((fs)->mfs_block_size/DIR_ENTRY_SIZE)

sys/lib/libsa/minixfs3.h

114

#define MFS_NINDIR(fs) ((fs)->mfs_block_size/ZONE_NUM_SIZE)

sys/lib/libsa/minixfs3.h

120

#define MFS_FSBTODB(fs, b) ((b) << (fs)->mfs_fsbtodb)

sys/lib/libsa/minixfs3.h

122

#define ino_to_fsba(fs, x) \

sys/lib/libsa/minixfs3.h

123

(((x) - 1) / (fs)->mfs_inodes_per_block + \

sys/lib/libsa/minixfs3.h

124

START_BLOCK + (fs)->mfs_imap_blocks + (fs)->mfs_zmap_blocks)

sys/lib/libsa/minixfs3.h

125

#define ino_to_fsbo(fs, x) (((x) - 1) % (fs)->mfs_inodes_per_block)

sys/lib/libsa/minixfs3.h

152

#define mfs_blkoff(fs, loc) /* calculates (loc % fs->mfs_bsize) */ \

sys/lib/libsa/minixfs3.h

153

((loc) & (fs)->mfs_qbmask)

sys/lib/libsa/minixfs3.h

154

#define mfs_lblkno(fs, loc) /* calculates (loc / fs->mfs_bsize) */ \

sys/lib/libsa/minixfs3.h

155

((loc) >> (fs)->mfs_bshift)

sys/lib/libsa/stand.h

100

#define FS_DEF(fs) FS_DEF_BASE(fs)

sys/lib/libsa/stand.h

127

#define FS_OPS(fs) { \

sys/lib/libsa/stand.h

128

__CONCAT(fs,_open), \

sys/lib/libsa/stand.h

129

__CONCAT(fs,_close), \

sys/lib/libsa/stand.h

130

__CONCAT(fs,_read), \

sys/lib/libsa/stand.h

131

__CONCAT(fs,_write), \

sys/lib/libsa/stand.h

132

__CONCAT(fs,_seek), \

sys/lib/libsa/stand.h

133

__CONCAT(fs,_stat), \

sys/lib/libsa/stand.h

134

__CONCAT(fs,_ls) }

sys/lib/libsa/stand.h

136

#define FS_OPS(fs) { \

sys/lib/libsa/stand.h

137

__CONCAT(fs,_open), \

sys/lib/libsa/stand.h

138

__CONCAT(fs,_close), \

sys/lib/libsa/stand.h

139

__CONCAT(fs,_read), \

sys/lib/libsa/stand.h

140

__CONCAT(fs,_write), \

sys/lib/libsa/stand.h

141

__CONCAT(fs,_seek), \

sys/lib/libsa/stand.h

142

__CONCAT(fs,_stat) }

sys/lib/libsa/stand.h

145

#define FS_OPEN(fs) ((fs)->open)

sys/lib/libsa/stand.h

146

#define FS_CLOSE(fs) ((fs)->close)

sys/lib/libsa/stand.h

147

#define FS_READ(fs) ((fs)->read)

sys/lib/libsa/stand.h

148

#define FS_WRITE(fs) ((fs)->write)

sys/lib/libsa/stand.h

149

#define FS_SEEK(fs) ((fs)->seek)

sys/lib/libsa/stand.h

150

#define FS_STAT(fs) ((fs)->stat)

sys/lib/libsa/stand.h

152

#define FS_LS(fs) ((fs)->ls)

sys/lib/libsa/stand.h

157

#define FS_OPEN(fs) ___CONCAT(LIBSA_SINGLE_FILESYSTEM,_open)

sys/lib/libsa/stand.h

158

#define FS_CLOSE(fs) ___CONCAT(LIBSA_SINGLE_FILESYSTEM,_close)

sys/lib/libsa/stand.h

159

#define FS_READ(fs) ___CONCAT(LIBSA_SINGLE_FILESYSTEM,_read)

sys/lib/libsa/stand.h

160

#define FS_WRITE(fs) ___CONCAT(LIBSA_SINGLE_FILESYSTEM,_write)

sys/lib/libsa/stand.h

161

#define FS_SEEK(fs) ___CONCAT(LIBSA_SINGLE_FILESYSTEM,_seek)

sys/lib/libsa/stand.h

162

#define FS_STAT(fs) ___CONCAT(LIBSA_SINGLE_FILESYSTEM,_stat)

sys/lib/libsa/stand.h

164

#define FS_LS(fs) ___CONCAT(LIBSA_SINGLE_FILESYSTEM,_ls)

sys/lib/libsa/stand.h

85

#define FS_DEF_BASE(fs) \

sys/lib/libsa/stand.h

86

extern __compactcall int __CONCAT(fs,_open)(const char *, struct open_file *); \

sys/lib/libsa/stand.h

87

extern __compactcall int __CONCAT(fs,_close)(struct open_file *); \

sys/lib/libsa/stand.h

88

extern __compactcall int __CONCAT(fs,_read)(struct open_file *, void *, \

sys/lib/libsa/stand.h

90

extern __compactcall int __CONCAT(fs,_write)(struct open_file *, void *, \

sys/lib/libsa/stand.h

92

extern __compactcall off_t __CONCAT(fs,_seek)(struct open_file *, off_t, int); \

sys/lib/libsa/stand.h

93

extern __compactcall int __CONCAT(fs,_stat)(struct open_file *, struct stat *)

sys/lib/libsa/stand.h

96

#define FS_DEF(fs) \

sys/lib/libsa/stand.h

97

FS_DEF_BASE(fs);\

sys/lib/libsa/stand.h

98

extern __compactcall void __CONCAT(fs,_ls)(struct open_file *, const char *)

sys/lib/libsa/ufs.c

1090

ffs_oldfscompat(FS *fs)

sys/lib/libsa/ufs.c

1099

if (fs->fs_magic == FS_UFS1_MAGIC

sys/lib/libsa/ufs.c

1101

&& fs->fs_old_inodefmt < FS_44INODEFMT

sys/lib/libsa/ufs.c

1104

fs->fs_qbmask = ~fs->fs_bmask;

sys/lib/libsa/ufs.c

1105

fs->fs_qfmask = ~fs->fs_fmask;

sys/lib/libsa/ufs.c

122

#define lfs_dino_getsize(fs, dp) ((dp)->di_size)

sys/lib/libsa/ufs.c

133

typedef struct fs FS;

sys/lib/libsa/ufs.c

143

#define cgstart(fc, c) cgstart_ufs2((fs), (c))

sys/lib/libsa/ufs.c

145

#define cgstart(fc, c) cgstart_ufs1((fs), (c))

sys/lib/libsa/ufs.c

157

#define FSBTODB(fs, indp) FFS_FSBTODB(fs, indp)

sys/lib/libsa/ufs.c

216

ffs_is_magic(FS *fs)

sys/lib/libsa/ufs.c

218

return fs->fs_magic == FS_UFS1_MAGIC;

sys/lib/libsa/ufs.c

223

ffs_is_magic_swapped(FS *fs)

sys/lib/libsa/ufs.c

225

return fs->fs_magic == bswap32(FS_UFS1_MAGIC);

sys/lib/libsa/ufs.c

233

ffs_is_magic(FS *fs)

sys/lib/libsa/ufs.c

235

return fs->fs_magic == FS_UFS2_MAGIC || fs->fs_magic == FS_UFS2EA_MAGIC;

sys/lib/libsa/ufs.c

240

ffs_is_magic_swapped(FS *fs)

sys/lib/libsa/ufs.c

242

return fs->fs_magic == bswap32(FS_UFS2_MAGIC) ||

sys/lib/libsa/ufs.c

243

fs->fs_magic == bswap32(FS_UFS2EA_MAGIC);

sys/lib/libsa/ufs.c

251

ffs_is_magic(FS *fs)

sys/lib/libsa/ufs.c

253

return fs->fs_magic == LFS_MAGIC;

sys/lib/libsa/ufs.c

258

ffs_is_magic_swapped(FS *fs)

sys/lib/libsa/ufs.c

260

return fs->fs_magic == bswap32(LFS_MAGIC);

sys/lib/libsa/ufs.c

267

ffs_fix_magic_swapped(struct file *fp, FS *fs)

sys/lib/libsa/ufs.c

270

fp->f_swapped = ffs_is_magic_swapped(fs);

sys/lib/libsa/ufs.c

273

ffs_sb_swap(fs, fs);

sys/lib/libsa/ufs.c

315

FS *fs = fp->f_fs;

sys/lib/libsa/ufs.c

326

entsize = fs->lfs_is64 ? sizeof(IFILE64) :

sys/lib/libsa/ufs.c

327

(lfs_sb_getversion(fs) > 1 ? sizeof(IFILE32) : sizeof(IFILE_V1));

sys/lib/libsa/ufs.c

329

(inumber / lfs_sb_getifpb(fs)) + lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs);

sys/lib/libsa/ufs.c

330

fp->f_seekp = (off_t)ifileent_blkno * lfs_sb_getbsize(fs) +

sys/lib/libsa/ufs.c

331

(inumber % lfs_sb_getifpb(fs)) * entsize;

sys/lib/libsa/ufs.c

339

*isp = FSBTODB(fs, lfs_if_getdaddr(fs, (IFILE *)ent_in_buf));

sys/lib/libsa/ufs.c

353

FS *fs = fp->f_fs;

sys/lib/libsa/ufs.c

365

inode_sector = FSBTODB(fs, lfs_sb_getidaddr(fs));

sys/lib/libsa/ufs.c

369

inode_sector = FSBTODB(fs, ino_to_fsba(fs, inumber));

sys/lib/libsa/ufs.c

378

inode_sector, fs->fs_bsize, buf, &rsize);

sys/lib/libsa/ufs.c

381

if (rsize != (size_t)fs->fs_bsize)

sys/lib/libsa/ufs.c

385

cnt = INOPBx(fs);

sys/lib/libsa/ufs.c

394

fp->f_di = ((struct ufs_dinode *)buf)[ino_to_fsbo(fs, inumber)];

sys/lib/libsa/ufs.c

417

FS *fs = fp->f_fs;

sys/lib/libsa/ufs.c

489

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

sys/lib/libsa/ufs.c

493

if (rsize != (size_t)fs->fs_bsize)

sys/lib/libsa/ufs.c

534

FS *fs = fp->f_fs;

sys/lib/libsa/ufs.c

540

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

sys/lib/libsa/ufs.c

541

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

sys/lib/libsa/ufs.c

543

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

sys/lib/libsa/ufs.c

545

block_size = (size_t)ffs_sblksize(fs, (int64_t)fp->f_di.di_size, file_block);

sys/lib/libsa/ufs.c

560

FSBTODB(fs, disk_block),

sys/lib/libsa/ufs.c

635

ffs_find_superblock(struct open_file *f, FS *fs)

sys/lib/libsa/ufs.c

648

sblock_try[i] / GETSECSIZE(f), SBLOCKSIZE, fs, &buf_size);

sys/lib/libsa/ufs.c

653

ffs_fix_magic_swapped(fp, fs);

sys/lib/libsa/ufs.c

654

if (fs->fs_sblockloc != sblock_try[i])

sys/lib/libsa/ufs.c

657

if (ffs_is_magic(fs))

sys/lib/libsa/ufs.c

663

SBLOCKOFFSET / GETSECSIZE(f), SBLOCKSIZE, fs, &buf_size);

sys/lib/libsa/ufs.c

668

ffs_fix_magic_swapped(fp, fs);

sys/lib/libsa/ufs.c

671

if (fs->lfs_version != REQUIRED_LFS_VERSION)

sys/lib/libsa/ufs.c

674

if (!ffs_is_magic(fs))

sys/lib/libsa/ufs.c

693

FS *fs;

sys/lib/libsa/ufs.c

708

fs = alloc(SBLOCKSIZE);

sys/lib/libsa/ufs.c

709

fp->f_fs = fs;

sys/lib/libsa/ufs.c

712

rc = ffs_find_superblock(f, fs);

sys/lib/libsa/ufs.c

725

fs->lfs_is64 = 0;

sys/lib/libsa/ufs.c

726

fs->lfs_dobyteswap = 0;

sys/lib/libsa/ufs.c

727

fs->lfs_hasolddirfmt = (fs->fs_maxsymlinklen <= 0);

sys/lib/libsa/ufs.c

730

ffs_oldfscompat(fs);

sys/lib/libsa/ufs.c

733

if (fs->fs_bsize > MAXBSIZE ||

sys/lib/libsa/ufs.c

734

(size_t)fs->fs_bsize < sizeof(FS)) {

sys/lib/libsa/ufs.c

752

mult = UFS_NINDIR(fs);

sys/lib/libsa/ufs.c

767

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

sys/lib/libsa/ufs.c

835

if (link_len < fs->fs_maxsymlinklen) {

sys/lib/libsa/ufs.c

851

F_READ, FSBTODB(fs, disk_block),

sys/lib/libsa/ufs.c

852

fs->fs_bsize, buf, &buf_size);

sys/lib/libsa/ufs.h

39

struct fs;

sys/lib/libsa/ufs.h

42

void ffs_sb_swap(const struct fs *, struct fs *);

sys/rump/include/rump/rumpdefs.h

54

#define RUMP__FCN_FSPRIV(inout, fs, num, len) \

sys/rump/include/rump/rumpdefs.h

56

(fs) << 8 | (num))

sys/sys/fcntl.h

272

#define _FCN_FSPRIV(inout, fs, num, len) \

sys/sys/fcntl.h

274

(fs) << 8 | (num))

sys/ufs/ext2fs/ext2fs.h

380

#define EXT2F_HAS_COMPAT_FEATURE(fs, feature) \

sys/ufs/ext2fs/ext2fs.h

381

((fs)->e2fs.e2fs_rev >= E2FS_REV1 && \

sys/ufs/ext2fs/ext2fs.h

382

((fs)->e2fs.e2fs_features_compat & (feature)) != 0)

sys/ufs/ext2fs/ext2fs.h

384

#define EXT2F_HAS_ROCOMPAT_FEATURE(fs, feature) \

sys/ufs/ext2fs/ext2fs.h

385

((fs)->e2fs.e2fs_rev >= E2FS_REV1 && \

sys/ufs/ext2fs/ext2fs.h

386

((fs)->e2fs.e2fs_features_rocompat & (feature)) != 0)

sys/ufs/ext2fs/ext2fs.h

388

#define EXT2F_HAS_INCOMPAT_FEATURE(fs, feature) \

sys/ufs/ext2fs/ext2fs.h

389

((fs)->e2fs.e2fs_rev >= E2FS_REV1 && \

sys/ufs/ext2fs/ext2fs.h

390

((fs)->e2fs.e2fs_features_incompat & (feature)) != 0)

sys/ufs/ext2fs/ext2fs.h

452

#define E2FS_HAS_GD_CSUM(fs) \

sys/ufs/ext2fs/ext2fs.h

453

EXT2F_HAS_ROCOMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM|EXT2F_ROCOMPAT_METADATA_CKSUM) != 0

sys/ufs/ext2fs/ext2fs.h

512

#define EXT2_FSBTODB(fs, b) ((b) << (fs)->e2fs_fsbtodb)

sys/ufs/ext2fs/ext2fs.h

513

#define EXT2_FSBTODB64(fs, b, b_hi) \

sys/ufs/ext2fs/ext2fs.h

514

(((((uint64_t)(b_hi)) << 32) | (b)) << (fs)->e2fs_fsbtodb)

sys/ufs/ext2fs/ext2fs.h

515

#define EXT2_FSBTODB64OFF(fs, b, b_hi, off) \

sys/ufs/ext2fs/ext2fs.h

516

((((((uint64_t)(b_hi)) << 32) | (b)) + (off)) << (fs)->e2fs_fsbtodb)

sys/ufs/ext2fs/ext2fs.h

517

#define EXT2_DBTOFSB(fs, b) ((b) >> (fs)->e2fs_fsbtodb)

sys/ufs/ext2fs/ext2fs.h

525

#define ino_to_cg(fs, x) (((x) - 1) / (fs)->e2fs.e2fs_ipg)

sys/ufs/ext2fs/ext2fs.h

526

#define _e2fs_gd(fs, x) (fs)->e2fs_gd[ino_to_cg((fs), (x))]

sys/ufs/ext2fs/ext2fs.h

527

#define ino_to_fsba(fs, x) \

sys/ufs/ext2fs/ext2fs.h

528

(fs2h32(_e2fs_gd(fs, x).ext2bgd_i_tables) + \

sys/ufs/ext2fs/ext2fs.h

529

(((uint64_t)fs2h32(_e2fs_gd(fs, x).ext2bgd_i_tables_hi)) << 32) + \

sys/ufs/ext2fs/ext2fs.h

530

(((x) - 1) % (fs)->e2fs.e2fs_ipg) / (fs)->e2fs_ipb)

sys/ufs/ext2fs/ext2fs.h

531

#define ino_to_fsbo(fs, x) (((x) - 1) % (fs)->e2fs_ipb)

sys/ufs/ext2fs/ext2fs.h

537

#define dtog(fs, d) (((d) - (fs)->e2fs.e2fs_first_dblock) / (fs)->e2fs.e2fs_fpg)

sys/ufs/ext2fs/ext2fs.h

538

#define dtogd(fs, d) \

sys/ufs/ext2fs/ext2fs.h

539

(((d) - (fs)->e2fs.e2fs_first_dblock) % (fs)->e2fs.e2fs_fpg)

sys/ufs/ext2fs/ext2fs.h

546

#define ext2_blkoff(fs, loc) /* calculates (loc % fs->e2fs_bsize) */ \

sys/ufs/ext2fs/ext2fs.h

547

((loc) & (fs)->e2fs_qbmask)

sys/ufs/ext2fs/ext2fs.h

548

#define ext2_lblktosize(fs, blk) /* calculates (blk * fs->e2fs_bsize) */ \

sys/ufs/ext2fs/ext2fs.h

549

((blk) << (fs)->e2fs_bshift)

sys/ufs/ext2fs/ext2fs.h

550

#define ext2_lblkno(fs, loc) /* calculates (loc / fs->e2fs_bsize) */ \

sys/ufs/ext2fs/ext2fs.h

551

((loc) >> (fs)->e2fs_bshift)

sys/ufs/ext2fs/ext2fs.h

552

#define ext2_blkroundup(fs, size) /* calculates roundup(size, fs->e2fs_bsize) */ \

sys/ufs/ext2fs/ext2fs.h

553

(((size) + (fs)->e2fs_qbmask) & (fs)->e2fs_bmask)

sys/ufs/ext2fs/ext2fs.h

554

#define ext2_fragroundup(fs, size) /* calculates roundup(size, fs->e2fs_bsize) */ \

sys/ufs/ext2fs/ext2fs.h

555

(((size) + (fs)->e2fs_qbmask) & (fs)->e2fs_bmask)

sys/ufs/ext2fs/ext2fs.h

560

#define freespace(fs) \

sys/ufs/ext2fs/ext2fs.h

561

((fs)->e2fs.e2fs_fbcount - (fs)->e2fs.e2fs_rbcount)

sys/ufs/ext2fs/ext2fs.h

566

#define EXT2_NINDIR(fs) ((fs)->e2fs_bsize / sizeof(uint32_t))

sys/ufs/ext2fs/ext2fs.h

89

#define fsbtodb(fs, b) ((daddr_t)(b) << (fs)->e2fs_fsbtodb)

sys/ufs/ext2fs/ext2fs.h

91

#define lblkno(fs, loc) ((loc) >> (fs->e2fs_bshift))

sys/ufs/ext2fs/ext2fs.h

92

#define blksize(fs, ip, lbn) ((fs)->e2fs_bsize)

sys/ufs/ext2fs/ext2fs_alloc.c

120

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_alloc.c

125

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_alloc.c

130

if (fs->e2fs.e2fs_fbcount == 0)

sys/ufs/ext2fs/ext2fs_alloc.c

134

freespace(fs) <= 0)

sys/ufs/ext2fs/ext2fs_alloc.c

136

if (bpref >= fs->e2fs.e2fs_bcount)

sys/ufs/ext2fs/ext2fs_alloc.c

139

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

sys/ufs/ext2fs/ext2fs_alloc.c

141

cg = dtog(fs, bpref);

sys/ufs/ext2fs/ext2fs_alloc.c

142

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

sys/ufs/ext2fs/ext2fs_alloc.c

145

ext2fs_setnblock(ip, ext2fs_nblock(ip) + btodb(fs->e2fs_bsize));

sys/ufs/ext2fs/ext2fs_alloc.c

151

ext2fs_fserr(fs, kauth_cred_geteuid(cred), "file system full");

sys/ufs/ext2fs/ext2fs_alloc.c

152

uprintf("\n%s: write failed, file system is full\n", fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_alloc.c

175

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_alloc.c

180

fs = pip->i_e2fs;

sys/ufs/ext2fs/ext2fs_alloc.c

181

if (fs->e2fs.e2fs_ficount == 0)

sys/ufs/ext2fs/ext2fs_alloc.c

185

cg = ext2fs_dirpref(fs);

sys/ufs/ext2fs/ext2fs_alloc.c

187

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

sys/ufs/ext2fs/ext2fs_alloc.c

188

ipref = cg * fs->e2fs.e2fs_ipg + 1;

sys/ufs/ext2fs/ext2fs_alloc.c

197

ext2fs_fserr(fs, kauth_cred_geteuid(cred), "out of inodes");

sys/ufs/ext2fs/ext2fs_alloc.c

198

uprintf("\n%s: create/symlink failed, no inodes free\n", fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_alloc.c

210

ext2fs_dirpref(struct m_ext2fs *fs)

sys/ufs/ext2fs/ext2fs_alloc.c

214

avgifree = fs->e2fs.e2fs_ficount / fs->e2fs_ncg;

sys/ufs/ext2fs/ext2fs_alloc.c

217

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

sys/ufs/ext2fs/ext2fs_alloc.c

219

(fs2h16(fs->e2fs_gd[cg].ext2bgd_nifree_hi) << 16)

sys/ufs/ext2fs/ext2fs_alloc.c

220

| fs2h16(fs->e2fs_gd[cg].ext2bgd_nifree);

sys/ufs/ext2fs/ext2fs_alloc.c

225

(fs2h16(fs->e2fs_gd[cg].ext2bgd_nbfree_hi) << 16)

sys/ufs/ext2fs/ext2fs_alloc.c

226

| fs2h16(fs->e2fs_gd[cg].ext2bgd_nbfree);

sys/ufs/ext2fs/ext2fs_alloc.c

250

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_alloc.c

253

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_alloc.c

278

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

sys/ufs/ext2fs/ext2fs_alloc.c

279

return fs->e2fs.e2fs_bpg * cg + fs->e2fs.e2fs_first_dblock + 1;

sys/ufs/ext2fs/ext2fs_alloc.c

294

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_alloc.c

298

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_alloc.c

308

for (i = 1; i < fs->e2fs_ncg; i *= 2) {

sys/ufs/ext2fs/ext2fs_alloc.c

310

if (cg >= fs->e2fs_ncg)

sys/ufs/ext2fs/ext2fs_alloc.c

311

cg -= fs->e2fs_ncg;

sys/ufs/ext2fs/ext2fs_alloc.c

321

cg = (icg + 2) % fs->e2fs_ncg;

sys/ufs/ext2fs/ext2fs_alloc.c

322

for (i = 2; i < fs->e2fs_ncg; i++) {

sys/ufs/ext2fs/ext2fs_alloc.c

327

if (cg == fs->e2fs_ncg)

sys/ufs/ext2fs/ext2fs_alloc.c

343

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_alloc.c

348

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_alloc.c

349

if (fs->e2fs_gd[cg].ext2bgd_nbfree == 0 &&

sys/ufs/ext2fs/ext2fs_alloc.c

350

fs->e2fs_gd[cg].ext2bgd_nbfree_hi == 0)

sys/ufs/ext2fs/ext2fs_alloc.c

352

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

sys/ufs/ext2fs/ext2fs_alloc.c

353

fs2h32(fs->e2fs_gd[cg].ext2bgd_b_bitmap),

sys/ufs/ext2fs/ext2fs_alloc.c

354

fs2h32(fs->e2fs_gd[cg].ext2bgd_b_bitmap_hi)),

sys/ufs/ext2fs/ext2fs_alloc.c

355

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

sys/ufs/ext2fs/ext2fs_alloc.c

361

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

sys/ufs/ext2fs/ext2fs_alloc.c

365

if (__predict_false(E2FS_HAS_GD_CSUM(fs) &&

sys/ufs/ext2fs/ext2fs_alloc.c

366

(fs->e2fs_gd[cg].ext2bgd_flags & h2fs16(E2FS_BG_BLOCK_UNINIT)))) {

sys/ufs/ext2fs/ext2fs_alloc.c

367

ext2fs_init_bb(fs, cg, &fs->e2fs_gd[cg], bbp);

sys/ufs/ext2fs/ext2fs_alloc.c

368

fs->e2fs_gd[cg].ext2bgd_flags &= h2fs16(~E2FS_BG_BLOCK_UNINIT);

sys/ufs/ext2fs/ext2fs_alloc.c

372

bpref = dtogd(fs, bpref);

sys/ufs/ext2fs/ext2fs_alloc.c

388

start = dtogd(fs, bpref) / NBBY;

sys/ufs/ext2fs/ext2fs_alloc.c

391

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

sys/ufs/ext2fs/ext2fs_alloc.c

405

bno = ext2fs_mapsearch(fs, bbp, bpref);

sys/ufs/ext2fs/ext2fs_alloc.c

418

cg, bno, fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_alloc.c

423

fs->e2fs.e2fs_fbcount--;

sys/ufs/ext2fs/ext2fs_alloc.c

424

ext2fs_cg_update(fs, cg, &fs->e2fs_gd[cg], -1, 0, 0, 0);

sys/ufs/ext2fs/ext2fs_alloc.c

425

fs->e2fs_fmod = 1;

sys/ufs/ext2fs/ext2fs_alloc.c

427

return cg * fs->e2fs.e2fs_fpg + fs->e2fs.e2fs_first_dblock + bno;

sys/ufs/ext2fs/ext2fs_alloc.c

442

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_alloc.c

450

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_alloc.c

451

if (fs->e2fs_gd[cg].ext2bgd_nifree == 0 &&

sys/ufs/ext2fs/ext2fs_alloc.c

452

fs->e2fs_gd[cg].ext2bgd_nifree_hi == 0)

sys/ufs/ext2fs/ext2fs_alloc.c

454

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

sys/ufs/ext2fs/ext2fs_alloc.c

455

fs2h32(fs->e2fs_gd[cg].ext2bgd_i_bitmap),

sys/ufs/ext2fs/ext2fs_alloc.c

456

fs2h32(fs->e2fs_gd[cg].ext2bgd_i_bitmap_hi)),

sys/ufs/ext2fs/ext2fs_alloc.c

457

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

sys/ufs/ext2fs/ext2fs_alloc.c

463

KASSERT(!E2FS_HAS_GD_CSUM(fs) || (fs->e2fs_gd[cg].ext2bgd_flags & h2fs16(E2FS_BG_INODE_ZEROED)) != 0);

sys/ufs/ext2fs/ext2fs_alloc.c

466

if (__predict_false(E2FS_HAS_GD_CSUM(fs) &&

sys/ufs/ext2fs/ext2fs_alloc.c

467

(fs->e2fs_gd[cg].ext2bgd_flags & h2fs16(E2FS_BG_INODE_UNINIT)))) {

sys/ufs/ext2fs/ext2fs_alloc.c

468

KASSERT(fs2h16(fs->e2fs_gd[cg].ext2bgd_nifree) == fs->e2fs.e2fs_ipg);

sys/ufs/ext2fs/ext2fs_alloc.c

469

memset(ibp, 0, fs->e2fs_bsize);

sys/ufs/ext2fs/ext2fs_alloc.c

470

fs->e2fs_gd[cg].ext2bgd_flags &= h2fs16(~E2FS_BG_INODE_UNINIT);

sys/ufs/ext2fs/ext2fs_alloc.c

474

ipref %= fs->e2fs.e2fs_ipg;

sys/ufs/ext2fs/ext2fs_alloc.c

479

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

sys/ufs/ext2fs/ext2fs_alloc.c

487

cg, (long long)ipref, fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_alloc.c

495

printf("%s: fs = %s\n", __func__, fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_alloc.c

501

fs->e2fs.e2fs_ficount--;

sys/ufs/ext2fs/ext2fs_alloc.c

502

ext2fs_cg_update(fs, cg, &fs->e2fs_gd[cg],

sys/ufs/ext2fs/ext2fs_alloc.c

504

fs->e2fs_fmod = 1;

sys/ufs/ext2fs/ext2fs_alloc.c

506

return cg * fs->e2fs.e2fs_ipg + ipref + 1;

sys/ufs/ext2fs/ext2fs_alloc.c

518

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_alloc.c

523

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_alloc.c

524

cg = dtog(fs, bno);

sys/ufs/ext2fs/ext2fs_alloc.c

526

KASSERT(!E2FS_HAS_GD_CSUM(fs) ||

sys/ufs/ext2fs/ext2fs_alloc.c

527

(fs->e2fs_gd[cg].ext2bgd_flags & h2fs16(E2FS_BG_BLOCK_UNINIT)) == 0);

sys/ufs/ext2fs/ext2fs_alloc.c

529

if ((u_int)bno >= fs->e2fs.e2fs_bcount) {

sys/ufs/ext2fs/ext2fs_alloc.c

532

ext2fs_fserr(fs, ip->i_uid, "bad block");

sys/ufs/ext2fs/ext2fs_alloc.c

535

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

sys/ufs/ext2fs/ext2fs_alloc.c

536

fs2h32(fs->e2fs_gd[cg].ext2bgd_b_bitmap),

sys/ufs/ext2fs/ext2fs_alloc.c

537

fs2h32(fs->e2fs_gd[cg].ext2bgd_b_bitmap_hi)),

sys/ufs/ext2fs/ext2fs_alloc.c

538

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

sys/ufs/ext2fs/ext2fs_alloc.c

543

bno = dtogd(fs, bno);

sys/ufs/ext2fs/ext2fs_alloc.c

547

fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_alloc.c

551

fs->e2fs.e2fs_fbcount++;

sys/ufs/ext2fs/ext2fs_alloc.c

552

ext2fs_cg_update(fs, cg, &fs->e2fs_gd[cg], 1, 0, 0, 0);

sys/ufs/ext2fs/ext2fs_alloc.c

553

fs->e2fs_fmod = 1;

sys/ufs/ext2fs/ext2fs_alloc.c

565

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_alloc.c

572

fs = pip->i_e2fs;

sys/ufs/ext2fs/ext2fs_alloc.c

574

if ((u_int)ino > fs->e2fs.e2fs_icount || (u_int)ino < EXT2_FIRSTINO)

sys/ufs/ext2fs/ext2fs_alloc.c

577

fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_alloc.c

579

cg = ino_to_cg(fs, ino);

sys/ufs/ext2fs/ext2fs_alloc.c

581

KASSERT(!E2FS_HAS_GD_CSUM(fs) ||

sys/ufs/ext2fs/ext2fs_alloc.c

582

(fs->e2fs_gd[cg].ext2bgd_flags & h2fs16(E2FS_BG_INODE_UNINIT)) == 0);

sys/ufs/ext2fs/ext2fs_alloc.c

584

error = bread(pip->i_devvp, EXT2_FSBTODB64(fs,

sys/ufs/ext2fs/ext2fs_alloc.c

585

fs2h32(fs->e2fs_gd[cg].ext2bgd_i_bitmap),

sys/ufs/ext2fs/ext2fs_alloc.c

586

fs2h32(fs->e2fs_gd[cg].ext2bgd_i_bitmap_hi)),

sys/ufs/ext2fs/ext2fs_alloc.c

587

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

sys/ufs/ext2fs/ext2fs_alloc.c

592

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

sys/ufs/ext2fs/ext2fs_alloc.c

596

(uintmax_t)ino, fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_alloc.c

597

if (fs->e2fs_ronly == 0)

sys/ufs/ext2fs/ext2fs_alloc.c

601

fs->e2fs.e2fs_ficount++;

sys/ufs/ext2fs/ext2fs_alloc.c

602

ext2fs_cg_update(fs, cg, &fs->e2fs_gd[cg],

sys/ufs/ext2fs/ext2fs_alloc.c

604

fs->e2fs_fmod = 1;

sys/ufs/ext2fs/ext2fs_alloc.c

617

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

sys/ufs/ext2fs/ext2fs_alloc.c

626

start = dtogd(fs, bpref) / NBBY;

sys/ufs/ext2fs/ext2fs_alloc.c

629

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

sys/ufs/ext2fs/ext2fs_alloc.c

637

__func__, start, len, fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_alloc.c

645

printf("%s: fs = %s\n", __func__, fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_alloc.c

658

ext2fs_fserr(struct m_ext2fs *fs, u_int uid, const char *cp)

sys/ufs/ext2fs/ext2fs_alloc.c

661

log(LOG_ERR, "uid %d on %s: %s\n", uid, fs->e2fs_fsmnt, cp);

sys/ufs/ext2fs/ext2fs_alloc.c

665

ext2fs_cg_update(struct m_ext2fs *fs, int cg, struct ext2_gd *gd, int nbfree, int nifree, int ndirs, daddr_t ioff)

sys/ufs/ext2fs/ext2fs_alloc.c

681

if (E2FS_HAS_GD_CSUM(fs) && nifree < 0 &&

sys/ufs/ext2fs/ext2fs_alloc.c

682

(ioff + 1) >= (fs->e2fs.e2fs_ipg -

sys/ufs/ext2fs/ext2fs_alloc.c

685

h2fs16(fs->e2fs.e2fs_ipg - (ioff + 1));

sys/ufs/ext2fs/ext2fs_alloc.c

688

KASSERT(!E2FS_HAS_GD_CSUM(fs) ||

sys/ufs/ext2fs/ext2fs_alloc.c

709

if (E2FS_HAS_GD_CSUM(fs))

sys/ufs/ext2fs/ext2fs_alloc.c

710

gd->ext2bgd_checksum = ext2fs_cg_get_csum(fs, cg, gd);

sys/ufs/ext2fs/ext2fs_alloc.c

797

ext2fs_cg_get_csum(struct m_ext2fs *fs, int cg, struct ext2_gd *gd)

sys/ufs/ext2fs/ext2fs_alloc.c

800

size_t cgsize = 1 << fs->e2fs_group_desc_shift;

sys/ufs/ext2fs/ext2fs_alloc.c

804

if (EXT2F_HAS_ROCOMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {

sys/ufs/ext2fs/ext2fs_alloc.c

810

crc32 = ext2fs_crc32c(~0, fs->e2fs.e2fs_uuid,

sys/ufs/ext2fs/ext2fs_alloc.c

811

sizeof(fs->e2fs.e2fs_uuid));

sys/ufs/ext2fs/ext2fs_alloc.c

820

if (!EXT2F_HAS_ROCOMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM))

sys/ufs/ext2fs/ext2fs_alloc.c

825

crc = crc16(~0, (uint8_t *)fs->e2fs.e2fs_uuid,

sys/ufs/ext2fs/ext2fs_alloc.c

826

sizeof(fs->e2fs.e2fs_uuid));

sys/ufs/ext2fs/ext2fs_alloc.c

835

ext2fs_init_bb(struct m_ext2fs *fs, int cg, struct ext2_gd *gd, char *bbp)

sys/ufs/ext2fs/ext2fs_alloc.c

839

memset(bbp, 0, fs->e2fs_bsize);

sys/ufs/ext2fs/ext2fs_alloc.c

847

for(i=0; i < fs->e2fs.e2fs_bpg - fs2h16(gd->ext2bgd_nbfree); i++)

sys/ufs/ext2fs/ext2fs_alloc.c

855

ext2fs_cg_verify_and_initialize(struct vnode *devvp, struct m_ext2fs *fs, int ronly)

sys/ufs/ext2fs/ext2fs_alloc.c

863

if (!E2FS_HAS_GD_CSUM(fs))

sys/ufs/ext2fs/ext2fs_alloc.c

866

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

sys/ufs/ext2fs/ext2fs_alloc.c

867

gd = &fs->e2fs_gd[cg];

sys/ufs/ext2fs/ext2fs_alloc.c

870

uint16_t csum = ext2fs_cg_get_csum(fs, cg, gd);

sys/ufs/ext2fs/ext2fs_alloc.c

890

ioff = fs->e2fs.e2fs_ipg - fs2h16(gd->ext2bgd_itable_unused_lo);

sys/ufs/ext2fs/ext2fs_alloc.c

891

boff = (ioff % fs->e2fs_ipb) * EXT2_DINODE_SIZE(fs);

sys/ufs/ext2fs/ext2fs_alloc.c

893

for(i = ioff / fs->e2fs_ipb; i < fs->e2fs_itpg; i++) {

sys/ufs/ext2fs/ext2fs_alloc.c

896

error = bread(devvp, EXT2_FSBTODB64OFF(fs,

sys/ufs/ext2fs/ext2fs_alloc.c

899

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

sys/ufs/ext2fs/ext2fs_alloc.c

906

fs->e2fs_bsize - boff);

sys/ufs/ext2fs/ext2fs_alloc.c

913

bp = getblk(devvp, EXT2_FSBTODB64OFF(fs,

sys/ufs/ext2fs/ext2fs_alloc.c

916

(int)fs->e2fs_bsize, 0, 0);

sys/ufs/ext2fs/ext2fs_alloc.c

924

gd->ext2bgd_checksum = ext2fs_cg_get_csum(fs, cg, gd);

sys/ufs/ext2fs/ext2fs_alloc.c

925

fs->e2fs_fmod = 1;

sys/ufs/ext2fs/ext2fs_balloc.c

119

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_balloc.c

135

error = bread(vp, bn, fs->e2fs_bsize,

sys/ufs/ext2fs/ext2fs_balloc.c

160

bp = getblk(vp, bn, fs->e2fs_bsize, 0, 0);

sys/ufs/ext2fs/ext2fs_balloc.c

161

bp->b_blkno = EXT2_FSBTODB(fs, newb);

sys/ufs/ext2fs/ext2fs_balloc.c

194

bp = getblk(vp, indirs[1].in_lbn, fs->e2fs_bsize, 0, 0);

sys/ufs/ext2fs/ext2fs_balloc.c

195

bp->b_blkno = EXT2_FSBTODB(fs, newb);

sys/ufs/ext2fs/ext2fs_balloc.c

214

indirs[i].in_lbn, (int)fs->e2fs_bsize, 0, &bp);

sys/ufs/ext2fs/ext2fs_balloc.c

236

nbp = getblk(vp, indirs[i].in_lbn, fs->e2fs_bsize, 0, 0);

sys/ufs/ext2fs/ext2fs_balloc.c

237

nbp->b_blkno = EXT2_FSBTODB(fs, nb);

sys/ufs/ext2fs/ext2fs_balloc.c

287

nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0);

sys/ufs/ext2fs/ext2fs_balloc.c

288

nbp->b_blkno = EXT2_FSBTODB(fs, nb);

sys/ufs/ext2fs/ext2fs_balloc.c

298

error = bread(vp, lbn, (int)fs->e2fs_bsize,

sys/ufs/ext2fs/ext2fs_balloc.c

304

nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0);

sys/ufs/ext2fs/ext2fs_balloc.c

305

nbp->b_blkno = EXT2_FSBTODB(fs, nb);

sys/ufs/ext2fs/ext2fs_balloc.c

317

deallocated += fs->e2fs_bsize;

sys/ufs/ext2fs/ext2fs_balloc.c

326

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

sys/ufs/ext2fs/ext2fs_balloc.c

340

bp = getblk(vp, indirs[i].in_lbn, (int)fs->e2fs_bsize,

sys/ufs/ext2fs/ext2fs_balloc.c

357

struct m_ext2fs *fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_balloc.c

361

bshift = fs->e2fs_bshift;

sys/ufs/ext2fs/ext2fs_balloc.c

373

error = ext2fs_balloc(ip, ext2_lblkno(fs, off), bsize, cred,

sys/ufs/ext2fs/ext2fs_balloc.c

98

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_bmap.c

135

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_bmap.c

142

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_bmap.c

152

ext4_ext_find_extent(fs, ip, lbn, &path);

sys/ufs/ext2fs/ext2fs_bmap.c

166

*bnp = fsbtodb(fs, lbn - ep->e_blk

sys/ufs/ext2fs/ext2fs_dinode.h

209

#define EXT2_DINODE_SIZE(fs) ((fs)->e2fs.e2fs_rev > E2FS_REV0 ? \

sys/ufs/ext2fs/ext2fs_dinode.h

210

(fs)->e2fs.e2fs_inode_size : \

sys/ufs/ext2fs/ext2fs_extents.c

181

ext4_ext_find_extent(struct m_ext2fs *fs, struct inode *ip,

sys/ufs/ext2fs/ext2fs_extents.c

209

size = blksize(fs, ip, nblk);

sys/ufs/ext2fs/ext2fs_extents.c

214

error = bread(ip->i_devvp, fsbtodb(fs, nblk), size, 0,

sys/ufs/ext2fs/ext2fs_extents.h

108

struct ext4_extent_path *ext4_ext_find_extent(struct m_ext2fs *fs,

sys/ufs/ext2fs/ext2fs_htree.c

142

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_htree.c

145

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_htree.c

146

space = fs->e2fs_bsize - EXT2_DIR_REC_LEN(0);

sys/ufs/ext2fs/ext2fs_htree.c

387

struct ext2fs *fs;

sys/ufs/ext2fs/ext2fs_htree.c

399

fs = &(dp->i_e2fs->e2fs);

sys/ufs/ext2fs/ext2fs_htree.c

426

root->h_info.h_hash_version = fs->e3fs_def_hash_version;

sys/ufs/ext2fs/ext2fs_htree.c

441

ext2fs_htree_split_dirblock(buf1, buf2, blksize, fs->e3fs_hash_seed,

sys/ufs/ext2fs/ext2fs_htree.c

486

struct ext2fs *fs;

sys/ufs/ext2fs/ext2fs_htree.c

504

fs = &(m_fs->e2fs);

sys/ufs/ext2fs/ext2fs_htree.c

621

fs->e3fs_hash_seed, hash_version, &split_hash, entry);

sys/ufs/ext2fs/ext2fs_htree.c

712

struct ext2fs *fs;/* F, G, and H are MD4 functions */

sys/ufs/ext2fs/ext2fs_htree.c

726

fs = &(ip->i_e2fs->e2fs);

sys/ufs/ext2fs/ext2fs_htree.c

745

ext2fs_htree_hash(name, namelen, fs->e3fs_hash_seed,

sys/ufs/ext2fs/ext2fs_inode.c

116

struct m_ext2fs *fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_inode.c

118

if (fs->e2fs.e2fs_rev <= E2FS_REV0) {

sys/ufs/ext2fs/ext2fs_inode.c

122

if (!EXT2F_HAS_ROCOMPAT_FEATURE(fs,

sys/ufs/ext2fs/ext2fs_inode.c

124

fs->e2fs.e2fs_features_rocompat |=

sys/ufs/ext2fs/ext2fs_inode.c

126

fs->e2fs_fmod = 1;

sys/ufs/ext2fs/ext2fs_inode.c

141

struct m_ext2fs * const fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_inode.c

143

if (EXT2F_HAS_ROCOMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE)) {

sys/ufs/ext2fs/ext2fs_inode.c

147

nblock = EXT2_FSBTODB(fs, nblock);

sys/ufs/ext2fs/ext2fs_inode.c

157

struct m_ext2fs * const fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_inode.c

165

if (!EXT2F_HAS_ROCOMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE))

sys/ufs/ext2fs/ext2fs_inode.c

175

if (EXT2_DBTOFSB(fs, nblock) <= 0xffffffffffffULL) {

sys/ufs/ext2fs/ext2fs_inode.c

177

ip->i_e2fs_nblock = EXT2_DBTOFSB(fs, nblock) & 0xffffffff;

sys/ufs/ext2fs/ext2fs_inode.c

178

ip->i_e2fs_nblock_high = (EXT2_DBTOFSB(fs, nblock) >> 32) & 0xffff;

sys/ufs/ext2fs/ext2fs_inode.c

240

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_inode.c

257

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_inode.c

260

EXT2_FSBTODB(fs, ino_to_fsba(fs, ip->i_number)),

sys/ufs/ext2fs/ext2fs_inode.c

261

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

sys/ufs/ext2fs/ext2fs_inode.c

267

(ino_to_fsbo(fs, ip->i_number) * EXT2_DINODE_SIZE(fs));

sys/ufs/ext2fs/ext2fs_inode.c

268

e2fs_isave(ip->i_din.e2fs_din, (struct ext2fs_dinode *)cp, EXT2_DINODE_SIZE(fs));

sys/ufs/ext2fs/ext2fs_inode.c

295

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_inode.c

326

fs = oip->i_e2fs;

sys/ufs/ext2fs/ext2fs_inode.c

357

offset = ext2_blkoff(fs, length);

sys/ufs/ext2fs/ext2fs_inode.c

359

size = fs->e2fs_bsize;

sys/ufs/ext2fs/ext2fs_inode.c

373

lastblock = ext2_lblkno(fs, length + fs->e2fs_bsize - 1) - 1;

sys/ufs/ext2fs/ext2fs_inode.c

375

lastiblock[DOUBLE] = lastiblock[SINGLE] - EXT2_NINDIR(fs);

sys/ufs/ext2fs/ext2fs_inode.c

376

lastiblock[TRIPLE] = lastiblock[DOUBLE] - EXT2_NINDIR(fs) * EXT2_NINDIR(fs);

sys/ufs/ext2fs/ext2fs_inode.c

377

nblocks = btodb(fs->e2fs_bsize);

sys/ufs/ext2fs/ext2fs_inode.c

424

indir_lbn[DOUBLE] = indir_lbn[SINGLE] - EXT2_NINDIR(fs) -1;

sys/ufs/ext2fs/ext2fs_inode.c

425

indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - EXT2_NINDIR(fs) * EXT2_NINDIR(fs) - 1;

sys/ufs/ext2fs/ext2fs_inode.c

431

EXT2_FSBTODB(fs, bn), lastiblock[level], level, &count);

sys/ufs/ext2fs/ext2fs_inode.c

455

blocksreleased += btodb(fs->e2fs_bsize);

sys/ufs/ext2fs/ext2fs_inode.c

502

struct m_ext2fs *fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_inode.c

518

factor *= EXT2_NINDIR(fs);

sys/ufs/ext2fs/ext2fs_inode.c

522

nblocks = btodb(fs->e2fs_bsize);

sys/ufs/ext2fs/ext2fs_inode.c

532

bp = getblk(vp, lbn, (int)fs->e2fs_bsize, 0, 0);

sys/ufs/ext2fs/ext2fs_inode.c

535

trace(TR_BREADHIT, pack(vp, fs->e2fs_bsize), lbn);

sys/ufs/ext2fs/ext2fs_inode.c

537

trace(TR_BREADMISS, pack(vp, fs->e2fs_bsize), lbn);

sys/ufs/ext2fs/ext2fs_inode.c

555

copy = kmem_alloc(fs->e2fs_bsize, KM_SLEEP);

sys/ufs/ext2fs/ext2fs_inode.c

556

memcpy((void *)copy, (void *)bap, (u_int)fs->e2fs_bsize);

sys/ufs/ext2fs/ext2fs_inode.c

558

(u_int)(EXT2_NINDIR(fs) - (last + 1)) * sizeof (uint32_t));

sys/ufs/ext2fs/ext2fs_inode.c

568

for (i = EXT2_NINDIR(fs) - 1,

sys/ufs/ext2fs/ext2fs_inode.c

576

error = ext2fs_indirtrunc(ip, nlbn, EXT2_FSBTODB(fs, nb),

sys/ufs/ext2fs/ext2fs_inode.c

595

error = ext2fs_indirtrunc(ip, nlbn, EXT2_FSBTODB(fs, nb),

sys/ufs/ext2fs/ext2fs_inode.c

604

kmem_free(copy, fs->e2fs_bsize);

sys/ufs/ext2fs/ext2fs_lookup.c

103

if (EXT2F_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FTYPE))

sys/ufs/ext2fs/ext2fs_lookup.c

159

struct m_ext2fs *fs = VTOI(vp)->i_e2fs;

sys/ufs/ext2fs/ext2fs_lookup.c

176

e2fs_count -= (uio->uio_offset + e2fs_count) & (fs->e2fs_bsize -1);

sys/ufs/ext2fs/ext2fs_lookup.c

206

ext2fs_dirconv2ffs(fs, dp, dstd);

sys/ufs/ext2fs/ext2fs_lookup.c

79

static void ext2fs_dirconv2ffs(struct m_ext2fs *fs,

sys/ufs/ext2fs/ext2fs_lookup.c

97

ext2fs_dirconv2ffs(struct m_ext2fs *fs, struct ext2fs_direct *e2dir, struct dirent *ffsdir)

sys/ufs/ext2fs/ext2fs_readwrite.c

157

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_readwrite.c

170

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_readwrite.c

189

lbn = ext2_lblkno(fs, uio->uio_offset);

sys/ufs/ext2fs/ext2fs_readwrite.c

191

size = fs->e2fs_bsize;

sys/ufs/ext2fs/ext2fs_readwrite.c

192

blkoffset = ext2_blkoff(fs, uio->uio_offset);

sys/ufs/ext2fs/ext2fs_readwrite.c

193

xfersize = fs->e2fs_bsize - blkoffset;

sys/ufs/ext2fs/ext2fs_readwrite.c

199

if (ext2_lblktosize(fs, nextlbn) >= ext2fs_size(ip))

sys/ufs/ext2fs/ext2fs_readwrite.c

202

int nextsize = fs->e2fs_bsize;

sys/ufs/ext2fs/ext2fs_readwrite.c

268

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_readwrite.c

295

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_readwrite.c

309

blkoffset = ext2_blkoff(fs, uio->uio_offset);

sys/ufs/ext2fs/ext2fs_readwrite.c

310

bytelen = MIN(fs->e2fs_bsize - blkoffset, uio->uio_resid);

sys/ufs/ext2fs/ext2fs_readwrite.c

348

round_page(ext2_blkroundup(fs, uio->uio_offset)),

sys/ufs/ext2fs/ext2fs_readwrite.c

365

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_readwrite.c

380

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_readwrite.c

395

lbn = ext2_lblkno(fs, uio->uio_offset);

sys/ufs/ext2fs/ext2fs_readwrite.c

396

blkoffset = ext2_blkoff(fs, uio->uio_offset);

sys/ufs/ext2fs/ext2fs_readwrite.c

397

xfersize = MIN(fs->e2fs_bsize - blkoffset, uio->uio_resid);

sys/ufs/ext2fs/ext2fs_readwrite.c

398

if (xfersize < fs->e2fs_bsize)

sys/ufs/ext2fs/ext2fs_readwrite.c

424

else if (xfersize + blkoffset == fs->e2fs_bsize)

sys/ufs/ext2fs/ext2fs_subr.c

85

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_subr.c

91

fs = ip->i_e2fs;

sys/ufs/ext2fs/ext2fs_subr.c

92

lbn = ext2_lblkno(fs, offset);

sys/ufs/ext2fs/ext2fs_subr.c

95

if ((error = bread(vp, lbn, fs->e2fs_bsize, 0, &bp)) != 0) {

sys/ufs/ext2fs/ext2fs_subr.c

99

*res = (char *)bp->b_data + ext2_blkoff(fs, offset);

sys/ufs/ext2fs/ext2fs_vfsops.c

1011

if (fs->e2fs_fmod != 0) {

sys/ufs/ext2fs/ext2fs_vfsops.c

1012

fs->e2fs_fmod = 0;

sys/ufs/ext2fs/ext2fs_vfsops.c

1013

fs->e2fs.e2fs_wtime = time_second;

sys/ufs/ext2fs/ext2fs_vfsops.c

1026

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

1031

fs = ump->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

1034

error = bread(ump->um_devvp, EXT2_FSBTODB(fs, ino_to_fsba(fs, ino)),

sys/ufs/ext2fs/ext2fs_vfsops.c

1035

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

sys/ufs/ext2fs/ext2fs_vfsops.c

1044

ip->i_e2fs = fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

1050

error = ext2fs_loadvnode_content(fs, ino, bp, ip);

sys/ufs/ext2fs/ext2fs_vfsops.c

1133

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

1143

fs = pdir->i_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

1161

KASSERT(!E2FS_HAS_GD_CSUM(fs) ||

sys/ufs/ext2fs/ext2fs_vfsops.c

1162

(fs->e2fs_gd[ino_to_cg(fs, ino)].ext2bgd_flags &

sys/ufs/ext2fs/ext2fs_vfsops.c

1169

(unsigned long long)ip->i_number, fs->e2fs_fsmnt);

sys/ufs/ext2fs/ext2fs_vfsops.c

1173

memset(ip->i_din.e2fs_din, 0, EXT2_DINODE_SIZE(fs));

sys/ufs/ext2fs/ext2fs_vfsops.c

1250

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

1256

fs = VFSTOUFS(mp)->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

1258

ufh.ufid_ino >= fs->e2fs_ncg * fs->e2fs.e2fs_ipg)

sys/ufs/ext2fs/ext2fs_vfsops.c

1307

struct m_ext2fs *fs = mp->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

1312

e2fs_sbsave(&fs->e2fs, (struct ext2fs*)bp->b_data);

sys/ufs/ext2fs/ext2fs_vfsops.c

1323

struct m_ext2fs *fs = mp->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

1328

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

sys/ufs/ext2fs/ext2fs_vfsops.c

1329

bp = getblk(mp->um_devvp, EXT2_FSBTODB(fs,

sys/ufs/ext2fs/ext2fs_vfsops.c

1330

fs->e2fs.e2fs_first_dblock +

sys/ufs/ext2fs/ext2fs_vfsops.c

1331

1 /* superblock */ + i), fs->e2fs_bsize, 0, 0);

sys/ufs/ext2fs/ext2fs_vfsops.c

1332

e2fs_cgsave(&fs->e2fs_gd[i *

sys/ufs/ext2fs/ext2fs_vfsops.c

1333

(fs->e2fs_bsize >> fs->e2fs_group_desc_shift)],

sys/ufs/ext2fs/ext2fs_vfsops.c

1334

bp->b_data, fs->e2fs_bsize, fs->e2fs_group_desc_shift);

sys/ufs/ext2fs/ext2fs_vfsops.c

1354

struct ext2fs *fs = &m_fs->e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

1359

if (fs->e2fs_magic != E2FS_MAGIC)

sys/ufs/ext2fs/ext2fs_vfsops.c

1361

if (fs->e2fs_rev > E2FS_REV1) {

sys/ufs/ext2fs/ext2fs_vfsops.c

1363

fs->e2fs_rev);

sys/ufs/ext2fs/ext2fs_vfsops.c

1366

if (fs->e2fs_log_bsize > 2) {

sys/ufs/ext2fs/ext2fs_vfsops.c

1368

printf("ext2fs: bad block size: %d\n", fs->e2fs_log_bsize);

sys/ufs/ext2fs/ext2fs_vfsops.c

1371

if (fs->e2fs_bpg == 0) {

sys/ufs/ext2fs/ext2fs_vfsops.c

1375

if (fs->e2fs_ipg == 0) {

sys/ufs/ext2fs/ext2fs_vfsops.c

1380

if (fs->e2fs_first_dblock >= fs->e2fs_bcount) {

sys/ufs/ext2fs/ext2fs_vfsops.c

1384

if (fs->e2fs_rbcount > fs->e2fs_bcount ||

sys/ufs/ext2fs/ext2fs_vfsops.c

1385

fs->e2fs_fbcount > fs->e2fs_bcount) {

sys/ufs/ext2fs/ext2fs_vfsops.c

1393

u32 = fs->e2fs_bcount - fs->e2fs_first_dblock; /* > 0 */

sys/ufs/ext2fs/ext2fs_vfsops.c

1394

m_fs->e2fs_ncg = howmany(u32, fs->e2fs_bpg);

sys/ufs/ext2fs/ext2fs_vfsops.c

1400

m_fs->e2fs_fsbtodb = fs->e2fs_log_bsize + LOG_MINBSIZE - DEV_BSHIFT;

sys/ufs/ext2fs/ext2fs_vfsops.c

1401

m_fs->e2fs_bsize = MINBSIZE << fs->e2fs_log_bsize;

sys/ufs/ext2fs/ext2fs_vfsops.c

1402

m_fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs_log_bsize;

sys/ufs/ext2fs/ext2fs_vfsops.c

1406

if (!(fs->e2fs_features_incompat & EXT2F_INCOMPAT_64BIT) ||

sys/ufs/ext2fs/ext2fs_vfsops.c

1407

(fs->e2fs_rev == E2FS_REV0))

sys/ufs/ext2fs/ext2fs_vfsops.c

1412

< fs->e3fs_desc_size;

sys/ufs/ext2fs/ext2fs_vfsops.c

1433

m_fs->e2fs_itpg = fs->e2fs_ipg / m_fs->e2fs_ipb;

sys/ufs/ext2fs/ext2fs_vfsops.c

1438

if (fs->e2fs_rev > E2FS_REV0) {

sys/ufs/ext2fs/ext2fs_vfsops.c

1440

if (fs->e2fs_first_ino != EXT2_FIRSTINO) {

sys/ufs/ext2fs/ext2fs_vfsops.c

1444

u32 = fs->e2fs_features_incompat & ~EXT2F_INCOMPAT_SUPP;

sys/ufs/ext2fs/ext2fs_vfsops.c

1453

u32 = fs->e2fs_features_rocompat & ~EXT2F_ROCOMPAT_SUPP;

sys/ufs/ext2fs/ext2fs_vfsops.c

1462

if (fs->e2fs_inode_size == 0 || !powerof2(fs->e2fs_inode_size) || fs->e2fs_inode_size > m_fs->e2fs_bsize) {

sys/ufs/ext2fs/ext2fs_vfsops.c

295

ext2fs_sb_setmountinfo(struct m_ext2fs *fs, struct mount *mp)

sys/ufs/ext2fs/ext2fs_vfsops.c

297

(void)strlcpy(fs->e2fs_fsmnt, mp->mnt_stat.f_mntonname,

sys/ufs/ext2fs/ext2fs_vfsops.c

298

sizeof(fs->e2fs_fsmnt));

sys/ufs/ext2fs/ext2fs_vfsops.c

299

if (fs->e2fs_ronly == 0 && fs->e2fs.e2fs_rev > E2FS_REV0) {

sys/ufs/ext2fs/ext2fs_vfsops.c

300

(void)strlcpy(fs->e2fs.e2fs_fsmnt, mp->mnt_stat.f_mntonname,

sys/ufs/ext2fs/ext2fs_vfsops.c

301

sizeof(fs->e2fs.e2fs_fsmnt));

sys/ufs/ext2fs/ext2fs_vfsops.c

303

fs->e2fs.e2fs_mtime = time_second;

sys/ufs/ext2fs/ext2fs_vfsops.c

304

fs->e2fs.e2fs_mnt_count++;

sys/ufs/ext2fs/ext2fs_vfsops.c

306

fs->e2fs_fmod = 1;

sys/ufs/ext2fs/ext2fs_vfsops.c

320

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

340

fs = ump->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

341

ext2fs_sb_setmountinfo(fs, mp);

sys/ufs/ext2fs/ext2fs_vfsops.c

344

setrootfstime((time_t)fs->e2fs.e2fs_wtime);

sys/ufs/ext2fs/ext2fs_vfsops.c

360

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

473

fs = ump->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

487

fs = ump->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

488

if (fs->e2fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {

sys/ufs/ext2fs/ext2fs_vfsops.c

498

(fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {

sys/ufs/ext2fs/ext2fs_vfsops.c

499

fs->e2fs.e2fs_state = E2FS_ISCLEAN;

sys/ufs/ext2fs/ext2fs_vfsops.c

504

fs->e2fs_ronly = 1;

sys/ufs/ext2fs/ext2fs_vfsops.c

513

if (fs->e2fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {

sys/ufs/ext2fs/ext2fs_vfsops.c

517

fs->e2fs_ronly = 0;

sys/ufs/ext2fs/ext2fs_vfsops.c

518

if (fs->e2fs.e2fs_state == E2FS_ISCLEAN)

sys/ufs/ext2fs/ext2fs_vfsops.c

519

fs->e2fs.e2fs_state = 0;

sys/ufs/ext2fs/ext2fs_vfsops.c

521

fs->e2fs.e2fs_state = E2FS_ERRORS;

sys/ufs/ext2fs/ext2fs_vfsops.c

522

fs->e2fs_fmod = 1;

sys/ufs/ext2fs/ext2fs_vfsops.c

531

ext2fs_sb_setmountinfo(fs, mp);

sys/ufs/ext2fs/ext2fs_vfsops.c

533

if (fs->e2fs_fmod != 0) { /* XXX */

sys/ufs/ext2fs/ext2fs_vfsops.c

534

fs->e2fs_fmod = 0;

sys/ufs/ext2fs/ext2fs_vfsops.c

535

if (fs->e2fs.e2fs_state == 0)

sys/ufs/ext2fs/ext2fs_vfsops.c

536

fs->e2fs.e2fs_wtime = time_second;

sys/ufs/ext2fs/ext2fs_vfsops.c

553

ext2fs_loadvnode_content(struct m_ext2fs *fs, ino_t ino, struct buf *bp, struct inode *ip)

sys/ufs/ext2fs/ext2fs_vfsops.c

559

(ino_to_fsbo(fs, ino) * EXT2_DINODE_SIZE(fs)));

sys/ufs/ext2fs/ext2fs_vfsops.c

562

if (EXT2_DINODE_FITS(din, e2di_extra_isize, EXT2_DINODE_SIZE(fs))

sys/ufs/ext2fs/ext2fs_vfsops.c

563

&& (EXT2_DINODE_SIZE(fs) - EXT2_REV0_DINODE_SIZE)

sys/ufs/ext2fs/ext2fs_vfsops.c

574

ip->i_din.e2fs_din = kmem_alloc(EXT2_DINODE_SIZE(fs), KM_SLEEP);

sys/ufs/ext2fs/ext2fs_vfsops.c

576

e2fs_iload(din, ip->i_din.e2fs_din, EXT2_DINODE_SIZE(fs));

sys/ufs/ext2fs/ext2fs_vfsops.c

603

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

623

fs = ump->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

632

e2fs_sbload(newfs, &fs->e2fs);

sys/ufs/ext2fs/ext2fs_vfsops.c

636

error = ext2fs_sbfill(fs, (mp->mnt_flag & MNT_RDONLY) != 0);

sys/ufs/ext2fs/ext2fs_vfsops.c

643

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

sys/ufs/ext2fs/ext2fs_vfsops.c

645

EXT2_FSBTODB(fs, fs->e2fs.e2fs_first_dblock +

sys/ufs/ext2fs/ext2fs_vfsops.c

647

fs->e2fs_bsize, 0, &bp);

sys/ufs/ext2fs/ext2fs_vfsops.c

652

&fs->e2fs_gd[i *

sys/ufs/ext2fs/ext2fs_vfsops.c

653

(fs->e2fs_bsize >> fs->e2fs_group_desc_shift)],

sys/ufs/ext2fs/ext2fs_vfsops.c

654

fs->e2fs_bsize, fs->e2fs_group_desc_shift);

sys/ufs/ext2fs/ext2fs_vfsops.c

678

error = bread(devvp, EXT2_FSBTODB(fs, ino_to_fsba(fs, ip->i_number)),

sys/ufs/ext2fs/ext2fs_vfsops.c

679

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

sys/ufs/ext2fs/ext2fs_vfsops.c

684

error = ext2fs_loadvnode_content(fs, ip->i_number, bp, ip);

sys/ufs/ext2fs/ext2fs_vfsops.c

706

struct ext2fs *fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

731

fs = (struct ext2fs *)bp->b_data;

sys/ufs/ext2fs/ext2fs_vfsops.c

733

e2fs_sbload(fs, &m_fs->e2fs);

sys/ufs/ext2fs/ext2fs_vfsops.c

824

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

833

fs = ump->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

834

if (fs->e2fs_ronly == 0 &&

sys/ufs/ext2fs/ext2fs_vfsops.c

836

(fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {

sys/ufs/ext2fs/ext2fs_vfsops.c

837

fs->e2fs.e2fs_state = E2FS_ISCLEAN;

sys/ufs/ext2fs/ext2fs_vfsops.c

843

error = VOP_CLOSE(ump->um_devvp, fs->e2fs_ronly ? FREAD : FREAD|FWRITE,

sys/ufs/ext2fs/ext2fs_vfsops.c

846

int32_t sh = fs->e2fs_bsize >> fs->e2fs_group_desc_shift;

sys/ufs/ext2fs/ext2fs_vfsops.c

847

kmem_free(fs->e2fs_gd, fs->e2fs_ngdb * sh * sizeof(struct ext2_gd));

sys/ufs/ext2fs/ext2fs_vfsops.c

848

kmem_free(fs, sizeof(*fs));

sys/ufs/ext2fs/ext2fs_vfsops.c

877

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

882

fs = ump->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

883

if (fs->e2fs.e2fs_magic != E2FS_MAGIC)

sys/ufs/ext2fs/ext2fs_vfsops.c

892

fs->e2fs_itpg;

sys/ufs/ext2fs/ext2fs_vfsops.c

893

overhead = fs->e2fs.e2fs_first_dblock +

sys/ufs/ext2fs/ext2fs_vfsops.c

894

fs->e2fs_ncg * overhead_per_group;

sys/ufs/ext2fs/ext2fs_vfsops.c

895

if (EXT2F_HAS_COMPAT_FEATURE(fs, EXT2F_COMPAT_SPARSESUPER2)) {

sys/ufs/ext2fs/ext2fs_vfsops.c

901

+ (fs->e2fs.e4fs_backup_bgs[0] ? 1 : 0)

sys/ufs/ext2fs/ext2fs_vfsops.c

902

+ (fs->e2fs.e4fs_backup_bgs[1] ? 1 : 0);

sys/ufs/ext2fs/ext2fs_vfsops.c

903

} else if (EXT2F_HAS_ROCOMPAT_FEATURE(fs, EXT2F_ROCOMPAT_SPARSESUPER)) {

sys/ufs/ext2fs/ext2fs_vfsops.c

904

for (i = 0, ngroups = 0; i < fs->e2fs_ncg; i++) {

sys/ufs/ext2fs/ext2fs_vfsops.c

909

ngroups = fs->e2fs_ncg;

sys/ufs/ext2fs/ext2fs_vfsops.c

911

ngdb = fs->e2fs_ngdb;

sys/ufs/ext2fs/ext2fs_vfsops.c

912

if (EXT2F_HAS_COMPAT_FEATURE(fs, EXT2F_COMPAT_RESIZE))

sys/ufs/ext2fs/ext2fs_vfsops.c

913

ngdb += fs->e2fs.e2fs_reserved_ngdb;

sys/ufs/ext2fs/ext2fs_vfsops.c

916

sbp->f_bsize = fs->e2fs_bsize;

sys/ufs/ext2fs/ext2fs_vfsops.c

917

sbp->f_frsize = MINBSIZE << fs->e2fs.e2fs_fsize;

sys/ufs/ext2fs/ext2fs_vfsops.c

918

sbp->f_iosize = fs->e2fs_bsize;

sys/ufs/ext2fs/ext2fs_vfsops.c

919

sbp->f_blocks = fs->e2fs.e2fs_bcount - overhead;

sys/ufs/ext2fs/ext2fs_vfsops.c

920

sbp->f_bfree = fs->e2fs.e2fs_fbcount;

sys/ufs/ext2fs/ext2fs_vfsops.c

921

sbp->f_bresvd = fs->e2fs.e2fs_rbcount;

sys/ufs/ext2fs/ext2fs_vfsops.c

926

sbp->f_files = fs->e2fs.e2fs_icount;

sys/ufs/ext2fs/ext2fs_vfsops.c

927

sbp->f_ffree = fs->e2fs.e2fs_ficount;

sys/ufs/ext2fs/ext2fs_vfsops.c

928

sbp->f_favail = fs->e2fs.e2fs_ficount;

sys/ufs/ext2fs/ext2fs_vfsops.c

966

struct m_ext2fs *fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

970

fs = ump->um_e2fs;

sys/ufs/ext2fs/ext2fs_vfsops.c

971

if (fs->e2fs_fmod != 0 && fs->e2fs_ronly != 0) { /* XXX */

sys/ufs/ext2fs/ext2fs_vfsops.c

972

printf("fs = %s\n", fs->e2fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

1001

if (!cg_chkmagic(cgp, UFS_FSNEEDSWAP(fs)))

sys/ufs/ffs/ffs_alloc.c

1003

cgp->cg_old_time = ufs_rw32(time_second, UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_alloc.c

1004

if ((fs->fs_magic != FS_UFS1_MAGIC) ||

sys/ufs/ffs/ffs_alloc.c

1005

(fs->fs_old_flags & FS_FLAGS_UPDATED))

sys/ufs/ffs/ffs_alloc.c

1006

cgp->cg_time = ufs_rw64(time_second, UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_alloc.c

1007

bno = dtogd(fs, bprev);

sys/ufs/ffs/ffs_alloc.c

1008

blksfree = cg_blksfree(cgp, UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_alloc.c

1009

for (i = ffs_numfrags(fs, osize); i < frags; i++)

sys/ufs/ffs/ffs_alloc.c

1018

for (i = frags; i < fs->fs_frag - bbase; i++)

sys/ufs/ffs/ffs_alloc.c

1021

ufs_add32(cgp->cg_frsum[i - ffs_numfrags(fs, osize)], -1, UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_alloc.c

1023

ufs_add32(cgp->cg_frsum[i - frags], 1, UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_alloc.c

1025

for (i = ffs_numfrags(fs, osize); i < frags; i++) {

sys/ufs/ffs/ffs_alloc.c

1027

ufs_add32(cgp->cg_cs.cs_nffree, -1, UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_alloc.c

1028

fs->fs_cstotal.cs_nffree--;

sys/ufs/ffs/ffs_alloc.c

1029

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

sys/ufs/ffs/ffs_alloc.c

1031

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

1032

ACTIVECG_CLR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

1055

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_alloc.c

1062

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

1068

if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)

sys/ufs/ffs/ffs_alloc.c

1071

error = bread(ip->i_devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_alloc.c

1072

(int)fs->fs_cgsize, B_MODIFY, &bp);

sys/ufs/ffs/ffs_alloc.c

1077

(cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize))

sys/ufs/ffs/ffs_alloc.c

1080

if ((fs->fs_magic != FS_UFS1_MAGIC) ||

sys/ufs/ffs/ffs_alloc.c

1081

(fs->fs_old_flags & FS_FLAGS_UPDATED))

sys/ufs/ffs/ffs_alloc.c

1083

if (size == fs->fs_bsize) {

sys/ufs/ffs/ffs_alloc.c

1086

ACTIVECG_CLR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

1098

bp, blkno + ffs_numfrags(fs, realsize),

sys/ufs/ffs/ffs_alloc.c

1111

frags = ffs_numfrags(fs, size);

sys/ufs/ffs/ffs_alloc.c

1112

for (allocsiz = frags; allocsiz < fs->fs_frag; allocsiz++)

sys/ufs/ffs/ffs_alloc.c

1115

if (allocsiz == fs->fs_frag) {

sys/ufs/ffs/ffs_alloc.c

1124

bno = dtogd(fs, blkno);

sys/ufs/ffs/ffs_alloc.c

1125

for (i = frags; i < fs->fs_frag; i++)

sys/ufs/ffs/ffs_alloc.c

1127

i = fs->fs_frag - frags;

sys/ufs/ffs/ffs_alloc.c

1129

fs->fs_cstotal.cs_nffree += i;

sys/ufs/ffs/ffs_alloc.c

1130

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

sys/ufs/ffs/ffs_alloc.c

1131

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

1133

ACTIVECG_CLR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

1138

bno = ffs_mapsearch(fs, cgp, bpref, allocsiz);

sys/ufs/ffs/ffs_alloc.c

114

static void ffs_fserr(struct fs *, kauth_cred_t, const char *);

sys/ufs/ffs/ffs_alloc.c

1151

fs->fs_cstotal.cs_nffree -= frags;

sys/ufs/ffs/ffs_alloc.c

1152

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

sys/ufs/ffs/ffs_alloc.c

1153

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

1157

blkno = cgbase(fs, cg) + bno;

sys/ufs/ffs/ffs_alloc.c

1158

ACTIVECG_CLR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

118

static int32_t ffs_mapsearch(struct fs *, struct cg *,

sys/ufs/ffs/ffs_alloc.c

1185

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_alloc.c

1191

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

1197

if (bpref == 0 || dtog(fs, bpref) != ufs_rw32(cgp->cg_cgx, needswap)) {

sys/ufs/ffs/ffs_alloc.c

120

static void ffs_blkfree_common(struct ufsmount *, struct fs *, dev_t, struct buf *,

sys/ufs/ffs/ffs_alloc.c

1200

bpref = ffs_blknum(fs, bpref);

sys/ufs/ffs/ffs_alloc.c

1201

bno = dtogd(fs, bpref);

sys/ufs/ffs/ffs_alloc.c

1205

if (ffs_isblock(fs, blksfree, ffs_fragstoblks(fs, bno)))

sys/ufs/ffs/ffs_alloc.c

1218

bno = ffs_mapsearch(fs, cgp, bpref, (int)fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

122

static void ffs_freefile_common(struct ufsmount *, struct fs *, dev_t, struct buf *, ino_t,

sys/ufs/ffs/ffs_alloc.c

1228

blkno = ffs_fragstoblks(fs, bno);

sys/ufs/ffs/ffs_alloc.c

1229

ffs_clrblock(fs, blksfree, blkno);

sys/ufs/ffs/ffs_alloc.c

1230

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

sys/ufs/ffs/ffs_alloc.c

1232

fs->fs_cstotal.cs_nbfree--;

sys/ufs/ffs/ffs_alloc.c

1233

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

sys/ufs/ffs/ffs_alloc.c

1234

if ((fs->fs_magic == FS_UFS1_MAGIC) &&

sys/ufs/ffs/ffs_alloc.c

1235

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

sys/ufs/ffs/ffs_alloc.c

1237

cylno = old_cbtocylno(fs, bno);

sys/ufs/ffs/ffs_alloc.c

1239

KASSERT(cylno < fs->fs_old_ncyl);

sys/ufs/ffs/ffs_alloc.c

1240

KASSERT(old_cbtorpos(fs, bno) >= 0);

sys/ufs/ffs/ffs_alloc.c

1241

KASSERT(fs->fs_old_nrpos == 0 || old_cbtorpos(fs, bno) < fs->fs_old_nrpos);

sys/ufs/ffs/ffs_alloc.c

1242

ufs_add16(old_cg_blks(fs, cgp, cylno, needswap)[old_cbtorpos(fs, bno)], -1,

sys/ufs/ffs/ffs_alloc.c

1246

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

1248

blkno = cgbase(fs, cg) + bno;

sys/ufs/ffs/ffs_alloc.c

1266

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_alloc.c

1274

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

1279

if (fs->fs_cs(fs, cg).cs_nifree == 0)

sys/ufs/ffs/ffs_alloc.c

1283

if (fs->fs_magic == FS_UFS2_MAGIC) {

sys/ufs/ffs/ffs_alloc.c

1286

initediblk = fs->fs_ipg;

sys/ufs/ffs/ffs_alloc.c

1291

error = bread(ip->i_devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_alloc.c

1292

(int)fs->fs_cgsize, B_MODIFY, &bp);

sys/ufs/ffs/ffs_alloc.c

1308

if (fs->fs_magic == FS_UFS2_MAGIC && ibp == NULL) {

sys/ufs/ffs/ffs_alloc.c

1311

nalloc = fs->fs_ipg - ufs_rw32(cgp->cg_cs.cs_nifree, needswap);

sys/ufs/ffs/ffs_alloc.c

1312

if (nalloc + FFS_INOPB(fs) > initediblk &&

sys/ufs/ffs/ffs_alloc.c

1321

error = ffs_getblk(ip->i_devvp, FFS_FSBTODB(fs,

sys/ufs/ffs/ffs_alloc.c

1322

ino_to_fsba(fs, cg * fs->fs_ipg + initediblk)),

sys/ufs/ffs/ffs_alloc.c

1323

FFS_NOBLK, fs->fs_bsize, false, &ibp);

sys/ufs/ffs/ffs_alloc.c

1327

maxiblk += FFS_INOPB(fs);

sys/ufs/ffs/ffs_alloc.c

1334

if ((fs->fs_magic != FS_UFS1_MAGIC) ||

sys/ufs/ffs/ffs_alloc.c

1335

(fs->fs_old_flags & FS_FLAGS_UPDATED))

sys/ufs/ffs/ffs_alloc.c

134

ffs_check_bad_allocation(const char *func, struct fs *fs, daddr_t bno,

sys/ufs/ffs/ffs_alloc.c

1340

ipref %= fs->fs_ipg;

sys/ufs/ffs/ffs_alloc.c

1362

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

1369

panic("%s: block not in map: fs=%s", __func__, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

137

if ((u_int)size > fs->fs_bsize || ffs_fragoff(fs, size) != 0 ||

sys/ufs/ffs/ffs_alloc.c

138

ffs_fragnum(fs, bno) + ffs_numfrags(fs, size) > fs->fs_frag) {

sys/ufs/ffs/ffs_alloc.c

1382

UFS_WAPBL_REGISTER_INODE(ip->i_ump->um_mountp, cg * fs->fs_ipg + ipref,

sys/ufs/ffs/ffs_alloc.c

1389

memset(ibp->b_data, 0, fs->fs_bsize);

sys/ufs/ffs/ffs_alloc.c

1391

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

sys/ufs/ffs/ffs_alloc.c

1399

initediblk += FFS_INOPB(fs);

sys/ufs/ffs/ffs_alloc.c

1404

ACTIVECG_CLR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

1407

fs->fs_cstotal.cs_nifree--;

sys/ufs/ffs/ffs_alloc.c

1408

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

sys/ufs/ffs/ffs_alloc.c

1409

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

141

(long long)dev, bno, fs->fs_bsize, size, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

1412

fs->fs_cstotal.cs_ndir++;

sys/ufs/ffs/ffs_alloc.c

1413

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

sys/ufs/ffs/ffs_alloc.c

1421

return ((ino_t)(cg * fs->fs_ipg + ipref));

sys/ufs/ffs/ffs_alloc.c

144

if (bno >= fs->fs_size) {

sys/ufs/ffs/ffs_alloc.c

1457

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

1464

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

1466

KASSERT((u_int)size <= fs->fs_bsize && ffs_fragoff(fs, size) == 0 &&

sys/ufs/ffs/ffs_alloc.c

1467

ffs_fragnum(fs, bno) + ffs_numfrags(fs, size) <= fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

1468

KASSERT(bno < fs->fs_size);

sys/ufs/ffs/ffs_alloc.c

147

ffs_fserr(fs, NOCRED, "bad block");

sys/ufs/ffs/ffs_alloc.c

1470

cg = dtog(fs, bno);

sys/ufs/ffs/ffs_alloc.c

1471

error = bread(ump->um_devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_alloc.c

1472

(int)fs->fs_cgsize, B_MODIFY, &bp);

sys/ufs/ffs/ffs_alloc.c

1483

cgbno = dtogd(fs, bno);

sys/ufs/ffs/ffs_alloc.c

1487

if (size == fs->fs_bsize) {

sys/ufs/ffs/ffs_alloc.c

1488

fragno = ffs_fragstoblks(fs, cgbno);

sys/ufs/ffs/ffs_alloc.c

1489

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

sys/ufs/ffs/ffs_alloc.c

1494

ffs_clrblock(fs, blksfree, fragno);

sys/ufs/ffs/ffs_alloc.c

1495

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

sys/ufs/ffs/ffs_alloc.c

1497

fs->fs_cstotal.cs_nbfree--;

sys/ufs/ffs/ffs_alloc.c

1498

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

sys/ufs/ffs/ffs_alloc.c

1500

bbase = cgbno - ffs_fragnum(fs, cgbno);

sys/ufs/ffs/ffs_alloc.c

1502

frags = ffs_numfrags(fs, size);

sys/ufs/ffs/ffs_alloc.c

1513

fragno = ffs_fragstoblks(fs, bbase);

sys/ufs/ffs/ffs_alloc.c

1514

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

sys/ufs/ffs/ffs_alloc.c

1515

ufs_add32(cgp->cg_cs.cs_nffree, fs->fs_frag, needswap);

sys/ufs/ffs/ffs_alloc.c

1516

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

sys/ufs/ffs/ffs_alloc.c

1517

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

sys/ufs/ffs/ffs_alloc.c

1518

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

sys/ufs/ffs/ffs_alloc.c

1520

fs->fs_cstotal.cs_nbfree--;

sys/ufs/ffs/ffs_alloc.c

1521

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

sys/ufs/ffs/ffs_alloc.c

1526

blk = blkmap(fs, blksfree, bbase);

sys/ufs/ffs/ffs_alloc.c

1527

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

sys/ufs/ffs/ffs_alloc.c

1535

fs->fs_cstotal.cs_nffree -= i;

sys/ufs/ffs/ffs_alloc.c

1536

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

sys/ufs/ffs/ffs_alloc.c

1540

blk = blkmap(fs, blksfree, bbase);

sys/ufs/ffs/ffs_alloc.c

1541

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

sys/ufs/ffs/ffs_alloc.c

1543

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

1544

ACTIVECG_CLR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

1560

ffs_blkfree_cg(struct fs *fs, struct vnode *devvp, daddr_t bno, long size)

sys/ufs/ffs/ffs_alloc.c

1570

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

1574

cg = dtog(fs, bno);

sys/ufs/ffs/ffs_alloc.c

1577

KASSERT(fs == ump->um_fs);

sys/ufs/ffs/ffs_alloc.c

1578

cgblkno = FFS_FSBTODB(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

1580

error = bread(devvp, cgblkno, (int)fs->fs_cgsize,

sys/ufs/ffs/ffs_alloc.c

1591

ffs_blkfree_common(ump, fs, dev, bp, bno, size, devvp_is_snapshot);

sys/ufs/ffs/ffs_alloc.c

1604

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

1616

ffs_blkfree_td(struct fs *fs, struct discardopdata *td)

sys/ufs/ffs/ffs_alloc.c

1624

ffs_lfragtosize(fs, (fs->fs_frag - ffs_fragnum(fs, td->bno))));

sys/ufs/ffs/ffs_alloc.c

1631

ffs_blkfree_cg(fs, td->devvp, td->bno, todo);

sys/ufs/ffs/ffs_alloc.c

1633

td->bno += ffs_numfrags(fs, todo);

sys/ufs/ffs/ffs_alloc.c

1643

struct fs *fs = ts->fs;

sys/ufs/ffs/ffs_alloc.c

1651

#define FFS_FSBTOBYTES(fs, b) ((b) << (fs)->fs_fshift)

sys/ufs/ffs/ffs_alloc.c

1654

start = FFS_FSBTOBYTES(fs, td->bno);

sys/ufs/ffs/ffs_alloc.c

1666

ffs_blkfree_td(fs, td);

sys/ufs/ffs/ffs_alloc.c

1676

ffs_discard_init(struct vnode *devvp, struct fs *fs)

sys/ufs/ffs/ffs_alloc.c

1692

ts->fs = fs;

sys/ufs/ffs/ffs_alloc.c

1718

ffs_blkfree_td(ts->fs, td);

sys/ufs/ffs/ffs_alloc.c

1733

ffs_blkfree(struct fs *fs, struct vnode *devvp, daddr_t bno, long size,

sys/ufs/ffs/ffs_alloc.c

1744

if (ffs_snapblkfree(fs, devvp, bno, size, inum))

sys/ufs/ffs/ffs_alloc.c

1747

error = ffs_check_bad_allocation(__func__, fs, bno, size, dev, inum);

sys/ufs/ffs/ffs_alloc.c

1752

ffs_blkfree_cg(fs, devvp, bno, size);

sys/ufs/ffs/ffs_alloc.c

1766

if (td->bno == bno + ffs_numfrags(fs, size)

sys/ufs/ffs/ffs_alloc.c

180

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

1832

ffs_blkfree_snap(struct fs *fs, struct vnode *devvp, daddr_t bno, long size,

sys/ufs/ffs/ffs_alloc.c

1842

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

1846

cg = dtog(fs, bno);

sys/ufs/ffs/ffs_alloc.c

1849

cgblkno = ffs_fragstoblks(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

1851

error = ffs_check_bad_allocation(__func__, fs, bno, size, dev, inum);

sys/ufs/ffs/ffs_alloc.c

1855

error = bread(devvp, cgblkno, (int)fs->fs_cgsize,

sys/ufs/ffs/ffs_alloc.c

1866

ffs_blkfree_common(ump, fs, dev, bp, bno, size, devvp_is_snapshot);

sys/ufs/ffs/ffs_alloc.c

187

fs = ip->i_fs;

sys/ufs/ffs/ffs_alloc.c

1872

ffs_blkfree_common(struct ufsmount *ump, struct fs *fs, dev_t dev,

sys/ufs/ffs/ffs_alloc.c

1880

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

1882

cg = dtog(fs, bno);

sys/ufs/ffs/ffs_alloc.c

1885

if ((fs->fs_magic != FS_UFS1_MAGIC) ||

sys/ufs/ffs/ffs_alloc.c

1886

(fs->fs_old_flags & FS_FLAGS_UPDATED))

sys/ufs/ffs/ffs_alloc.c

1888

cgbno = dtogd(fs, bno);

sys/ufs/ffs/ffs_alloc.c

1891

if (size == fs->fs_bsize) {

sys/ufs/ffs/ffs_alloc.c

1892

fragno = ffs_fragstoblks(fs, cgbno);

sys/ufs/ffs/ffs_alloc.c

1893

if (!ffs_isfreeblock(fs, blksfree, fragno)) {

sys/ufs/ffs/ffs_alloc.c

1900

(unsigned long long)dev, bno, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

1902

ffs_setblock(fs, blksfree, fragno);

sys/ufs/ffs/ffs_alloc.c

1903

ffs_clusteracct(fs, cgp, fragno, 1);

sys/ufs/ffs/ffs_alloc.c

1905

fs->fs_cstotal.cs_nbfree++;

sys/ufs/ffs/ffs_alloc.c

1906

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

sys/ufs/ffs/ffs_alloc.c

1907

if ((fs->fs_magic == FS_UFS1_MAGIC) &&

sys/ufs/ffs/ffs_alloc.c

1908

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

sys/ufs/ffs/ffs_alloc.c

1909

i = old_cbtocylno(fs, cgbno);

sys/ufs/ffs/ffs_alloc.c

1911

KASSERT(i < fs->fs_old_ncyl);

sys/ufs/ffs/ffs_alloc.c

1912

KASSERT(old_cbtorpos(fs, cgbno) >= 0);

sys/ufs/ffs/ffs_alloc.c

1913

KASSERT(fs->fs_old_nrpos == 0 || old_cbtorpos(fs, cgbno) < fs->fs_old_nrpos);

sys/ufs/ffs/ffs_alloc.c

1914

ufs_add16(old_cg_blks(fs, cgp, i, needswap)[old_cbtorpos(fs, cgbno)], 1,

sys/ufs/ffs/ffs_alloc.c

1919

bbase = cgbno - ffs_fragnum(fs, cgbno);

sys/ufs/ffs/ffs_alloc.c

1923

blk = blkmap(fs, blksfree, bbase);

sys/ufs/ffs/ffs_alloc.c

1924

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

sys/ufs/ffs/ffs_alloc.c

1928

frags = ffs_numfrags(fs, size);

sys/ufs/ffs/ffs_alloc.c

1935

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

1940

fs->fs_cstotal.cs_nffree += i;

sys/ufs/ffs/ffs_alloc.c

1941

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

sys/ufs/ffs/ffs_alloc.c

1945

blk = blkmap(fs, blksfree, bbase);

sys/ufs/ffs/ffs_alloc.c

1946

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

sys/ufs/ffs/ffs_alloc.c

1950

fragno = ffs_fragstoblks(fs, bbase);

sys/ufs/ffs/ffs_alloc.c

1951

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

sys/ufs/ffs/ffs_alloc.c

1952

ufs_add32(cgp->cg_cs.cs_nffree, -fs->fs_frag, needswap);

sys/ufs/ffs/ffs_alloc.c

1953

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

sys/ufs/ffs/ffs_alloc.c

1954

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

sys/ufs/ffs/ffs_alloc.c

1955

ffs_clusteracct(fs, cgp, fragno, 1);

sys/ufs/ffs/ffs_alloc.c

1957

fs->fs_cstotal.cs_nbfree++;

sys/ufs/ffs/ffs_alloc.c

1958

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

sys/ufs/ffs/ffs_alloc.c

1959

if ((fs->fs_magic == FS_UFS1_MAGIC) &&

sys/ufs/ffs/ffs_alloc.c

1960

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

sys/ufs/ffs/ffs_alloc.c

1961

i = old_cbtocylno(fs, bbase);

sys/ufs/ffs/ffs_alloc.c

1963

KASSERT(i < fs->fs_old_ncyl);

sys/ufs/ffs/ffs_alloc.c

1964

KASSERT(old_cbtorpos(fs, bbase) >= 0);

sys/ufs/ffs/ffs_alloc.c

1965

KASSERT(fs->fs_old_nrpos == 0 || old_cbtorpos(fs, bbase) < fs->fs_old_nrpos);

sys/ufs/ffs/ffs_alloc.c

1966

ufs_add16(old_cg_blks(fs, cgp, i, needswap)[old_cbtorpos(fs,

sys/ufs/ffs/ffs_alloc.c

1972

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

1973

ACTIVECG_CLR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

1997

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_alloc.c

2005

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

2007

cg = ino_to_cg(fs, ino);

sys/ufs/ffs/ffs_alloc.c

2010

cgbno = FFS_FSBTODB(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

2012

if (ino >= fs->fs_ipg * fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

2014

(long long)dev, (unsigned long long)ino, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2015

error = bread(devvp, cgbno, (int)fs->fs_cgsize,

sys/ufs/ffs/ffs_alloc.c

2026

ffs_freefile_common(ump, fs, dev, bp, ino, mode, false);

sys/ufs/ffs/ffs_alloc.c

2034

ffs_freefile_snap(struct fs *fs, struct vnode *devvp, ino_t ino, int mode)

sys/ufs/ffs/ffs_alloc.c

2042

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

2046

cg = ino_to_cg(fs, ino);

sys/ufs/ffs/ffs_alloc.c

2049

cgbno = ffs_fragstoblks(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

2050

if (ino >= fs->fs_ipg * fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

2053

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2054

error = bread(devvp, cgbno, (int)fs->fs_cgsize,

sys/ufs/ffs/ffs_alloc.c

2064

ffs_freefile_common(ump, fs, dev, bp, ino, mode, true);

sys/ufs/ffs/ffs_alloc.c

2072

ffs_freefile_common(struct ufsmount *ump, struct fs *fs, dev_t dev,

sys/ufs/ffs/ffs_alloc.c

2078

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

2081

cg = ino_to_cg(fs, ino);

sys/ufs/ffs/ffs_alloc.c

2084

if ((fs->fs_magic != FS_UFS1_MAGIC) ||

sys/ufs/ffs/ffs_alloc.c

2085

(fs->fs_old_flags & FS_FLAGS_UPDATED))

sys/ufs/ffs/ffs_alloc.c

2088

cgino = ino % fs->fs_ipg;

sys/ufs/ffs/ffs_alloc.c

209

ffs_lblktosize(fs, (voff_t)lbn) < round_page(vp->v_size) &&

sys/ufs/ffs/ffs_alloc.c

2092

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2093

if (fs->fs_ronly == 0)

sys/ufs/ffs/ffs_alloc.c

2103

fs->fs_cstotal.cs_nifree++;

sys/ufs/ffs/ffs_alloc.c

2104

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

sys/ufs/ffs/ffs_alloc.c

2107

fs->fs_cstotal.cs_ndir--;

sys/ufs/ffs/ffs_alloc.c

2108

fs->fs_cs(fs, cg).cs_ndir--;

sys/ufs/ffs/ffs_alloc.c

211

ffs_blkoff(fs, size) != 0)) {

sys/ufs/ffs/ffs_alloc.c

2110

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_alloc.c

2111

ACTIVECG_CLR(fs, cg);

sys/ufs/ffs/ffs_alloc.c

2119

ffs_checkfreefile(struct fs *fs, struct vnode *devvp, ino_t ino)

sys/ufs/ffs/ffs_alloc.c

2131

cg = ino_to_cg(fs, ino);

sys/ufs/ffs/ffs_alloc.c

2133

cgbno = ffs_fragstoblks(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

2135

cgbno = FFS_FSBTODB(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_alloc.c

2136

if (ino >= fs->fs_ipg * fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

2138

if (bread(devvp, cgbno, (int)fs->fs_cgsize, 0, &bp)) {

sys/ufs/ffs/ffs_alloc.c

214

voff_t off = trunc_page(ffs_lblktosize(fs, lbn));

sys/ufs/ffs/ffs_alloc.c

2142

if (!cg_chkmagic(cgp, UFS_FSNEEDSWAP(fs))) {

sys/ufs/ffs/ffs_alloc.c

2146

inosused = cg_inosused(cgp, UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_alloc.c

2147

ino %= fs->fs_ipg;

sys/ufs/ffs/ffs_alloc.c

215

voff_t endoff = round_page(ffs_lblktosize(fs, lbn) + size);

sys/ufs/ffs/ffs_alloc.c

2160

ffs_mapsearch(struct fs *fs, struct cg *cgp, daddr_t bpref, int allocsiz)

sys/ufs/ffs/ffs_alloc.c

2167

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_alloc.c

2176

start = dtogd(fs, bpref) / NBBY;

sys/ufs/ffs/ffs_alloc.c

2180

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

sys/ufs/ffs/ffs_alloc.c

2185

(const u_char *)fragtbl[fs->fs_frag],

sys/ufs/ffs/ffs_alloc.c

2186

(1 << (allocsiz - 1 + (fs->fs_frag & (NBBY - 1)))));

sys/ufs/ffs/ffs_alloc.c

2192

(const u_char *)fragtbl[fs->fs_frag],

sys/ufs/ffs/ffs_alloc.c

2193

(1 << (allocsiz - 1 + (fs->fs_frag & (NBBY - 1)))));

sys/ufs/ffs/ffs_alloc.c

2197

ostart, olen, fs->fs_fsmnt,

sys/ufs/ffs/ffs_alloc.c

2209

for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {

sys/ufs/ffs/ffs_alloc.c

2210

blk = blkmap(fs, blksfree, bno);

sys/ufs/ffs/ffs_alloc.c

2214

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

sys/ufs/ffs/ffs_alloc.c

2222

bno, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

2233

ffs_fserr(struct fs *fs, kauth_cred_t cred, const char *cp)

sys/ufs/ffs/ffs_alloc.c

2240

fs->fs_fsmnt, cp);

sys/ufs/ffs/ffs_alloc.c

2244

fs->fs_fsmnt, cp);

sys/ufs/ffs/ffs_alloc.c

232

KASSERTMSG(((u_int)size <= fs->fs_bsize),

sys/ufs/ffs/ffs_alloc.c

234

(unsigned long long)ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

235

KASSERTMSG((ffs_fragoff(fs, size) == 0),

sys/ufs/ffs/ffs_alloc.c

237

(unsigned long long)ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

239

if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)

sys/ufs/ffs/ffs_alloc.c

241

if (freespace(fs, fs->fs_minfree) <= 0 &&

sys/ufs/ffs/ffs_alloc.c

252

if (bpref >= fs->fs_size)

sys/ufs/ffs/ffs_alloc.c

255

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

sys/ufs/ffs/ffs_alloc.c

257

cg = dtog(fs, bpref);

sys/ufs/ffs/ffs_alloc.c

290

ffs_fserr(fs, cred, "file system full");

sys/ufs/ffs/ffs_alloc.c

291

uprintf("\n%s: write failed, file system is full\n", fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

312

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

318

fs = ip->i_fs;

sys/ufs/ffs/ffs_alloc.c

339

voff_t off = trunc_page(ffs_lblktosize(fs, lbprev));

sys/ufs/ffs/ffs_alloc.c

340

voff_t endoff = round_page(ffs_lblktosize(fs, lbprev) + osize);

sys/ufs/ffs/ffs_alloc.c

354

KASSERTMSG(((u_int)osize <= fs->fs_bsize),

sys/ufs/ffs/ffs_alloc.c

356

(unsigned long long)ip->i_dev, fs->fs_bsize, osize, nsize,

sys/ufs/ffs/ffs_alloc.c

357

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

358

KASSERTMSG((ffs_fragoff(fs, osize) == 0),

sys/ufs/ffs/ffs_alloc.c

360

(unsigned long long)ip->i_dev, fs->fs_bsize, osize, nsize,

sys/ufs/ffs/ffs_alloc.c

361

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

362

KASSERTMSG(((u_int)nsize <= fs->fs_bsize),

sys/ufs/ffs/ffs_alloc.c

364

(unsigned long long)ip->i_dev, fs->fs_bsize, osize, nsize,

sys/ufs/ffs/ffs_alloc.c

365

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

366

KASSERTMSG((ffs_fragoff(fs, nsize) == 0),

sys/ufs/ffs/ffs_alloc.c

368

(unsigned long long)ip->i_dev, fs->fs_bsize, osize, nsize,

sys/ufs/ffs/ffs_alloc.c

369

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

371

if (freespace(fs, fs->fs_minfree) <= 0 &&

sys/ufs/ffs/ffs_alloc.c

381

(unsigned long long)ip->i_dev, fs->fs_bsize, bprev,

sys/ufs/ffs/ffs_alloc.c

382

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

404

cg = dtog(fs, bprev);

sys/ufs/ffs/ffs_alloc.c

414

if (bp->b_blkno != FFS_FSBTODB(fs, bno)) {

sys/ufs/ffs/ffs_alloc.c

417

(unsigned long long)FFS_FSBTODB(fs, bno));

sys/ufs/ffs/ffs_alloc.c

435

if (bpref >= fs->fs_size)

sys/ufs/ffs/ffs_alloc.c

437

switch ((int)fs->fs_optim) {

sys/ufs/ffs/ffs_alloc.c

447

if (fs->fs_minfree < 5 ||

sys/ufs/ffs/ffs_alloc.c

448

fs->fs_cstotal.cs_nffree >

sys/ufs/ffs/ffs_alloc.c

449

fs->fs_dsize * fs->fs_minfree / (2 * 100))

sys/ufs/ffs/ffs_alloc.c

455

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

458

fs->fs_optim = FS_OPTTIME;

sys/ufs/ffs/ffs_alloc.c

471

request = fs->fs_bsize;

sys/ufs/ffs/ffs_alloc.c

472

if (fs->fs_cstotal.cs_nffree <

sys/ufs/ffs/ffs_alloc.c

473

fs->fs_dsize * (fs->fs_minfree - 2) / 100)

sys/ufs/ffs/ffs_alloc.c

479

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

482

fs->fs_optim = FS_OPTSPACE;

sys/ufs/ffs/ffs_alloc.c

486

__func__, (unsigned long long)ip->i_dev, fs->fs_optim,

sys/ufs/ffs/ffs_alloc.c

487

fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

502

ip->i_ump->um_mountp, FFS_FSBTODB(fs, bprev),

sys/ufs/ffs/ffs_alloc.c

507

ffs_blkfree(fs, ip->i_devvp, bprev, (long)osize,

sys/ufs/ffs/ffs_alloc.c

516

bp->b_blkno = FFS_FSBTODB(fs, bno);

sys/ufs/ffs/ffs_alloc.c

546

ffs_fserr(fs, cred, "file system full");

sys/ufs/ffs/ffs_alloc.c

547

uprintf("\n%s: write failed, file system is full\n", fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

573

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

581

fs = pip->i_fs;

sys/ufs/ffs/ffs_alloc.c

589

if (fs->fs_cstotal.cs_nifree == 0)

sys/ufs/ffs/ffs_alloc.c

596

if (ipref >= fs->fs_ncg * fs->fs_ipg)

sys/ufs/ffs/ffs_alloc.c

598

cg = ino_to_cg(fs, ipref);

sys/ufs/ffs/ffs_alloc.c

604

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

sys/ufs/ffs/ffs_alloc.c

605

fs->fs_contigdirs[cg]++;

sys/ufs/ffs/ffs_alloc.c

607

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

sys/ufs/ffs/ffs_alloc.c

608

fs->fs_contigdirs[cg]--;

sys/ufs/ffs/ffs_alloc.c

620

ffs_fserr(fs, cred, "out of inodes");

sys/ufs/ffs/ffs_alloc.c

621

uprintf("\n%s: create/symlink failed, no inodes free\n", fs->fs_fsmnt);

sys/ufs/ffs/ffs_alloc.c

641

register struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

651

fs = pip->i_fs;

sys/ufs/ffs/ffs_alloc.c

653

avgifree = fs->fs_cstotal.cs_nifree / fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

654

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

655

avgndir = fs->fs_cstotal.cs_ndir / fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

661

prefcg = cprng_fast32() % fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

663

minndir = fs->fs_ipg;

sys/ufs/ffs/ffs_alloc.c

664

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

sys/ufs/ffs/ffs_alloc.c

665

if (fs->fs_cs(fs, cg).cs_ndir < minndir &&

sys/ufs/ffs/ffs_alloc.c

666

fs->fs_cs(fs, cg).cs_nifree >= avgifree &&

sys/ufs/ffs/ffs_alloc.c

667

fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/ufs/ffs/ffs_alloc.c

669

minndir = fs->fs_cs(fs, cg).cs_ndir;

sys/ufs/ffs/ffs_alloc.c

672

if (fs->fs_cs(fs, cg).cs_ndir < minndir &&

sys/ufs/ffs/ffs_alloc.c

673

fs->fs_cs(fs, cg).cs_nifree >= avgifree &&

sys/ufs/ffs/ffs_alloc.c

674

fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/ufs/ffs/ffs_alloc.c

676

minndir = fs->fs_cs(fs, cg).cs_ndir;

sys/ufs/ffs/ffs_alloc.c

678

return ((ino_t)(fs->fs_ipg * mincg));

sys/ufs/ffs/ffs_alloc.c

688

maxndir = uimin(avgndir + fs->fs_ipg / 16, fs->fs_ipg);

sys/ufs/ffs/ffs_alloc.c

695

cgsize = (int64_t)fs->fs_fsize * fs->fs_fpg;

sys/ufs/ffs/ffs_alloc.c

696

dirsize = (int64_t)fs->fs_avgfilesize * fs->fs_avgfpdir;

sys/ufs/ffs/ffs_alloc.c

698

curdsz = (cgsize - (int64_t)avgbfree * fs->fs_bsize) / avgndir;

sys/ufs/ffs/ffs_alloc.c

703

maxcontigdirs = (avgbfree * fs->fs_bsize) / dirsize;

sys/ufs/ffs/ffs_alloc.c

706

if (fs->fs_avgfpdir > 0)

sys/ufs/ffs/ffs_alloc.c

708

fs->fs_ipg / fs->fs_avgfpdir);

sys/ufs/ffs/ffs_alloc.c

717

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

sys/ufs/ffs/ffs_alloc.c

718

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

sys/ufs/ffs/ffs_alloc.c

719

if (fs->fs_cs(fs, cg).cs_ndir < maxndir &&

sys/ufs/ffs/ffs_alloc.c

720

fs->fs_cs(fs, cg).cs_nifree >= minifree &&

sys/ufs/ffs/ffs_alloc.c

721

fs->fs_cs(fs, cg).cs_nbfree >= minbfree) {

sys/ufs/ffs/ffs_alloc.c

722

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

sys/ufs/ffs/ffs_alloc.c

723

return ((ino_t)(fs->fs_ipg * cg));

sys/ufs/ffs/ffs_alloc.c

726

if (fs->fs_cs(fs, cg).cs_ndir < maxndir &&

sys/ufs/ffs/ffs_alloc.c

727

fs->fs_cs(fs, cg).cs_nifree >= minifree &&

sys/ufs/ffs/ffs_alloc.c

728

fs->fs_cs(fs, cg).cs_nbfree >= minbfree) {

sys/ufs/ffs/ffs_alloc.c

729

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

sys/ufs/ffs/ffs_alloc.c

730

return ((ino_t)(fs->fs_ipg * cg));

sys/ufs/ffs/ffs_alloc.c

735

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

sys/ufs/ffs/ffs_alloc.c

736

if (fs->fs_cs(fs, cg).cs_nifree >= avgifree)

sys/ufs/ffs/ffs_alloc.c

737

return ((ino_t)(fs->fs_ipg * cg));

sys/ufs/ffs/ffs_alloc.c

739

if (fs->fs_cs(fs, cg).cs_nifree >= avgifree)

sys/ufs/ffs/ffs_alloc.c

741

return ((ino_t)(fs->fs_ipg * cg));

sys/ufs/ffs/ffs_alloc.c

774

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

780

fs = ip->i_fs;

sys/ufs/ffs/ffs_alloc.c

798

return ip->i_ffs_first_data_blk + ffs_blkstofrags(fs, lbn);

sys/ufs/ffs/ffs_alloc.c

801

if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {

sys/ufs/ffs/ffs_alloc.c

802

if (lbn < UFS_NDADDR + FFS_NINDIR(fs)) {

sys/ufs/ffs/ffs_alloc.c

803

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

sys/ufs/ffs/ffs_alloc.c

804

return (cgbase(fs, cg) + fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

812

ino_to_cg(fs, ip->i_number) + lbn / fs->fs_maxbpg;

sys/ufs/ffs/ffs_alloc.c

814

startcg = dtog(fs,

sys/ufs/ffs/ffs_alloc.c

815

ufs_rw32(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + 1);

sys/ufs/ffs/ffs_alloc.c

816

startcg %= fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

817

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

818

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

sys/ufs/ffs/ffs_alloc.c

819

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/ufs/ffs/ffs_alloc.c

820

return (cgbase(fs, cg) + fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

823

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/ufs/ffs/ffs_alloc.c

824

return (cgbase(fs, cg) + fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

831

return ufs_rw32(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + fs->fs_frag;

sys/ufs/ffs/ffs_alloc.c

838

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

844

fs = ip->i_fs;

sys/ufs/ffs/ffs_alloc.c

862

return ip->i_ffs_first_data_blk + ffs_blkstofrags(fs, lbn);

sys/ufs/ffs/ffs_alloc.c

865

if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {

sys/ufs/ffs/ffs_alloc.c

866

if (lbn < UFS_NDADDR + FFS_NINDIR(fs)) {

sys/ufs/ffs/ffs_alloc.c

867

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

sys/ufs/ffs/ffs_alloc.c

868

return (cgbase(fs, cg) + fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

876

ino_to_cg(fs, ip->i_number) + lbn / fs->fs_maxbpg;

sys/ufs/ffs/ffs_alloc.c

878

startcg = dtog(fs,

sys/ufs/ffs/ffs_alloc.c

879

ufs_rw64(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + 1);

sys/ufs/ffs/ffs_alloc.c

880

startcg %= fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

881

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

882

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

sys/ufs/ffs/ffs_alloc.c

883

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/ufs/ffs/ffs_alloc.c

884

return (cgbase(fs, cg) + fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

887

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

sys/ufs/ffs/ffs_alloc.c

888

return (cgbase(fs, cg) + fs->fs_frag);

sys/ufs/ffs/ffs_alloc.c

895

return ufs_rw64(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + fs->fs_frag;

sys/ufs/ffs/ffs_alloc.c

919

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

923

fs = ip->i_fs;

sys/ufs/ffs/ffs_alloc.c

936

for (i = 1; i < fs->fs_ncg; i *= 2) {

sys/ufs/ffs/ffs_alloc.c

938

if (cg >= fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

939

cg -= fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

949

cg = (icg + 2) % fs->fs_ncg;

sys/ufs/ffs/ffs_alloc.c

950

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

sys/ufs/ffs/ffs_alloc.c

955

if (cg == fs->fs_ncg)

sys/ufs/ffs/ffs_alloc.c

974

struct fs *fs;

sys/ufs/ffs/ffs_alloc.c

982

fs = ip->i_fs;

sys/ufs/ffs/ffs_alloc.c

987

if (fs->fs_cs(fs, cg).cs_nffree < ffs_numfrags(fs, nsize - osize))

sys/ufs/ffs/ffs_alloc.c

989

frags = ffs_numfrags(fs, nsize);

sys/ufs/ffs/ffs_alloc.c

990

bbase = ffs_fragnum(fs, bprev);

sys/ufs/ffs/ffs_alloc.c

991

if (bbase > ffs_fragnum(fs, (bprev + frags - 1))) {

sys/ufs/ffs/ffs_alloc.c

996

error = bread(ip->i_devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_alloc.c

997

(int)fs->fs_cgsize, B_MODIFY, &bp);

sys/ufs/ffs/ffs_balloc.c

1015

(int)fs->fs_bsize, 0, &bp);

sys/ufs/ffs/ffs_balloc.c

1026

fs->fs_bsize, false, &bp) == 0)

sys/ufs/ffs/ffs_balloc.c

1031

ffs_blkfree(fs, ip->i_devvp, *blkp, fs->fs_bsize, ip->i_number);

sys/ufs/ffs/ffs_balloc.c

1032

deallocated += fs->fs_bsize;

sys/ufs/ffs/ffs_balloc.c

116

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_balloc.c

125

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_balloc.c

128

lbn = ffs_lblkno(fs, off);

sys/ufs/ffs/ffs_balloc.c

129

size = ffs_blkoff(fs, off) + size;

sys/ufs/ffs/ffs_balloc.c

130

if (size > fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

147

lastlbn = ffs_lblkno(fs, ip->i_size);

sys/ufs/ffs/ffs_balloc.c

150

osize = ffs_blksize(fs, ip, nb);

sys/ufs/ffs/ffs_balloc.c

151

if (osize < fs->fs_bsize && osize > 0) {

sys/ufs/ffs/ffs_balloc.c

153

error = ffs_realloccg(ip, nb, ffs_getdb(fs, ip, nb),

sys/ufs/ffs/ffs_balloc.c

156

osize, (int)fs->fs_bsize, flags, cred, bpp,

sys/ufs/ffs/ffs_balloc.c

160

ip->i_size = ffs_lblktosize(fs, nb + 1);

sys/ufs/ffs/ffs_balloc.c

180

if (nb != 0 && ip->i_size >= ffs_lblktosize(fs, lbn + 1)) {

sys/ufs/ffs/ffs_balloc.c

190

error = bread(vp, lbn, fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

204

osize = ffs_fragroundup(fs, ffs_blkoff(fs, ip->i_size));

sys/ufs/ffs/ffs_balloc.c

205

nsize = ffs_fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

230

ffs_getdb(fs, ip, lbn),

sys/ufs/ffs/ffs_balloc.c

244

if (ip->i_size < ffs_lblktosize(fs, lbn + 1))

sys/ufs/ffs/ffs_balloc.c

245

nsize = ffs_fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

247

nsize = fs->fs_bsize;

sys/ufs/ffs/ffs_balloc.c

256

error = ffs_getblk(vp, lbn, FFS_FSBTODB(fs, newb),

sys/ufs/ffs/ffs_balloc.c

286

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

292

error = ffs_getblk(vp, indirs[1].in_lbn, FFS_FSBTODB(fs, nb),

sys/ufs/ffs/ffs_balloc.c

293

fs->fs_bsize, true, &bp);

sys/ufs/ffs/ffs_balloc.c

314

indirs[i].in_lbn, (int)fs->fs_bsize, 0, &bp);

sys/ufs/ffs/ffs_balloc.c

339

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

347

error = ffs_getblk(vp, indirs[i].in_lbn, FFS_FSBTODB(fs, nb),

sys/ufs/ffs/ffs_balloc.c

348

fs->fs_bsize, true, &nbp);

sys/ufs/ffs/ffs_balloc.c

395

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, flags, cred,

sys/ufs/ffs/ffs_balloc.c

404

error = ffs_getblk(vp, lbn, FFS_FSBTODB(fs, nb),

sys/ufs/ffs/ffs_balloc.c

405

fs->fs_bsize, (flags & B_CLRBUF) != 0, bpp);

sys/ufs/ffs/ffs_balloc.c

431

error = bread(vp, lbn, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

437

error = ffs_getblk(vp, lbn, FFS_FSBTODB(fs, nb),

sys/ufs/ffs/ffs_balloc.c

438

fs->fs_bsize, true, &nbp);

sys/ufs/ffs/ffs_balloc.c

466

fs->fs_bsize, false, &bp) != 0)

sys/ufs/ffs/ffs_balloc.c

469

nb = FFS_FSBTODB(fs, cgtod(fs, dtog(fs,

sys/ufs/ffs/ffs_balloc.c

470

FFS_DBTOFSB(fs, bp->b_blkno))));

sys/ufs/ffs/ffs_balloc.c

473

fs->fs_cgsize, false, &bp) != 0)

sys/ufs/ffs/ffs_balloc.c

495

(int)fs->fs_bsize, 0, &bp);

sys/ufs/ffs/ffs_balloc.c

506

fs->fs_bsize, false, &bp) == 0)

sys/ufs/ffs/ffs_balloc.c

511

ffs_blkfree(fs, ip->i_devvp, *blkp, fs->fs_bsize, ip->i_number);

sys/ufs/ffs/ffs_balloc.c

512

deallocated += fs->fs_bsize;

sys/ufs/ffs/ffs_balloc.c

534

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_balloc.c

543

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_balloc.c

548

lbn = ffs_lblkno(fs, off);

sys/ufs/ffs/ffs_balloc.c

549

size = ffs_blkoff(fs, off) + size;

sys/ufs/ffs/ffs_balloc.c

550

if (size > fs->fs_bsize)

sys/ufs/ffs/ffs_balloc.c

573

lastlbn = ffs_lblkno(fs, dp->di_extsize);

sys/ufs/ffs/ffs_balloc.c

576

osize = ffs_sblksize(fs, dp->di_extsize, nb);

sys/ufs/ffs/ffs_balloc.c

577

if (osize < fs->fs_bsize && osize > 0) {

sys/ufs/ffs/ffs_balloc.c

580

ffs_extb(fs, dp, nb),

sys/ufs/ffs/ffs_balloc.c

583

osize, (int)fs->fs_bsize, flags, cred,

sys/ufs/ffs/ffs_balloc.c

587

dp->di_extsize = ffs_lblktosize(fs, nb + 1);

sys/ufs/ffs/ffs_balloc.c

588

dp->di_extb[nb] = FFS_DBTOFSB(fs, bp->b_blkno);

sys/ufs/ffs/ffs_balloc.c

600

if (nb != 0 && dp->di_extsize >= ffs_lblktosize(fs, lbn + 1)) {

sys/ufs/ffs/ffs_balloc.c

601

error = bread(vp, -1 - lbn, fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

607

bp->b_blkno = FFS_FSBTODB(fs, nb);

sys/ufs/ffs/ffs_balloc.c

616

osize = ffs_fragroundup(fs, ffs_blkoff(fs, dp->di_extsize));

sys/ufs/ffs/ffs_balloc.c

617

nsize = ffs_fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

625

bp->b_blkno = FFS_FSBTODB(fs, nb);

sys/ufs/ffs/ffs_balloc.c

630

ffs_extb(fs, dp, lbn),

sys/ufs/ffs/ffs_balloc.c

638

if (dp->di_extsize < ffs_lblktosize(fs, lbn + 1))

sys/ufs/ffs/ffs_balloc.c

639

nsize = ffs_fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

641

nsize = fs->fs_bsize;

sys/ufs/ffs/ffs_balloc.c

649

error = ffs_getblk(vp, -1 - lbn, FFS_FSBTODB(fs, newb),

sys/ufs/ffs/ffs_balloc.c

654

dp->di_extb[lbn] = FFS_DBTOFSB(fs, bp->b_blkno);

sys/ufs/ffs/ffs_balloc.c

665

lastlbn = ffs_lblkno(fs, ip->i_size);

sys/ufs/ffs/ffs_balloc.c

668

osize = ffs_blksize(fs, ip, nb);

sys/ufs/ffs/ffs_balloc.c

669

if (osize < fs->fs_bsize && osize > 0) {

sys/ufs/ffs/ffs_balloc.c

671

error = ffs_realloccg(ip, nb, ffs_getdb(fs, ip, lbn),

sys/ufs/ffs/ffs_balloc.c

674

osize, (int)fs->fs_bsize, flags, cred, bpp,

sys/ufs/ffs/ffs_balloc.c

678

ip->i_size = ffs_lblktosize(fs, nb + 1);

sys/ufs/ffs/ffs_balloc.c

698

if (nb != 0 && ip->i_size >= ffs_lblktosize(fs, lbn + 1)) {

sys/ufs/ffs/ffs_balloc.c

708

error = bread(vp, lbn, fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

722

osize = ffs_fragroundup(fs, ffs_blkoff(fs, ip->i_size));

sys/ufs/ffs/ffs_balloc.c

723

nsize = ffs_fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

748

ffs_getdb(fs, ip, lbn),

sys/ufs/ffs/ffs_balloc.c

762

if (ip->i_size < ffs_lblktosize(fs, lbn + 1))

sys/ufs/ffs/ffs_balloc.c

763

nsize = ffs_fragroundup(fs, size);

sys/ufs/ffs/ffs_balloc.c

765

nsize = fs->fs_bsize;

sys/ufs/ffs/ffs_balloc.c

774

error = ffs_getblk(vp, lbn, FFS_FSBTODB(fs, newb),

sys/ufs/ffs/ffs_balloc.c

804

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

81

ffs_extb(struct fs *fs, struct ufs2_dinode *dp, daddr_t nb)

sys/ufs/ffs/ffs_balloc.c

810

error = ffs_getblk(vp, indirs[1].in_lbn, FFS_FSBTODB(fs, nb),

sys/ufs/ffs/ffs_balloc.c

811

fs->fs_bsize, true, &bp);

sys/ufs/ffs/ffs_balloc.c

83

return ufs_rw64(dp->di_extb[nb], UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_balloc.c

832

indirs[i].in_lbn, (int)fs->fs_bsize, 0, &bp);

sys/ufs/ffs/ffs_balloc.c

857

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

865

error = ffs_getblk(vp, indirs[i].in_lbn, FFS_FSBTODB(fs, nb),

sys/ufs/ffs/ffs_balloc.c

866

fs->fs_bsize, true, &nbp);

sys/ufs/ffs/ffs_balloc.c

913

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, flags, cred,

sys/ufs/ffs/ffs_balloc.c

922

error = ffs_getblk(vp, lbn, FFS_FSBTODB(fs, nb),

sys/ufs/ffs/ffs_balloc.c

923

fs->fs_bsize, (flags & B_CLRBUF) != 0, bpp);

sys/ufs/ffs/ffs_balloc.c

949

error = bread(vp, lbn, (int)fs->fs_bsize,

sys/ufs/ffs/ffs_balloc.c

955

error = ffs_getblk(vp, lbn, FFS_FSBTODB(fs, nb),

sys/ufs/ffs/ffs_balloc.c

956

fs->fs_bsize, true, &nbp);

sys/ufs/ffs/ffs_balloc.c

984

fs->fs_bsize, false, &bp) != 0)

sys/ufs/ffs/ffs_balloc.c

987

nb = FFS_FSBTODB(fs, cgtod(fs, dtog(fs,

sys/ufs/ffs/ffs_balloc.c

988

FFS_DBTOFSB(fs, bp->b_blkno))));

sys/ufs/ffs/ffs_balloc.c

991

fs->fs_cgsize, false, &bp) != 0)

sys/ufs/ffs/ffs_bswap.c

194

ffs_cg_swap(struct cg *o, struct cg *n, struct fs *fs)

sys/ufs/ffs/ffs_bswap.c

218

if ((fs->fs_magic != FS_UFS2_MAGIC) &&

sys/ufs/ffs/ffs_bswap.c

219

(fs->fs_old_postblformat == FS_42POSTBLFMT)) { /* old format */

sys/ufs/ffs/ffs_bswap.c

258

for (i = 1; i < fs->fs_contigsumsize + 1; i++)

sys/ufs/ffs/ffs_bswap.c

261

if (fs->fs_magic == FS_UFS2_MAGIC)

sys/ufs/ffs/ffs_bswap.c

269

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

sys/ufs/ffs/ffs_bswap.c

272

for (i = 0; i < fs->fs_old_cpg * fs->fs_old_nrpos; i++)

sys/ufs/ffs/ffs_bswap.c

55

ffs_sb_swap(const struct fs *o, struct fs *n)

sys/ufs/ffs/ffs_bswap.c

68

for (i = 0; i < offsetof(struct fs, fs_fmod) / sizeof(u_int32_t); i++)

sys/ufs/ffs/ffs_extattr.c

118

#define lblktosize(fs, o) ffs_lblktosize(fs, o)

sys/ufs/ffs/ffs_extattr.c

119

#define lblkno(fs, o) ffs_lblkno(fs, o)

sys/ufs/ffs/ffs_extattr.c

120

#define blkoff(fs, o) ffs_blkoff(fs, o)

sys/ufs/ffs/ffs_extattr.c

121

#define sblksize(fs, o, lbn) ffs_sblksize(fs, o, lbn)

sys/ufs/ffs/ffs_extattr.c

141

struct fs *fs;

sys/ufs/ffs/ffs_extattr.c

150

fs = ITOFS(ip);

sys/ufs/ffs/ffs_extattr.c

167

lbn = lblkno(fs, uio->uio_offset);

sys/ufs/ffs/ffs_extattr.c

176

size = sblksize(fs, dp->di_extsize, lbn);

sys/ufs/ffs/ffs_extattr.c

177

blkoffset = blkoff(fs, uio->uio_offset);

sys/ufs/ffs/ffs_extattr.c

184

xfersize = fs->fs_bsize - blkoffset;

sys/ufs/ffs/ffs_extattr.c

196

if (lblktosize(fs, nextlbn) >= dp->di_extsize) {

sys/ufs/ffs/ffs_extattr.c

209

u_int nextsize = sblksize(fs, dp->di_extsize, nextlbn);

sys/ufs/ffs/ffs_extattr.c

260

struct fs *fs;

sys/ufs/ffs/ffs_extattr.c

268

fs = ITOFS(ip);

sys/ufs/ffs/ffs_extattr.c

280

UFS_NXADDR * fs->fs_bsize)

sys/ufs/ffs/ffs_extattr.c

293

lbn = lblkno(fs, uio->uio_offset);

sys/ufs/ffs/ffs_extattr.c

294

blkoffset = blkoff(fs, uio->uio_offset);

sys/ufs/ffs/ffs_extattr.c

295

xfersize = fs->fs_bsize - blkoffset;

sys/ufs/ffs/ffs_extattr.c

303

if (fs->fs_bsize > xfersize)

sys/ufs/ffs/ffs_extattr.c

318

if ((bp->b_flags & BC_NOCACHE) && fs->fs_bsize <= xfersize)

sys/ufs/ffs/ffs_extattr.c

324

size = sblksize(fs, dp->di_extsize, lbn) - bp->b_resid;

sys/ufs/ffs/ffs_extattr.c

344

xfersize + blkoffset == fs->fs_bsize ||

sys/ufs/ffs/ffs_extattr.c

413

struct fs *fs;

sys/ufs/ffs/ffs_extattr.c

421

fs = ITOFS(ip);

sys/ufs/ffs/ffs_extattr.c

424

if ((uoff_t)easize + extra > UFS_NXADDR * fs->fs_bsize)

sys/ufs/ffs/ffs_extattr.c

710

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_extattr.c

742

if (ealen < 0 || ealen > lblktosize(fs, UFS_NXADDR))

sys/ufs/ffs/ffs_extattr.c

792

if (easize > lblktosize(fs, UFS_NXADDR)) {

sys/ufs/ffs/ffs_extern.h

100

void *ffs_discard_init(struct vnode *, struct fs *);

sys/ufs/ffs/ffs_extern.h

102

void ffs_blkfree_snap(struct fs *, struct vnode *, daddr_t, long, ino_t);

sys/ufs/ffs/ffs_extern.h

104

int ffs_checkfreefile(struct fs *, struct vnode *, ino_t);

sys/ufs/ffs/ffs_extern.h

106

int ffs_freefile_snap(struct fs *, struct vnode *, ino_t, int);

sys/ufs/ffs/ffs_extern.h

157

int ffs_snapblkfree(struct fs *, struct vnode *, daddr_t, long, ino_t);

sys/ufs/ffs/ffs_extern.h

170

int ffs_wapbl_replay_start(struct mount *, struct fs *, struct vnode *);

sys/ufs/ffs/ffs_extern.h

171

void ffs_wapbl_blkalloc(struct fs *, struct vnode *, daddr_t, int);

sys/ufs/ffs/ffs_extern.h

191

void ffs_sb_swap(const struct fs *, struct fs *);

sys/ufs/ffs/ffs_extern.h

198

void ffs_cg_swap(struct cg *, struct cg *, struct fs *);

sys/ufs/ffs/ffs_extern.h

202

void ffs_load_inode(struct buf *, struct inode *, struct fs *, ino_t);

sys/ufs/ffs/ffs_extern.h

205

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

sys/ufs/ffs/ffs_extern.h

206

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

sys/ufs/ffs/ffs_extern.h

207

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

sys/ufs/ffs/ffs_extern.h

208

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

sys/ufs/ffs/ffs_extern.h

209

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

sys/ufs/ffs/ffs_extern.h

212

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

sys/ufs/ffs/ffs_extern.h

49

struct fs;

sys/ufs/ffs/ffs_extern.h

99

void ffs_blkfree(struct fs *, struct vnode *, daddr_t, long, ino_t);

sys/ufs/ffs/ffs_inode.c

114

struct fs *fs;

sys/ufs/ffs/ffs_inode.c

131

fs = ip->i_fs;

sys/ufs/ffs/ffs_inode.c

145

if (fs->fs_magic == FS_UFS1_MAGIC && /* XXX */

sys/ufs/ffs/ffs_inode.c

146

fs->fs_old_inodefmt < FS_44INODEFMT) { /* XXX */

sys/ufs/ffs/ffs_inode.c

151

FFS_FSBTODB(fs, ino_to_fsba(fs, ip->i_number)),

sys/ufs/ffs/ffs_inode.c

152

(int)fs->fs_bsize, B_MODIFY, &bp);

sys/ufs/ffs/ffs_inode.c

170

if (fs->fs_magic == FS_UFS1_MAGIC) {

sys/ufs/ffs/ffs_inode.c

172

(ino_to_fsbo(fs, ip->i_number) * DINODE1_SIZE);

sys/ufs/ffs/ffs_inode.c

174

if (UFS_FSNEEDSWAP(fs))

sys/ufs/ffs/ffs_inode.c

182

(ino_to_fsbo(fs, ip->i_number) * DINODE2_SIZE);

sys/ufs/ffs/ffs_inode.c

184

if (UFS_FSNEEDSWAP(fs))

sys/ufs/ffs/ffs_inode.c

214

struct fs *fs;

sys/ufs/ffs/ffs_inode.c

246

fs = oip->i_fs;

sys/ufs/ffs/ffs_inode.c

250

if (fs->fs_magic == FS_UFS2_MAGIC && oip->i_din2->di_extsize > 0) {

sys/ufs/ffs/ffs_inode.c

251

extblocks = btodb(ffs_fragroundup(fs, oip->i_din2->di_extsize));

sys/ufs/ffs/ffs_inode.c

275

bsize = ffs_sblksize(fs, osize, i);

sys/ufs/ffs/ffs_inode.c

278

FFS_FSBTODB(fs, oldblks[i]), bsize, NULL);

sys/ufs/ffs/ffs_inode.c

282

ffs_blkfree(fs, oip->i_devvp, oldblks[i],

sys/ufs/ffs/ffs_inode.c

322

if (ffs_lblkno(fs, osize) < UFS_NDADDR &&

sys/ufs/ffs/ffs_inode.c

323

ffs_lblkno(fs, osize) != ffs_lblkno(fs, length) &&

sys/ufs/ffs/ffs_inode.c

324

ffs_blkroundup(fs, osize) != osize) {

sys/ufs/ffs/ffs_inode.c

327

eob = ffs_blkroundup(fs, osize);

sys/ufs/ffs/ffs_inode.c

339

trunc_page(osize & fs->fs_bmask),

sys/ufs/ffs/ffs_inode.c

368

offset = ffs_blkoff(fs, length);

sys/ufs/ffs/ffs_inode.c

382

lbn = ffs_lblkno(fs, length);

sys/ufs/ffs/ffs_inode.c

383

size = ffs_blksize(fs, oip, lbn);

sys/ufs/ffs/ffs_inode.c

384

eoz = MIN(MAX(ffs_lblktosize(fs, lbn) + size, round_page(pgoffset)),

sys/ufs/ffs/ffs_inode.c

409

lastblock = ffs_lblkno(fs, length + fs->fs_bsize - 1) - 1;

sys/ufs/ffs/ffs_inode.c

411

lastiblock[DOUBLE] = lastiblock[SINGLE] - FFS_NINDIR(fs);

sys/ufs/ffs/ffs_inode.c

412

lastiblock[TRIPLE] = lastiblock[DOUBLE] - FFS_NINDIR(fs) * FFS_NINDIR(fs);

sys/ufs/ffs/ffs_inode.c

413

nblocks = btodb(fs->fs_bsize);

sys/ufs/ffs/ffs_inode.c

470

indir_lbn[DOUBLE] = indir_lbn[SINGLE] - FFS_NINDIR(fs) - 1;

sys/ufs/ffs/ffs_inode.c

471

indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - FFS_NINDIR(fs) * FFS_NINDIR(fs) - 1;

sys/ufs/ffs/ffs_inode.c

473

bn = ffs_getib(fs, oip, level);

sys/ufs/ffs/ffs_inode.c

479

FFS_FSBTODB(fs, bn), fs->fs_bsize,

sys/ufs/ffs/ffs_inode.c

488

FFS_FSBTODB(fs, bn), lastiblock[level], level,

sys/ufs/ffs/ffs_inode.c

500

ffs_blkfree(fs, oip->i_devvp, bn,

sys/ufs/ffs/ffs_inode.c

501

fs->fs_bsize, oip->i_number);

sys/ufs/ffs/ffs_inode.c

514

bn = ffs_getdb(fs, oip, i);

sys/ufs/ffs/ffs_inode.c

518

bsize = ffs_blksize(fs, oip, i);

sys/ufs/ffs/ffs_inode.c

523

FFS_FSBTODB(fs, bn), bsize, NULL);

sys/ufs/ffs/ffs_inode.c

527

ffs_blkfree(fs, oip->i_devvp, bn, bsize, oip->i_number);

sys/ufs/ffs/ffs_inode.c

538

bn = ffs_getdb(fs, oip, lastblock);

sys/ufs/ffs/ffs_inode.c

546

oldspace = ffs_blksize(fs, oip, lastblock);

sys/ufs/ffs/ffs_inode.c

549

newspace = ffs_blksize(fs, oip, lastblock);

sys/ufs/ffs/ffs_inode.c

558

bn += ffs_numfrags(fs, newspace);

sys/ufs/ffs/ffs_inode.c

562

oip->i_ump->um_mountp, FFS_FSBTODB(fs, bn),

sys/ufs/ffs/ffs_inode.c

567

ffs_blkfree(fs, oip->i_devvp, bn,

sys/ufs/ffs/ffs_inode.c

631

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_inode.c

640

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_inode.c

661

factor *= FFS_NINDIR(fs);

sys/ufs/ffs/ffs_inode.c

665

nblocks = btodb(fs->fs_bsize);

sys/ufs/ffs/ffs_inode.c

675

error = ffs_getblk(vp, lbn, FFS_NOBLK, fs->fs_bsize, false, &bp);

sys/ufs/ffs/ffs_inode.c

681

trace(TR_BREADHIT, pack(vp, fs->fs_bsize), lbn);

sys/ufs/ffs/ffs_inode.c

683

trace(TR_BREADMISS, pack(vp, fs->fs_bsize), lbn);

sys/ufs/ffs/ffs_inode.c

713

copy = kmem_alloc(fs->fs_bsize, KM_SLEEP);

sys/ufs/ffs/ffs_inode.c

714

memcpy((void *)copy, bp->b_data, (u_int)fs->fs_bsize);

sys/ufs/ffs/ffs_inode.c

715

for (i = last + 1; i < FFS_NINDIR(fs); i++)

sys/ufs/ffs/ffs_inode.c

730

for (i = FFS_NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;

sys/ufs/ffs/ffs_inode.c

740

FFS_FSBTODB(fs, nb), fs->fs_bsize,

sys/ufs/ffs/ffs_inode.c

749

error = ffs_indirtrunc(ip, nlbn, FFS_FSBTODB(fs, nb),

sys/ufs/ffs/ffs_inode.c

762

ffs_blkfree(fs, ip->i_devvp, nb, fs->fs_bsize,

sys/ufs/ffs/ffs_inode.c

776

error = ffs_indirtrunc(ip, nlbn, FFS_FSBTODB(fs, nb),

sys/ufs/ffs/ffs_inode.c

788

kmem_free(copy, fs->fs_bsize);

sys/ufs/ffs/ffs_quota2.c

50

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_quota2.c

55

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

sys/ufs/ffs/ffs_quota2.c

59

ump->umq2_bsize = fs->fs_bsize;

sys/ufs/ffs/ffs_quota2.c

60

ump->umq2_bmask = fs->fs_qbmask;

sys/ufs/ffs/ffs_quota2.c

61

if (fs->fs_quota_magic != Q2_HEAD_MAGIC) {

sys/ufs/ffs/ffs_quota2.c

66

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

sys/ufs/ffs/ffs_quota2.c

67

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

sys/ufs/ffs/ffs_quota2.c

72

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

sys/ufs/ffs/ffs_quota2.c

73

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

sys/ufs/ffs/ffs_quota2.c

79

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

sys/ufs/ffs/ffs_quota2.c

81

error = VFS_VGET(mp, fs->fs_quotafile[USRQUOTA],

sys/ufs/ffs/ffs_quota2.c

95

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

sys/ufs/ffs/ffs_quota2.c

97

error = VFS_VGET(mp, fs->fs_quotafile[GRPQUOTA],

sys/ufs/ffs/ffs_snapshot.c

100

struct fs *, daddr_t);

sys/ufs/ffs/ffs_snapshot.c

1009

if ((error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)(base + loc)),

sys/ufs/ffs/ffs_snapshot.c

1010

fs->fs_bsize, l->l_cred, B_METAONLY, &ibp)) != 0)

sys/ufs/ffs/ffs_snapshot.c

1012

indiroff = (base + loc - UFS_NDADDR) % FFS_NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1014

if (indiroff >= FFS_NINDIR(fs)) {

sys/ufs/ffs/ffs_snapshot.c

1017

ffs_lblktosize(fs, (off_t)(base + loc)),

sys/ufs/ffs/ffs_snapshot.c

1018

fs->fs_bsize, l->l_cred, B_METAONLY, &ibp)) != 0)

sys/ufs/ffs/ffs_snapshot.c

1022

if (ffs_isblock(fs, cg_blksfree(cgp, ns), loc))

sys/ufs/ffs/ffs_snapshot.c

104

static int expunge(struct vnode *, struct inode *, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1043

expunge(struct vnode *snapvp, struct inode *cancelip, struct fs *fs,

sys/ufs/ffs/ffs_snapshot.c

1056

ns = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_snapshot.c

1066

lbn = ffs_fragstoblks(fs, ino_to_fsba(fs, cancelip->i_number));

sys/ufs/ffs/ffs_snapshot.c

107

daddr_t, daddr_t, daddr_t, daddr_t, struct fs *, acctfunc_t, int);

sys/ufs/ffs/ffs_snapshot.c

1071

error = bread(snapvp, lbn, fs->fs_bsize,

sys/ufs/ffs/ffs_snapshot.c

1074

error = ffs_balloc(snapvp, ffs_lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1075

fs->fs_bsize, l->l_cred, 0, &bp);

sys/ufs/ffs/ffs_snapshot.c

108

static int fullacct(struct vnode *, void *, int, int, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1087

if (fs->fs_magic == FS_UFS1_MAGIC) {

sys/ufs/ffs/ffs_snapshot.c

1089

ino_to_fsbo(fs, cancelip->i_number);

sys/ufs/ffs/ffs_snapshot.c

110

static int snapacct(struct vnode *, void *, int, int, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1102

ino_to_fsbo(fs, cancelip->i_number);

sys/ufs/ffs/ffs_snapshot.c

112

static int mapacct(struct vnode *, void *, int, int, struct fs *,

sys/ufs/ffs/ffs_snapshot.c

1120

numblks = howmany(cancelip->i_size, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1121

if (fs->fs_magic == FS_UFS1_MAGIC)

sys/ufs/ffs/ffs_snapshot.c

1125

error = (*acctfunc)(snapvp, bap, 0, UFS_NDADDR, fs, 0, expungetype);

sys/ufs/ffs/ffs_snapshot.c

1128

if (fs->fs_magic == FS_UFS1_MAGIC)

sys/ufs/ffs/ffs_snapshot.c

1132

error = (*acctfunc)(snapvp, bap, 0, UFS_NIADDR, fs, -1, expungetype);

sys/ufs/ffs/ffs_snapshot.c

1142

blksperindir, fs, acctfunc, expungetype);

sys/ufs/ffs/ffs_snapshot.c

1145

blksperindir *= FFS_NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1160

daddr_t blksperindir, struct fs *fs, acctfunc_t acctfunc, int expungetype)

sys/ufs/ffs/ffs_snapshot.c

1182

error = ffs_getblk(cancelvp, lbn, FFS_FSBTODB(fs, blkno), fs->fs_bsize,

sys/ufs/ffs/ffs_snapshot.c

1187

rwfsblk(bp->b_vp, B_READ, bp->b_data, ffs_fragstoblks(fs, blkno)))) {

sys/ufs/ffs/ffs_snapshot.c

1195

if (last > FFS_NINDIR(fs))

sys/ufs/ffs/ffs_snapshot.c

1196

last = FFS_NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1197

bap = malloc(fs->fs_bsize, M_DEVBUF, M_WAITOK | M_ZERO);

sys/ufs/ffs/ffs_snapshot.c

1198

memcpy((void *)bap, bp->b_data, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1201

fs, level == 0 ? rlbn : -1, expungetype);

sys/ufs/ffs/ffs_snapshot.c

1208

subblksperindir = blksperindir / FFS_NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1212

subblksperindir, fs, acctfunc, expungetype);

sys/ufs/ffs/ffs_snapshot.c

122

static int blocks_in_journal(struct fs *);

sys/ufs/ffs/ffs_snapshot.c

1229

struct fs *fs, daddr_t lblkno,

sys/ufs/ffs/ffs_snapshot.c

1234

if ((error = snapacct(vp, bap, oldblkp, lastblkp, fs, lblkno, exptype)))

sys/ufs/ffs/ffs_snapshot.c

1236

return (mapacct(vp, bap, oldblkp, lastblkp, fs, lblkno, exptype));

sys/ufs/ffs/ffs_snapshot.c

1244

struct fs *fs, daddr_t lblkno,

sys/ufs/ffs/ffs_snapshot.c

1263

lbn = ffs_fragstoblks(fs, blkno);

sys/ufs/ffs/ffs_snapshot.c

1268

error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1269

fs->fs_bsize, l->l_cred, B_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

1273

(lbn - UFS_NDADDR) % FFS_NINDIR(fs));

sys/ufs/ffs/ffs_snapshot.c

1291

(lbn - UFS_NDADDR) % FFS_NINDIR(fs), expungetype);

sys/ufs/ffs/ffs_snapshot.c

1311

struct fs *fs, daddr_t lblkno, int expungetype)

sys/ufs/ffs/ffs_snapshot.c

1336

blkno = ffs_blkstofrags(fs, lblkno);

sys/ufs/ffs/ffs_snapshot.c

1337

ffs_blkfree_snap(fs, vp, blkno, fs->fs_bsize, inum);

sys/ufs/ffs/ffs_snapshot.c

1353

blocks_in_journal(struct fs *fs)

sys/ufs/ffs/ffs_snapshot.c

1357

if ((fs->fs_flags & FS_DOWAPBL) == 0)

sys/ufs/ffs/ffs_snapshot.c

1360

if (fs->fs_journal_version == UFS_WAPBL_VERSION) {

sys/ufs/ffs/ffs_snapshot.c

1361

switch (fs->fs_journal_location) {

sys/ufs/ffs/ffs_snapshot.c

1363

bpj = (off_t)fs->fs_journallocs[UFS_WAPBL_EPART_BLKSZ]*

sys/ufs/ffs/ffs_snapshot.c

1364

fs->fs_journallocs[UFS_WAPBL_EPART_COUNT];

sys/ufs/ffs/ffs_snapshot.c

1367

bpj = (off_t)fs->fs_journallocs[UFS_WAPBL_INFS_BLKSZ]*

sys/ufs/ffs/ffs_snapshot.c

1368

fs->fs_journallocs[UFS_WAPBL_INFS_COUNT];

sys/ufs/ffs/ffs_snapshot.c

1372

bpj /= fs->fs_bsize;

sys/ufs/ffs/ffs_snapshot.c

1386

struct fs *fs;

sys/ufs/ffs/ffs_snapshot.c

1411

fs = ip->i_fs;

sys/ufs/ffs/ffs_snapshot.c

1413

if (fs->fs_snapinum[snaploc] == ip->i_number)

sys/ufs/ffs/ffs_snapshot.c

1417

if (fs->fs_snapinum[snaploc] == 0)

sys/ufs/ffs/ffs_snapshot.c

1419

fs->fs_snapinum[snaploc - 1] = fs->fs_snapinum[snaploc];

sys/ufs/ffs/ffs_snapshot.c

1421

fs->fs_snapinum[snaploc - 1] = 0;

sys/ufs/ffs/ffs_snapshot.c

1435

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_snapshot.c

1485

else if ((dblk == ffs_blkstofrags(fs, blkno) &&

sys/ufs/ffs/ffs_snapshot.c

1486

ffs_snapblkfree(fs, ip->i_devvp, dblk, fs->fs_bsize,

sys/ufs/ffs/ffs_snapshot.c

1488

DIP_ADD(ip, blocks, -btodb(fs->fs_bsize));

sys/ufs/ffs/ffs_snapshot.c

1492

numblks = howmany(ip->i_size, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1493

for (blkno = UFS_NDADDR; blkno < numblks; blkno += FFS_NINDIR(fs)) {

sys/ufs/ffs/ffs_snapshot.c

1494

error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)blkno),

sys/ufs/ffs/ffs_snapshot.c

1495

fs->fs_bsize, l->l_cred, B_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

1498

if (fs->fs_size - blkno > FFS_NINDIR(fs))

sys/ufs/ffs/ffs_snapshot.c

1499

last = FFS_NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1501

last = fs->fs_size - blkno;

sys/ufs/ffs/ffs_snapshot.c

1506

else if (dblk == ffs_blkstofrags(fs, blkno) &&

sys/ufs/ffs/ffs_snapshot.c

1507

ffs_snapblkfree(fs, ip->i_devvp, dblk,

sys/ufs/ffs/ffs_snapshot.c

1508

fs->fs_bsize, ip->i_number)) {

sys/ufs/ffs/ffs_snapshot.c

1509

DIP_ADD(ip, blocks, -btodb(fs->fs_bsize));

sys/ufs/ffs/ffs_snapshot.c

1549

ffs_snapblkfree(struct fs *fs, struct vnode *devvp, daddr_t bno,

sys/ufs/ffs/ffs_snapshot.c

1564

lbn = ffs_fragstoblks(fs, bno);

sys/ufs/ffs/ffs_snapshot.c

1580

error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)lbn),

sys/ufs/ffs/ffs_snapshot.c

1581

fs->fs_bsize, FSCRED, B_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

1586

indiroff = (lbn - UFS_NDADDR) % FFS_NINDIR(fs);

sys/ufs/ffs/ffs_snapshot.c

1644

if (size == fs->fs_bsize) {

sys/ufs/ffs/ffs_snapshot.c

1693

saved_data = malloc(fs->fs_bsize, M_UFSMNT, M_WAITOK);

sys/ufs/ffs/ffs_snapshot.c

1732

struct fs *fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_snapshot.c

1747

ns = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_snapshot.c

1752

mp->mnt_stat.f_iosize = fs->fs_bsize;

sys/ufs/ffs/ffs_snapshot.c

1759

if (fs->fs_snapinum[snaploc] == 0)

sys/ufs/ffs/ffs_snapshot.c

1761

if ((error = VFS_VGET(mp, fs->fs_snapinum[snaploc],

sys/ufs/ffs/ffs_snapshot.c

1770

fs->fs_snapinum[snaploc]);

sys/ufs/ffs/ffs_snapshot.c

1774

if (fs->fs_snapinum[loc] == 0)

sys/ufs/ffs/ffs_snapshot.c

1776

fs->fs_snapinum[loc - 1] = fs->fs_snapinum[loc];

sys/ufs/ffs/ffs_snapshot.c

1778

fs->fs_snapinum[loc - 1] = 0;

sys/ufs/ffs/ffs_snapshot.c

1789

ffs_lblktosize(fs, howmany(fs->fs_size, fs->fs_frag)),

sys/ufs/ffs/ffs_snapshot.c

1804

ffs_lblktosize(fs, howmany(fs->fs_size, fs->fs_frag)),

sys/ufs/ffs/ffs_snapshot.c

183

struct fs *copy_fs = NULL;

sys/ufs/ffs/ffs_snapshot.c

184

struct fs *fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_snapshot.c

1885

struct fs *fs;

sys/ufs/ffs/ffs_snapshot.c

1910

fs = ip->i_fs;

sys/ufs/ffs/ffs_snapshot.c

1911

lbn = ffs_fragstoblks(fs, FFS_DBTOFSB(fs, bp->b_blkno));

sys/ufs/ffs/ffs_snapshot.c

1912

if (bp->b_blkno >= FFS_FSBTODB(fs, fs->fs_size)) {

sys/ufs/ffs/ffs_snapshot.c

1916

if ((fs->fs_flags & FS_DOWAPBL) &&

sys/ufs/ffs/ffs_snapshot.c

1917

fs->fs_journal_location == UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM) {

sys/ufs/ffs/ffs_snapshot.c

1920

log_start = (off_t)fs->fs_journallocs[UFS_WAPBL_INFS_ADDR] *

sys/ufs/ffs/ffs_snapshot.c

1921

fs->fs_journallocs[UFS_WAPBL_INFS_BLKSZ];

sys/ufs/ffs/ffs_snapshot.c

1922

log_end = log_start + fs->fs_journallocs[UFS_WAPBL_INFS_COUNT] *

sys/ufs/ffs/ffs_snapshot.c

1923

fs->fs_journallocs[UFS_WAPBL_INFS_BLKSZ];

sys/ufs/ffs/ffs_snapshot.c

1958

if (data_valid && bp->b_bcount == fs->fs_bsize)

sys/ufs/ffs/ffs_snapshot.c

2031

saved_data = malloc(fs->fs_bsize, M_UFSMNT, M_WAITOK);

sys/ufs/ffs/ffs_snapshot.c

2072

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_snapshot.c

2085

fsbytes = ffs_lfragtosize(fs, fs->fs_size);

sys/ufs/ffs/ffs_snapshot.c

2090

lbn = ffs_lblkno(fs, uio->uio_offset);

sys/ufs/ffs/ffs_snapshot.c

2092

size = fs->fs_bsize;

sys/ufs/ffs/ffs_snapshot.c

2093

blkoffset = ffs_blkoff(fs, uio->uio_offset);

sys/ufs/ffs/ffs_snapshot.c

2094

xfersize = MIN(MIN(fs->fs_bsize - blkoffset, uio->uio_resid),

sys/ufs/ffs/ffs_snapshot.c

2097

if (ffs_lblktosize(fs, nextlbn + 1) >= fsbytes) {

sys/ufs/ffs/ffs_snapshot.c

2098

if (ffs_lblktosize(fs, lbn) + size > fsbytes)

sys/ufs/ffs/ffs_snapshot.c

2099

size = ffs_fragroundup(fs,

sys/ufs/ffs/ffs_snapshot.c

2100

fsbytes - ffs_lblktosize(fs, lbn));

sys/ufs/ffs/ffs_snapshot.c

2103

int nextsize = fs->fs_bsize;

sys/ufs/ffs/ffs_snapshot.c

211

if (fs->fs_snapinum[snaploc] == 0)

sys/ufs/ffs/ffs_snapshot.c

2145

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_snapshot.c

2168

error = bread(vp, indirs[num-1].in_lbn, fs->fs_bsize, 0, &bp);

sys/ufs/ffs/ffs_snapshot.c

2186

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_snapshot.c

2191

nbp->b_bcount = nbp->b_bufsize = fs->fs_bsize;

sys/ufs/ffs/ffs_snapshot.c

2194

nbp->b_blkno = nbp->b_rawblkno = FFS_FSBTODB(fs, ffs_blkstofrags(fs, lbn));

sys/ufs/ffs/ffs_snapshot.c

2216

struct fs *fs = VTOI(vp)->i_fs;

sys/ufs/ffs/ffs_snapshot.c

2227

KASSERT(bp->b_bcount == fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

2230

ffs_fragstoblks(fs, FFS_DBTOFSB(fs, bp->b_blkno)));

sys/ufs/ffs/ffs_snapshot.c

2248

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_snapshot.c

2252

error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)lbn), fs->fs_bsize,

sys/ufs/ffs/ffs_snapshot.c

2256

memcpy(bp->b_data, data, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

275

copy_fs = (struct fs *)((char *)sbbuf + ffs_blkoff(fs, fs->fs_sblockloc));

sys/ufs/ffs/ffs_snapshot.c

287

fs->fs_snapinum[snaploc] = ip->i_number;

sys/ufs/ffs/ffs_snapshot.c

350

if (bp->b_bcount == fs->fs_bsize)

sys/ufs/ffs/ffs_snapshot.c

369

if (fs->fs_active != NULL) {

sys/ufs/ffs/ffs_snapshot.c

370

free(fs->fs_active, M_DEVBUF);

sys/ufs/ffs/ffs_snapshot.c

371

fs->fs_active = NULL;

sys/ufs/ffs/ffs_snapshot.c

381

fs->fs_snapinum[snaploc] = 0;

sys/ufs/ffs/ffs_snapshot.c

401

endtime.tv_usec / 1000, redo, fs->fs_ncg);

sys/ufs/ffs/ffs_snapshot.c

429

struct fs *fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_snapshot.c

431

const int wbreak = blocks_in_journal(fs)/8;

sys/ufs/ffs/ffs_snapshot.c

474

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

sys/ufs/ffs/ffs_snapshot.c

476

blkno = ufs_rw64(blkno, UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_snapshot.c

478

(void *)&blkno, sizeof(blkno), ffs_lblktosize(fs, (off_t)numblks),

sys/ufs/ffs/ffs_snapshot.c

496

for (blkno = UFS_NDADDR, n = 0; blkno < numblks; blkno += FFS_NINDIR(fs)) {

sys/ufs/ffs/ffs_snapshot.c

497

error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)blkno),

sys/ufs/ffs/ffs_snapshot.c

498

fs->fs_bsize, l->l_cred, B_METAONLY, &ibp);

sys/ufs/ffs/ffs_snapshot.c

512

error = ffs_balloc(vp, fs->fs_sblockloc, fs->fs_sbsize, l->l_cred,

sys/ufs/ffs/ffs_snapshot.c

517

blkno = ffs_fragstoblks(fs, fs->fs_csaddr);

sys/ufs/ffs/ffs_snapshot.c

518

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

sys/ufs/ffs/ffs_snapshot.c

520

error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)(blkno + loc)),

sys/ufs/ffs/ffs_snapshot.c

521

fs->fs_bsize, l->l_cred, 0, &nbp);

sys/ufs/ffs/ffs_snapshot.c

535

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

sys/ufs/ffs/ffs_snapshot.c

536

error = ffs_balloc(vp, ffs_lfragtosize(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_snapshot.c

537

fs->fs_bsize, l->l_cred, 0, &nbp);

sys/ufs/ffs/ffs_snapshot.c

565

struct fs *copyfs, *fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_snapshot.c

572

*sbbuf = malloc(fs->fs_bsize, M_UFSMNT, M_WAITOK);

sys/ufs/ffs/ffs_snapshot.c

573

loc = ffs_blkoff(fs, fs->fs_sblockloc);

sys/ufs/ffs/ffs_snapshot.c

576

copyfs = (struct fs *)((char *)(*sbbuf) + loc);

sys/ufs/ffs/ffs_snapshot.c

577

memcpy(copyfs, fs, fs->fs_sbsize);

sys/ufs/ffs/ffs_snapshot.c

578

size = fs->fs_bsize < SBLOCKSIZE ? fs->fs_bsize : SBLOCKSIZE;

sys/ufs/ffs/ffs_snapshot.c

579

if (fs->fs_sbsize < size)

sys/ufs/ffs/ffs_snapshot.c

580

memset((char *)(*sbbuf) + loc + fs->fs_sbsize, 0,

sys/ufs/ffs/ffs_snapshot.c

581

size - fs->fs_sbsize);

sys/ufs/ffs/ffs_snapshot.c

582

size = ffs_blkroundup(fs, fs->fs_cssize);

sys/ufs/ffs/ffs_snapshot.c

583

if (fs->fs_contigsumsize > 0)

sys/ufs/ffs/ffs_snapshot.c

584

size += fs->fs_ncg * sizeof(int32_t);

sys/ufs/ffs/ffs_snapshot.c

587

memcpy(copyfs->fs_csp, fs->fs_csp, fs->fs_cssize);

sys/ufs/ffs/ffs_snapshot.c

588

space = (char *)space + fs->fs_cssize;

sys/ufs/ffs/ffs_snapshot.c

589

loc = howmany(fs->fs_cssize, fs->fs_fsize);

sys/ufs/ffs/ffs_snapshot.c

590

i = fs->fs_frag - loc % fs->fs_frag;

sys/ufs/ffs/ffs_snapshot.c

591

len = (i == fs->fs_frag) ? 0 : i * fs->fs_fsize;

sys/ufs/ffs/ffs_snapshot.c

593

if ((error = bread(devvp, FFS_FSBTODB(fs, fs->fs_csaddr + loc),

sys/ufs/ffs/ffs_snapshot.c

604

if (fs->fs_contigsumsize > 0) {

sys/ufs/ffs/ffs_snapshot.c

606

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

sys/ufs/ffs/ffs_snapshot.c

607

*lp++ = fs->fs_contigsumsize;

sys/ufs/ffs/ffs_snapshot.c

617

struct fs *copy_fs;

sys/ufs/ffs/ffs_snapshot.c

657

snapshot_expunge(struct mount *mp, struct vnode *vp, struct fs *copy_fs,

sys/ufs/ffs/ffs_snapshot.c

662

struct fs *fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_snapshot.c

672

if ((fs->fs_flags & FS_DOWAPBL) &&

sys/ufs/ffs/ffs_snapshot.c

673

fs->fs_journal_location == UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM) {

sys/ufs/ffs/ffs_snapshot.c

674

error = VFS_VGET(mp, fs->fs_journallocs[UFS_WAPBL_INFS_INO],

sys/ufs/ffs/ffs_snapshot.c

682

*snaplistsize = fs->fs_ncg + howmany(fs->fs_cssize, fs->fs_bsize) +

sys/ufs/ffs/ffs_snapshot.c

697

loc = howmany(xp->i_size, fs->fs_bsize) - 1;

sys/ufs/ffs/ffs_snapshot.c

699

len = ffs_fragroundup(fs, ffs_blkoff(fs, xp->i_size));

sys/ufs/ffs/ffs_snapshot.c

700

if (len > 0 && len < fs->fs_bsize) {

sys/ufs/ffs/ffs_snapshot.c

739

*blkp++ = ffs_lblkno(fs, fs->fs_sblockloc);

sys/ufs/ffs/ffs_snapshot.c

740

blkno = ffs_fragstoblks(fs, fs->fs_csaddr);

sys/ufs/ffs/ffs_snapshot.c

741

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

sys/ufs/ffs/ffs_snapshot.c

742

if (ffs_fragstoblks(fs, cgtod(fs, cg)) > blkno)

sys/ufs/ffs/ffs_snapshot.c

744

*blkp++ = ffs_fragstoblks(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_snapshot.c

746

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

sys/ufs/ffs/ffs_snapshot.c

749

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

sys/ufs/ffs/ffs_snapshot.c

750

*blkp++ = ffs_fragstoblks(fs, cgtod(fs, cg));

sys/ufs/ffs/ffs_snapshot.c

771

struct fs *copy_fs, daddr_t snaplistsize)

sys/ufs/ffs/ffs_snapshot.c

775

struct fs *fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_snapshot.c

782

error = expunge(vp, xp, fs, snapacct, BLK_SNAP);

sys/ufs/ffs/ffs_snapshot.c

819

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

sys/ufs/ffs/ffs_snapshot.c

821

snaplist[i] = ufs_rw64(snaplist[i], UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_snapshot.c

823

snaplistsize * sizeof(daddr_t), ffs_lblktosize(fs, (off_t)numblks),

sys/ufs/ffs/ffs_snapshot.c

826

snaplist[i] = ufs_rw64(snaplist[i], UFS_FSNEEDSWAP(fs));

sys/ufs/ffs/ffs_snapshot.c

846

struct fs *copyfs, *fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_snapshot.c

850

copyfs = (struct fs *)((char *)sbbuf + ffs_blkoff(fs, fs->fs_sblockloc));

sys/ufs/ffs/ffs_snapshot.c

856

blkno = ffs_fragstoblks(fs, fs->fs_csaddr);

sys/ufs/ffs/ffs_snapshot.c

857

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

sys/ufs/ffs/ffs_snapshot.c

860

if (UFS_FSNEEDSWAP(fs)) {

sys/ufs/ffs/ffs_snapshot.c

862

ffs_csum_swap(space, space, fs->fs_cssize);

sys/ufs/ffs/ffs_snapshot.c

869

error = bread(vp, blkno + loc, fs->fs_bsize,

sys/ufs/ffs/ffs_snapshot.c

874

memcpy(bp->b_data, space, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

875

space = (char *)space + fs->fs_bsize;

sys/ufs/ffs/ffs_snapshot.c

880

error = bread(vp, ffs_lblkno(fs, fs->fs_sblockloc),

sys/ufs/ffs/ffs_snapshot.c

881

fs->fs_bsize, B_MODIFY, &bp);

sys/ufs/ffs/ffs_snapshot.c

885

memcpy(bp->b_data, sbbuf, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

896

error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)loc),

sys/ufs/ffs/ffs_snapshot.c

897

fs->fs_bsize, l->l_cred, 0, &bp);

sys/ufs/ffs/ffs_snapshot.c

921

struct fs *fs = VTOI(vp)->i_fs;

sys/ufs/ffs/ffs_snapshot.c

926

fs->fs_active = malloc(howmany(fs->fs_ncg, NBBY),

sys/ufs/ffs/ffs_snapshot.c

928

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

sys/ufs/ffs/ffs_snapshot.c

929

if (passno == 2 && ACTIVECG_ISSET(fs, cg))

sys/ufs/ffs/ffs_snapshot.c

93

(struct vnode *, void *, int, int, struct fs *, daddr_t, int);

sys/ufs/ffs/ffs_snapshot.c

937

error = ffs_balloc(vp, ffs_lfragtosize(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_snapshot.c

938

fs->fs_bsize, curlwp->l_cred, 0, &nbp);

sys/ufs/ffs/ffs_snapshot.c

966

struct fs *fs;

sys/ufs/ffs/ffs_snapshot.c

972

fs = ip->i_fs;

sys/ufs/ffs/ffs_snapshot.c

973

ns = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_snapshot.c

974

error = bread(ip->i_devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_snapshot.c

975

(int)fs->fs_cgsize, 0, &bp);

sys/ufs/ffs/ffs_snapshot.c

98

struct fs *, daddr_t *, daddr_t **);

sys/ufs/ffs/ffs_snapshot.c

984

ACTIVECG_SET(fs, cg);

sys/ufs/ffs/ffs_snapshot.c

986

memcpy(data, bp->b_data, fs->fs_cgsize);

sys/ufs/ffs/ffs_snapshot.c

988

if (fs->fs_cgsize < fs->fs_bsize)

sys/ufs/ffs/ffs_snapshot.c

989

memset((char *)data + fs->fs_cgsize, 0,

sys/ufs/ffs/ffs_snapshot.c

990

fs->fs_bsize - fs->fs_cgsize);

sys/ufs/ffs/ffs_snapshot.c

991

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

sys/ufs/ffs/ffs_snapshot.c

992

len = howmany(fs->fs_fpg, fs->fs_frag);

sys/ufs/ffs/ffs_snapshot.c

993

base = cgbase(fs, cg) / fs->fs_frag;

sys/ufs/ffs/ffs_snapshot.c

999

if (ffs_isblock(fs, cg_blksfree(cgp, ns), loc))

sys/ufs/ffs/ffs_subr.c

100

if (UFS_FSNEEDSWAP(fs))

sys/ufs/ffs/ffs_subr.c

144

ffs_fragacct(struct fs *fs, int fragmap, uint32_t fraglist[], int cnt,

sys/ufs/ffs/ffs_subr.c

151

inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1;

sys/ufs/ffs/ffs_subr.c

153

for (siz = 1; siz < fs->fs_frag; siz++) {

sys/ufs/ffs/ffs_subr.c

154

if ((inblk & (1 << (siz + (fs->fs_frag & (NBBY - 1))))) == 0)

sys/ufs/ffs/ffs_subr.c

158

for (pos = siz; pos <= fs->fs_frag; pos++) {

sys/ufs/ffs/ffs_subr.c

181

ffs_isblock(struct fs *fs, u_char *cp, int32_t h)

sys/ufs/ffs/ffs_subr.c

185

switch ((int)fs->fs_fragshift) {

sys/ufs/ffs/ffs_subr.c

199

(int)fs->fs_fragshift);

sys/ufs/ffs/ffs_subr.c

209

ffs_isfreeblock(struct fs *fs, u_char *cp, int32_t h)

sys/ufs/ffs/ffs_subr.c

212

switch ((int)fs->fs_fragshift) {

sys/ufs/ffs/ffs_subr.c

223

(int)fs->fs_fragshift);

sys/ufs/ffs/ffs_subr.c

231

ffs_clrblock(struct fs *fs, u_char *cp, int32_t h)

sys/ufs/ffs/ffs_subr.c

234

switch ((int)fs->fs_fragshift) {

sys/ufs/ffs/ffs_subr.c

249

(int)fs->fs_fragshift);

sys/ufs/ffs/ffs_subr.c

257

ffs_setblock(struct fs *fs, u_char *cp, int32_t h)

sys/ufs/ffs/ffs_subr.c

260

switch ((int)fs->fs_fragshift) {

sys/ufs/ffs/ffs_subr.c

275

(int)fs->fs_fragshift);

sys/ufs/ffs/ffs_subr.c

285

ffs_clusteracct(struct fs *fs, struct cg *cgp, int32_t blkno, int cnt)

sys/ufs/ffs/ffs_subr.c

292

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_subr.c

296

if (fs->fs_contigsumsize <= 0)

sys/ufs/ffs/ffs_subr.c

311

end = start + fs->fs_contigsumsize;

sys/ufs/ffs/ffs_subr.c

332

end = start - fs->fs_contigsumsize;

sys/ufs/ffs/ffs_subr.c

354

if (i > fs->fs_contigsumsize)

sys/ufs/ffs/ffs_subr.c

355

i = fs->fs_contigsumsize;

sys/ufs/ffs/ffs_subr.c

365

lp = &sump[fs->fs_contigsumsize];

sys/ufs/ffs/ffs_subr.c

366

for (i = fs->fs_contigsumsize; i > 0; i--)

sys/ufs/ffs/ffs_subr.c

370

fs->fs_maxcluster[ufs_rw32(cgp->cg_cgx, needswap)] = i;

sys/ufs/ffs/ffs_subr.c

76

ffs_load_inode(struct buf *bp, struct inode *ip, struct fs *fs, ino_t ino)

sys/ufs/ffs/ffs_subr.c

82

dp1 = (struct ufs1_dinode *)bp->b_data + ino_to_fsbo(fs, ino);

sys/ufs/ffs/ffs_subr.c

84

if (UFS_FSNEEDSWAP(fs))

sys/ufs/ffs/ffs_subr.c

98

dp2 = (struct ufs2_dinode *)bp->b_data + ino_to_fsbo(fs, ino);

sys/ufs/ffs/ffs_vfsops.c

1011

error = bread(devvp, FFS_FSBTODB(fs, ino_to_fsba(fs, ip->i_number)),

sys/ufs/ffs/ffs_vfsops.c

1012

(int)fs->fs_bsize, 0, &bp);

sys/ufs/ffs/ffs_vfsops.c

1017

ffs_load_inode(bp, ip, fs, ip->i_number);

sys/ufs/ffs/ffs_vfsops.c

1032

ffs_superblock_validate(struct fs *fs)

sys/ufs/ffs/ffs_vfsops.c

1038

if (fs->fs_sbsize > SBLOCKSIZE || fs->fs_sbsize < sizeof(struct fs))

sys/ufs/ffs/ffs_vfsops.c

1042

if (fs->fs_bsize > MAXBSIZE || fs->fs_bsize < MINBSIZE)

sys/ufs/ffs/ffs_vfsops.c

1044

if (!powerof2(fs->fs_bsize))

sys/ufs/ffs/ffs_vfsops.c

1048

if (!powerof2(fs->fs_fsize))

sys/ufs/ffs/ffs_vfsops.c

1050

if (fs->fs_fsize == 0)

sys/ufs/ffs/ffs_vfsops.c

1057

if (fs->fs_size == 0 && fs->fs_old_size == 0)

sys/ufs/ffs/ffs_vfsops.c

1059

if (fs->fs_cssize == 0)

sys/ufs/ffs/ffs_vfsops.c

1061

if (fs->fs_ipg == 0)

sys/ufs/ffs/ffs_vfsops.c

1063

if (fs->fs_fpg == 0)

sys/ufs/ffs/ffs_vfsops.c

1065

if (fs->fs_ncg == 0)

sys/ufs/ffs/ffs_vfsops.c

1067

if (fs->fs_maxbpg == 0)

sys/ufs/ffs/ffs_vfsops.c

1071

if (fs->fs_magic == FS_UFS1_MAGIC)

sys/ufs/ffs/ffs_vfsops.c

1072

fs_inopb = fs->fs_bsize / sizeof(struct ufs1_dinode);

sys/ufs/ffs/ffs_vfsops.c

1074

fs_inopb = fs->fs_bsize / sizeof(struct ufs2_dinode);

sys/ufs/ffs/ffs_vfsops.c

1075

if (fs->fs_inopb != fs_inopb)

sys/ufs/ffs/ffs_vfsops.c

1079

if (fs->fs_bsize < fs->fs_fsize)

sys/ufs/ffs/ffs_vfsops.c

1083

for (i = fs->fs_bsize; i > 1; i >>= 1)

sys/ufs/ffs/ffs_vfsops.c

1085

if (fs->fs_bshift != fs_bshift)

sys/ufs/ffs/ffs_vfsops.c

1089

for (i = fs->fs_fsize; i > 1; i >>= 1)

sys/ufs/ffs/ffs_vfsops.c

1091

if (fs->fs_fshift != fs_fshift)

sys/ufs/ffs/ffs_vfsops.c

1095

for (i = fs->fs_frag; i > 1; i >>= 1)

sys/ufs/ffs/ffs_vfsops.c

1097

if (fs->fs_fragshift != fs_fragshift)

sys/ufs/ffs/ffs_vfsops.c

1101

if (fs->fs_bmask != ~(fs->fs_bsize - 1))

sys/ufs/ffs/ffs_vfsops.c

1103

if (fs->fs_fmask != ~(fs->fs_fsize - 1))

sys/ufs/ffs/ffs_vfsops.c

1111

if ((fs_frag = ffs_numfrags(fs, fs->fs_bsize)) > MAXFRAG)

sys/ufs/ffs/ffs_vfsops.c

1113

if (fs->fs_frag != fs_frag)

sys/ufs/ffs/ffs_vfsops.c

1117

if ((fs->fs_cgsize < sizeof(struct cg)) ||

sys/ufs/ffs/ffs_vfsops.c

1118

(fs->fs_cgsize > fs->fs_bsize))

sys/ufs/ffs/ffs_vfsops.c

1125

ffs_is_appleufs(struct vnode *devvp, struct fs *fs)

sys/ufs/ffs/ffs_vfsops.c

1154

error = ffs_appleufs_validate(fs->fs_fsmnt, applefs, NULL);

sys/ufs/ffs/ffs_vfsops.c

1172

struct fs *fs = NULL;

sys/ufs/ffs/ffs_vfsops.c

118

static int ffs_superblock_validate(struct fs *);

sys/ufs/ffs/ffs_vfsops.c

119

static int ffs_is_appleufs(struct vnode *, struct fs *);

sys/ufs/ffs/ffs_vfsops.c

1224

fs = NULL;

sys/ufs/ffs/ffs_vfsops.c

1233

fs = NULL;

sys/ufs/ffs/ffs_vfsops.c

1236

fs = (struct fs *)bp->b_data;

sys/ufs/ffs/ffs_vfsops.c

1239

DPRINTF("fs_magic 0x%x", fs->fs_magic);

sys/ufs/ffs/ffs_vfsops.c

1246

if (fs->fs_magic == FS_UFS2EA_MAGIC) {

sys/ufs/ffs/ffs_vfsops.c

1248

fs->fs_magic = FS_UFS2_MAGIC;

sys/ufs/ffs/ffs_vfsops.c

1249

} else if (fs->fs_magic == FS_UFS2EA_MAGIC_SWAPPED) {

sys/ufs/ffs/ffs_vfsops.c

1251

fs->fs_magic = FS_UFS2_MAGIC_SWAPPED;

sys/ufs/ffs/ffs_vfsops.c

1253

if (fs->fs_magic == FS_UFS1_MAGIC) {

sys/ufs/ffs/ffs_vfsops.c

1254

fs_sbsize = fs->fs_sbsize;

sys/ufs/ffs/ffs_vfsops.c

1258

} else if (fs->fs_magic == FS_UFS1_MAGIC_SWAPPED) {

sys/ufs/ffs/ffs_vfsops.c

1259

fs_sbsize = bswap32(fs->fs_sbsize);

sys/ufs/ffs/ffs_vfsops.c

1263

} else if (fs->fs_magic == FS_UFS2_MAGIC) {

sys/ufs/ffs/ffs_vfsops.c

1264

fs_sbsize = fs->fs_sbsize;

sys/ufs/ffs/ffs_vfsops.c

1268

} else if (fs->fs_magic == FS_UFS2_MAGIC_SWAPPED) {

sys/ufs/ffs/ffs_vfsops.c

1269

fs_sbsize = bswap32(fs->fs_sbsize);

sys/ufs/ffs/ffs_vfsops.c

1277

if (fstype == UFS1 && !(fs->fs_old_flags & FS_FLAGS_UPDATED)) {

sys/ufs/ffs/ffs_vfsops.c

1287

fs_sblockloc = fs->fs_sblockloc;

sys/ufs/ffs/ffs_vfsops.c

1299

if (fs_sbsize > SBLOCKSIZE || fs_sbsize < sizeof(struct fs))

sys/ufs/ffs/ffs_vfsops.c

1301

fs = kmem_alloc((u_long)fs_sbsize, KM_SLEEP);

sys/ufs/ffs/ffs_vfsops.c

1302

memcpy(fs, bp->b_data, fs_sbsize);

sys/ufs/ffs/ffs_vfsops.c

1307

ffs_sb_swap((struct fs*)bp->b_data, fs);

sys/ufs/ffs/ffs_vfsops.c

1308

fs->fs_flags |= FS_SWAPPED;

sys/ufs/ffs/ffs_vfsops.c

1311

fs->fs_flags &= ~FS_SWAPPED;

sys/ufs/ffs/ffs_vfsops.c

1317

if (!ffs_superblock_validate(fs)) {

sys/ufs/ffs/ffs_vfsops.c

1318

kmem_free(fs, fs_sbsize);

sys/ufs/ffs/ffs_vfsops.c

1326

ump->um_fs = fs;

sys/ufs/ffs/ffs_vfsops.c

1329

if ((mp->mnt_wapbl_replay == 0) && (fs->fs_flags & FS_DOWAPBL)) {

sys/ufs/ffs/ffs_vfsops.c

1330

error = ffs_wapbl_replay_start(mp, fs, devvp);

sys/ufs/ffs/ffs_vfsops.c

1339

fs->fs_fsmnt);

sys/ufs/ffs/ffs_vfsops.c

1348

fs->fs_clean = FS_WASCLEAN;

sys/ufs/ffs/ffs_vfsops.c

1352

fs->fs_fsmnt);

sys/ufs/ffs/ffs_vfsops.c

1358

kmem_free(fs, fs_sbsize);

sys/ufs/ffs/ffs_vfsops.c

1359

fs = NULL;

sys/ufs/ffs/ffs_vfsops.c

1364

if ((fs->fs_flags & FS_DOWAPBL) && (mp->mnt_flag & MNT_FORCE) == 0) {

sys/ufs/ffs/ffs_vfsops.c

1371

ffs_oldfscompat_read(fs, ump, sblockloc);

sys/ufs/ffs/ffs_vfsops.c

1372

ump->um_maxfilesize = fs->fs_maxfilesize;

sys/ufs/ffs/ffs_vfsops.c

1374

if (fs->fs_flags & ~(FS_KNOWN_FLAGS | FS_INTERNAL)) {

sys/ufs/ffs/ffs_vfsops.c

1376

mp->mnt_stat.f_mntonname, fs->fs_flags,

sys/ufs/ffs/ffs_vfsops.c

1385

fs->fs_fmod = 0;

sys/ufs/ffs/ffs_vfsops.c

1386

if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {

sys/ufs/ffs/ffs_vfsops.c

1387

fs->fs_pendingblocks = 0;

sys/ufs/ffs/ffs_vfsops.c

1388

fs->fs_pendinginodes = 0;

sys/ufs/ffs/ffs_vfsops.c

1392

if (fs->fs_sbsize < SBLOCKSIZE)

sys/ufs/ffs/ffs_vfsops.c

1398

if (ffs_is_appleufs(devvp, fs)) {

sys/ufs/ffs/ffs_vfsops.c

1419

if (fs->fs_flags & FS_DOWAPBL) {

sys/ufs/ffs/ffs_vfsops.c

1426

(fs->fs_clean & (FS_WASCLEAN | FS_ISCLEAN)) == 0) {

sys/ufs/ffs/ffs_vfsops.c

1431

if ((fs->fs_clean & FS_ISCLEAN) == 0 &&

sys/ufs/ffs/ffs_vfsops.c

1443

error = bread(devvp, FFS_FSBTODB(fs, fs->fs_size - 1),

sys/ufs/ffs/ffs_vfsops.c

1444

fs->fs_fsize, 0, &bp);

sys/ufs/ffs/ffs_vfsops.c

1447

(intmax_t)FFS_FSBTODB(fs, fs->fs_size - 1),

sys/ufs/ffs/ffs_vfsops.c

1452

if (bp->b_bcount != fs->fs_fsize) {

sys/ufs/ffs/ffs_vfsops.c

1454

fs->fs_fsize);

sys/ufs/ffs/ffs_vfsops.c

1463

fs->fs_ronly = ronly;

sys/ufs/ffs/ffs_vfsops.c

1465

if (!((fs->fs_flags & FS_DOWAPBL) && (fs->fs_clean & FS_WASCLEAN))) {

sys/ufs/ffs/ffs_vfsops.c

1467

fs->fs_clean =

sys/ufs/ffs/ffs_vfsops.c

1468

fs->fs_clean == FS_ISCLEAN ? FS_WASCLEAN : 0;

sys/ufs/ffs/ffs_vfsops.c

1469

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_vfsops.c

1473

bsize = fs->fs_cssize;

sys/ufs/ffs/ffs_vfsops.c

1474

blks = howmany(bsize, fs->fs_fsize);

sys/ufs/ffs/ffs_vfsops.c

1475

if (fs->fs_contigsumsize > 0)

sys/ufs/ffs/ffs_vfsops.c

1476

bsize += fs->fs_ncg * sizeof(int32_t);

sys/ufs/ffs/ffs_vfsops.c

1477

bsize += fs->fs_ncg * sizeof(*fs->fs_contigdirs);

sys/ufs/ffs/ffs_vfsops.c

1480

fs->fs_csp = space;

sys/ufs/ffs/ffs_vfsops.c

1482

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

sys/ufs/ffs/ffs_vfsops.c

1483

bsize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

1484

if (i + fs->fs_frag > blks)

sys/ufs/ffs/ffs_vfsops.c

1485

bsize = (blks - i) * fs->fs_fsize;

sys/ufs/ffs/ffs_vfsops.c

1486

error = bread(devvp, FFS_FSBTODB(fs, fs->fs_csaddr + i), bsize,

sys/ufs/ffs/ffs_vfsops.c

1490

(intmax_t)FFS_FSBTODB(fs, fs->fs_csaddr + i),

sys/ufs/ffs/ffs_vfsops.c

1506

if (fs->fs_contigsumsize > 0) {

sys/ufs/ffs/ffs_vfsops.c

1507

fs->fs_maxcluster = lp = space;

sys/ufs/ffs/ffs_vfsops.c

1508

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

sys/ufs/ffs/ffs_vfsops.c

1509

*lp++ = fs->fs_contigsumsize;

sys/ufs/ffs/ffs_vfsops.c

1512

bsize = fs->fs_ncg * sizeof(*fs->fs_contigdirs);

sys/ufs/ffs/ffs_vfsops.c

1513

fs->fs_contigdirs = space;

sys/ufs/ffs/ffs_vfsops.c

1515

memset(fs->fs_contigdirs, 0, bsize);

sys/ufs/ffs/ffs_vfsops.c

1518

if (fs->fs_avgfilesize <= 0)

sys/ufs/ffs/ffs_vfsops.c

1519

fs->fs_avgfilesize = AVFILESIZ;

sys/ufs/ffs/ffs_vfsops.c

1520

if (fs->fs_avgfpdir <= 0)

sys/ufs/ffs/ffs_vfsops.c

1521

fs->fs_avgfpdir = AFPDIR;

sys/ufs/ffs/ffs_vfsops.c

1522

fs->fs_active = NULL;

sys/ufs/ffs/ffs_vfsops.c

1539

ump->um_maxsymlinklen = fs->fs_maxsymlinklen;

sys/ufs/ffs/ffs_vfsops.c

1546

mp->mnt_fs_bshift = fs->fs_bshift;

sys/ufs/ffs/ffs_vfsops.c

1555

error = ffs_acls(mp, fs->fs_flags);

sys/ufs/ffs/ffs_vfsops.c

1561

ump->um_nindir = fs->fs_nindir;

sys/ufs/ffs/ffs_vfsops.c

1562

ump->um_lognindir = ffs(fs->fs_nindir) - 1;

sys/ufs/ffs/ffs_vfsops.c

1563

ump->um_bptrtodb = fs->fs_fshift - DEV_BSHIFT;

sys/ufs/ffs/ffs_vfsops.c

1564

ump->um_seqinc = fs->fs_frag;

sys/ufs/ffs/ffs_vfsops.c

1568

if (ronly == 0 && fs->fs_snapinum[0] != 0)

sys/ufs/ffs/ffs_vfsops.c

1572

KDASSERT(fs->fs_ronly == 0);

sys/ufs/ffs/ffs_vfsops.c

1598

if (fs->fs_flags & FS_DOQUOTA2) {

sys/ufs/ffs/ffs_vfsops.c

1613

ump->um_discarddata = ffs_discard_init(devvp, fs);

sys/ufs/ffs/ffs_vfsops.c

1617

kmem_free(fs->fs_csp, allocsbsize);

sys/ufs/ffs/ffs_vfsops.c

1627

if (fs)

sys/ufs/ffs/ffs_vfsops.c

1628

kmem_free(fs, fs->fs_sbsize);

sys/ufs/ffs/ffs_vfsops.c

1650

ffs_oldfscompat_read(struct fs *fs, struct ufsmount *ump, daddr_t sblockloc)

sys/ufs/ffs/ffs_vfsops.c

1655

if ((fs->fs_magic != FS_UFS1_MAGIC) ||

sys/ufs/ffs/ffs_vfsops.c

1656

(fs->fs_old_flags & FS_FLAGS_UPDATED))

sys/ufs/ffs/ffs_vfsops.c

1663

memcpy(ump->um_oldfscompat, &fs->fs_old_postbl_start, 512);

sys/ufs/ffs/ffs_vfsops.c

1666

extrasave[0] = fs->fs_old_npsect;

sys/ufs/ffs/ffs_vfsops.c

1667

extrasave[1] = fs->fs_old_interleave;

sys/ufs/ffs/ffs_vfsops.c

1668

extrasave[2] = fs->fs_old_trackskew;

sys/ufs/ffs/ffs_vfsops.c

1674

fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;

sys/ufs/ffs/ffs_vfsops.c

1675

fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;

sys/ufs/ffs/ffs_vfsops.c

1676

fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;

sys/ufs/ffs/ffs_vfsops.c

1677

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

sys/ufs/ffs/ffs_vfsops.c

1679

fs->fs_maxbsize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

1680

fs->fs_time = fs->fs_old_time;

sys/ufs/ffs/ffs_vfsops.c

1681

fs->fs_size = fs->fs_old_size;

sys/ufs/ffs/ffs_vfsops.c

1682

fs->fs_dsize = fs->fs_old_dsize;

sys/ufs/ffs/ffs_vfsops.c

1683

fs->fs_csaddr = fs->fs_old_csaddr;

sys/ufs/ffs/ffs_vfsops.c

1684

fs->fs_sblockloc = sblockloc;

sys/ufs/ffs/ffs_vfsops.c

1686

fs->fs_flags = fs->fs_old_flags | (fs->fs_flags & FS_INTERNAL);

sys/ufs/ffs/ffs_vfsops.c

1688

if (fs->fs_old_postblformat == FS_42POSTBLFMT) {

sys/ufs/ffs/ffs_vfsops.c

1689

fs->fs_old_nrpos = 8;

sys/ufs/ffs/ffs_vfsops.c

1690

fs->fs_old_npsect = fs->fs_old_nsect;

sys/ufs/ffs/ffs_vfsops.c

1691

fs->fs_old_interleave = 1;

sys/ufs/ffs/ffs_vfsops.c

1692

fs->fs_old_trackskew = 0;

sys/ufs/ffs/ffs_vfsops.c

1695

if (fs->fs_magic == FS_UFS1_MAGIC &&

sys/ufs/ffs/ffs_vfsops.c

1696

fs->fs_old_inodefmt < FS_44INODEFMT) {

sys/ufs/ffs/ffs_vfsops.c

1697

fs->fs_maxfilesize = (u_quad_t) 1LL << 39;

sys/ufs/ffs/ffs_vfsops.c

1698

fs->fs_qbmask = ~fs->fs_bmask;

sys/ufs/ffs/ffs_vfsops.c

1699

fs->fs_qfmask = ~fs->fs_fmask;

sys/ufs/ffs/ffs_vfsops.c

1702

maxfilesize = (u_int64_t)0x80000000 * fs->fs_bsize - 1;

sys/ufs/ffs/ffs_vfsops.c

1703

if (fs->fs_maxfilesize > maxfilesize)

sys/ufs/ffs/ffs_vfsops.c

1704

fs->fs_maxfilesize = maxfilesize;

sys/ufs/ffs/ffs_vfsops.c

1707

if (fs->fs_avgfilesize <= 0)

sys/ufs/ffs/ffs_vfsops.c

1708

fs->fs_avgfilesize = AVFILESIZ;

sys/ufs/ffs/ffs_vfsops.c

1709

if (fs->fs_avgfpdir <= 0)

sys/ufs/ffs/ffs_vfsops.c

1710

fs->fs_avgfpdir = AFPDIR;

sys/ufs/ffs/ffs_vfsops.c

1714

fs->fs_save_cgsize = fs->fs_cgsize;

sys/ufs/ffs/ffs_vfsops.c

1715

fs->fs_cgsize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

1728

ffs_oldfscompat_write(struct fs *fs, struct ufsmount *ump)

sys/ufs/ffs/ffs_vfsops.c

1732

if ((fs->fs_magic != FS_UFS1_MAGIC) ||

sys/ufs/ffs/ffs_vfsops.c

1733

(fs->fs_old_flags & FS_FLAGS_UPDATED))

sys/ufs/ffs/ffs_vfsops.c

1736

fs->fs_old_time = fs->fs_time;

sys/ufs/ffs/ffs_vfsops.c

1737

fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;

sys/ufs/ffs/ffs_vfsops.c

1738

fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;

sys/ufs/ffs/ffs_vfsops.c

1739

fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;

sys/ufs/ffs/ffs_vfsops.c

1740

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

sys/ufs/ffs/ffs_vfsops.c

1741

fs->fs_old_flags = fs->fs_flags;

sys/ufs/ffs/ffs_vfsops.c

1745

fs->fs_cgsize = fs->fs_save_cgsize;

sys/ufs/ffs/ffs_vfsops.c

1749

memcpy(&fs->fs_old_postbl_start, ump->um_oldfscompat, 512);

sys/ufs/ffs/ffs_vfsops.c

1752

fs->fs_old_npsect = extrasave[0];

sys/ufs/ffs/ffs_vfsops.c

1753

fs->fs_old_interleave = extrasave[1];

sys/ufs/ffs/ffs_vfsops.c

1754

fs->fs_old_trackskew = extrasave[2];

sys/ufs/ffs/ffs_vfsops.c

1766

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

1786

if (fs->fs_ronly == 0 && UFS_WAPBL_BEGIN(mp) == 0) {

sys/ufs/ffs/ffs_vfsops.c

1788

fs->fs_clean & FS_WASCLEAN) {

sys/ufs/ffs/ffs_vfsops.c

1790

fs->fs_clean = FS_ISCLEAN;

sys/ufs/ffs/ffs_vfsops.c

1791

fs->fs_fmod = 0;

sys/ufs/ffs/ffs_vfsops.c

1800

KDASSERT(fs->fs_ronly);

sys/ufs/ffs/ffs_vfsops.c

1814

(void)VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD | FWRITE,

sys/ufs/ffs/ffs_vfsops.c

1818

bsize = fs->fs_cssize;

sys/ufs/ffs/ffs_vfsops.c

1819

if (fs->fs_contigsumsize > 0)

sys/ufs/ffs/ffs_vfsops.c

1820

bsize += fs->fs_ncg * sizeof(int32_t);

sys/ufs/ffs/ffs_vfsops.c

1821

bsize += fs->fs_ncg * sizeof(*fs->fs_contigdirs);

sys/ufs/ffs/ffs_vfsops.c

1822

kmem_free(fs->fs_csp, bsize);

sys/ufs/ffs/ffs_vfsops.c

1824

kmem_free(fs, fs->fs_sbsize);

sys/ufs/ffs/ffs_vfsops.c

1903

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

1906

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

1908

sbp->f_bsize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

1909

sbp->f_frsize = fs->fs_fsize;

sys/ufs/ffs/ffs_vfsops.c

1910

sbp->f_iosize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

1911

sbp->f_blocks = fs->fs_dsize;

sys/ufs/ffs/ffs_vfsops.c

1912

sbp->f_bfree = ffs_blkstofrags(fs, fs->fs_cstotal.cs_nbfree) +

sys/ufs/ffs/ffs_vfsops.c

1913

fs->fs_cstotal.cs_nffree + FFS_DBTOFSB(fs, fs->fs_pendingblocks);

sys/ufs/ffs/ffs_vfsops.c

1914

sbp->f_bresvd = ((u_int64_t) fs->fs_dsize * (u_int64_t)

sys/ufs/ffs/ffs_vfsops.c

1915

fs->fs_minfree) / (u_int64_t) 100;

sys/ufs/ffs/ffs_vfsops.c

1920

sbp->f_files = fs->fs_ncg * fs->fs_ipg - UFS_ROOTINO;

sys/ufs/ffs/ffs_vfsops.c

1921

sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;

sys/ufs/ffs/ffs_vfsops.c

195

struct fs *fs = VFSTOUFS(mp)->um_fs;

sys/ufs/ffs/ffs_vfsops.c

197

if (ino < UFS_ROOTINO || ino >= fs->fs_ncg * fs->fs_ipg) {

sys/ufs/ffs/ffs_vfsops.c

1983

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

1988

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

1989

if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */

sys/ufs/ffs/ffs_vfsops.c

1990

panic("%s: rofs mod, fs=%s", __func__, fs->fs_fsmnt);

sys/ufs/ffs/ffs_vfsops.c

2058

if (fs->fs_fmod != 0) {

sys/ufs/ffs/ffs_vfsops.c

2059

fs->fs_fmod = 0;

sys/ufs/ffs/ffs_vfsops.c

206

if (fs->fs_magic != FS_UFS2_MAGIC)

sys/ufs/ffs/ffs_vfsops.c

2060

fs->fs_time = time_second;

sys/ufs/ffs/ffs_vfsops.c

2087

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

2092

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

2095

error = bread(ump->um_devvp, FFS_FSBTODB(fs, ino_to_fsba(fs, ino)),

sys/ufs/ffs/ffs_vfsops.c

2096

(int)fs->fs_bsize, 0, &bp);

sys/ufs/ffs/ffs_vfsops.c

210

int cg = ino_to_cg(fs, ino);

sys/ufs/ffs/ffs_vfsops.c

2104

ip->i_fs = fs;

sys/ufs/ffs/ffs_vfsops.c

2113

ffs_load_inode(bp, ip, fs, ino);

sys/ufs/ffs/ffs_vfsops.c

213

int error = bread(ump->um_devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_vfsops.c

214

(int)fs->fs_cgsize, B_MODIFY, &bp);

sys/ufs/ffs/ffs_vfsops.c

2158

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

2166

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

2191

if (fs->fs_magic == FS_UFS1_MAGIC && /* XXX */

sys/ufs/ffs/ffs_vfsops.c

2192

fs->fs_old_inodefmt < FS_44INODEFMT) { /* XXX */

sys/ufs/ffs/ffs_vfsops.c

221

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_vfsops.c

2211

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

2222

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

2244

__func__, ino, fs->fs_fsmnt, DIP(ip, mode), ip->i_mode,

sys/ufs/ffs/ffs_vfsops.c

2251

__func__, ino, fs->fs_fsmnt, DIP(ip, gen), ip->i_gen,

sys/ufs/ffs/ffs_vfsops.c

2312

if (fs->fs_magic == FS_UFS2_MAGIC) {

sys/ufs/ffs/ffs_vfsops.c

234

if (cg * fs->fs_ipg + initediblk < ino) {

sys/ufs/ffs/ffs_vfsops.c

236

cg, fs->fs_ipg, initediblk, ino);

sys/ufs/ffs/ffs_vfsops.c

2413

struct fs *fs = mp->um_fs;

sys/ufs/ffs/ffs_vfsops.c

2414

struct fs *bfs;

sys/ufs/ffs/ffs_vfsops.c

2419

fs->fs_sblockloc / DEV_BSIZE, FFS_NOBLK,

sys/ufs/ffs/ffs_vfsops.c

2420

fs->fs_sbsize, false, &bp);

sys/ufs/ffs/ffs_vfsops.c

2425

memcpy(bp->b_data, fs, fs->fs_sbsize);

sys/ufs/ffs/ffs_vfsops.c

2428

bfs = (struct fs *)bp->b_data;

sys/ufs/ffs/ffs_vfsops.c

2431

ffs_oldfscompat_write((struct fs *)bp->b_data, mp);

sys/ufs/ffs/ffs_vfsops.c

2451

struct fs *fs = mp->um_fs;

sys/ufs/ffs/ffs_vfsops.c

2460

blks = howmany(fs->fs_cssize, fs->fs_fsize);

sys/ufs/ffs/ffs_vfsops.c

2461

space = fs->fs_csp;

sys/ufs/ffs/ffs_vfsops.c

2462

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

sys/ufs/ffs/ffs_vfsops.c

2463

size = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

2464

if (i + fs->fs_frag > blks)

sys/ufs/ffs/ffs_vfsops.c

2465

size = (blks - i) * fs->fs_fsize;

sys/ufs/ffs/ffs_vfsops.c

2466

error = ffs_getblk(mp->um_devvp, FFS_FSBTODB(fs, fs->fs_csaddr + i),

sys/ufs/ffs/ffs_vfsops.c

355

static void ffs_oldfscompat_read(struct fs *, struct ufsmount *, daddr_t);

sys/ufs/ffs/ffs_vfsops.c

356

static void ffs_oldfscompat_write(struct fs *, struct ufsmount *);

sys/ufs/ffs/ffs_vfsops.c

365

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

391

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

392

memset(fs->fs_fsmnt, 0, sizeof(fs->fs_fsmnt));

sys/ufs/ffs/ffs_vfsops.c

393

(void)copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);

sys/ufs/ffs/ffs_vfsops.c

396

setrootfstime((time_t)fs->fs_time);

sys/ufs/ffs/ffs_vfsops.c

469

struct fs *fs;

sys/ufs/ffs/ffs_vfsops.c

618

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

633

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

634

if (fs->fs_ronly == 0 && (mp->mnt_iflag & IMNT_WANTRDONLY)) {

sys/ufs/ffs/ffs_vfsops.c

652

fs->fs_clean & FS_WASCLEAN) {

sys/ufs/ffs/ffs_vfsops.c

654

fs->fs_flags &= ~FS_DOSOFTDEP;

sys/ufs/ffs/ffs_vfsops.c

655

fs->fs_clean = FS_ISCLEAN;

sys/ufs/ffs/ffs_vfsops.c

672

if (fs->fs_ronly == 0 && (mp->mnt_iflag & IMNT_WANTRDONLY)) {

sys/ufs/ffs/ffs_vfsops.c

676

fs->fs_ronly = 1;

sys/ufs/ffs/ffs_vfsops.c

677

fs->fs_fmod = 0;

sys/ufs/ffs/ffs_vfsops.c

680

error = ffs_acls(mp, fs->fs_flags);

sys/ufs/ffs/ffs_vfsops.c

691

if (fs->fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {

sys/ufs/ffs/ffs_vfsops.c

696

if (fs->fs_flags & FS_DOQUOTA2) {

sys/ufs/ffs/ffs_vfsops.c

706

fs->fs_ronly = 0;

sys/ufs/ffs/ffs_vfsops.c

707

fs->fs_clean =

sys/ufs/ffs/ffs_vfsops.c

708

fs->fs_clean == FS_ISCLEAN ? FS_WASCLEAN : 0;

sys/ufs/ffs/ffs_vfsops.c

709

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_vfsops.c

711

if (fs->fs_flags & FS_DOWAPBL) {

sys/ufs/ffs/ffs_vfsops.c

727

fs->fs_clean = FS_WASCLEAN;

sys/ufs/ffs/ffs_vfsops.c

730

if (fs->fs_snapinum[0] != 0)

sys/ufs/ffs/ffs_vfsops.c

743

if (!fs->fs_ronly) {

sys/ufs/ffs/ffs_vfsops.c

753

ump->um_discarddata = ffs_discard_init(devvp, fs);

sys/ufs/ffs/ffs_vfsops.c

759

(void)strncpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname,

sys/ufs/ffs/ffs_vfsops.c

760

sizeof(fs->fs_fsmnt));

sys/ufs/ffs/ffs_vfsops.c

762

fs->fs_flags &= ~FS_DOSOFTDEP;

sys/ufs/ffs/ffs_vfsops.c

764

if ((fs->fs_ronly && (fs->fs_clean & FS_ISCLEAN) == 0) ||

sys/ufs/ffs/ffs_vfsops.c

765

(!fs->fs_ronly && (fs->fs_clean & FS_WASCLEAN) == 0)) {

sys/ufs/ffs/ffs_vfsops.c

768

fs->fs_clean);

sys/ufs/ffs/ffs_vfsops.c

773

if (fs->fs_fmod != 0) {

sys/ufs/ffs/ffs_vfsops.c

774

KASSERT(!fs->fs_ronly);

sys/ufs/ffs/ffs_vfsops.c

776

if (fs->fs_clean & FS_WASCLEAN)

sys/ufs/ffs/ffs_vfsops.c

777

fs->fs_time = time_second;

sys/ufs/ffs/ffs_vfsops.c

778

fs->fs_fmod = 0;

sys/ufs/ffs/ffs_vfsops.c

819

struct fs *fs, *newfs;

sys/ufs/ffs/ffs_vfsops.c

846

fs = ump->um_fs;

sys/ufs/ffs/ffs_vfsops.c

847

fs_sbsize = fs->fs_sbsize;

sys/ufs/ffs/ffs_vfsops.c

848

error = bread(devvp, fs->fs_sblockloc / DEV_BSIZE, fs_sbsize,

sys/ufs/ffs/ffs_vfsops.c

857

ffs_sb_swap((struct fs *)bp->b_data, newfs);

sys/ufs/ffs/ffs_vfsops.c

889

(newfs->fs_cssize != fs->fs_cssize) ||

sys/ufs/ffs/ffs_vfsops.c

890

(newfs->fs_contigsumsize != fs->fs_contigsumsize) ||

sys/ufs/ffs/ffs_vfsops.c

891

(newfs->fs_ncg != fs->fs_ncg)) {

sys/ufs/ffs/ffs_vfsops.c

897

sblockloc = fs->fs_sblockloc;

sys/ufs/ffs/ffs_vfsops.c

903

newfs->fs_csp = fs->fs_csp;

sys/ufs/ffs/ffs_vfsops.c

904

newfs->fs_maxcluster = fs->fs_maxcluster;

sys/ufs/ffs/ffs_vfsops.c

905

newfs->fs_contigdirs = fs->fs_contigdirs;

sys/ufs/ffs/ffs_vfsops.c

906

newfs->fs_ronly = fs->fs_ronly;

sys/ufs/ffs/ffs_vfsops.c

907

newfs->fs_active = fs->fs_active;

sys/ufs/ffs/ffs_vfsops.c

908

memcpy(fs, newfs, (u_int)fs_sbsize);

sys/ufs/ffs/ffs_vfsops.c

915

if (ffs_is_appleufs(devvp, fs)) {

sys/ufs/ffs/ffs_vfsops.c

930

ump->um_maxsymlinklen = fs->fs_maxsymlinklen;

sys/ufs/ffs/ffs_vfsops.c

937

ffs_oldfscompat_read(fs, ump, sblockloc);

sys/ufs/ffs/ffs_vfsops.c

940

ump->um_maxfilesize = fs->fs_maxfilesize;

sys/ufs/ffs/ffs_vfsops.c

941

if (fs->fs_flags & ~(FS_KNOWN_FLAGS | FS_INTERNAL)) {

sys/ufs/ffs/ffs_vfsops.c

943

mp->mnt_stat.f_mntonname, fs->fs_flags,

sys/ufs/ffs/ffs_vfsops.c

951

if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {

sys/ufs/ffs/ffs_vfsops.c

952

fs->fs_pendingblocks = 0;

sys/ufs/ffs/ffs_vfsops.c

953

fs->fs_pendinginodes = 0;

sys/ufs/ffs/ffs_vfsops.c

961

blks = howmany(fs->fs_cssize, fs->fs_fsize);

sys/ufs/ffs/ffs_vfsops.c

962

space = fs->fs_csp;

sys/ufs/ffs/ffs_vfsops.c

963

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

sys/ufs/ffs/ffs_vfsops.c

964

bsize = fs->fs_bsize;

sys/ufs/ffs/ffs_vfsops.c

965

if (i + fs->fs_frag > blks)

sys/ufs/ffs/ffs_vfsops.c

966

bsize = (blks - i) * fs->fs_fsize;

sys/ufs/ffs/ffs_vfsops.c

967

error = bread(devvp, FFS_FSBTODB(fs, fs->fs_csaddr + i), bsize,

sys/ufs/ffs/ffs_vfsops.c

973

if (UFS_FSNEEDSWAP(fs))

sys/ufs/ffs/ffs_vfsops.c

985

if (fs->fs_contigsumsize > 0) {

sys/ufs/ffs/ffs_vfsops.c

986

lp = fs->fs_maxcluster;

sys/ufs/ffs/ffs_vfsops.c

987

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

sys/ufs/ffs/ffs_vfsops.c

988

*lp++ = fs->fs_contigsumsize;

sys/ufs/ffs/ffs_vnops.c

568

struct fs *fs = ip->i_fs;

sys/ufs/ffs/ffs_vnops.c

571

olbn = ffs_lblkno(fs, ip->i_size);

sys/ufs/ffs/ffs_vnops.c

572

nlbn = ffs_lblkno(fs, size);

sys/ufs/ffs/ffs_vnops.c

574

*eobp = ffs_fragroundup(fs, size);

sys/ufs/ffs/ffs_vnops.c

576

*eobp = ffs_blkroundup(fs, size);

sys/ufs/ffs/ffs_wapbl.c

100

if ((fs->fs_magic == FS_UFS1_MAGIC) &&

sys/ufs/ffs/ffs_wapbl.c

101

((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0))

sys/ufs/ffs/ffs_wapbl.c

176

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_wapbl.c

187

ffs_blkfree(fs, ump->um_devvp,

sys/ufs/ffs/ffs_wapbl.c

188

FFS_DBTOFSB(fs, wd->wd_blkno), wd->wd_len, -1);

sys/ufs/ffs/ffs_wapbl.c

192

if (fs->fs_fmod != 0) {

sys/ufs/ffs/ffs_wapbl.c

193

fs->fs_fmod = 0;

sys/ufs/ffs/ffs_wapbl.c

194

fs->fs_time = time_second;

sys/ufs/ffs/ffs_wapbl.c

207

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_wapbl.c

217

ffs_blkalloc_ump(ump, FFS_DBTOFSB(fs, wd->wd_blkno),

sys/ufs/ffs/ffs_wapbl.c

226

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_wapbl.c

233

if (ffs_superblock_layout(fs) < 2)

sys/ufs/ffs/ffs_wapbl.c

237

if (fs->fs_journallocs[0] == 0 &&

sys/ufs/ffs/ffs_wapbl.c

238

fs->fs_journallocs[1] == 0 &&

sys/ufs/ffs/ffs_wapbl.c

239

fs->fs_journallocs[2] == 0 &&

sys/ufs/ffs/ffs_wapbl.c

240

fs->fs_journallocs[3] == 0) {

sys/ufs/ffs/ffs_wapbl.c

245

switch (fs->fs_journal_location) {

sys/ufs/ffs/ffs_wapbl.c

252

log_ino = fs->fs_journallocs[UFS_WAPBL_INFS_INO];

sys/ufs/ffs/ffs_wapbl.c

261

fs->fs_fsmnt, error);

sys/ufs/ffs/ffs_wapbl.c

269

"%" PRId64 "\n", __func__, fs->fs_fsmnt, log_ino);

sys/ufs/ffs/ffs_wapbl.c

291

fs->fs_fsmnt, fs->fs_journal_location);

sys/ufs/ffs/ffs_wapbl.c

298

fs->fs_journal_version = 0;

sys/ufs/ffs/ffs_wapbl.c

299

fs->fs_journal_location = 0;

sys/ufs/ffs/ffs_wapbl.c

300

fs->fs_journal_flags = 0;

sys/ufs/ffs/ffs_wapbl.c

301

fs->fs_journallocs[0] = 0;

sys/ufs/ffs/ffs_wapbl.c

302

fs->fs_journallocs[1] = 0;

sys/ufs/ffs/ffs_wapbl.c

303

fs->fs_journallocs[2] = 0;

sys/ufs/ffs/ffs_wapbl.c

304

fs->fs_journallocs[3] = 0;

sys/ufs/ffs/ffs_wapbl.c

314

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_wapbl.c

323

if (fs->fs_journal_flags & UFS_WAPBL_FLAGS_CLEAR_LOG) {

sys/ufs/ffs/ffs_wapbl.c

331

KDASSERT(fs->fs_ronly == 0);

sys/ufs/ffs/ffs_wapbl.c

334

if (ffs_superblock_layout(fs) < 2) {

sys/ufs/ffs/ffs_wapbl.c

342

error = wapbl_log_position(mp, fs, devvp, &off,

sys/ufs/ffs/ffs_wapbl.c

371

fs->fs_fsmnt);

sys/ufs/ffs/ffs_wapbl.c

374

if ((fs->fs_flags & FS_DOWAPBL) == 0) {

sys/ufs/ffs/ffs_wapbl.c

375

fs->fs_flags |= FS_DOWAPBL;

sys/ufs/ffs/ffs_wapbl.c

396

fs->fs_fsmnt);

sys/ufs/ffs/ffs_wapbl.c

405

} else if (fs->fs_flags & FS_DOWAPBL) {

sys/ufs/ffs/ffs_wapbl.c

406

fs->fs_fmod = 1;

sys/ufs/ffs/ffs_wapbl.c

407

fs->fs_flags &= ~FS_DOWAPBL;

sys/ufs/ffs/ffs_wapbl.c

417

if ((fs->fs_ronly == 0) && mp->mnt_wapbl_replay) {

sys/ufs/ffs/ffs_wapbl.c

426

KASSERT(fs->fs_ronly == 0);

sys/ufs/ffs/ffs_wapbl.c

439

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_wapbl.c

443

KDASSERT(fs->fs_ronly == 0);

sys/ufs/ffs/ffs_wapbl.c

460

KASSERT(fs->fs_flags & FS_DOWAPBL);

sys/ufs/ffs/ffs_wapbl.c

462

fs->fs_flags &= ~FS_DOWAPBL;

sys/ufs/ffs/ffs_wapbl.c

470

fs->fs_flags |= FS_DOWAPBL;

sys/ufs/ffs/ffs_wapbl.c

473

fs->fs_flags &= ~FS_DOWAPBL; /* Repeat in case of forced error */

sys/ufs/ffs/ffs_wapbl.c

477

printf("%s: %s: disabled logging\n", __func__, fs->fs_fsmnt);

sys/ufs/ffs/ffs_wapbl.c

485

ffs_wapbl_replay_start(struct mount *mp, struct fs *fs, struct vnode *devvp)

sys/ufs/ffs/ffs_wapbl.c

497

if (ffs_superblock_layout(fs) < 2)

sys/ufs/ffs/ffs_wapbl.c

500

error = wapbl_log_position(mp, fs, devvp, &off, &count, &blksize,

sys/ufs/ffs/ffs_wapbl.c

540

wapbl_log_position(struct mount *mp, struct fs *fs, struct vnode *devvp,

sys/ufs/ffs/ffs_wapbl.c

549

if (fs->fs_journal_version == UFS_WAPBL_VERSION) {

sys/ufs/ffs/ffs_wapbl.c

550

switch (fs->fs_journal_location) {

sys/ufs/ffs/ffs_wapbl.c

553

*startp = fs->fs_journallocs[UFS_WAPBL_EPART_ADDR];

sys/ufs/ffs/ffs_wapbl.c

554

*countp = fs->fs_journallocs[UFS_WAPBL_EPART_COUNT];

sys/ufs/ffs/ffs_wapbl.c

555

*blksizep = fs->fs_journallocs[UFS_WAPBL_EPART_BLKSZ];

sys/ufs/ffs/ffs_wapbl.c

562

*startp = fs->fs_journallocs[UFS_WAPBL_INFS_ADDR];

sys/ufs/ffs/ffs_wapbl.c

563

*countp = fs->fs_journallocs[UFS_WAPBL_INFS_COUNT];

sys/ufs/ffs/ffs_wapbl.c

564

*blksizep = fs->fs_journallocs[UFS_WAPBL_INFS_BLKSZ];

sys/ufs/ffs/ffs_wapbl.c

571

fs->fs_fsmnt, fs->fs_journal_location);

sys/ufs/ffs/ffs_wapbl.c

577

ffs_lfragtosize(fs, fs->fs_size) / UFS_WAPBL_JOURNAL_SCALE;

sys/ufs/ffs/ffs_wapbl.c

585

logstart = FFS_FSBTODB(fs, fs->fs_size);

sys/ufs/ffs/ffs_wapbl.c

606

fs->fs_journallocs[UFS_WAPBL_EPART_ADDR] = *startp;

sys/ufs/ffs/ffs_wapbl.c

607

fs->fs_journallocs[UFS_WAPBL_EPART_COUNT] = *countp;

sys/ufs/ffs/ffs_wapbl.c

608

fs->fs_journallocs[UFS_WAPBL_EPART_BLKSZ] = *blksizep;

sys/ufs/ffs/ffs_wapbl.c

609

fs->fs_journallocs[UFS_WAPBL_EPART_UNUSED] = *extradatap;

sys/ufs/ffs/ffs_wapbl.c

617

error = wapbl_create_infs_log(mp, fs, devvp,

sys/ufs/ffs/ffs_wapbl.c

625

fs->fs_journallocs[UFS_WAPBL_INFS_ADDR] = *startp;

sys/ufs/ffs/ffs_wapbl.c

626

fs->fs_journallocs[UFS_WAPBL_INFS_COUNT] = *countp;

sys/ufs/ffs/ffs_wapbl.c

627

fs->fs_journallocs[UFS_WAPBL_INFS_BLKSZ] = *blksizep;

sys/ufs/ffs/ffs_wapbl.c

628

fs->fs_journallocs[UFS_WAPBL_INFS_INO] = *extradatap;

sys/ufs/ffs/ffs_wapbl.c

633

fs->fs_journal_version = UFS_WAPBL_VERSION;

sys/ufs/ffs/ffs_wapbl.c

634

fs->fs_journal_location = location;

sys/ufs/ffs/ffs_wapbl.c

635

fs->fs_journal_flags = 0;

sys/ufs/ffs/ffs_wapbl.c

647

wapbl_create_infs_log(struct mount *mp, struct fs *fs, struct vnode *devvp,

sys/ufs/ffs/ffs_wapbl.c

709

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_wapbl.c

717

if (fs->fs_journal_flags & UFS_WAPBL_FLAGS_CREATE_LOG &&

sys/ufs/ffs/ffs_wapbl.c

718

fs->fs_journal_location == UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM)

sys/ufs/ffs/ffs_wapbl.c

719

logsize = fs->fs_journallocs[UFS_WAPBL_INFS_COUNT];

sys/ufs/ffs/ffs_wapbl.c

723

fs->fs_fsmnt, vp->v_size);

sys/ufs/ffs/ffs_wapbl.c

729

"%" PRId64 "MB\n", __func__, fs->fs_fsmnt,

sys/ufs/ffs/ffs_wapbl.c

730

ffs_lblktosize(fs, size) / (1024 * 1024));

sys/ufs/ffs/ffs_wapbl.c

734

logsize = ffs_lblktosize(fs, size); /* final log size */

sys/ufs/ffs/ffs_wapbl.c

741

printf("%s: %s: GOP_ALLOC error %d\n", __func__, fs->fs_fsmnt,

sys/ufs/ffs/ffs_wapbl.c

746

*startp = FFS_FSBTODB(fs, addr);

sys/ufs/ffs/ffs_wapbl.c

773

struct fs *fs = ump->um_fs;

sys/ufs/ffs/ffs_wapbl.c

78

static int ffs_superblock_layout(struct fs *);

sys/ufs/ffs/ffs_wapbl.c

782

const int needswap = UFS_FSNEEDSWAP(fs);

sys/ufs/ffs/ffs_wapbl.c

786

logsize = ffs_lfragtosize(fs, fs->fs_dsize) /

sys/ufs/ffs/ffs_wapbl.c

79

static int wapbl_log_position(struct mount *, struct fs *, struct vnode *,

sys/ufs/ffs/ffs_wapbl.c

797

desired_blks = logsize / fs->fs_bsize;

sys/ufs/ffs/ffs_wapbl.c

809

__func__, fs->fs_fsmnt, error);

sys/ufs/ffs/ffs_wapbl.c

81

static int wapbl_create_infs_log(struct mount *, struct fs *, struct vnode *,

sys/ufs/ffs/ffs_wapbl.c

824

"ufs_getlbns\n", __func__, fs->fs_fsmnt, num);

sys/ufs/ffs/ffs_wapbl.c

842

bpcg = ffs_fragstoblks(fs, fs->fs_fpg);

sys/ufs/ffs/ffs_wapbl.c

845

" is not big enough for journal\n", __func__, fs->fs_fsmnt,

sys/ufs/ffs/ffs_wapbl.c

846

ffs_lblktosize(fs, bpcg) / (1024 * 1024));

sys/ufs/ffs/ffs_wapbl.c

864

for (cg = fs->fs_ncg / 2, s = 0, n = 1;

sys/ufs/ffs/ffs_wapbl.c

865

best_blks < desired_blks && cg >= 0 && cg < fs->fs_ncg;

sys/ufs/ffs/ffs_wapbl.c

867

DPRINTF("check cg %d of %d\n", cg, fs->fs_ncg);

sys/ufs/ffs/ffs_wapbl.c

868

error = bread(devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),

sys/ufs/ffs/ffs_wapbl.c

869

fs->fs_cgsize, 0, &bp);

sys/ufs/ffs/ffs_wapbl.c

874

if (!cg_chkmagic(cgp, UFS_FSNEEDSWAP(fs))) {

sys/ufs/ffs/ffs_wapbl.c

885

if (ffs_isblock(fs, blksfree, blkno))

sys/ufs/ffs/ffs_wapbl.c

895

if (!ffs_isblock(fs, blksfree, blkno))

sys/ufs/ffs/ffs_wapbl.c

900

best_addr = ffs_blkstofrags(fs, start_addr) +

sys/ufs/ffs/ffs_wapbl.c

901

cgbase(fs, cg);

sys/ufs/ffs/ffs_wapbl.c

921

*addr = best_addr + ffs_blkstofrags(fs, indir_blks);

sys/ufs/ffs/ffs_wapbl.c

98

ffs_superblock_layout(struct fs *fs)

sys/ufs/ffs/fs.h

387

((fs_)->fs_old_postbloff == offsetof(struct fs, fs_old_postbl_start))) \

sys/ufs/ffs/fs.h

391

#define old_fs_rotbl(fs) \

sys/ufs/ffs/fs.h

392

(((fs)->fs_old_postblformat == FS_42POSTBLFMT) \

sys/ufs/ffs/fs.h

393

? ((uint8_t *)(&(fs)->fs_magic+1)) \

sys/ufs/ffs/fs.h

394

: ((uint8_t *)((uint8_t *)(fs) + (fs)->fs_old_rotbloff)))

sys/ufs/ffs/fs.h

460

#define ACTIVECG_SET(fs, cg) \

sys/ufs/ffs/fs.h

462

if ((fs)->fs_active != NULL) \

sys/ufs/ffs/fs.h

463

setbit((fs)->fs_active, (cg)); \

sys/ufs/ffs/fs.h

465

#define ACTIVECG_CLR(fs, cg) \

sys/ufs/ffs/fs.h

467

if ((fs)->fs_active != NULL) \

sys/ufs/ffs/fs.h

468

clrbit((fs)->fs_active, (cg)); \

sys/ufs/ffs/fs.h

470

#define ACTIVECG_ISSET(fs, cg) \

sys/ufs/ffs/fs.h

471

((fs)->fs_active != NULL && isset((fs)->fs_active, (cg)))

sys/ufs/ffs/fs.h

479

#define CGSIZE_IF(fs, ipg, fpg) \

sys/ufs/ffs/fs.h

481

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

sys/ufs/ffs/fs.h

482

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

sys/ufs/ffs/fs.h

485

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

sys/ufs/ffs/fs.h

486

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

sys/ufs/ffs/fs.h

487

/* cluster map */ howmany(ffs_fragstoblks(fs, (fpg)), NBBY)))

sys/ufs/ffs/fs.h

489

#define CGSIZE(fs) CGSIZE_IF((fs), (fs)->fs_ipg, (fs)->fs_fpg)

sys/ufs/ffs/fs.h

500

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

sys/ufs/ffs/fs.h

567

#define old_cg_blks_old(fs, cgp, cylno, ns) \

sys/ufs/ffs/fs.h

573

#define old_cg_blks_new(fs, cgp, cylno, ns) \

sys/ufs/ffs/fs.h

575

ufs_rw32((cgp)->cg_old_boff, (ns))) + (cylno) * (fs)->fs_old_nrpos)

sys/ufs/ffs/fs.h

580

#define old_cg_blks(fs, cgp, cylno, ns) \

sys/ufs/ffs/fs.h

582

old_cg_blks_old(fs, cgp, cylno, ns) : old_cg_blks_new(fs, cgp, cylno, ns))

sys/ufs/ffs/fs.h

622

#define FFS_FSBTODB(fs, b) ((b) << ((fs)->fs_fshift - DEV_BSHIFT))

sys/ufs/ffs/fs.h

623

#define FFS_DBTOFSB(fs, b) ((b) >> ((fs)->fs_fshift - DEV_BSHIFT))

sys/ufs/ffs/fs.h

625

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

sys/ufs/ffs/fs.h

626

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

sys/ufs/ffs/fs.h

633

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

sys/ufs/ffs/fs.h

634

#define cgstart_ufs1(fs, c) \

sys/ufs/ffs/fs.h

635

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

sys/ufs/ffs/fs.h

636

#define cgstart_ufs2(fs, c) cgbase((fs), (c))

sys/ufs/ffs/fs.h

637

#define cgstart(fs, c) ((fs)->fs_magic == FS_UFS2_MAGIC \

sys/ufs/ffs/fs.h

638

? cgstart_ufs2((fs), (c)) : cgstart_ufs1((fs), (c)))

sys/ufs/ffs/fs.h

639

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

sys/ufs/ffs/fs.h

640

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

sys/ufs/ffs/fs.h

641

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

sys/ufs/ffs/fs.h

642

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

sys/ufs/ffs/fs.h

650

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

sys/ufs/ffs/fs.h

651

#define ino_to_fsba(fs, x) \

sys/ufs/ffs/fs.h

652

((daddr_t)(cgimin(fs, ino_to_cg(fs, (ino_t)(x))) + \

sys/ufs/ffs/fs.h

653

(ffs_blkstofrags((fs), ((((ino_t)(x)) % (fs)->fs_ipg) / FFS_INOPB(fs))))))

sys/ufs/ffs/fs.h

654

#define ino_to_fsbo(fs, x) (((ino_t)(x)) % FFS_INOPB(fs))

sys/ufs/ffs/fs.h

660

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

sys/ufs/ffs/fs.h

661

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

sys/ufs/ffs/fs.h

667

#define blkmap(fs, map, loc) \

sys/ufs/ffs/fs.h

668

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

sys/ufs/ffs/fs.h

669

#define old_cbtocylno(fs, bno) \

sys/ufs/ffs/fs.h

670

(FFS_FSBTODB(fs, bno) / (fs)->fs_old_spc)

sys/ufs/ffs/fs.h

671

#define old_cbtorpos(fs, bno) \

sys/ufs/ffs/fs.h

672

((fs)->fs_old_nrpos <= 1 ? 0 : \

sys/ufs/ffs/fs.h

673

(FFS_FSBTODB(fs, bno) % (fs)->fs_old_spc / (fs)->fs_old_nsect * (fs)->fs_old_trackskew + \

sys/ufs/ffs/fs.h

674

FFS_FSBTODB(fs, bno) % (fs)->fs_old_spc % (fs)->fs_old_nsect * (fs)->fs_old_interleave) % \

sys/ufs/ffs/fs.h

675

(fs)->fs_old_nsect * (fs)->fs_old_nrpos / (fs)->fs_old_npsect)

sys/ufs/ffs/fs.h

682

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

sys/ufs/ffs/fs.h

683

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

sys/ufs/ffs/fs.h

684

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

sys/ufs/ffs/fs.h

685

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

sys/ufs/ffs/fs.h

686

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

sys/ufs/ffs/fs.h

687

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

sys/ufs/ffs/fs.h

688

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

sys/ufs/ffs/fs.h

689

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

sys/ufs/ffs/fs.h

690

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

sys/ufs/ffs/fs.h

691

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

sys/ufs/ffs/fs.h

692

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

sys/ufs/ffs/fs.h

693

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

sys/ufs/ffs/fs.h

694

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

sys/ufs/ffs/fs.h

695

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

sys/ufs/ffs/fs.h

696

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

sys/ufs/ffs/fs.h

697

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

sys/ufs/ffs/fs.h

698

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

sys/ufs/ffs/fs.h

699

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

sys/ufs/ffs/fs.h

700

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

sys/ufs/ffs/fs.h

701

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

sys/ufs/ffs/fs.h

702

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

sys/ufs/ffs/fs.h

703

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

sys/ufs/ffs/fs.h

704

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

sys/ufs/ffs/fs.h

705

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

sys/ufs/ffs/fs.h

706

#define ffs_getdb(fs, ip, lb) \

sys/ufs/ffs/fs.h

707

((fs)->fs_magic == FS_UFS2_MAGIC ? \

sys/ufs/ffs/fs.h

708

(daddr_t)ufs_rw64((ip)->i_ffs2_db[lb], UFS_FSNEEDSWAP(fs)) : \

sys/ufs/ffs/fs.h

709

(daddr_t)ufs_rw32((ip)->i_ffs1_db[lb], UFS_FSNEEDSWAP(fs)))

sys/ufs/ffs/fs.h

710

#define ffs_getib(fs, ip, lb) \

sys/ufs/ffs/fs.h

711

((fs)->fs_magic == FS_UFS2_MAGIC ? \

sys/ufs/ffs/fs.h

712

(daddr_t)ufs_rw64((ip)->i_ffs2_ib[lb], UFS_FSNEEDSWAP(fs)) : \

sys/ufs/ffs/fs.h

713

(daddr_t)ufs_rw32((ip)->i_ffs1_ib[lb], UFS_FSNEEDSWAP(fs)))

sys/ufs/ffs/fs.h

719

#define freespace(fs, percentreserved) \

sys/ufs/ffs/fs.h

720

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

sys/ufs/ffs/fs.h

721

(fs)->fs_cstotal.cs_nffree - \

sys/ufs/ffs/fs.h

722

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

sys/ufs/ffs/fs.h

727

#define ffs_blksize(fs, ip, lbn) \

sys/ufs/ffs/fs.h

728

(((lbn) >= UFS_NDADDR || (ip)->i_size >= ffs_lblktosize(fs, (lbn) + 1)) \

sys/ufs/ffs/fs.h

729

? (fs)->fs_bsize \

sys/ufs/ffs/fs.h

730

: ((int32_t)ffs_fragroundup(fs, ffs_blkoff(fs, (ip)->i_size))))

sys/ufs/ffs/fs.h

732

#define ffs_sblksize(fs, size, lbn) \

sys/ufs/ffs/fs.h

733

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

sys/ufs/ffs/fs.h

734

? (fs)->fs_bsize \

sys/ufs/ffs/fs.h

735

: ((int32_t)ffs_fragroundup(fs, ffs_blkoff(fs, (uint64_t)(size)))))

sys/ufs/ffs/fs.h

741

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

sys/ufs/ffs/fs.h

742

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

sys/ufs/ffs/fs.h

747

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

sys/ufs/lfs/lfs.h

1166

struct lfs *fs; /* The filesystem */

sys/ufs/lfs/lfs.h

1175

struct lfs *fs; /* The file system */

sys/ufs/lfs/lfs.h

1231

struct lfs *fs; /* file system pointer */

sys/ufs/lfs/lfs.h

1485

# define ASSERT_SEGLOCK(fs) KASSERT(LFS_SEGLOCK_HELD(fs))

sys/ufs/lfs/lfs.h

1486

# define ASSERT_NO_SEGLOCK(fs) KASSERT(!LFS_SEGLOCK_HELD(fs))

sys/ufs/lfs/lfs.h

1487

# define ASSERT_DUNNO_SEGLOCK(fs)

sys/ufs/lfs/lfs.h

1488

# define ASSERT_MAYBE_SEGLOCK(fs)

sys/ufs/lfs/lfs.h

1490

# define ASSERT_DUNNO_SEGLOCK(fs) \

sys/ufs/lfs/lfs.h

1492

LFS_SEGLOCK_HELD(fs)))

sys/ufs/lfs/lfs.h

1493

# define ASSERT_SEGLOCK(fs) do { \

sys/ufs/lfs/lfs.h

1494

if (!LFS_SEGLOCK_HELD(fs)) { \

sys/ufs/lfs/lfs.h

1498

# define ASSERT_NO_SEGLOCK(fs) do { \

sys/ufs/lfs/lfs.h

1499

if (LFS_SEGLOCK_HELD(fs)) { \

sys/ufs/lfs/lfs.h

636

#define LFS_ORPHAN_NEXTFREE(fs) \

sys/ufs/lfs/lfs.h

637

((fs)->lfs_is64 ? ~(uint64_t)0 : ~(uint32_t)0)

sys/ufs/lfs/lfs.h

639

#define INUM_IS_BAD(fs, ino) \

sys/ufs/lfs/lfs.h

640

(ino == LFS_UNUSED_INUM || ino == LFS_ORPHAN_NEXTFREE(fs))

sys/ufs/lfs/lfs_accessors.h

1046

#define SEGSUM_SIZE(fs) \

sys/ufs/lfs/lfs_accessors.h

1047

(fs->lfs_is64 ? sizeof(SEGSUM64) : \

sys/ufs/lfs/lfs_accessors.h

1048

lfs_sb_getversion(fs) > 1 ? sizeof(SEGSUM32) : sizeof(SEGSUM_V1))

sys/ufs/lfs/lfs_accessors.h

1058

segsum_finfobase(STRUCT_LFS *fs, SEGSUM *ssp)

sys/ufs/lfs/lfs_accessors.h

1060

return (FINFO *)((char *)ssp + SEGSUM_SIZE(fs));

sys/ufs/lfs/lfs_accessors.h

1063

#define SEGSUM_FINFOBASE(fs, ssp) \

sys/ufs/lfs/lfs_accessors.h

1064

((FINFO *)((char *)(ssp) + SEGSUM_SIZE(fs)));

sys/ufs/lfs/lfs_accessors.h

1069

lfs_ss_get##field(STRUCT_LFS *fs, SEGSUM *ssp) \

sys/ufs/lfs/lfs_accessors.h

1071

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

1078

lfs_ss_set##field(STRUCT_LFS *fs, SEGSUM *ssp, type val) \

sys/ufs/lfs/lfs_accessors.h

1080

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

1104

lfs_ss_getsumstart(STRUCT_LFS *fs)

sys/ufs/lfs/lfs_accessors.h

1107

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1121

lfs_ss_getocreate(STRUCT_LFS *fs, SEGSUM *ssp)

sys/ufs/lfs/lfs_accessors.h

1123

KASSERT(fs->lfs_is64 == 0);

sys/ufs/lfs/lfs_accessors.h

1131

lfs_ss_setocreate(STRUCT_LFS *fs, SEGSUM *ssp, uint32_t val)

sys/ufs/lfs/lfs_accessors.h

1133

KASSERT(fs->lfs_is64 == 0);

sys/ufs/lfs/lfs_accessors.h

1151

lfs_sb_get##field(STRUCT_LFS *fs) \

sys/ufs/lfs/lfs_accessors.h

1153

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

1154

return fs->lfs_dlfs_u.u_64.dlfs_##field; \

sys/ufs/lfs/lfs_accessors.h

1156

return fs->lfs_dlfs_u.u_32.dlfs_##field; \

sys/ufs/lfs/lfs_accessors.h

1160

lfs_sb_set##field(STRUCT_LFS *fs, type val) \

sys/ufs/lfs/lfs_accessors.h

1162

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

1163

fs->lfs_dlfs_u.u_64.dlfs_##field = val; \

sys/ufs/lfs/lfs_accessors.h

1165

fs->lfs_dlfs_u.u_32.dlfs_##field = val; \

sys/ufs/lfs/lfs_accessors.h

1169

lfs_sb_add##field(STRUCT_LFS *fs, type val) \

sys/ufs/lfs/lfs_accessors.h

1171

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

1172

type *p64 = &fs->lfs_dlfs_u.u_64.dlfs_##field; \

sys/ufs/lfs/lfs_accessors.h

1175

type32 *p32 = &fs->lfs_dlfs_u.u_32.dlfs_##field; \

sys/ufs/lfs/lfs_accessors.h

1180

lfs_sb_sub##field(STRUCT_LFS *fs, type val) \

sys/ufs/lfs/lfs_accessors.h

1182

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

1183

type *p64 = &fs->lfs_dlfs_u.u_64.dlfs_##field; \

sys/ufs/lfs/lfs_accessors.h

1186

type32 *p32 = &fs->lfs_dlfs_u.u_32.dlfs_##field; \

sys/ufs/lfs/lfs_accessors.h

1195

lfs_sb_get##field(STRUCT_LFS *fs) \

sys/ufs/lfs/lfs_accessors.h

1197

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

1200

return fs->lfs_dlfs_u.u_32.dlfs_##field; \

sys/ufs/lfs/lfs_accessors.h

1267

#define lfs_sb_getotstamp(fs) lfs_sb_getinopf(fs)

sys/ufs/lfs/lfs_accessors.h

1268

#define lfs_sb_setotstamp(fs, val) lfs_sb_setinopf(fs, val)

sys/ufs/lfs/lfs_accessors.h

1274

lfs_sb_getsboff(STRUCT_LFS *fs, unsigned n)

sys/ufs/lfs/lfs_accessors.h

1279

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1280

return fs->lfs_dlfs_u.u_64.dlfs_sboffs[n];

sys/ufs/lfs/lfs_accessors.h

1282

return fs->lfs_dlfs_u.u_32.dlfs_sboffs[n];

sys/ufs/lfs/lfs_accessors.h

1286

lfs_sb_setsboff(STRUCT_LFS *fs, unsigned n, int32_t val)

sys/ufs/lfs/lfs_accessors.h

1291

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1292

fs->lfs_dlfs_u.u_64.dlfs_sboffs[n] = val;

sys/ufs/lfs/lfs_accessors.h

1294

fs->lfs_dlfs_u.u_32.dlfs_sboffs[n] = val;

sys/ufs/lfs/lfs_accessors.h

1302

lfs_sb_getfsmnt(STRUCT_LFS *fs)

sys/ufs/lfs/lfs_accessors.h

1304

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1305

return (const char *)fs->lfs_dlfs_u.u_64.dlfs_fsmnt;

sys/ufs/lfs/lfs_accessors.h

1307

return (const char *)fs->lfs_dlfs_u.u_32.dlfs_fsmnt;

sys/ufs/lfs/lfs_accessors.h

1312

lfs_sb_setfsmnt(STRUCT_LFS *fs, const char *str)

sys/ufs/lfs/lfs_accessors.h

1314

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1315

(void)strncpy((char *)fs->lfs_dlfs_u.u_64.dlfs_fsmnt, str,

sys/ufs/lfs/lfs_accessors.h

1316

sizeof(fs->lfs_dlfs_u.u_64.dlfs_fsmnt));

sys/ufs/lfs/lfs_accessors.h

1318

(void)strncpy((char *)fs->lfs_dlfs_u.u_32.dlfs_fsmnt, str,

sys/ufs/lfs/lfs_accessors.h

1319

sizeof(fs->lfs_dlfs_u.u_32.dlfs_fsmnt));

sys/ufs/lfs/lfs_accessors.h

1324

#define LFS_MAX_DADDR(fs) \

sys/ufs/lfs/lfs_accessors.h

1325

((fs)->lfs_is64 ? 0x7fffffffffffffff : 0x7fffffff)

sys/ufs/lfs/lfs_accessors.h

1328

#define LFS_NINDIR(fs) (lfs_sb_getnindir(fs))

sys/ufs/lfs/lfs_accessors.h

1331

#define LFS_INOPB(fs) (lfs_sb_getinopb(fs))

sys/ufs/lfs/lfs_accessors.h

1333

#define LFS_INOPF(fs) (lfs_sb_getinopf(fs))

sys/ufs/lfs/lfs_accessors.h

1335

#define lfs_blkoff(fs, loc) ((int)((loc) & lfs_sb_getbmask(fs)))

sys/ufs/lfs/lfs_accessors.h

1336

#define lfs_fragoff(fs, loc) /* calculates (loc % fs->lfs_fsize) */ \

sys/ufs/lfs/lfs_accessors.h

1337

((int)((loc) & lfs_sb_getffmask(fs)))

sys/ufs/lfs/lfs_accessors.h

1342

LFS_FSBTODB(STRUCT_LFS *fs, uint64_t b)

sys/ufs/lfs/lfs_accessors.h

1345

return b << (lfs_sb_getffshift(fs) - DEV_BSHIFT);

sys/ufs/lfs/lfs_accessors.h

1347

return b << lfs_sb_getfsbtodb(fs);

sys/ufs/lfs/lfs_accessors.h

1352

LFS_DBTOFSB(STRUCT_LFS *fs, uint64_t b)

sys/ufs/lfs/lfs_accessors.h

1355

return b >> (lfs_sb_getffshift(fs) - DEV_BSHIFT);

sys/ufs/lfs/lfs_accessors.h

1357

return b >> lfs_sb_getfsbtodb(fs);

sys/ufs/lfs/lfs_accessors.h

1361

#define lfs_lblkno(fs, loc) ((loc) >> lfs_sb_getbshift(fs))

sys/ufs/lfs/lfs_accessors.h

1362

#define lfs_lblktosize(fs, blk) ((blk) << lfs_sb_getbshift(fs))

sys/ufs/lfs/lfs_accessors.h

1366

lfs_fsbtob(STRUCT_LFS *fs, uint64_t b)

sys/ufs/lfs/lfs_accessors.h

1368

return b << lfs_sb_getffshift(fs);

sys/ufs/lfs/lfs_accessors.h

1372

lfs_btofsb(STRUCT_LFS *fs, uint64_t b)

sys/ufs/lfs/lfs_accessors.h

1374

return b >> lfs_sb_getffshift(fs);

sys/ufs/lfs/lfs_accessors.h

1377

#define lfs_numfrags(fs, loc) /* calculates (loc / fs->lfs_fsize) */ \

sys/ufs/lfs/lfs_accessors.h

1378

((loc) >> lfs_sb_getffshift(fs))

sys/ufs/lfs/lfs_accessors.h

1379

#define lfs_blkroundup(fs, size)/* calculates roundup(size, lfs_sb_getbsize(fs)) */ \

sys/ufs/lfs/lfs_accessors.h

1380

((off_t)(((size) + lfs_sb_getbmask(fs)) & (~lfs_sb_getbmask(fs))))

sys/ufs/lfs/lfs_accessors.h

1381

#define lfs_fragroundup(fs, size)/* calculates roundup(size, fs->lfs_fsize) */ \

sys/ufs/lfs/lfs_accessors.h

1382

((off_t)(((size) + lfs_sb_getffmask(fs)) & (~lfs_sb_getffmask(fs))))

sys/ufs/lfs/lfs_accessors.h

1383

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

sys/ufs/lfs/lfs_accessors.h

1384

((frags) >> lfs_sb_getfbshift(fs))

sys/ufs/lfs/lfs_accessors.h

1385

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

sys/ufs/lfs/lfs_accessors.h

1386

((blks) << lfs_sb_getfbshift(fs))

sys/ufs/lfs/lfs_accessors.h

1387

#define lfs_fragnum(fs, fsb) /* calculates (fsb % fs->lfs_frag) */ \

sys/ufs/lfs/lfs_accessors.h

1388

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

sys/ufs/lfs/lfs_accessors.h

1389

#define lfs_blknum(fs, fsb) /* calculates rounddown(fsb, fs->lfs_frag) */ \

sys/ufs/lfs/lfs_accessors.h

1390

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

sys/ufs/lfs/lfs_accessors.h

1391

#define lfs_dblksize(fs, dp, lbn) \

sys/ufs/lfs/lfs_accessors.h

1392

(((lbn) >= ULFS_NDADDR || lfs_dino_getsize(fs, dp) >= ((lbn) + 1) << lfs_sb_getbshift(fs)) \

sys/ufs/lfs/lfs_accessors.h

1393

? lfs_sb_getbsize(fs) \

sys/ufs/lfs/lfs_accessors.h

1394

: (lfs_fragroundup(fs, lfs_blkoff(fs, lfs_dino_getsize(fs, dp)))))

sys/ufs/lfs/lfs_accessors.h

1396

#define lfs_segsize(fs) (lfs_sb_getversion(fs) == 1 ? \

sys/ufs/lfs/lfs_accessors.h

1397

lfs_lblktosize((fs), lfs_sb_getssize(fs)) : \

sys/ufs/lfs/lfs_accessors.h

1398

lfs_sb_getssize(fs))

sys/ufs/lfs/lfs_accessors.h

1400

#define lfs_segtod(fs, seg) (lfs_btofsb(fs, lfs_segsize(fs)) * (seg))

sys/ufs/lfs/lfs_accessors.h

1401

#define lfs_dtosn(fs, daddr) /* block address to segment number */ \

sys/ufs/lfs/lfs_accessors.h

1402

((uint32_t)(((daddr) - lfs_sb_gets0addr(fs)) / lfs_segtod((fs), 1)))

sys/ufs/lfs/lfs_accessors.h

1403

#define lfs_sntod(fs, sn) /* segment number to disk address */ \

sys/ufs/lfs/lfs_accessors.h

1404

((daddr_t)(lfs_segtod((fs), (sn)) + lfs_sb_gets0addr(fs)))

sys/ufs/lfs/lfs_accessors.h

1409

lfs_blksize(STRUCT_LFS *fs, struct inode *ip, uint64_t lbn)

sys/ufs/lfs/lfs_accessors.h

1411

if (lbn >= ULFS_NDADDR || lfs_dino_getsize(fs, ip->i_din) >= (lbn + 1) << lfs_sb_getbshift(fs)) {

sys/ufs/lfs/lfs_accessors.h

1412

return lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_accessors.h

1414

return lfs_fragroundup(fs, lfs_blkoff(fs, lfs_dino_getsize(fs, ip->i_din)));

sys/ufs/lfs/lfs_accessors.h

1424

lfs_blocks_fromvoid(STRUCT_LFS *fs, union lfs_blocks *bp, void *p)

sys/ufs/lfs/lfs_accessors.h

1426

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1434

lfs_blocks_fromfinfo(STRUCT_LFS *fs, union lfs_blocks *bp, FINFO *fip)

sys/ufs/lfs/lfs_accessors.h

1438

firstblock = (char *)fip + FINFOSIZE(fs);

sys/ufs/lfs/lfs_accessors.h

1439

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1447

lfs_blocks_get(STRUCT_LFS *fs, union lfs_blocks *bp, unsigned idx)

sys/ufs/lfs/lfs_accessors.h

1449

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1457

lfs_blocks_set(STRUCT_LFS *fs, union lfs_blocks *bp, unsigned idx, daddr_t val)

sys/ufs/lfs/lfs_accessors.h

1459

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1467

lfs_blocks_inc(STRUCT_LFS *fs, union lfs_blocks *bp)

sys/ufs/lfs/lfs_accessors.h

1469

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1477

lfs_blocks_eq(STRUCT_LFS *fs, union lfs_blocks *bp1, union lfs_blocks *bp2)

sys/ufs/lfs/lfs_accessors.h

1479

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

1487

lfs_blocks_sub(STRUCT_LFS *fs, union lfs_blocks *bp1, union lfs_blocks *bp2)

sys/ufs/lfs/lfs_accessors.h

1490

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

188

#define LFS_SWAP_int16_t(fs, val) (val)

sys/ufs/lfs/lfs_accessors.h

189

#define LFS_SWAP_int32_t(fs, val) (val)

sys/ufs/lfs/lfs_accessors.h

190

#define LFS_SWAP_int64_t(fs, val) (val)

sys/ufs/lfs/lfs_accessors.h

191

#define LFS_SWAP_uint16_t(fs, val) (val)

sys/ufs/lfs/lfs_accessors.h

192

#define LFS_SWAP_uint32_t(fs, val) (val)

sys/ufs/lfs/lfs_accessors.h

193

#define LFS_SWAP_uint64_t(fs, val) (val)

sys/ufs/lfs/lfs_accessors.h

195

#define LFS_SWAP_int16_t(fs, val) \

sys/ufs/lfs/lfs_accessors.h

196

((fs)->lfs_dobyteswap ? (int16_t)bswap16(val) : (val))

sys/ufs/lfs/lfs_accessors.h

197

#define LFS_SWAP_int32_t(fs, val) \

sys/ufs/lfs/lfs_accessors.h

198

((fs)->lfs_dobyteswap ? (int32_t)bswap32(val) : (val))

sys/ufs/lfs/lfs_accessors.h

199

#define LFS_SWAP_int64_t(fs, val) \

sys/ufs/lfs/lfs_accessors.h

200

((fs)->lfs_dobyteswap ? (int64_t)bswap64(val) : (val))

sys/ufs/lfs/lfs_accessors.h

201

#define LFS_SWAP_uint16_t(fs, val) \

sys/ufs/lfs/lfs_accessors.h

202

((fs)->lfs_dobyteswap ? bswap16(val) : (val))

sys/ufs/lfs/lfs_accessors.h

203

#define LFS_SWAP_uint32_t(fs, val) \

sys/ufs/lfs/lfs_accessors.h

204

((fs)->lfs_dobyteswap ? bswap32(val) : (val))

sys/ufs/lfs/lfs_accessors.h

205

#define LFS_SWAP_uint64_t(fs, val) \

sys/ufs/lfs/lfs_accessors.h

206

((fs)->lfs_dobyteswap ? bswap64(val) : (val))

sys/ufs/lfs/lfs_accessors.h

214

#define LFS_LITTLE_ENDIAN_ONDISK(fs) (!(fs)->lfs_dobyteswap)

sys/ufs/lfs/lfs_accessors.h

216

#define LFS_LITTLE_ENDIAN_ONDISK(fs) ((fs)->lfs_dobyteswap)

sys/ufs/lfs/lfs_accessors.h

249

#define LFS_DIRHEADERSIZE(fs) \

sys/ufs/lfs/lfs_accessors.h

250

((fs)->lfs_is64 ? sizeof(struct lfs_dirheader64) : sizeof(struct lfs_dirheader32))

sys/ufs/lfs/lfs_accessors.h

258

#define LFS_DIRECTSIZ(fs, namlen) \

sys/ufs/lfs/lfs_accessors.h

259

(LFS_DIRHEADERSIZE(fs) + (((namlen)+1 + 3) &~ 3))

sys/ufs/lfs/lfs_accessors.h

279

#define LFS_DIRSIZ(fs, dp) LFS_DIRECTSIZ(fs, lfs_dir_getnamlen(fs, dp))

sys/ufs/lfs/lfs_accessors.h

285

#define LFS_NEXTDIR(fs, dp) \

sys/ufs/lfs/lfs_accessors.h

286

((LFS_DIRHEADER *)((char *)(dp) + lfs_dir_getreclen(fs, dp)))

sys/ufs/lfs/lfs_accessors.h

289

lfs_dir_nameptr(const STRUCT_LFS *fs, LFS_DIRHEADER *dh)

sys/ufs/lfs/lfs_accessors.h

291

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

299

lfs_dir_getino(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh)

sys/ufs/lfs/lfs_accessors.h

301

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

302

return LFS_SWAP_uint64_t(fs, dh->u_64.dh_ino);

sys/ufs/lfs/lfs_accessors.h

304

return LFS_SWAP_uint32_t(fs, dh->u_32.dh_ino);

sys/ufs/lfs/lfs_accessors.h

309

lfs_dir_getreclen(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh)

sys/ufs/lfs/lfs_accessors.h

311

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

312

return LFS_SWAP_uint16_t(fs, dh->u_64.dh_reclen);

sys/ufs/lfs/lfs_accessors.h

314

return LFS_SWAP_uint16_t(fs, dh->u_32.dh_reclen);

sys/ufs/lfs/lfs_accessors.h

319

lfs_dir_gettype(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh)

sys/ufs/lfs/lfs_accessors.h

321

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

322

KASSERT(fs->lfs_hasolddirfmt == 0);

sys/ufs/lfs/lfs_accessors.h

324

} else if (fs->lfs_hasolddirfmt) {

sys/ufs/lfs/lfs_accessors.h

332

lfs_dir_getnamlen(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh)

sys/ufs/lfs/lfs_accessors.h

334

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

335

KASSERT(fs->lfs_hasolddirfmt == 0);

sys/ufs/lfs/lfs_accessors.h

337

} else if (fs->lfs_hasolddirfmt && LFS_LITTLE_ENDIAN_ONDISK(fs)) {

sys/ufs/lfs/lfs_accessors.h

346

lfs_dir_setino(STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint64_t ino)

sys/ufs/lfs/lfs_accessors.h

348

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

349

dh->u_64.dh_ino = LFS_SWAP_uint64_t(fs, ino);

sys/ufs/lfs/lfs_accessors.h

351

dh->u_32.dh_ino = LFS_SWAP_uint32_t(fs, ino);

sys/ufs/lfs/lfs_accessors.h

356

lfs_dir_setreclen(STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint16_t reclen)

sys/ufs/lfs/lfs_accessors.h

358

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

359

dh->u_64.dh_reclen = LFS_SWAP_uint16_t(fs, reclen);

sys/ufs/lfs/lfs_accessors.h

361

dh->u_32.dh_reclen = LFS_SWAP_uint16_t(fs, reclen);

sys/ufs/lfs/lfs_accessors.h

366

lfs_dir_settype(const STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint8_t type)

sys/ufs/lfs/lfs_accessors.h

368

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

369

KASSERT(fs->lfs_hasolddirfmt == 0);

sys/ufs/lfs/lfs_accessors.h

371

} else if (fs->lfs_hasolddirfmt) {

sys/ufs/lfs/lfs_accessors.h

380

lfs_dir_setnamlen(const STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint8_t namlen)

sys/ufs/lfs/lfs_accessors.h

382

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

383

KASSERT(fs->lfs_hasolddirfmt == 0);

sys/ufs/lfs/lfs_accessors.h

385

} else if (fs->lfs_hasolddirfmt && LFS_LITTLE_ENDIAN_ONDISK(fs)) {

sys/ufs/lfs/lfs_accessors.h

394

lfs_copydirname(STRUCT_LFS *fs, char *dest, const char *src,

sys/ufs/lfs/lfs_accessors.h

399

KASSERT(reclen > LFS_DIRHEADERSIZE(fs));

sys/ufs/lfs/lfs_accessors.h

400

spacelen = reclen - LFS_DIRHEADERSIZE(fs);

sys/ufs/lfs/lfs_accessors.h

410

lfs_dirtemplate_dotdot(STRUCT_LFS *fs, union lfs_dirtemplate *dt)

sys/ufs/lfs/lfs_accessors.h

413

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

421

lfs_dirtemplate_dotdotname(STRUCT_LFS *fs, union lfs_dirtemplate *dt)

sys/ufs/lfs/lfs_accessors.h

423

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

440

#define LFS_MAXSYMLINKLEN(fs) \

sys/ufs/lfs/lfs_accessors.h

441

((fs)->lfs_is64 ? LFS64_MAXSYMLINKLEN : LFS32_MAXSYMLINKLEN)

sys/ufs/lfs/lfs_accessors.h

443

#define DINOSIZE(fs) ((fs)->lfs_is64 ? sizeof(struct lfs64_dinode) : sizeof(struct lfs32_dinode))

sys/ufs/lfs/lfs_accessors.h

445

#define DINO_IN_BLOCK(fs, base, ix) \

sys/ufs/lfs/lfs_accessors.h

446

((union lfs_dinode *)((char *)(base) + DINOSIZE(fs) * (ix)))

sys/ufs/lfs/lfs_accessors.h

449

lfs_copy_dinode(STRUCT_LFS *fs,

sys/ufs/lfs/lfs_accessors.h

458

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

467

lfs_dino_get##field(STRUCT_LFS *fs, union lfs_dinode *dip) \

sys/ufs/lfs/lfs_accessors.h

469

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

470

return LFS_SWAP_##type(fs, dip->u_64.di_##field); \

sys/ufs/lfs/lfs_accessors.h

472

return LFS_SWAP_##type32(fs, dip->u_32.di_##field); \

sys/ufs/lfs/lfs_accessors.h

476

lfs_dino_set##field(STRUCT_LFS *fs, union lfs_dinode *dip, type val) \

sys/ufs/lfs/lfs_accessors.h

478

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

481

dip->u_64.di_##field = LFS_SWAP_##type(fs, val); \

sys/ufs/lfs/lfs_accessors.h

485

dip->u_32.di_##field = LFS_SWAP_##type32(fs, val); \

sys/ufs/lfs/lfs_accessors.h

509

lfs_dino_getdb(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix)

sys/ufs/lfs/lfs_accessors.h

512

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

513

return LFS_SWAP_int64_t(fs, dip->u_64.di_db[ix]);

sys/ufs/lfs/lfs_accessors.h

516

return (int32_t)LFS_SWAP_int32_t(fs, dip->u_32.di_db[ix]);

sys/ufs/lfs/lfs_accessors.h

521

lfs_dino_getib(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix)

sys/ufs/lfs/lfs_accessors.h

524

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

525

return LFS_SWAP_int64_t(fs, dip->u_64.di_ib[ix]);

sys/ufs/lfs/lfs_accessors.h

528

return (int32_t)LFS_SWAP_int32_t(fs, dip->u_32.di_ib[ix]);

sys/ufs/lfs/lfs_accessors.h

533

lfs_dino_setdb(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix, daddr_t val)

sys/ufs/lfs/lfs_accessors.h

536

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

537

dip->u_64.di_db[ix] = LFS_SWAP_int64_t(fs, val);

sys/ufs/lfs/lfs_accessors.h

539

dip->u_32.di_db[ix] = LFS_SWAP_uint32_t(fs, val);

sys/ufs/lfs/lfs_accessors.h

544

lfs_dino_setib(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix, daddr_t val)

sys/ufs/lfs/lfs_accessors.h

547

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

548

dip->u_64.di_ib[ix] = LFS_SWAP_int64_t(fs, val);

sys/ufs/lfs/lfs_accessors.h

550

dip->u_32.di_ib[ix] = LFS_SWAP_uint32_t(fs, val);

sys/ufs/lfs/lfs_accessors.h

556

lfs_dino_setbirthtime(STRUCT_LFS *fs, union lfs_dinode *dip,

sys/ufs/lfs/lfs_accessors.h

559

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

572

lfs_iblock_get(STRUCT_LFS *fs, void *block, unsigned ix)

sys/ufs/lfs/lfs_accessors.h

574

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

586

lfs_iblock_set(STRUCT_LFS *fs, void *block, unsigned ix, daddr_t val)

sys/ufs/lfs/lfs_accessors.h

588

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

659

#define SEGUPB(fs) (lfs_sb_getsepb(fs))

sys/ufs/lfs/lfs_accessors.h

660

#define SEGTABSIZE_SU(fs) \

sys/ufs/lfs/lfs_accessors.h

661

((lfs_sb_getnseg(fs) + SEGUPB(fs) - 1) / lfs_sb_getsepb(fs))

sys/ufs/lfs/lfs_accessors.h

707

#define LFS_BLKPTRSIZE(fs) ((fs)->lfs_is64 ? sizeof(int64_t) : sizeof(int32_t))

sys/ufs/lfs/lfs_accessors.h

711

#define LFS_INUMSIZE(fs) ((fs)->lfs_is64 ? sizeof(int64_t) : sizeof(int32_t))

sys/ufs/lfs/lfs_accessors.h

714

#define FINFOSIZE(fs) ((fs)->lfs_is64 ? sizeof(FINFO64) : sizeof(FINFO32))

sys/ufs/lfs/lfs_accessors.h

717

#define FINFO_FULLSIZE(fs, fip) \

sys/ufs/lfs/lfs_accessors.h

718

(FINFOSIZE(fs) + lfs_fi_getnblocks(fs, fip) * LFS_BLKPTRSIZE(fs))

sys/ufs/lfs/lfs_accessors.h

720

#define NEXT_FINFO(fs, fip) \

sys/ufs/lfs/lfs_accessors.h

721

((FINFO *)((char *)(fip) + FINFO_FULLSIZE(fs, fip)))

sys/ufs/lfs/lfs_accessors.h

725

lfs_fi_get##field(STRUCT_LFS *fs, FINFO *fip) \

sys/ufs/lfs/lfs_accessors.h

727

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

734

lfs_fi_set##field(STRUCT_LFS *fs, FINFO *fip, type val) \

sys/ufs/lfs/lfs_accessors.h

736

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

753

lfs_fi_getblock(STRUCT_LFS *fs, FINFO *fip, unsigned idx)

sys/ufs/lfs/lfs_accessors.h

757

firstblock = (char *)fip + FINFOSIZE(fs);

sys/ufs/lfs/lfs_accessors.h

758

KASSERT(idx < lfs_fi_getnblocks(fs, fip));

sys/ufs/lfs/lfs_accessors.h

759

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

767

lfs_fi_setblock(STRUCT_LFS *fs, FINFO *fip, unsigned idx, daddr_t blk)

sys/ufs/lfs/lfs_accessors.h

771

firstblock = (char *)fip + FINFOSIZE(fs);

sys/ufs/lfs/lfs_accessors.h

772

KASSERT(idx < lfs_fi_getnblocks(fs, fip));

sys/ufs/lfs/lfs_accessors.h

773

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

784

#define IINFOSIZE(fs) ((fs)->lfs_is64 ? sizeof(IINFO64) : sizeof(IINFO32))

sys/ufs/lfs/lfs_accessors.h

787

#define SEGSUM_IINFOSTART(fs, buf) \

sys/ufs/lfs/lfs_accessors.h

788

((IINFO *)((char *)buf + lfs_sb_getsumsize(fs) - IINFOSIZE(fs)))

sys/ufs/lfs/lfs_accessors.h

790

#define NEXTLOWER_IINFO(fs, iip) \

sys/ufs/lfs/lfs_accessors.h

791

((IINFO *)((char *)(iip) - IINFOSIZE(fs)))

sys/ufs/lfs/lfs_accessors.h

793

#define NTH_IINFO(fs, buf, n) \

sys/ufs/lfs/lfs_accessors.h

794

((IINFO *)((char *)SEGSUM_IINFOSTART(fs, buf) - (n)*IINFOSIZE(fs)))

sys/ufs/lfs/lfs_accessors.h

797

lfs_ii_getblock(STRUCT_LFS *fs, IINFO *iip)

sys/ufs/lfs/lfs_accessors.h

799

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

807

lfs_ii_setblock(STRUCT_LFS *fs, IINFO *iip, uint64_t block)

sys/ufs/lfs/lfs_accessors.h

809

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_accessors.h

820

#define IFILE_ENTRYSIZE(fs) \

sys/ufs/lfs/lfs_accessors.h

821

((fs)->lfs_is64 ? sizeof(IFILE64) : sizeof(IFILE32))

sys/ufs/lfs/lfs_accessors.h

825

# define LFS_MAXINO(fs) (((fs->lfs_ivnode->v_size >> lfs_sb_getbshift(fs)) \

sys/ufs/lfs/lfs_accessors.h

826

- lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) \

sys/ufs/lfs/lfs_accessors.h

827

* lfs_sb_getifpb(fs))

sys/ufs/lfs/lfs_accessors.h

828

#define LFS_ASSERT_MAXINO(fs, ino) KASSERTMSG(ino < LFS_MAXINO(fs), \

sys/ufs/lfs/lfs_accessors.h

829

"inode %jd >= max %jd", (intmax_t)(ino), (intmax_t)LFS_MAXINO(fs));

sys/ufs/lfs/lfs_accessors.h

878

lfs_if_get##field(STRUCT_LFS *fs, IFILE *ifp) \

sys/ufs/lfs/lfs_accessors.h

880

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

887

lfs_if_set##field(STRUCT_LFS *fs, IFILE *ifp, type val) \

sys/ufs/lfs/lfs_accessors.h

889

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

911

#define CLEANSIZE_SU(fs) \

sys/ufs/lfs/lfs_accessors.h

912

((((fs)->lfs_is64 ? sizeof(CLEANERINFO64) : sizeof(CLEANERINFO32)) + \

sys/ufs/lfs/lfs_accessors.h

913

lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs))

sys/ufs/lfs/lfs_accessors.h

917

lfs_ci_get##field(STRUCT_LFS *fs, CLEANERINFO *cip) \

sys/ufs/lfs/lfs_accessors.h

919

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

926

lfs_ci_set##field(STRUCT_LFS *fs, CLEANERINFO *cip, type val) \

sys/ufs/lfs/lfs_accessors.h

928

if (fs->lfs_is64) { \

sys/ufs/lfs/lfs_accessors.h

948

lfs_ci_shiftcleantodirty(STRUCT_LFS *fs, CLEANERINFO *cip, unsigned num)

sys/ufs/lfs/lfs_accessors.h

950

lfs_ci_setclean(fs, cip, lfs_ci_getclean(fs, cip) - num);

sys/ufs/lfs/lfs_accessors.h

951

lfs_ci_setdirty(fs, cip, lfs_ci_getdirty(fs, cip) + num);

sys/ufs/lfs/lfs_accessors.h

955

lfs_ci_shiftdirtytoclean(STRUCT_LFS *fs, CLEANERINFO *cip, unsigned num)

sys/ufs/lfs/lfs_accessors.h

957

lfs_ci_setdirty(fs, cip, lfs_ci_getdirty(fs, cip) - num);

sys/ufs/lfs/lfs_accessors.h

958

lfs_ci_setclean(fs, cip, lfs_ci_getclean(fs, cip) + num);

sys/ufs/lfs/lfs_accessors.h

977

#define LFS_SYNC_CLEANERINFO(cip, fs, bp, w) do { \

sys/ufs/lfs/lfs_accessors.h

979

if ((w) || lfs_ci_getbfree(fs, cip) != lfs_sb_getbfree(fs) || \

sys/ufs/lfs/lfs_accessors.h

980

lfs_ci_getavail(fs, cip) != lfs_sb_getavail(fs) - fs->lfs_ravail - \

sys/ufs/lfs/lfs_accessors.h

981

fs->lfs_favail) { \

sys/ufs/lfs/lfs_accessors.h

982

lfs_ci_setbfree(fs, cip, lfs_sb_getbfree(fs)); \

sys/ufs/lfs/lfs_accessors.h

983

lfs_ci_setavail(fs, cip, lfs_sb_getavail(fs) - fs->lfs_ravail - \

sys/ufs/lfs/lfs_accessors.h

984

fs->lfs_favail); \

sys/ufs/lfs/lfs_accessors.h

986

fs->lfs_flags |= LFS_IFDIRTY; \

sys/ufs/lfs/lfs_alloc.c

1011

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_alloc.c

1018

lfs_check_freelist(struct lfs *fs, const char *func, int line)

sys/ufs/lfs/lfs_alloc.c

1030

lfs_prelock(fs, 0);

sys/ufs/lfs/lfs_alloc.c

1032

ip = VTOI(fs->lfs_ivnode);

sys/ufs/lfs/lfs_alloc.c

1033

maxino = ((ip->i_size >> lfs_sb_getbshift(fs)) - lfs_sb_getcleansz(fs) -

sys/ufs/lfs/lfs_alloc.c

1034

lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);

sys/ufs/lfs/lfs_alloc.c

1041

LFS_GET_TAILFREE(fs, cip, bp, &tailino);

sys/ufs/lfs/lfs_alloc.c

1044

LFS_IENTRY(ifp, fs, i, bp);

sys/ufs/lfs/lfs_alloc.c

1045

if (lfs_if_getdaddr(fs, ifp) == LFS_UNUSED_DADDR) {

sys/ufs/lfs/lfs_alloc.c

1047

if (lfs_if_getnextfree(fs, ifp) == LFS_UNUSED_INUM

sys/ufs/lfs/lfs_alloc.c

1050

dump_freelist(fs);

sys/ufs/lfs/lfs_alloc.c

1059

|| (!INUM_IS_BAD(fs, lfs_if_getnextfree(fs, ifp)))) {

sys/ufs/lfs/lfs_alloc.c

1060

if (lfs_if_getdaddr(fs, ifp) != LFS_UNUSED_DADDR) {

sys/ufs/lfs/lfs_alloc.c

1062

dump_freelist(fs);

sys/ufs/lfs/lfs_alloc.c

1068

(intmax_t)lfs_if_getdaddr(fs, ifp),

sys/ufs/lfs/lfs_alloc.c

1069

(intmax_t)lfs_if_getnextfree(fs, ifp));

sys/ufs/lfs/lfs_alloc.c

1082

LFS_GET_HEADFREE(fs, cip, bp, &headino);

sys/ufs/lfs/lfs_alloc.c

1089

LFS_IENTRY(ifp, fs, thisino, bp);

sys/ufs/lfs/lfs_alloc.c

1090

nextfree = lfs_if_getnextfree(fs, ifp);

sys/ufs/lfs/lfs_alloc.c

1097

dump_freelist(fs);

sys/ufs/lfs/lfs_alloc.c

1104

dump_freelist(fs);

sys/ufs/lfs/lfs_alloc.c

1111

dump_freelist(fs);

sys/ufs/lfs/lfs_alloc.c

1117

lfs_preunlock(fs);

sys/ufs/lfs/lfs_alloc.c

1121

dump_freelist(struct lfs *fs)

sys/ufs/lfs/lfs_alloc.c

1130

ip = VTOI(fs->lfs_ivnode);

sys/ufs/lfs/lfs_alloc.c

1131

maxino = ((ip->i_size >> lfs_sb_getbshift(fs)) - lfs_sb_getcleansz(fs) -

sys/ufs/lfs/lfs_alloc.c

1132

lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);

sys/ufs/lfs/lfs_alloc.c

1134

LFS_GET_HEADFREE(fs, cip, bp, &headino);

sys/ufs/lfs/lfs_alloc.c

1136

LFS_GET_TAILFREE(fs, cip, bp, &tailino);

sys/ufs/lfs/lfs_alloc.c

1140

LFS_IENTRY(ifp, fs, i, bp);

sys/ufs/lfs/lfs_alloc.c

1141

ni = lfs_if_getnextfree(fs, ifp);

sys/ufs/lfs/lfs_alloc.c

116

lfs_extend_ifile(struct lfs *fs, kauth_cred_t cred)

sys/ufs/lfs/lfs_alloc.c

129

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_alloc.c

138

vp = fs->lfs_ivnode;

sys/ufs/lfs/lfs_alloc.c

140

blkno = lfs_lblkno(fs, ip->i_size);

sys/ufs/lfs/lfs_alloc.c

141

if ((error = lfs_balloc(vp, ip->i_size, lfs_sb_getbsize(fs), cred, 0,

sys/ufs/lfs/lfs_alloc.c

145

ip->i_size += lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_alloc.c

146

lfs_dino_setsize(fs, ip->i_din, ip->i_size);

sys/ufs/lfs/lfs_alloc.c

154

maxino = ((ip->i_size >> lfs_sb_getbshift(fs)) - lfs_sb_getcleansz(fs) -

sys/ufs/lfs/lfs_alloc.c

155

lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);

sys/ufs/lfs/lfs_alloc.c

156

fs->lfs_ino_bitmap = (lfs_bm_t *)

sys/ufs/lfs/lfs_alloc.c

157

realloc(fs->lfs_ino_bitmap, ((maxino + BMMASK) >> BMSHIFT) *

sys/ufs/lfs/lfs_alloc.c

159

KASSERT(fs->lfs_ino_bitmap != NULL);

sys/ufs/lfs/lfs_alloc.c

162

i = (blkno - lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs)) *

sys/ufs/lfs/lfs_alloc.c

163

lfs_sb_getifpb(fs);

sys/ufs/lfs/lfs_alloc.c

166

xmax = i + lfs_sb_getifpb(fs);

sys/ufs/lfs/lfs_alloc.c

174

LFS_GET_HEADFREE(fs, cip, cbp, &oldhead);

sys/ufs/lfs/lfs_alloc.c

175

LFS_PUT_HEADFREE(fs, cip, cbp, i);

sys/ufs/lfs/lfs_alloc.c

176

LFS_GET_TAILFREE(fs, cip, cbp, &tail);

sys/ufs/lfs/lfs_alloc.c

182

LFS_PUT_TAILFREE(fs, cip, cbp, tail);

sys/ufs/lfs/lfs_alloc.c

184

KASSERTMSG((lfs_sb_getfreehd(fs) != LFS_UNUSED_INUM),

sys/ufs/lfs/lfs_alloc.c

195

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_alloc.c

197

SET_BITMAP_FREE(fs, i);

sys/ufs/lfs/lfs_alloc.c

204

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

sys/ufs/lfs/lfs_alloc.c

206

SET_BITMAP_FREE(fs, i);

sys/ufs/lfs/lfs_alloc.c

215

SET_BITMAP_FREE(fs, i);

sys/ufs/lfs/lfs_alloc.c

224

(intmax_t)xmax - lfs_sb_getifpb(fs), (intmax_t)tail));

sys/ufs/lfs/lfs_alloc.c

249

struct lfs *fs;

sys/ufs/lfs/lfs_alloc.c

255

fs = VTOI(pvp)->i_lfs;

sys/ufs/lfs/lfs_alloc.c

256

if (fs->lfs_ronly)

sys/ufs/lfs/lfs_alloc.c

259

if (!(fs->lfs_flags & LFS_NOTYET))

sys/ufs/lfs/lfs_alloc.c

260

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_alloc.c

262

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_alloc.c

264

lfs_prelock(fs, 0);

sys/ufs/lfs/lfs_alloc.c

267

LFS_GET_HEADFREE(fs, cip, cbp, ino);

sys/ufs/lfs/lfs_alloc.c

275

CLR_BITMAP_FREE(fs, *ino);

sys/ufs/lfs/lfs_alloc.c

281

LFS_IENTRY(ifp, fs, *ino, bp);

sys/ufs/lfs/lfs_alloc.c

282

if (lfs_if_getdaddr(fs, ifp) != LFS_UNUSED_DADDR)

sys/ufs/lfs/lfs_alloc.c

287

LFS_PUT_HEADFREE(fs, cip, cbp, lfs_if_getnextfree(fs, ifp));

sys/ufs/lfs/lfs_alloc.c

289

*ino, (uintmax_t)lfs_if_getnextfree(fs, ifp)));

sys/ufs/lfs/lfs_alloc.c

295

*gen = lfs_if_getversion(fs, ifp);

sys/ufs/lfs/lfs_alloc.c

306

lfs_if_setdaddr(fs, ifp, LFS_ILLEGAL_DADDR);

sys/ufs/lfs/lfs_alloc.c

307

lfs_if_setnextfree(fs, ifp, LFS_UNUSED_INUM);

sys/ufs/lfs/lfs_alloc.c

308

LFS_WRITEIENTRY(ifp, fs, *ino, bp);

sys/ufs/lfs/lfs_alloc.c

310

if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {

sys/ufs/lfs/lfs_alloc.c

315

if ((error = lfs_extend_ifile(fs, cred)) != 0) {

sys/ufs/lfs/lfs_alloc.c

317

LFS_PUT_HEADFREE(fs, cip, cbp, *ino);

sys/ufs/lfs/lfs_alloc.c

320

lfs_preunlock(fs);

sys/ufs/lfs/lfs_alloc.c

324

KASSERTMSG((lfs_sb_getfreehd(fs) != LFS_UNUSED_INUM),

sys/ufs/lfs/lfs_alloc.c

329

fs->lfs_fmod = 1;

sys/ufs/lfs/lfs_alloc.c

333

lfs_sb_addnfiles(fs, 1);

sys/ufs/lfs/lfs_alloc.c

336

lfs_preunlock(fs);

sys/ufs/lfs/lfs_alloc.c

338

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_alloc.c

350

lfs_valloc_fixed(struct lfs *fs, ino_t ino, int vers)

sys/ufs/lfs/lfs_alloc.c

358

if (fs->lfs_ronly)

sys/ufs/lfs/lfs_alloc.c

361

if (!(fs->lfs_flags & LFS_NOTYET))

sys/ufs/lfs/lfs_alloc.c

362

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_alloc.c

364

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_alloc.c

366

lfs_prelock(fs, 0);

sys/ufs/lfs/lfs_alloc.c

374

while (VTOI(fs->lfs_ivnode)->i_size <= (ino /

sys/ufs/lfs/lfs_alloc.c

375

lfs_sb_getifpb(fs) + lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs))

sys/ufs/lfs/lfs_alloc.c

376

<< lfs_sb_getbshift(fs)) {

sys/ufs/lfs/lfs_alloc.c

379

lfs_extend_ifile(fs, NOCRED);

sys/ufs/lfs/lfs_alloc.c

386

LFS_IENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

387

oldnext = lfs_if_getnextfree(fs, ifp);

sys/ufs/lfs/lfs_alloc.c

391

LFS_GET_TAILFREE(fs, cip, cbp, &tailino);

sys/ufs/lfs/lfs_alloc.c

394

LFS_GET_HEADFREE(fs, cip, cbp, &headino);

sys/ufs/lfs/lfs_alloc.c

397

LFS_PUT_HEADFREE(fs, cip, cbp, oldnext);

sys/ufs/lfs/lfs_alloc.c

402

maxino = ((VTOI(fs->lfs_ivnode)->i_size >> lfs_sb_getbshift(fs))

sys/ufs/lfs/lfs_alloc.c

403

- lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs))

sys/ufs/lfs/lfs_alloc.c

404

* lfs_sb_getifpb(fs);

sys/ufs/lfs/lfs_alloc.c

410

LFS_IENTRY(ifp, fs, thisino, bp);

sys/ufs/lfs/lfs_alloc.c

411

nextfree = lfs_if_getnextfree(fs, ifp);

sys/ufs/lfs/lfs_alloc.c

424

lfs_preunlock(fs);

sys/ufs/lfs/lfs_alloc.c

430

lfs_preunlock(fs);

sys/ufs/lfs/lfs_alloc.c

436

lfs_if_setnextfree(fs, ifp, oldnext);

sys/ufs/lfs/lfs_alloc.c

442

LFS_PUT_TAILFREE(fs, cip, cbp, thisino);

sys/ufs/lfs/lfs_alloc.c

446

LFS_IENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

447

lfs_if_setversion(fs, ifp, vers);

sys/ufs/lfs/lfs_alloc.c

448

lfs_if_setnextfree(fs, ifp, LFS_UNUSED_INUM);

sys/ufs/lfs/lfs_alloc.c

450

lfs_if_setdaddr(fs, ifp, LFS_ILLEGAL_DADDR);

sys/ufs/lfs/lfs_alloc.c

451

LFS_WRITEIENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

453

if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {

sys/ufs/lfs/lfs_alloc.c

459

if ((error = lfs_extend_ifile(fs, NOCRED)) != 0) {

sys/ufs/lfs/lfs_alloc.c

461

LFS_PUT_HEADFREE(fs, cip, cbp, ino);

sys/ufs/lfs/lfs_alloc.c

464

lfs_preunlock(fs);

sys/ufs/lfs/lfs_alloc.c

468

KASSERTMSG((lfs_sb_getfreehd(fs) != LFS_UNUSED_INUM),

sys/ufs/lfs/lfs_alloc.c

472

lfs_preunlock(fs);

sys/ufs/lfs/lfs_alloc.c

474

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_alloc.c

485

lfs_last_alloc_ino(struct lfs *fs)

sys/ufs/lfs/lfs_alloc.c

489

maxino = ((fs->lfs_ivnode->v_size >> lfs_sb_getbshift(fs)) -

sys/ufs/lfs/lfs_alloc.c

490

lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) *

sys/ufs/lfs/lfs_alloc.c

491

lfs_sb_getifpb(fs);

sys/ufs/lfs/lfs_alloc.c

493

if (ISSET_BITMAP_FREE(fs, ino) == 0)

sys/ufs/lfs/lfs_alloc.c

506

lfs_freelist_prev(struct lfs *fs, ino_t ino)

sys/ufs/lfs/lfs_alloc.c

510

if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {

sys/ufs/lfs/lfs_alloc.c

518

if (ISSET_BITMAP_FREE(fs, tino))

sys/ufs/lfs/lfs_alloc.c

528

freehdbb = (lfs_sb_getfreehd(fs) >> BMSHIFT);

sys/ufs/lfs/lfs_alloc.c

530

if (fs->lfs_ino_bitmap[bb])

sys/ufs/lfs/lfs_alloc.c

532

if (fs->lfs_ino_bitmap[bb] == 0)

sys/ufs/lfs/lfs_alloc.c

538

if (ISSET_BITMAP_FREE(fs, tino))

sys/ufs/lfs/lfs_alloc.c

563

struct lfs *fs;

sys/ufs/lfs/lfs_alloc.c

568

fs = ip->i_lfs;

sys/ufs/lfs/lfs_alloc.c

571

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_alloc.c

573

KASSERT(!fs->lfs_ronly);

sys/ufs/lfs/lfs_alloc.c

579

while (lfs_sb_getversion(fs) > 1 && WRITEINPROG(vp)) {

sys/ufs/lfs/lfs_alloc.c

584

lfs_prelock(fs, 0);

sys/ufs/lfs/lfs_alloc.c

586

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_alloc.c

601

--fs->lfs_dirvcount;

sys/ufs/lfs/lfs_alloc.c

602

TAILQ_REMOVE(&fs->lfs_dchainhd, ip, i_lfs_dchain);

sys/ufs/lfs/lfs_alloc.c

603

wakeup(&fs->lfs_dirvcount);

sys/ufs/lfs/lfs_alloc.c

617

fsd = rb_tree_insert_node(&fs->lfs_segdhd, isd);

sys/ufs/lfs/lfs_alloc.c

629

lfs_finalize_ino_seguse(fs, ip);

sys/ufs/lfs/lfs_alloc.c

645

SET_BITMAP_FREE(fs, ino);

sys/ufs/lfs/lfs_alloc.c

653

lfs_update_iaddr(fs, ip, LFS_UNUSED_DADDR);

sys/ufs/lfs/lfs_alloc.c

656

LFS_IENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

659

lfs_if_setversion(fs, ifp, lfs_if_getversion(fs, ifp) + 1);

sys/ufs/lfs/lfs_alloc.c

662

if (lfs_sb_getversion(fs) == 1) {

sys/ufs/lfs/lfs_alloc.c

667

LFS_GET_HEADFREE(fs, cip, cbp, &nextfree);

sys/ufs/lfs/lfs_alloc.c

668

lfs_if_setnextfree(fs, ifp, nextfree);

sys/ufs/lfs/lfs_alloc.c

669

LFS_PUT_HEADFREE(fs, cip, cbp, ino);

sys/ufs/lfs/lfs_alloc.c

672

LFS_WRITEIENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

682

lfs_if_setnextfree(fs, ifp, LFS_UNUSED_INUM);

sys/ufs/lfs/lfs_alloc.c

683

LFS_WRITEIENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

690

tino = lfs_freelist_prev(fs, ino);

sys/ufs/lfs/lfs_alloc.c

700

LFS_IENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

702

LFS_GET_HEADFREE(fs, cip, cbp, &nextfree);

sys/ufs/lfs/lfs_alloc.c

703

lfs_if_setnextfree(fs, ifp, nextfree);

sys/ufs/lfs/lfs_alloc.c

704

LFS_PUT_HEADFREE(fs, cip, cbp, ino);

sys/ufs/lfs/lfs_alloc.c

708

LFS_WRITEIENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

711

LFS_GET_TAILFREE(fs, cip, cbp, &otail);

sys/ufs/lfs/lfs_alloc.c

713

LFS_PUT_TAILFREE(fs, cip, cbp, ino);

sys/ufs/lfs/lfs_alloc.c

729

LFS_IENTRY(ifp, fs, tino, bp);

sys/ufs/lfs/lfs_alloc.c

731

onf = lfs_if_getnextfree(fs, ifp);

sys/ufs/lfs/lfs_alloc.c

732

lfs_if_setnextfree(fs, ifp, ino);

sys/ufs/lfs/lfs_alloc.c

734

LFS_WRITEIENTRY(ifp, fs, tino, bp);

sys/ufs/lfs/lfs_alloc.c

737

LFS_IENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

739

lfs_if_setnextfree(fs, ifp, onf);

sys/ufs/lfs/lfs_alloc.c

741

LFS_WRITEIENTRY(ifp, fs, tino, bp);

sys/ufs/lfs/lfs_alloc.c

745

LFS_GET_TAILFREE(fs, cip, cbp, &otail);

sys/ufs/lfs/lfs_alloc.c

746

LFS_PUT_TAILFREE(fs, cip, cbp, ino);

sys/ufs/lfs/lfs_alloc.c

757

fs->lfs_fmod = 1;

sys/ufs/lfs/lfs_alloc.c

761

lfs_sb_subnfiles(fs, 1);

sys/ufs/lfs/lfs_alloc.c

763

lfs_preunlock(fs);

sys/ufs/lfs/lfs_alloc.c

765

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_alloc.c

777

lfs_order_freelist(struct lfs *fs, ino_t **orphanp, size_t *norphanp)

sys/ufs/lfs/lfs_alloc.c

787

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_alloc.c

788

lfs_prelock(fs, 0);

sys/ufs/lfs/lfs_alloc.c

790

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_alloc.c

793

maxino = ((fs->lfs_ivnode->v_size >> lfs_sb_getbshift(fs)) -

sys/ufs/lfs/lfs_alloc.c

794

lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);

sys/ufs/lfs/lfs_alloc.c

798

fs->lfs_ino_bitmap =

sys/ufs/lfs/lfs_alloc.c

801

KASSERT(fs->lfs_ino_bitmap != NULL);

sys/ufs/lfs/lfs_alloc.c

810

if (ino % lfs_sb_getifpb(fs) == 0)

sys/ufs/lfs/lfs_alloc.c

811

LFS_IENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

813

LFS_IENTRY_NEXT(ifp, fs);

sys/ufs/lfs/lfs_alloc.c

830

if (lfs_if_getnextfree(fs, ifp) == LFS_ORPHAN_NEXTFREE(fs)) {

sys/ufs/lfs/lfs_alloc.c

851

if (DADDR_IS_BAD(lfs_if_getdaddr(fs, ifp))) {

sys/ufs/lfs/lfs_alloc.c

868

LFS_IENTRY(ifp, fs, lastino, bp);

sys/ufs/lfs/lfs_alloc.c

870

lfs_if_setnextfree(fs, ifp, ino);

sys/ufs/lfs/lfs_alloc.c

872

LFS_WRITEIENTRY(ifp, fs, lastino, bp);

sys/ufs/lfs/lfs_alloc.c

875

LFS_IENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_alloc.c

881

SET_BITMAP_FREE(fs, ino);

sys/ufs/lfs/lfs_alloc.c

885

if ((ino + 1) % lfs_sb_getifpb(fs) == 0)

sys/ufs/lfs/lfs_alloc.c

891

LFS_PUT_HEADFREE(fs, cip, bp, firstino);

sys/ufs/lfs/lfs_alloc.c

892

LFS_PUT_TAILFREE(fs, cip, bp, lastino);

sys/ufs/lfs/lfs_alloc.c

895

lfs_preunlock(fs);

sys/ufs/lfs/lfs_alloc.c

913

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_alloc.c

930

lfs_orphan(struct lfs *fs, struct vnode *vp)

sys/ufs/lfs/lfs_alloc.c

940

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_alloc.c

968

lfs_fraglock_enter(fs, RW_READER);

sys/ufs/lfs/lfs_alloc.c

969

LFS_IENTRY(ifp, fs, ip->i_number, bp);

sys/ufs/lfs/lfs_alloc.c

970

nextfree = lfs_if_getnextfree(fs, ifp);

sys/ufs/lfs/lfs_alloc.c

971

if (nextfree == LFS_ORPHAN_NEXTFREE(fs)) {

sys/ufs/lfs/lfs_alloc.c

973

lfs_fraglock_exit(fs);

sys/ufs/lfs/lfs_alloc.c

977

lfs_if_setnextfree(fs, ifp, LFS_ORPHAN_NEXTFREE(fs));

sys/ufs/lfs/lfs_alloc.c

978

LFS_WRITEIENTRY(ifp, fs, ip->i_number, bp);

sys/ufs/lfs/lfs_alloc.c

979

lfs_fraglock_exit(fs);

sys/ufs/lfs/lfs_alloc.c

988

lfs_free_orphans(struct lfs *fs, ino_t *orphan, size_t norphan)

sys/ufs/lfs/lfs_alloc.c

994

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_alloc.c

995

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_alloc.c

998

error = VFS_VGET(fs->lfs_ivnode->v_mount, orphan[i],

sys/ufs/lfs/lfs_balloc.c

127

struct lfs *fs;

sys/ufs/lfs/lfs_balloc.c

134

fs = ip->i_lfs;

sys/ufs/lfs/lfs_balloc.c

137

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_balloc.c

141

offset = lfs_blkoff(fs, startoffset);

sys/ufs/lfs/lfs_balloc.c

144

KASSERT(iosize <= lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_balloc.c

147

lbn = lfs_lblkno(fs, startoffset);

sys/ufs/lfs/lfs_balloc.c

177

lastblock = lfs_lblkno(fs, ip->i_size);

sys/ufs/lfs/lfs_balloc.c

187

osize = lfs_blksize(fs, ip, lastblock);

sys/ufs/lfs/lfs_balloc.c

188

if (osize < lfs_sb_getbsize(fs) && osize > 0) {

sys/ufs/lfs/lfs_balloc.c

189

if ((error = lfs_fragextend(vp, osize, lfs_sb_getbsize(fs),

sys/ufs/lfs/lfs_balloc.c

194

ip->i_size = (lastblock + 1) * lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_balloc.c

195

lfs_dino_setsize(fs, ip->i_din, ip->i_size);

sys/ufs/lfs/lfs_balloc.c

212

if (lbn < ULFS_NDADDR && lfs_lblkno(fs, ip->i_size) <= lbn) {

sys/ufs/lfs/lfs_balloc.c

213

osize = lfs_blksize(fs, ip, lbn);

sys/ufs/lfs/lfs_balloc.c

214

nsize = lfs_fragroundup(fs, offset + iosize);

sys/ufs/lfs/lfs_balloc.c

215

if (lfs_lblktosize(fs, lbn) >= ip->i_size) {

sys/ufs/lfs/lfs_balloc.c

217

frags = lfs_numfrags(fs, nsize);

sys/ufs/lfs/lfs_balloc.c

218

if (!ISSPACE(fs, frags, cred))

sys/ufs/lfs/lfs_balloc.c

236

lfs_sb_subbfree(fs, frags);

sys/ufs/lfs/lfs_balloc.c

240

lfs_dino_setdb(fs, ip->i_din, lbn, UNWRITTEN);

sys/ufs/lfs/lfs_balloc.c

270

KASSERT(daddr <= LFS_MAX_DADDR(fs));

sys/ufs/lfs/lfs_balloc.c

276

frags = fs->um_seqinc;

sys/ufs/lfs/lfs_balloc.c

288

if (ISSPACE(fs, bcount, cred)) {

sys/ufs/lfs/lfs_balloc.c

291

lfs_sb_subbfree(fs, bcount);

sys/ufs/lfs/lfs_balloc.c

312

if (num > 0 && lfs_dino_getib(fs, ip->i_din, indirs[0].in_off) == 0) {

sys/ufs/lfs/lfs_balloc.c

313

lfs_dino_setib(fs, ip->i_din, indirs[0].in_off, UNWRITTEN);

sys/ufs/lfs/lfs_balloc.c

325

idaddr = lfs_dino_getib(fs, ip->i_din, indirs[0].in_off);

sys/ufs/lfs/lfs_balloc.c

339

lfs_sb_getbsize(fs), 0,0);

sys/ufs/lfs/lfs_balloc.c

353

ibp->b_blkno = LFS_FSBTODB(fs, idaddr);

sys/ufs/lfs/lfs_balloc.c

365

if (lfs_iblock_get(fs, ibp->b_data, indirs[i].in_off) == 0)

sys/ufs/lfs/lfs_balloc.c

366

lfs_iblock_set(fs, ibp->b_data, indirs[i].in_off,

sys/ufs/lfs/lfs_balloc.c

370

idaddr = lfs_iblock_get(fs, ibp->b_data, indirs[i].in_off);

sys/ufs/lfs/lfs_balloc.c

372

if (vp == fs->lfs_ivnode) {

sys/ufs/lfs/lfs_balloc.c

399

*bpp = bp = getblk(vp, lbn, lfs_blksize(fs, ip, lbn), 0, 0);

sys/ufs/lfs/lfs_balloc.c

427

lfs_dino_setdb(fs, ip->i_din, lbn, UNWRITTEN);

sys/ufs/lfs/lfs_balloc.c

439

lfs_dino_setib(fs, ip->i_din, indirs[0].in_off, UNWRITTEN);

sys/ufs/lfs/lfs_balloc.c

447

if (bread(vp, idp->in_lbn, lfs_sb_getbsize(fs),

sys/ufs/lfs/lfs_balloc.c

451

lfs_iblock_set(fs, ibp->b_data, idp->in_off, UNWRITTEN);

sys/ufs/lfs/lfs_balloc.c

453

if (vp == fs->lfs_ivnode) {

sys/ufs/lfs/lfs_balloc.c

466

if (iosize == lfs_sb_getbsize(fs))

sys/ufs/lfs/lfs_balloc.c

495

struct lfs *fs;

sys/ufs/lfs/lfs_balloc.c

505

fs = ip->i_lfs;

sys/ufs/lfs/lfs_balloc.c

511

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_balloc.c

514

frags = (long)lfs_numfrags(fs, nsize - osize);

sys/ufs/lfs/lfs_balloc.c

529

lfs_fraglock_enter(fs, RW_READER);

sys/ufs/lfs/lfs_balloc.c

533

if (!ISSPACE(fs, frags, cred)) {

sys/ufs/lfs/lfs_balloc.c

562

if (!lfs_fits(fs, frags)) {

sys/ufs/lfs/lfs_balloc.c

568

lfs_fraglock_exit(fs);

sys/ufs/lfs/lfs_balloc.c

569

lfs_availwait(fs, frags);

sys/ufs/lfs/lfs_balloc.c

572

lfs_sb_subavail(fs, frags);

sys/ufs/lfs/lfs_balloc.c

577

lfs_sb_subbfree(fs, frags);

sys/ufs/lfs/lfs_balloc.c

602

lfs_fraglock_exit(fs);

sys/ufs/lfs/lfs_balloc.c

625

struct lfs *fs;

sys/ufs/lfs/lfs_balloc.c

635

fs = ip->i_lfs;

sys/ufs/lfs/lfs_balloc.c

637

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_balloc.c

640

lfs_availwait(fs, lfs_btofsb(fs, 1 << lfs_sb_getbshift(fs)));

sys/ufs/lfs/lfs_balloc.c

653

fs->lfs_favail += lfs_btofsb(fs, (1 << lfs_sb_getbshift(fs)));

sys/ufs/lfs/lfs_balloc.c

654

fs->lfs_pages += lfs_sb_getbsize(fs) >> PAGE_SHIFT;

sys/ufs/lfs/lfs_balloc.c

656

lfs_subsys_pages += lfs_sb_getbsize(fs) >> PAGE_SHIFT;

sys/ufs/lfs/lfs_balloc.c

661

lfs_do_deregister(struct lfs *fs, struct inode *ip, struct lbnentry *lbp)

sys/ufs/lfs/lfs_balloc.c

665

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_balloc.c

669

if (fs->lfs_favail > lfs_btofsb(fs, (1 << lfs_sb_getbshift(fs))))

sys/ufs/lfs/lfs_balloc.c

670

fs->lfs_favail -= lfs_btofsb(fs, (1 << lfs_sb_getbshift(fs)));

sys/ufs/lfs/lfs_balloc.c

671

fs->lfs_pages -= lfs_sb_getbsize(fs) >> PAGE_SHIFT;

sys/ufs/lfs/lfs_balloc.c

674

lfs_subsys_pages -= lfs_sb_getbsize(fs) >> PAGE_SHIFT;

sys/ufs/lfs/lfs_balloc.c

686

struct lfs *fs;

sys/ufs/lfs/lfs_balloc.c

694

fs = ip->i_lfs;

sys/ufs/lfs/lfs_balloc.c

695

KASSERT(fs != NULL);

sys/ufs/lfs/lfs_balloc.c

702

if (fs->lfs_sp && (fs->lfs_sp->seg_flags & SEGM_CLEAN)) {

sys/ufs/lfs/lfs_balloc.c

709

lfs_do_deregister(fs, ip, lbp);

sys/ufs/lfs/lfs_balloc.c

718

struct lfs *fs;

sys/ufs/lfs/lfs_balloc.c

722

fs = ip->i_lfs;

sys/ufs/lfs/lfs_balloc.c

727

lfs_do_deregister(fs, ip, lbp);

sys/ufs/lfs/lfs_bio.c

124

lfs_fits_buf(struct lfs *fs, int n, int bytes)

sys/ufs/lfs/lfs_bio.c

128

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_bio.c

154

lfs_reservebuf(struct lfs *fs, struct vnode *vp,

sys/ufs/lfs/lfs_bio.c

159

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_bio.c

163

cantwait = (VTOI(vp)->i_state & IN_ADIROP) || fs->lfs_unlockvp == vp;

sys/ufs/lfs/lfs_bio.c

165

while (!cantwait && n > 0 && !lfs_fits_buf(fs, n, bytes)) {

sys/ufs/lfs/lfs_bio.c

168

DLOG((DLOG_FLUSH, "lfs_reservebuf: flush filesystem %p with checkpoint\n", fs));

sys/ufs/lfs/lfs_bio.c

169

lfs_flush(fs, SEGM_CKP, 0);

sys/ufs/lfs/lfs_bio.c

209

lfs_reserveavail(struct lfs *fs, struct vnode *vp,

sys/ufs/lfs/lfs_bio.c

217

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_bio.c

220

cantwait = (VTOI(vp)->i_state & IN_ADIROP) || fs->lfs_unlockvp == vp;

sys/ufs/lfs/lfs_bio.c

222

!lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail)) {

sys/ufs/lfs/lfs_bio.c

228

fsb + fs->lfs_ravail + fs->lfs_favail,

sys/ufs/lfs/lfs_bio.c

229

(intmax_t)lfs_sb_getbfree(fs),

sys/ufs/lfs/lfs_bio.c

230

(intmax_t)LFS_EST_BFREE(fs)));

sys/ufs/lfs/lfs_bio.c

235

LFS_CLEANERINFO(cip, fs, bp);

sys/ufs/lfs/lfs_bio.c

236

LFS_SYNC_CLEANERINFO(cip, fs, bp, 0);

sys/ufs/lfs/lfs_bio.c

237

lfs_wakeup_cleaner(fs);

sys/ufs/lfs/lfs_bio.c

241

if (lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail))

sys/ufs/lfs/lfs_bio.c

244

error = mtsleep(&fs->lfs_availsleep, PCATCH | PUSER,

sys/ufs/lfs/lfs_bio.c

256

fs->lfs_ravail += fsb;

sys/ufs/lfs/lfs_bio.c

268

lfs_reserve(struct lfs *fs, struct vnode *vp, struct vnode *vp2, int fsb)

sys/ufs/lfs/lfs_bio.c

272

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_bio.c

276

while(fs->lfs_flags & LFS_UNDIROP) {

sys/ufs/lfs/lfs_bio.c

277

mtsleep(&fs->lfs_flags, PRIBIO + 1, "lfsrundirop", 0,

sys/ufs/lfs/lfs_bio.c

285

KASSERT(vp2 == NULL || vp2 != fs->lfs_unlockvp);

sys/ufs/lfs/lfs_bio.c

298

error = lfs_reserveavail(fs, vp, vp2, fsb);

sys/ufs/lfs/lfs_bio.c

305

error = lfs_reservebuf(fs, vp, vp2, fsb, lfs_fsbtob(fs, fsb));

sys/ufs/lfs/lfs_bio.c

307

lfs_reserveavail(fs, vp, vp2, -fsb);

sys/ufs/lfs/lfs_bio.c

348

lfs_fits(struct lfs *fs, int fsb)

sys/ufs/lfs/lfs_bio.c

352

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_bio.c

353

needed = fsb + lfs_btofsb(fs, lfs_sb_getsumsize(fs)) +

sys/ufs/lfs/lfs_bio.c

354

((howmany(lfs_sb_getuinodes(fs) + 1, LFS_INOPB(fs)) +

sys/ufs/lfs/lfs_bio.c

355

lfs_sb_getsegtabsz(fs) +

sys/ufs/lfs/lfs_bio.c

356

1) << (lfs_sb_getbshift(fs) - lfs_sb_getffshift(fs)));

sys/ufs/lfs/lfs_bio.c

358

if (needed >= lfs_sb_getavail(fs)) {

sys/ufs/lfs/lfs_bio.c

362

(long)fsb, (long)lfs_sb_getuinodes(fs), (intmax_t)needed,

sys/ufs/lfs/lfs_bio.c

363

(intmax_t)lfs_sb_getavail(fs)));

sys/ufs/lfs/lfs_bio.c

371

lfs_availwait(struct lfs *fs, int fsb)

sys/ufs/lfs/lfs_bio.c

377

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_bio.c

380

if (LFS_SEGLOCK_HELD(fs) &&

sys/ufs/lfs/lfs_bio.c

381

fs->lfs_sp->seg_flags & (SEGM_CLEAN | SEGM_FORCE_CKP)) {

sys/ufs/lfs/lfs_bio.c

387

while (!lfs_fits(fs, fsb)) {

sys/ufs/lfs/lfs_bio.c

394

LFS_CLEANERINFO(cip, fs, cbp);

sys/ufs/lfs/lfs_bio.c

395

LFS_SYNC_CLEANERINFO(cip, fs, cbp, 0);

sys/ufs/lfs/lfs_bio.c

402

lfs_wakeup_cleaner(fs);

sys/ufs/lfs/lfs_bio.c

403

KASSERTMSG(!LFS_SEGLOCK_HELD(fs), "lfs_availwait: deadlock");

sys/ufs/lfs/lfs_bio.c

404

error = tsleep(&fs->lfs_availsleep, PCATCH | PUSER,

sys/ufs/lfs/lfs_bio.c

415

struct lfs *fs;

sys/ufs/lfs/lfs_bio.c

421

fs = VFSTOULFS(vp->v_mount)->um_lfs;

sys/ufs/lfs/lfs_bio.c

423

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_bio.c

427

KASSERT(!(flags & BW_CLEAN) || lfs_cleanerlock_held(fs));

sys/ufs/lfs/lfs_bio.c

436

if (fs->lfs_ronly || (lfs_sb_getpflags(fs) & LFS_PF_CLEAN)) {

sys/ufs/lfs/lfs_bio.c

447

return (fs->lfs_ronly ? EROFS : 0);

sys/ufs/lfs/lfs_bio.c

465

fsb = lfs_numfrags(fs, bp->b_bcount);

sys/ufs/lfs/lfs_bio.c

469

lfs_setclean(fs, vp);

sys/ufs/lfs/lfs_bio.c

476

lfs_sb_subavail(fs, fsb);

sys/ufs/lfs/lfs_bio.c

503

lfs_flush_fs(struct lfs *fs, int flags)

sys/ufs/lfs/lfs_bio.c

505

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_bio.c

507

if (fs->lfs_ronly)

sys/ufs/lfs/lfs_bio.c

513

fs->lfs_pdflush = 0;

sys/ufs/lfs/lfs_bio.c

515

lfs_writer_enter(fs, "fldirop");

sys/ufs/lfs/lfs_bio.c

516

lfs_segwrite(fs->lfs_ivnode->v_mount, flags);

sys/ufs/lfs/lfs_bio.c

517

lfs_writer_leave(fs);

sys/ufs/lfs/lfs_bio.c

519

fs->lfs_favail = 0; /* XXX */

sys/ufs/lfs/lfs_bio.c

533

lfs_flush(struct lfs *fs, int flags, int only_onefs)

sys/ufs/lfs/lfs_bio.c

541

KDASSERT(fs == NULL || !LFS_SEGLOCK_HELD(fs));

sys/ufs/lfs/lfs_bio.c

542

KASSERT(!(fs == NULL && only_onefs));

sys/ufs/lfs/lfs_bio.c

556

if (fs != NULL) {

sys/ufs/lfs/lfs_bio.c

557

if (!(fs->lfs_flags & LFS_NOTYET)

sys/ufs/lfs/lfs_bio.c

558

&& vfs_busy(fs->lfs_ivnode->v_mount))

sys/ufs/lfs/lfs_bio.c

561

lfs_flush_fs(fs, flags);

sys/ufs/lfs/lfs_bio.c

563

if (!(fs->lfs_flags & LFS_NOTYET))

sys/ufs/lfs/lfs_bio.c

564

vfs_unbusy(fs->lfs_ivnode->v_mount);

sys/ufs/lfs/lfs_bio.c

573

if (tfs == fs)

sys/ufs/lfs/lfs_bio.c

591

#define INOCOUNT(fs) howmany(lfs_sb_getuinodes(fs), LFS_INOPB(fs))

sys/ufs/lfs/lfs_bio.c

592

#define INOBYTES(fs) (lfs_sb_getuinodes(fs) * DINOSIZE(fs))

sys/ufs/lfs/lfs_bio.c

599

lfs_needsflush(struct lfs *fs)

sys/ufs/lfs/lfs_bio.c

601

if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS)

sys/ufs/lfs/lfs_bio.c

603

if (locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES)

sys/ufs/lfs/lfs_bio.c

607

if (fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs))

sys/ufs/lfs/lfs_bio.c

611

if (fs->lfs_diropwait > 0)

sys/ufs/lfs/lfs_bio.c

621

lfs_needswait(struct lfs *fs)

sys/ufs/lfs/lfs_bio.c

623

if (locked_queue_count + INOCOUNT(fs) > LFS_WAIT_BUFS)

sys/ufs/lfs/lfs_bio.c

625

if (locked_queue_bytes + INOBYTES(fs) > LFS_WAIT_BYTES)

sys/ufs/lfs/lfs_bio.c

629

if (fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs)) /* XXX */

sys/ufs/lfs/lfs_bio.c

633

if (fs->lfs_diropwait > 0)

sys/ufs/lfs/lfs_bio.c

648

struct lfs *fs;

sys/ufs/lfs/lfs_bio.c

663

fs = ip->i_lfs;

sys/ufs/lfs/lfs_bio.c

665

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_bio.c

672

while (fs->lfs_dirops > 0 && lfs_needswait(fs)) {

sys/ufs/lfs/lfs_bio.c

673

++fs->lfs_diropwait;

sys/ufs/lfs/lfs_bio.c

674

mtsleep(&fs->lfs_writer, PRIBIO+1, "bufdirop", 0,

sys/ufs/lfs/lfs_bio.c

676

--fs->lfs_diropwait;

sys/ufs/lfs/lfs_bio.c

680

if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS)

sys/ufs/lfs/lfs_bio.c

682

locked_queue_count + INOCOUNT(fs), LFS_MAX_BUFS));

sys/ufs/lfs/lfs_bio.c

683

if (locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES)

sys/ufs/lfs/lfs_bio.c

685

locked_queue_bytes + INOBYTES(fs), LFS_MAX_BYTES));

sys/ufs/lfs/lfs_bio.c

689

if (lfs_fs_pagetrip && fs->lfs_pages > lfs_fs_pagetrip)

sys/ufs/lfs/lfs_bio.c

691

fs->lfs_pages, lfs_fs_pagetrip));

sys/ufs/lfs/lfs_bio.c

695

if (fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs))

sys/ufs/lfs/lfs_bio.c

697

fs->lfs_dirvcount, LFS_MAX_FSDIROP(fs)));

sys/ufs/lfs/lfs_bio.c

698

if (fs->lfs_diropwait > 0)

sys/ufs/lfs/lfs_bio.c

700

fs->lfs_diropwait));

sys/ufs/lfs/lfs_bio.c

704

if (fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) ||

sys/ufs/lfs/lfs_bio.c

705

lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0) {

sys/ufs/lfs/lfs_bio.c

706

KASSERT(fs->lfs_dirops == 0);

sys/ufs/lfs/lfs_bio.c

707

fs->lfs_writer++;

sys/ufs/lfs/lfs_bio.c

709

lfs_flush_dirops(fs);

sys/ufs/lfs/lfs_bio.c

711

if (--fs->lfs_writer == 0)

sys/ufs/lfs/lfs_bio.c

712

cv_broadcast(&fs->lfs_diropscv);

sys/ufs/lfs/lfs_bio.c

713

KASSERT(fs->lfs_dirops == 0);

sys/ufs/lfs/lfs_bio.c

714

} else if (lfs_needsflush(fs)) {

sys/ufs/lfs/lfs_bio.c

715

lfs_flush(fs, flags, 0);

sys/ufs/lfs/lfs_bio.c

716

} else if (lfs_fs_pagetrip && fs->lfs_pages > lfs_fs_pagetrip) {

sys/ufs/lfs/lfs_bio.c

721

++fs->lfs_pdflush;

sys/ufs/lfs/lfs_bio.c

725

while (lfs_needswait(fs)) {

sys/ufs/lfs/lfs_bio.c

744

if (locked_queue_count + INOCOUNT(fs) >= LFS_MAX_BUFS ||

sys/ufs/lfs/lfs_bio.c

745

locked_queue_bytes + INOBYTES(fs) >= LFS_MAX_BYTES) {

sys/ufs/lfs/lfs_bio.c

746

lfs_flush(fs, flags | SEGM_CKP, 0);

sys/ufs/lfs/lfs_bio.c

757

lfs_newbuf(struct lfs *fs, struct vnode *vp, daddr_t daddr, size_t size, int type)

sys/ufs/lfs/lfs_bio.c

762

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_bio.c

763

nbytes = roundup(size, lfs_fsbtob(fs, 1));

sys/ufs/lfs/lfs_bio.c

767

bp->b_data = lfs_malloc(fs, nbytes, type);

sys/ufs/lfs/lfs_bio.c

780

bp->b_private = fs;

sys/ufs/lfs/lfs_bio.c

793

lfs_freebuf(struct lfs *fs, struct buf *bp)

sys/ufs/lfs/lfs_bio.c

804

lfs_free(fs, bp->b_data, LFS_NB_UNKNOWN);

sys/ufs/lfs/lfs_cksum.c

103

lfs_sb_cksum(struct lfs *fs)

sys/ufs/lfs/lfs_cksum.c

108

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_cksum.c

109

ptr = &fs->lfs_dlfs_u.u_64;

sys/ufs/lfs/lfs_cksum.c

112

ptr = &fs->lfs_dlfs_u.u_32;

sys/ufs/lfs/lfs_debug.c

195

lfs_dump_dinode(struct lfs *fs, union lfs_dinode *dip)

sys/ufs/lfs/lfs_debug.c

200

"mode ", lfs_dino_getmode(fs, dip),

sys/ufs/lfs/lfs_debug.c

201

"nlink ", lfs_dino_getnlink(fs, dip),

sys/ufs/lfs/lfs_debug.c

202

"uid ", lfs_dino_getuid(fs, dip),

sys/ufs/lfs/lfs_debug.c

203

"gid ", lfs_dino_getgid(fs, dip),

sys/ufs/lfs/lfs_debug.c

204

"size ", (uintmax_t)lfs_dino_getsize(fs, dip),

sys/ufs/lfs/lfs_debug.c

205

"blocks ", (uintmax_t)lfs_dino_getblocks(fs, dip));

sys/ufs/lfs/lfs_debug.c

206

printf("inum %ju\n", (uintmax_t)lfs_dino_getinumber(fs, dip));

sys/ufs/lfs/lfs_debug.c

209

printf("\t%jx", (intmax_t)lfs_dino_getdb(fs, dip, i));

sys/ufs/lfs/lfs_debug.c

214

printf("\t%jx", (intmax_t)lfs_dino_getib(fs, dip, i));

sys/ufs/lfs/lfs_debug.c

219

lfs_check_segsum(struct lfs *fs, struct segment *sp, char *file, int line)

sys/ufs/lfs/lfs_debug.c

229

if (sp->sum_bytes_left >= FINFOSIZE(fs)

sys/ufs/lfs/lfs_debug.c

230

&& lfs_fi_getnblocks(fs, sp->fip) > 512) {

sys/ufs/lfs/lfs_debug.c

232

lfs_fi_getnblocks(fs, sp->fip));

sys/ufs/lfs/lfs_debug.c

240

file, line, sp->sum_bytes_left, lfs_sb_getsumsize(fs)-sp->sum_bytes_left);

sys/ufs/lfs/lfs_debug.c

244

actual = lfs_sb_getsumsize(fs)

sys/ufs/lfs/lfs_debug.c

246

- ((char *)NEXT_FINFO(fs, sp->fip) - (char *)(sp->segsum))

sys/ufs/lfs/lfs_debug.c

249

- LFS_INUMSIZE(fs)*((sp->ninodes+LFS_INOPB(fs)-1) / LFS_INOPB(fs));

sys/ufs/lfs/lfs_debug.c

263

lfs_sb_getsumsize(fs)-sp->sum_bytes_left,

sys/ufs/lfs/lfs_debug.c

267

&& ((char *)(sp->segsum))[lfs_sb_getsumsize(fs)

sys/ufs/lfs/lfs_debug.c

268

- sizeof(int32_t) * ((sp->ninodes+LFS_INOPB(fs)-1) / LFS_INOPB(fs))

sys/ufs/lfs/lfs_debug.c

272

lfs_sb_getsumsize(fs)-sp->sum_bytes_left,

sys/ufs/lfs/lfs_debug.c

281

lfs_check_bpp(struct lfs *fs, struct segment *sp, char *file, int line)

sys/ufs/lfs/lfs_debug.c

287

devvp = VTOI(fs->lfs_ivnode)->i_devvp;

sys/ufs/lfs/lfs_debug.c

308

blkno += LFS_FSBTODB(fs, lfs_btofsb(fs, (*bpp)->b_bcount));

sys/ufs/lfs/lfs_extern.h

146

# define DEBUG_CHECK_FREELIST(fs) \

sys/ufs/lfs/lfs_extern.h

149

lfs_check_freelist((fs), __func__, __LINE__); \

sys/ufs/lfs/lfs_extern.h

152

# define DEBUG_CHECK_FREELIST(fs)

sys/ufs/lfs/lfs_extern.h

245

void lfs_acquire_finfo(struct lfs *fs, ino_t, int);

sys/ufs/lfs/lfs_extern.h

246

void lfs_release_finfo(struct lfs *fs);

sys/ufs/lfs/lfs_inode.c

101

lfs_ifind(struct lfs *fs, ino_t ino, struct buf *bp)

sys/ufs/lfs/lfs_inode.c

106

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_inode.c

112

num = LFS_INOPB(fs);

sys/ufs/lfs/lfs_inode.c

114

ldip = DINO_IN_BLOCK(fs, bp->b_data, i);

sys/ufs/lfs/lfs_inode.c

115

if (lfs_dino_getinumber(fs, ldip) == ino)

sys/ufs/lfs/lfs_inode.c

120

printf("offset is 0x%jx (seg %d)\n", (uintmax_t)lfs_sb_getoffset(fs),

sys/ufs/lfs/lfs_inode.c

121

lfs_dtosn(fs, lfs_sb_getoffset(fs)));

sys/ufs/lfs/lfs_inode.c

123

(uintmax_t)LFS_DBTOFSB(fs, bp->b_blkno),

sys/ufs/lfs/lfs_inode.c

124

lfs_dtosn(fs, LFS_DBTOFSB(fs, bp->b_blkno)));

sys/ufs/lfs/lfs_inode.c

134

struct lfs *fs = VFSTOULFS(vp->v_mount)->um_lfs;

sys/ufs/lfs/lfs_inode.c

138

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_inode.c

170

++fs->lfs_diropwait;

sys/ufs/lfs/lfs_inode.c

178

if (fs->lfs_dirops == 0)

sys/ufs/lfs/lfs_inode.c

181

mtsleep(&fs->lfs_writer, PRIBIO+1, "lfs_fsync",

sys/ufs/lfs/lfs_inode.c

186

--fs->lfs_diropwait;

sys/ufs/lfs/lfs_inode.c

187

fs->lfs_writer++;

sys/ufs/lfs/lfs_inode.c

189

KASSERT(fs->lfs_dirops == 0);

sys/ufs/lfs/lfs_inode.c

190

lfs_flush_fs(fs, SEGM_SYNC);

sys/ufs/lfs/lfs_inode.c

195

if (--fs->lfs_writer == 0)

sys/ufs/lfs/lfs_inode.c

196

cv_broadcast(&fs->lfs_diropscv);

sys/ufs/lfs/lfs_inode.c

220

struct lfs *fs;

sys/ufs/lfs/lfs_inode.c

242

fs = oip->i_lfs;

sys/ufs/lfs/lfs_inode.c

245

(oip->i_size < fs->um_maxsymlinklen ||

sys/ufs/lfs/lfs_inode.c

246

(fs->um_maxsymlinklen == 0 &&

sys/ufs/lfs/lfs_inode.c

247

lfs_dino_getblocks(fs, oip->i_din) == 0))) {

sys/ufs/lfs/lfs_inode.c

252

lfs_dino_setsize(fs, oip->i_din, 0);

sys/ufs/lfs/lfs_inode.c

262

lfs_imtime(fs);

sys/ufs/lfs/lfs_inode.c

264

usepc = (ovp->v_type == VREG && ovp != fs->lfs_ivnode);

sys/ufs/lfs/lfs_inode.c

266

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_inode.c

273

if (length > fs->um_maxfilesize)

sys/ufs/lfs/lfs_inode.c

279

if (lfs_lblkno(fs, osize) < ULFS_NDADDR &&

sys/ufs/lfs/lfs_inode.c

280

lfs_lblkno(fs, osize) != lfs_lblkno(fs, length) &&

sys/ufs/lfs/lfs_inode.c

281

lfs_blkroundup(fs, osize) != osize) {

sys/ufs/lfs/lfs_inode.c

284

eob = lfs_blkroundup(fs, osize);

sys/ufs/lfs/lfs_inode.c

296

trunc_page(osize & lfs_sb_getbmask(fs)),

sys/ufs/lfs/lfs_inode.c

312

oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + lfs_sb_getbsize(fs) - 1) - 1;

sys/ufs/lfs/lfs_inode.c

315

error = lfs_reserve(fs, ovp, NULL,

sys/ufs/lfs/lfs_inode.c

316

lfs_btofsb(fs, (ULFS_NIADDR + 2) << lfs_sb_getbshift(fs)));

sys/ufs/lfs/lfs_inode.c

321

lfs_reserve(fs, ovp, NULL,

sys/ufs/lfs/lfs_inode.c

322

-lfs_btofsb(fs, (ULFS_NIADDR + 2) << lfs_sb_getbshift(fs)));

sys/ufs/lfs/lfs_inode.c

326

lfs_dino_setsize(fs, oip->i_din, oip->i_size);

sys/ufs/lfs/lfs_inode.c

330

oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + lfs_sb_getbsize(fs) - 1) - 1;

sys/ufs/lfs/lfs_inode.c

335

if ((error = lfs_reserve(fs, ovp, NULL,

sys/ufs/lfs/lfs_inode.c

336

lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)))) != 0)

sys/ufs/lfs/lfs_inode.c

347

offset = lfs_blkoff(fs, length);

sys/ufs/lfs/lfs_inode.c

351

if (ovp != fs->lfs_ivnode)

sys/ufs/lfs/lfs_inode.c

352

lfs_prelock(fs, 0);

sys/ufs/lfs/lfs_inode.c

355

lfs_dino_setsize(fs, oip->i_din, oip->i_size);

sys/ufs/lfs/lfs_inode.c

357

lbn = lfs_lblkno(fs, length);

sys/ufs/lfs/lfs_inode.c

363

lfs_reserve(fs, ovp, NULL,

sys/ufs/lfs/lfs_inode.c

364

-lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));

sys/ufs/lfs/lfs_inode.c

368

odb = lfs_btofsb(fs, bp->b_bcount);

sys/ufs/lfs/lfs_inode.c

370

lfs_dino_setsize(fs, oip->i_din, oip->i_size);

sys/ufs/lfs/lfs_inode.c

371

size = lfs_blksize(fs, oip, lbn);

sys/ufs/lfs/lfs_inode.c

382

lfs_sb_addavail(fs, odb - lfs_btofsb(fs, size));

sys/ufs/lfs/lfs_inode.c

404

lfs_reserve(fs, ovp, NULL,

sys/ufs/lfs/lfs_inode.c

405

-lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));

sys/ufs/lfs/lfs_inode.c

408

xlbn = lfs_lblkno(fs, length);

sys/ufs/lfs/lfs_inode.c

409

size = lfs_blksize(fs, oip, xlbn);

sys/ufs/lfs/lfs_inode.c

410

eoz = MIN(lfs_lblktosize(fs, xlbn) + size, osize);

sys/ufs/lfs/lfs_inode.c

420

lfs_reserve(fs, ovp, NULL,

sys/ufs/lfs/lfs_inode.c

421

-lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));

sys/ufs/lfs/lfs_inode.c

430

lfs_dino_setsize(fs, oip->i_din, oip->i_size);

sys/ufs/lfs/lfs_inode.c

440

if (length > QUAD_MAX - lfs_sb_getbsize(fs))

sys/ufs/lfs/lfs_inode.c

441

lastblock = lfs_lblkno(fs, QUAD_MAX - lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_inode.c

443

lastblock = lfs_lblkno(fs, length + lfs_sb_getbsize(fs) - 1) - 1;

sys/ufs/lfs/lfs_inode.c

445

lastiblock[DOUBLE] = lastiblock[SINGLE] - LFS_NINDIR(fs);

sys/ufs/lfs/lfs_inode.c

446

lastiblock[TRIPLE] = lastiblock[DOUBLE] - LFS_NINDIR(fs) * LFS_NINDIR(fs);

sys/ufs/lfs/lfs_inode.c

447

nblocks = lfs_btofsb(fs, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_inode.c

454

newblks[i] = lfs_dino_getdb(fs, oip->i_din, i);

sys/ufs/lfs/lfs_inode.c

457

newblks[ULFS_NDADDR + i] = lfs_dino_getib(fs, oip->i_din, i);

sys/ufs/lfs/lfs_inode.c

468

lfs_dino_setsize(fs, oip->i_din, oip->i_size);

sys/ufs/lfs/lfs_inode.c

477

indir_lbn[DOUBLE] = indir_lbn[SINGLE] - LFS_NINDIR(fs) - 1;

sys/ufs/lfs/lfs_inode.c

478

indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - LFS_NINDIR(fs) * LFS_NINDIR(fs) - 1;

sys/ufs/lfs/lfs_inode.c

480

bn = lfs_dino_getib(fs, oip->i_din, level);

sys/ufs/lfs/lfs_inode.c

491

if (lfs_dino_getib(fs, oip->i_din, level) > 0)

sys/ufs/lfs/lfs_inode.c

494

lfs_dino_setib(fs, oip->i_din, level, 0);

sys/ufs/lfs/lfs_inode.c

495

lfs_blkfree(fs, oip, bn, lfs_sb_getbsize(fs),

sys/ufs/lfs/lfs_inode.c

510

bn = lfs_dino_getdb(fs, oip->i_din, i);

sys/ufs/lfs/lfs_inode.c

513

bsize = lfs_blksize(fs, oip, i);

sys/ufs/lfs/lfs_inode.c

514

if (lfs_dino_getdb(fs, oip->i_din, i) > 0) {

sys/ufs/lfs/lfs_inode.c

517

real_released += lfs_btofsb(fs, obsize);

sys/ufs/lfs/lfs_inode.c

521

blocksreleased += lfs_btofsb(fs, bsize);

sys/ufs/lfs/lfs_inode.c

522

lfs_dino_setdb(fs, oip->i_din, i, 0);

sys/ufs/lfs/lfs_inode.c

523

lfs_blkfree(fs, oip, bn, obsize, &lastseg, &bc);

sys/ufs/lfs/lfs_inode.c

533

bn = lfs_dino_getdb(fs, oip->i_din, lastblock);

sys/ufs/lfs/lfs_inode.c

544

oldspace = lfs_blksize(fs, oip, lastblock);

sys/ufs/lfs/lfs_inode.c

550

lfs_dino_setsize(fs, oip->i_din, oip->i_size);

sys/ufs/lfs/lfs_inode.c

551

newspace = lfs_blksize(fs, oip, lastblock);

sys/ufs/lfs/lfs_inode.c

555

blocksreleased += lfs_btofsb(fs, oldspace - newspace);

sys/ufs/lfs/lfs_inode.c

560

real_released += lfs_btofsb(fs, olddspace - newspace);

sys/ufs/lfs/lfs_inode.c

567

lfs_update_seguse(fs, oip, lastseg, bc);

sys/ufs/lfs/lfs_inode.c

570

(lfs_dino_getib(fs, oip->i_din, level) == 0)),

sys/ufs/lfs/lfs_inode.c

574

(lfs_dino_getdb(fs, oip->i_din, i) == 0)),

sys/ufs/lfs/lfs_inode.c

585

lfs_dino_setsize(fs, oip->i_din, oip->i_size);

sys/ufs/lfs/lfs_inode.c

589

lfs_dino_setblocks(fs, oip->i_din,

sys/ufs/lfs/lfs_inode.c

590

lfs_dino_getblocks(fs, oip->i_din) - real_released);

sys/ufs/lfs/lfs_inode.c

591

lfs_sb_addbfree(fs, blocksreleased);

sys/ufs/lfs/lfs_inode.c

594

lfs_dino_getblocks(fs, oip->i_din) == 0),

sys/ufs/lfs/lfs_inode.c

597

lfs_dino_getblocks(fs, oip->i_din), oip->i_lfs_effnblks);

sys/ufs/lfs/lfs_inode.c

601

lfs_dino_getblocks(fs, oip->i_din), oip->i_lfs_effnblks);

sys/ufs/lfs/lfs_inode.c

608

TAILQ_REMOVE(&fs->lfs_pchainhd, oip, i_lfs_pchain);

sys/ufs/lfs/lfs_inode.c

616

lfs_reserve(fs, ovp, NULL,

sys/ufs/lfs/lfs_inode.c

617

-lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));

sys/ufs/lfs/lfs_inode.c

620

oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + lfs_sb_getbsize(fs) - 1) - 1;

sys/ufs/lfs/lfs_inode.c

621

if (ovp != fs->lfs_ivnode)

sys/ufs/lfs/lfs_inode.c

622

lfs_preunlock(fs);

sys/ufs/lfs/lfs_inode.c

628

lfs_blkfree(struct lfs *fs, struct inode *ip, daddr_t daddr,

sys/ufs/lfs/lfs_inode.c

634

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_inode.c

635

bsize = lfs_fragroundup(fs, bsize);

sys/ufs/lfs/lfs_inode.c

637

if (*lastseg != (seg = lfs_dtosn(fs, daddr))) {

sys/ufs/lfs/lfs_inode.c

638

error = lfs_update_seguse(fs, ip, *lastseg, *num);

sys/ufs/lfs/lfs_inode.c

650

lfs_update_seguse(struct lfs *fs, struct inode *ip, long lastseg, size_t num)

sys/ufs/lfs/lfs_inode.c

654

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_inode.c

674

lfs_finalize_seguse(struct lfs *fs, void *v)

sys/ufs/lfs/lfs_inode.c

681

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_inode.c

683

LFS_SEGENTRY(sup, fs, sd->segnum, bp);

sys/ufs/lfs/lfs_inode.c

693

LFS_WRITESEGENTRY(sup, fs, sd->segnum, bp);

sys/ufs/lfs/lfs_inode.c

701

lfs_finalize_ino_seguse(struct lfs *fs, struct inode *ip)

sys/ufs/lfs/lfs_inode.c

703

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_inode.c

704

lfs_finalize_seguse(fs, &ip->i_lfs_segdhd);

sys/ufs/lfs/lfs_inode.c

709

lfs_finalize_fs_seguse(struct lfs *fs)

sys/ufs/lfs/lfs_inode.c

711

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_inode.c

712

lfs_finalize_seguse(fs, &fs->lfs_segdhd);

sys/ufs/lfs/lfs_inode.c

731

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/lfs_inode.c

741

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_inode.c

749

factor *= LFS_NINDIR(fs);

sys/ufs/lfs/lfs_inode.c

753

nblocks = lfs_btofsb(fs, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_inode.c

763

bp = getblk(vp, lbn, lfs_sb_getbsize(fs), 0, 0);

sys/ufs/lfs/lfs_inode.c

766

trace(TR_BREADHIT, pack(vp, lfs_sb_getbsize(fs)), lbn);

sys/ufs/lfs/lfs_inode.c

768

trace(TR_BREADMISS, pack(vp, lfs_sb_getbsize(fs)), lbn);

sys/ufs/lfs/lfs_inode.c

773

bp->b_blkno = LFS_FSBTODB(fs, dbn);

sys/ufs/lfs/lfs_inode.c

789

bap = lfs_malloc(fs, lfs_sb_getbsize(fs), LFS_NB_IBLOCK);

sys/ufs/lfs/lfs_inode.c

790

memcpy(bap, bp->b_data, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_inode.c

793

for (i = last + 1; i < LFS_NINDIR(fs); i++) {

sys/ufs/lfs/lfs_inode.c

794

lfs_iblock_set(fs, bp->b_data, i, 0);

sys/ufs/lfs/lfs_inode.c

807

for (i = LFS_NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;

sys/ufs/lfs/lfs_inode.c

809

nb = lfs_iblock_get(fs, bap, i);

sys/ufs/lfs/lfs_inode.c

822

lfs_blkfree(fs, ip, nb, lfs_sb_getbsize(fs), lastsegp, bcp);

sys/ufs/lfs/lfs_inode.c

823

if (lfs_iblock_get(fs, bap, i) > 0)

sys/ufs/lfs/lfs_inode.c

833

nb = lfs_iblock_get(fs, bap, i);

sys/ufs/lfs/lfs_inode.c

846

lfs_free(fs, bap, LFS_NB_IBLOCK);

sys/ufs/lfs/lfs_inode.c

851

lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));

sys/ufs/lfs/lfs_inode.c

852

wakeup(&fs->lfs_availsleep);

sys/ufs/lfs/lfs_inode.c

874

struct lfs *fs;

sys/ufs/lfs/lfs_inode.c

883

fs = VTOI(vp)->i_lfs;

sys/ufs/lfs/lfs_inode.c

885

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_inode.c

902

lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));

sys/ufs/lfs/lfs_inode.c

903

wakeup(&fs->lfs_availsleep);

sys/ufs/lfs/lfs_inode.c

923

lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));

sys/ufs/lfs/lfs_inode.c

924

wakeup(&fs->lfs_availsleep);

sys/ufs/lfs/lfs_inode.h

267

# define LFS_BCLEAN_LOG(fs, bp)

sys/ufs/lfs/lfs_itimes.c

110

lfs_dino_setmtime(fs, ip->i_din, mod->tv_sec);

sys/ufs/lfs/lfs_itimes.c

111

lfs_dino_setmtimensec(fs, ip->i_din, mod->tv_nsec);

sys/ufs/lfs/lfs_itimes.c

119

lfs_dino_setctime(fs, ip->i_din, cre->tv_sec);

sys/ufs/lfs/lfs_itimes.c

120

lfs_dino_setctimensec(fs, ip->i_din, cre->tv_nsec);

sys/ufs/lfs/lfs_itimes.c

61

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/lfs_itimes.c

75

lfs_dino_setatime(fs, ip->i_din, acc->tv_sec);

sys/ufs/lfs/lfs_itimes.c

76

lfs_dino_setatimensec(fs, ip->i_din, acc->tv_nsec);

sys/ufs/lfs/lfs_itimes.c

77

if (fs->lfs_is64 || lfs_sb_getversion(fs) > 1) {

sys/ufs/lfs/lfs_itimes.c

82

if (!LFS_SEGLOCK_HELD(fs))

sys/ufs/lfs/lfs_itimes.c

83

lfs_fraglock_enter(fs, RW_READER);

sys/ufs/lfs/lfs_itimes.c

85

LFS_IENTRY(ifp, fs, ip->i_number, ibp);

sys/ufs/lfs/lfs_itimes.c

86

lfs_if_setatime_sec(fs, ifp, acc->tv_sec);

sys/ufs/lfs/lfs_itimes.c

87

lfs_if_setatime_nsec(fs, ifp, acc->tv_nsec);

sys/ufs/lfs/lfs_itimes.c

89

LFS_WRITEIENTRY(ifp, fs, ip->i_number, ibp);

sys/ufs/lfs/lfs_itimes.c

90

if (!LFS_SEGLOCK_HELD(fs))

sys/ufs/lfs/lfs_itimes.c

91

lfs_fraglock_exit(fs);

sys/ufs/lfs/lfs_itimes.c

96

fs->lfs_flags |= LFS_IFDIRTY;

sys/ufs/lfs/lfs_kclean.c

1001

fs->lfs_clean_accum += offset;

sys/ufs/lfs/lfs_kclean.c

1004

fs->lfs_lastcleaned = maxsn;

sys/ufs/lfs/lfs_kclean.c

1011

if (fs->lfs_flags & LFS_MUSTCLEAN) {

sys/ufs/lfs/lfs_kclean.c

1015

lfs_segwrite(fs->lfs_ivnode->v_mount,

sys/ufs/lfs/lfs_kclean.c

1017

lfs_segwrite(fs->lfs_ivnode->v_mount,

sys/ufs/lfs/lfs_kclean.c

1021

} else if (fs->lfs_clean_accum > target) {

sys/ufs/lfs/lfs_kclean.c

1023

lfs_segwrite(fs->lfs_ivnode->v_mount, SEGM_CKP);

sys/ufs/lfs/lfs_kclean.c

1024

fs->lfs_clean_accum = 0;

sys/ufs/lfs/lfs_kclean.c

1025

} else if (lfs_dtosn(fs, lfs_sb_getoffset(fs)) != oldsn

sys/ufs/lfs/lfs_kclean.c

1028

lfs_segwrite(fs->lfs_ivnode->v_mount, SEGM_CKP);

sys/ufs/lfs/lfs_kclean.c

1029

fs->lfs_clean_accum = 0;

sys/ufs/lfs/lfs_kclean.c

1047

lfs_rewrite_file(struct lfs *fs, ino_t *inoa, int len, bool scramble,

sys/ufs/lfs/lfs_kclean.c

1060

if ((error = lfs_cleanerlock(fs)) != 0)

sys/ufs/lfs/lfs_kclean.c

1062

lfs_seglock(fs, 0);

sys/ufs/lfs/lfs_kclean.c

1064

error = VFS_VGET(fs->lfs_ivnode->v_mount, inoa[i],

sys/ufs/lfs/lfs_kclean.c

1078

hiblk = lfs_lblkno(fs, ip->i_size + lfs_sb_getbsize(fs) - 1) - 1;

sys/ufs/lfs/lfs_kclean.c

108

num = LFS_INOPB(fs);

sys/ufs/lfs/lfs_kclean.c

1084

if (lfs_needsflush(fs)) {

sys/ufs/lfs/lfs_kclean.c

1085

lfs_segwrite(fs->lfs_ivnode->v_mount, 0);

sys/ufs/lfs/lfs_kclean.c

1088

error = bread(vp, lbn, lfs_blksize(fs, ip, lbn), 0, &bp);

sys/ufs/lfs/lfs_kclean.c

1094

*directp += lfs_btofsb(fs, bp->b_bcount);

sys/ufs/lfs/lfs_kclean.c

110

dip = DINO_IN_BLOCK(fs, lifa->buf, i);

sys/ufs/lfs/lfs_kclean.c

1104

lfs_segwrite(fs->lfs_ivnode->v_mount, 0);

sys/ufs/lfs/lfs_kclean.c

1105

*offsetp += lfs_btofsb(fs, fs->lfs_sp->bytes_written);

sys/ufs/lfs/lfs_kclean.c

1106

lfs_segunlock(fs);

sys/ufs/lfs/lfs_kclean.c

1107

lfs_cleanerunlock(fs);

sys/ufs/lfs/lfs_kclean.c

111

ino = lfs_dino_getinumber(fs, dip);

sys/ufs/lfs/lfs_kclean.c

1113

lfs_cleanctl(struct lfs *fs, struct lfs_autoclean_params *params)

sys/ufs/lfs/lfs_kclean.c

1117

fs->lfs_autoclean = *params;

sys/ufs/lfs/lfs_kclean.c

1120

switch (fs->lfs_autoclean.mode) {

sys/ufs/lfs/lfs_kclean.c

1139

fs->lfs_autoclean_status != LFS_AUTOCLEAN_STATUS_OFF) {

sys/ufs/lfs/lfs_kclean.c

114

true_addr = lfs_sb_getidaddr(fs);

sys/ufs/lfs/lfs_kclean.c

1140

cv_wait(&fs->lfs_cleanquitcv, &lfs_lock);

sys/ufs/lfs/lfs_kclean.c

1142

if (fs->lfs_clean_selector == NULL && cleanfunc != NULL)

sys/ufs/lfs/lfs_kclean.c

1151

if (fs->lfs_clean_selector != NULL && cleanfunc == NULL) {

sys/ufs/lfs/lfs_kclean.c

1159

fs->lfs_clean_selector = cleanfunc;

sys/ufs/lfs/lfs_kclean.c

117

LFS_IENTRY(ifp, fs, ino, ibp);

sys/ufs/lfs/lfs_kclean.c

118

true_addr = lfs_if_getdaddr(fs, ifp);

sys/ufs/lfs/lfs_kclean.c

124

LFS_ASSERT_MAXINO(fs, ino);

sys/ufs/lfs/lfs_kclean.c

133

vp = fs->lfs_ivnode;

sys/ufs/lfs/lfs_kclean.c

135

error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,

sys/ufs/lfs/lfs_kclean.c

140

KASSERT(VTOI(vp)->i_gen == lfs_dino_getgen(fs, dip));

sys/ufs/lfs/lfs_kclean.c

141

lfs_setclean(fs, vp);

sys/ufs/lfs/lfs_kclean.c

142

if (vp != fs->lfs_ivnode) {

sys/ufs/lfs/lfs_kclean.c

154

struct lfs *fs;

sys/ufs/lfs/lfs_kclean.c

165

fs = lifa->fs;

sys/ufs/lfs/lfs_kclean.c

167

devvp = VTOI(fs->lfs_ivnode)->i_devvp;

sys/ufs/lfs/lfs_kclean.c

170

error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),

sys/ufs/lfs/lfs_kclean.c

181

num = LFS_INOPB(fs);

sys/ufs/lfs/lfs_kclean.c

183

dip = DINO_IN_BLOCK(fs, lifa->buf, i);

sys/ufs/lfs/lfs_kclean.c

184

ino = lfs_dino_getinumber(fs, dip);

sys/ufs/lfs/lfs_kclean.c

187

true_addr = lfs_sb_getidaddr(fs);

sys/ufs/lfs/lfs_kclean.c

190

LFS_IENTRY(ifp, fs, ino, ibp);

sys/ufs/lfs/lfs_kclean.c

191

true_addr = lfs_if_getdaddr(fs, ifp);

sys/ufs/lfs/lfs_kclean.c

200

LFS_ASSERT_MAXINO(fs, ino);

sys/ufs/lfs/lfs_kclean.c

208

error = check_clean_list(fs, ino);

sys/ufs/lfs/lfs_kclean.c

211

error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,

sys/ufs/lfs/lfs_kclean.c

216

KASSERT(VTOI(vp)->i_gen == lfs_dino_getgen(fs, dip));

sys/ufs/lfs/lfs_kclean.c

219

lfs_setclean(fs, vp);

sys/ufs/lfs/lfs_kclean.c

220

lfs_writeinode(fs, fs->lfs_sp, VTOI(vp));

sys/ufs/lfs/lfs_kclean.c

232

rewrite_block(struct lfs *fs, struct vnode *vp, daddr_t lbn, daddr_t offset, size_t size, int *have_finfop)

sys/ufs/lfs/lfs_kclean.c

247

if (offset != 0 && LFS_DBTOFSB(fs, daddr) != offset)

sys/ufs/lfs/lfs_kclean.c

258

if (vp == fs->lfs_ivnode) {

sys/ufs/lfs/lfs_kclean.c

264

lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);

sys/ufs/lfs/lfs_kclean.c

265

fs->lfs_sp->vp = vp;

sys/ufs/lfs/lfs_kclean.c

276

while (lfs_gatherblock(fs->lfs_sp, bp, &bufcache_lock)) {

sys/ufs/lfs/lfs_kclean.c

282

KASSERT(fs->lfs_sp->cbpp[-1] == bp);

sys/ufs/lfs/lfs_kclean.c

288

check_clean_list(struct lfs *fs, ino_t ino)

sys/ufs/lfs/lfs_kclean.c

296

TAILQ_FOREACH(ip, &fs->lfs_cleanhd, i_lfs_clean) {

sys/ufs/lfs/lfs_kclean.c

307

struct lfs *fs;

sys/ufs/lfs/lfs_kclean.c

318

fs = lffa->fs;

sys/ufs/lfs/lfs_kclean.c

324

ino = lfs_fi_getino(fs, fip);

sys/ufs/lfs/lfs_kclean.c

325

gen = lfs_fi_getversion(fs, fip);

sys/ufs/lfs/lfs_kclean.c

328

vp = fs->lfs_ivnode;

sys/ufs/lfs/lfs_kclean.c

330

LFS_ASSERT_MAXINO(fs, ino);

sys/ufs/lfs/lfs_kclean.c

331

error = check_clean_list(fs, ino);

sys/ufs/lfs/lfs_kclean.c

335

error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,

sys/ufs/lfs/lfs_kclean.c

350

if (vp != NULL && vp != fs->lfs_ivnode) {

sys/ufs/lfs/lfs_kclean.c

355

bytes = ((lfs_fi_getnblocks(fs, fip) - 1) << lfs_sb_getbshift(fs))

sys/ufs/lfs/lfs_kclean.c

356

+ lfs_fi_getlastlength(fs, fip);

sys/ufs/lfs/lfs_kclean.c

357

*offsetp += lfs_btofsb(fs, bytes);

sys/ufs/lfs/lfs_kclean.c

367

lfs_setclean(fs, vp);

sys/ufs/lfs/lfs_kclean.c

368

size = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_kclean.c

370

for (j = 0; j < lfs_fi_getnblocks(fs, fip); ++j) {

sys/ufs/lfs/lfs_kclean.c

371

if (j == lfs_fi_getnblocks(fs, fip) - 1)

sys/ufs/lfs/lfs_kclean.c

372

size = lfs_fi_getlastlength(fs, fip);

sys/ufs/lfs/lfs_kclean.c

379

lbn = lfs_fi_getblock(fs, fip, j);

sys/ufs/lfs/lfs_kclean.c

380

error = rewrite_block(fs, vp, lbn, *offsetp,

sys/ufs/lfs/lfs_kclean.c

385

*fragsp += lfs_btofsb(fs, size);

sys/ufs/lfs/lfs_kclean.c

387

*offsetp += lfs_btofsb(fs, size);

sys/ufs/lfs/lfs_kclean.c

394

lfs_updatemeta(fs->lfs_sp);

sys/ufs/lfs/lfs_kclean.c

395

fs->lfs_sp->vp = NULL;

sys/ufs/lfs/lfs_kclean.c

396

lfs_release_finfo(fs);

sys/ufs/lfs/lfs_kclean.c

397

lfs_writeinode(fs, fs->lfs_sp, VTOI(vp));

sys/ufs/lfs/lfs_kclean.c

401

if (vp != fs->lfs_ivnode) {

sys/ufs/lfs/lfs_kclean.c

412

struct lfs *fs;

sys/ufs/lfs/lfs_kclean.c

421

fs = lffa->fs;

sys/ufs/lfs/lfs_kclean.c

426

ino = lfs_fi_getino(fs, fip);

sys/ufs/lfs/lfs_kclean.c

427

gen = lfs_fi_getversion(fs, fip);

sys/ufs/lfs/lfs_kclean.c

430

vp = fs->lfs_ivnode;

sys/ufs/lfs/lfs_kclean.c

432

LFS_ASSERT_MAXINO(fs, ino);

sys/ufs/lfs/lfs_kclean.c

433

error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,

sys/ufs/lfs/lfs_kclean.c

439

lfs_setclean(fs, vp);

sys/ufs/lfs/lfs_kclean.c

441

if (vp == fs->lfs_ivnode)

sys/ufs/lfs/lfs_kclean.c

450

bytes = ((lfs_fi_getnblocks(fs, fip) - 1) << lfs_sb_getbshift(fs))

sys/ufs/lfs/lfs_kclean.c

451

+ lfs_fi_getlastlength(fs, fip);

sys/ufs/lfs/lfs_kclean.c

452

*offsetp += lfs_btofsb(fs, bytes);

sys/ufs/lfs/lfs_kclean.c

461

lfs_rewrite_segment(struct lfs *fs, int sn, int *fragsp, kauth_cred_t cred, struct lwp *l)

sys/ufs/lfs/lfs_kclean.c

465

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_kclean.c

467

offset = lfs_sntod(fs, sn);

sys/ufs/lfs/lfs_kclean.c

468

lfs_skip_superblock(fs, &offset);

sys/ufs/lfs/lfs_kclean.c

469

endpseg = lfs_sntod(fs, sn + 1);

sys/ufs/lfs/lfs_kclean.c

474

lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,

sys/ufs/lfs/lfs_kclean.c

486

lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,

sys/ufs/lfs/lfs_kclean.c

496

lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,

sys/ufs/lfs/lfs_kclean.c

508

lfs_rewrite_segments(struct lfs *fs, int *snn, int len, int *directp, int *offsetp, struct lwp *l)

sys/ufs/lfs/lfs_kclean.c

516

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_kclean.c

521

lfs_writer_enter(fs, "rewritesegs");

sys/ufs/lfs/lfs_kclean.c

522

if ((error = lfs_cleanerlock(fs)) != 0) {

sys/ufs/lfs/lfs_kclean.c

523

lfs_writer_leave(fs);

sys/ufs/lfs/lfs_kclean.c

535

LFS_SEGENTRY(sup, fs, snn[i], bp);

sys/ufs/lfs/lfs_kclean.c

544

offset = lfs_sntod(fs, snn[i]);

sys/ufs/lfs/lfs_kclean.c

545

lfs_skip_superblock(fs, &offset);

sys/ufs/lfs/lfs_kclean.c

546

endpseg = lfs_sntod(fs, snn[i] + 1);

sys/ufs/lfs/lfs_kclean.c

549

lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,

sys/ufs/lfs/lfs_kclean.c

558

lfs_seglock(fs, SEGM_CLEAN);

sys/ufs/lfs/lfs_kclean.c

563

LFS_SEGENTRY(sup, fs, snn[i], bp);

sys/ufs/lfs/lfs_kclean.c

572

error = lfs_rewrite_segment(fs, snn[i], directp, cred, l);

sys/ufs/lfs/lfs_kclean.c

576

while (lfs_writeseg(fs, fs->lfs_sp))

sys/ufs/lfs/lfs_kclean.c

579

*offsetp = lfs_btofsb(fs, fs->lfs_sp->bytes_written);

sys/ufs/lfs/lfs_kclean.c

580

lfs_segunlock(fs);

sys/ufs/lfs/lfs_kclean.c

581

lfs_cleanerunlock(fs);

sys/ufs/lfs/lfs_kclean.c

582

lfs_writer_leave(fs);

sys/ufs/lfs/lfs_kclean.c

590

struct lfs *fs;

sys/ufs/lfs/lfs_kclean.c

601

fs = lifa->fs;

sys/ufs/lfs/lfs_kclean.c

603

devvp = VTOI(fs->lfs_ivnode)->i_devvp;

sys/ufs/lfs/lfs_kclean.c

606

error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),

sys/ufs/lfs/lfs_kclean.c

615

num = LFS_INOPB(fs);

sys/ufs/lfs/lfs_kclean.c

617

dip = DINO_IN_BLOCK(fs, dbp->b_data, i);

sys/ufs/lfs/lfs_kclean.c

618

ino = lfs_dino_getinumber(fs, dip);

sys/ufs/lfs/lfs_kclean.c

621

true_addr = lfs_sb_getidaddr(fs);

sys/ufs/lfs/lfs_kclean.c

624

LFS_IENTRY(ifp, fs, ino, ibp);

sys/ufs/lfs/lfs_kclean.c

625

true_addr = lfs_if_getdaddr(fs, ifp);

sys/ufs/lfs/lfs_kclean.c

641

struct lfs *fs;

sys/ufs/lfs/lfs_kclean.c

651

fs = lffa->fs;

sys/ufs/lfs/lfs_kclean.c

656

ino = lfs_fi_getino(fs, fip);

sys/ufs/lfs/lfs_kclean.c

657

gen = lfs_fi_getversion(fs, fip);

sys/ufs/lfs/lfs_kclean.c

658

error = VFS_VGET(fs->lfs_ivnode->v_mount, ino, LK_EXCLUSIVE|LK_NOWAIT, &vp);

sys/ufs/lfs/lfs_kclean.c

673

bytes = ((lfs_fi_getnblocks(fs, fip) - 1)

sys/ufs/lfs/lfs_kclean.c

674

<< lfs_sb_getbshift(fs))

sys/ufs/lfs/lfs_kclean.c

675

+ lfs_fi_getlastlength(fs, fip);

sys/ufs/lfs/lfs_kclean.c

676

*offsetp += lfs_btofsb(fs, bytes);

sys/ufs/lfs/lfs_kclean.c

685

size = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_kclean.c

686

for (j = 0; j < lfs_fi_getnblocks(fs, fip); ++j) {

sys/ufs/lfs/lfs_kclean.c

687

if (j == lfs_fi_getnblocks(fs, fip) - 1)

sys/ufs/lfs/lfs_kclean.c

688

size = lfs_fi_getlastlength(fs, fip);

sys/ufs/lfs/lfs_kclean.c

690

lbn = lfs_fi_getblock(fs, fip, j);

sys/ufs/lfs/lfs_kclean.c

698

if (LFS_DBTOFSB(fs, daddr) == *offsetp) {

sys/ufs/lfs/lfs_kclean.c

703

*offsetp += lfs_btofsb(fs, size);

sys/ufs/lfs/lfs_kclean.c

714

lfs_checkempty(struct lfs *fs, int sn, kauth_cred_t cred, struct lwp *l)

sys/ufs/lfs/lfs_kclean.c

719

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_kclean.c

721

offset = lfs_sntod(fs, sn);

sys/ufs/lfs/lfs_kclean.c

722

lfs_skip_superblock(fs, &offset);

sys/ufs/lfs/lfs_kclean.c

723

endpseg = lfs_sntod(fs, sn + 1);

sys/ufs/lfs/lfs_kclean.c

726

error = lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,

sys/ufs/lfs/lfs_kclean.c

737

segselect_greedy(struct lfs *fs, int sn, SEGUSE *sup)

sys/ufs/lfs/lfs_kclean.c

739

return lfs_sb_getssize(fs) - sup->su_nbytes;

sys/ufs/lfs/lfs_kclean.c

743

segselect_cb_rosenblum(struct lfs *fs, int sn, SEGUSE *sup, long age)

sys/ufs/lfs/lfs_kclean.c

747

benefit = (int64_t)lfs_sb_getssize(fs) - sup->su_nbytes -

sys/ufs/lfs/lfs_kclean.c

748

(sup->su_nsums + 1) * lfs_sb_getfsize(fs);

sys/ufs/lfs/lfs_kclean.c

751

if (lfs_sb_getbsize(fs) > lfs_sb_getfsize(fs)) /* fragmentation */

sys/ufs/lfs/lfs_kclean.c

752

benefit -= (lfs_sb_getbsize(fs) / 2);

sys/ufs/lfs/lfs_kclean.c

757

cost = lfs_sb_getssize(fs) + sup->su_nbytes;

sys/ufs/lfs/lfs_kclean.c

762

segselect_cb_time(struct lfs *fs, int sn, SEGUSE *sup)

sys/ufs/lfs/lfs_kclean.c

769

return segselect_cb_rosenblum(fs, sn, sup, age);

sys/ufs/lfs/lfs_kclean.c

783

segselect_cb_serial(struct lfs *fs, int sn, SEGUSE *sup)

sys/ufs/lfs/lfs_kclean.c

790

addr = lfs_segtod(fs, sn);

sys/ufs/lfs/lfs_kclean.c

791

lfs_skip_superblock(fs, &addr);

sys/ufs/lfs/lfs_kclean.c

792

bread(fs->lfs_devvp, LFS_FSBTODB(fs, addr),

sys/ufs/lfs/lfs_kclean.c

793

lfs_sb_getsumsize(fs), 0, &bp);

sys/ufs/lfs/lfs_kclean.c

794

magic = lfs_ss_getmagic(fs, ((SEGSUM *)bp->b_data));

sys/ufs/lfs/lfs_kclean.c

795

serial = lfs_ss_getserial(fs, ((SEGSUM *)bp->b_data));

sys/ufs/lfs/lfs_kclean.c

801

age = lfs_sb_getserial(fs) - serial;

sys/ufs/lfs/lfs_kclean.c

802

return segselect_cb_rosenblum(fs, sn, sup, age);

sys/ufs/lfs/lfs_kclean.c

81

struct lfs *fs;

sys/ufs/lfs/lfs_kclean.c

811

struct lfs *fs;

sys/ufs/lfs/lfs_kclean.c

840

fs = VFSTOULFS(mp)->um_lfs;

sys/ufs/lfs/lfs_kclean.c

843

if (fs->lfs_clean_selector == NULL) {

sys/ufs/lfs/lfs_kclean.c

845

if (fs->lfs_autoclean_status) {

sys/ufs/lfs/lfs_kclean.c

846

fs->lfs_autoclean_status =

sys/ufs/lfs/lfs_kclean.c

848

cv_broadcast(&fs->lfs_cleanquitcv);

sys/ufs/lfs/lfs_kclean.c

853

cleaned_something += clean(fs);

sys/ufs/lfs/lfs_kclean.c

884

clean(struct lfs *fs)

sys/ufs/lfs/lfs_kclean.c

896

func = fs->lfs_clean_selector;

sys/ufs/lfs/lfs_kclean.c

901

thresh = fs->lfs_autoclean.thresh;

sys/ufs/lfs/lfs_kclean.c

902

if (fs->lfs_flags & LFS_MUSTCLEAN)

sys/ufs/lfs/lfs_kclean.c

911

bfree = lfs_sb_getbfree(fs)

sys/ufs/lfs/lfs_kclean.c

912

+ lfs_segtod(fs, 1) * lfs_sb_getminfree(fs);

sys/ufs/lfs/lfs_kclean.c

913

avail = lfs_sb_getavail(fs) - fs->lfs_ravail - fs->lfs_favail;

sys/ufs/lfs/lfs_kclean.c

916

thresh = lfs_sb_getssize(fs) * (bfree - avail)

sys/ufs/lfs/lfs_kclean.c

917

/ (lfs_sb_getsize(fs) - avail);

sys/ufs/lfs/lfs_kclean.c

918

if (thresh > lfs_sb_getsumsize(fs) + 5 * lfs_sb_getbsize(fs))

sys/ufs/lfs/lfs_kclean.c

919

thresh = lfs_sb_getsumsize(fs) + 5 * lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_kclean.c

92

fs = lifa->fs;

sys/ufs/lfs/lfs_kclean.c

920

if (thresh > lfs_sb_getssize(fs) - lfs_sb_getbsize(fs))

sys/ufs/lfs/lfs_kclean.c

924

target = fs->lfs_autoclean.target;

sys/ufs/lfs/lfs_kclean.c

927

target = lfs_segtod(fs, 1) / 2;

sys/ufs/lfs/lfs_kclean.c

930

oldsn = lfs_dtosn(fs, lfs_sb_getoffset(fs));

sys/ufs/lfs/lfs_kclean.c

935

for (sn = 0; sn < lfs_sb_getnseg(fs); sn++) {

sys/ufs/lfs/lfs_kclean.c

938

LFS_SEGENTRY(sup, fs, sn, bp);

sys/ufs/lfs/lfs_kclean.c

94

devvp = VTOI(fs->lfs_ivnode)->i_devvp;

sys/ufs/lfs/lfs_kclean.c

950

prio = (*func)(fs, sn, sup);

sys/ufs/lfs/lfs_kclean.c

968

nclean, (int)lfs_sb_getnseg(fs), nzero, nempty, nready,

sys/ufs/lfs/lfs_kclean.c

97

error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),

sys/ufs/lfs/lfs_kclean.c

977

if (maxprio > 0 && fs->lfs_lastcleaned == maxsn) {

sys/ufs/lfs/lfs_kclean.c

978

LFS_SEGENTRY(sup, fs, maxsn, bp);

sys/ufs/lfs/lfs_kclean.c

980

LFS_WRITESEGENTRY(sup, fs, sn, bp);

sys/ufs/lfs/lfs_kclean.c

991

lfs_seguse_clrflag_all(fs, SEGUSE_ERROR);

sys/ufs/lfs/lfs_kclean.c

997

(void)lfs_rewrite_segments(fs, &maxsn, 1,

sys/ufs/lfs/lfs_kernel.h

71

#define LFS_SEGLOCK_HELD(fs) lfs_seglock_held(fs)

sys/ufs/lfs/lfs_kernel.h

81

struct lfs *fs; /* LFS that this belongs to */

sys/ufs/lfs/lfs_pages.c

188

write_and_wait(struct lfs *fs, struct vnode *vp, struct vm_page *pg,

sys/ufs/lfs/lfs_pages.c

194

struct segment *sp = fs->lfs_sp;

sys/ufs/lfs/lfs_pages.c

206

lfs_release_finfo(fs);

sys/ufs/lfs/lfs_pages.c

207

(void) lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_pages.c

213

lfs_acquire_finfo(fs, ip->i_number,

sys/ufs/lfs/lfs_pages.c

241

check_dirty(struct lfs *fs, struct vnode *vp,

sys/ufs/lfs/lfs_pages.c

253

int pages_per_block = lfs_sb_getbsize(fs) >> PAGE_SHIFT;

sys/ufs/lfs/lfs_pages.c

257

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_pages.c

262

KASSERT((soff & (lfs_sb_getbsize(fs) - 1)) == 0);

sys/ufs/lfs/lfs_pages.c

287

(pagedaemon || LFS_SEGLOCK_HELD(fs))) {

sys/ufs/lfs/lfs_pages.c

317

soff += MAX(PAGE_SIZE, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_pages.c

362

soff += MAX(PAGE_SIZE, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_pages.c

425

struct lfs *fs;

sys/ufs/lfs/lfs_pages.c

441

fs = ip->i_lfs;

sys/ufs/lfs/lfs_pages.c

450

if (vp == fs->lfs_ivnode || vp->v_type != VREG) {

sys/ufs/lfs/lfs_pages.c

474

TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);

sys/ufs/lfs/lfs_pages.c

482

blkeof = lfs_blkroundup(fs, ip->i_size);

sys/ufs/lfs/lfs_pages.c

496

for (off = origoffset; off < blkeof; off += lfs_sb_getbsize(fs)) {

sys/ufs/lfs/lfs_pages.c

523

startoffset = origoffset & ~(lfs_sb_getbmask(fs));

sys/ufs/lfs/lfs_pages.c

524

max_endoffset = (trunc_page(LLONG_MAX) >> lfs_sb_getbshift(fs))

sys/ufs/lfs/lfs_pages.c

525

<< lfs_sb_getbshift(fs);

sys/ufs/lfs/lfs_pages.c

532

endoffset = round_page(lfs_blkroundup(fs, origendoffset));

sys/ufs/lfs/lfs_pages.c

601

r = check_dirty(fs, vp, startoffset, endoffset, blkeof,

sys/ufs/lfs/lfs_pages.c

657

TAILQ_INSERT_TAIL(&fs->lfs_pchainhd, ip, i_lfs_pchain);

sys/ufs/lfs/lfs_pages.c

685

lfs_flush_fs(fs, sync ? SEGM_SYNC : 0);

sys/ufs/lfs/lfs_pages.c

727

error = lfs_seglock(fs, (sync ? SEGM_SYNC : 0));

sys/ufs/lfs/lfs_pages.c

733

lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);

sys/ufs/lfs/lfs_pages.c

735

sp = fs->lfs_sp;

sys/ufs/lfs/lfs_pages.c

743

fs->lfs_reclino = ip->i_number;

sys/ufs/lfs/lfs_pages.c

754

lfs_ss_setflags(fs, ssp,

sys/ufs/lfs/lfs_pages.c

755

lfs_ss_getflags(fs, ssp) | (SS_DIROP|SS_CONT));

sys/ufs/lfs/lfs_pages.c

770

if (check_dirty(fs, vp, startoffset, endoffset, blkeof,

sys/ufs/lfs/lfs_pages.c

772

write_and_wait(fs, vp, busypg, seglocked, NULL);

sys/ufs/lfs/lfs_pages.c

775

lfs_release_finfo(fs);

sys/ufs/lfs/lfs_pages.c

776

lfs_segunlock(fs);

sys/ufs/lfs/lfs_pages.c

793

ip->i_number, (uintmax_t)lfs_sb_getoffset(fs),

sys/ufs/lfs/lfs_pages.c

794

lfs_dtosn(fs, lfs_sb_getoffset(fs))));

sys/ufs/lfs/lfs_pages.c

798

write_and_wait(fs, vp, busypg, seglocked, "again");

sys/ufs/lfs/lfs_pages.c

802

lfs_sb_getcurseg(fs) != fs->lfs_startseg)

sys/ufs/lfs/lfs_pages.c

808

(int)ip->i_number, (uintmax_t)lfs_sb_getoffset(fs),

sys/ufs/lfs/lfs_pages.c

809

lfs_dtosn(fs, lfs_sb_getoffset(fs))));

sys/ufs/lfs/lfs_pages.c

833

lfs_gather(fs, fs->lfs_sp, vp, lfs_match_indir);

sys/ufs/lfs/lfs_pages.c

834

lfs_gather(fs, fs->lfs_sp, vp, lfs_match_dindir);

sys/ufs/lfs/lfs_pages.c

835

lfs_gather(fs, fs->lfs_sp, vp, lfs_match_tindir);

sys/ufs/lfs/lfs_pages.c

859

lfs_release_finfo(fs);

sys/ufs/lfs/lfs_pages.c

860

lfs_writeseg(fs, fs->lfs_sp);

sys/ufs/lfs/lfs_pages.c

869

TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);

sys/ufs/lfs/lfs_pages.c

879

lfs_segunlock(fs);

sys/ufs/lfs/lfs_rename.c

318

struct lfs *fs;

sys/ufs/lfs/lfs_rename.c

325

fs = VTOI(vp)->i_lfs;

sys/ufs/lfs/lfs_rename.c

327

return lfs_dir_getnamlen(fs, ep);

sys/ufs/lfs/lfs_rename.c

341

struct lfs *fs;

sys/ufs/lfs/lfs_rename.c

366

fs = ump->um_lfs;

sys/ufs/lfs/lfs_rename.c

369

KASSERT(fs == VTOI(dvp)->i_lfs);

sys/ufs/lfs/lfs_rename.c

371

dirblksiz = fs->um_dirblksiz;

sys/ufs/lfs/lfs_rename.c

419

reclen = lfs_dir_getreclen(fs, ep);

sys/ufs/lfs/lfs_rename.c

421

if (lfs_dir_getino(fs, ep) == 0)

sys/ufs/lfs/lfs_rename.c

424

if (lfs_dir_getino(fs, ep) == ULFS_WINO)

sys/ufs/lfs/lfs_rename.c

430

if (memcmp(lfs_dir_nameptr(fs, ep), fcnp->cn_nameptr, fcnp->cn_namelen))

sys/ufs/lfs/lfs_rename.c

575

struct lfs *fs;

sys/ufs/lfs/lfs_rename.c

587

fs = VTOI(vp)->i_lfs;

sys/ufs/lfs/lfs_rename.c

594

dotdot = lfs_dirtemplate_dotdot(fs, &dirbuf);

sys/ufs/lfs/lfs_rename.c

595

name = lfs_dirtemplate_dotdotname(fs, &dirbuf);

sys/ufs/lfs/lfs_rename.c

596

if (lfs_dir_getnamlen(fs, dotdot) != 2 ||

sys/ufs/lfs/lfs_rename.c

602

*ino_ret = lfs_dir_getino(fs, dotdot);

sys/ufs/lfs/lfs_rename.c

734

struct lfs *fs;

sys/ufs/lfs/lfs_rename.c

763

fs = VTOI(fdvp)->i_lfs;

sys/ufs/lfs/lfs_rename.c

764

KASSERT(fs == VTOI(tdvp)->i_lfs);

sys/ufs/lfs/lfs_rename.c

940

position = LFS_DIRECTSIZ(fs, 1);

sys/ufs/lfs/lfs_rfw.c

1000

LFS_SEGENTRY(sup, fs, sn, bp);

sys/ufs/lfs/lfs_rfw.c

1006

lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));

sys/ufs/lfs/lfs_rfw.c

1008

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, endpseg), bp);

sys/ufs/lfs/lfs_rfw.c

1010

LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, endpseg), bp);

sys/ufs/lfs/lfs_rfw.c

1021

lfs_parse_pseg(fs, &offset, nextserial++, cred,

sys/ufs/lfs/lfs_rfw.c

1024

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_rfw.c

1034

lfs_parse_pseg(fs, &offset, nextserial++, cred,

sys/ufs/lfs/lfs_rfw.c

1037

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_rfw.c

1047

lfs_parse_pseg(fs, &offset, nextserial++, cred,

sys/ufs/lfs/lfs_rfw.c

1050

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_rfw.c

1056

lfs_sb_setserial(fs, endserial);

sys/ufs/lfs/lfs_rfw.c

1068

lfs_sb_getfsmnt(fs), rblkcnt);

sys/ufs/lfs/lfs_rfw.c

1075

lfs_reset_avail(fs);

sys/ufs/lfs/lfs_rfw.c

1092

struct lfs *fs;

sys/ufs/lfs/lfs_rfw.c

1095

fs = VFSTOULFS(mp)->um_lfs;

sys/ufs/lfs/lfs_rfw.c

1099

if (vp == fs->lfs_ivnode)

sys/ufs/lfs/lfs_rfw.c

111

lfs_rf_valloc(struct lfs *fs, ino_t ino, int vers, struct lwp *l,

sys/ufs/lfs/lfs_rfw.c

120

LFS_ASSERT_MAXINO(fs, ino);

sys/ufs/lfs/lfs_rfw.c

122

ASSERT_SEGLOCK(fs); /* XXX it doesn't, really */

sys/ufs/lfs/lfs_rfw.c

129

error = VFS_VGET(fs->lfs_ivnode->v_mount, ino, LK_EXCLUSIVE, &vp);

sys/ufs/lfs/lfs_rfw.c

139

: lfs_dino_getnlink(fs, dip)), (intmax_t)vers));

sys/ufs/lfs/lfs_rfw.c

147

&& lfs_dino_getnlink(fs, dip) > 0) {

sys/ufs/lfs/lfs_rfw.c

157

vp->v_type = IFTOVT(lfs_dino_getmode(fs, dip));

sys/ufs/lfs/lfs_rfw.c

158

update_inoblk_copy_dinode(fs, ip->i_din, dip);

sys/ufs/lfs/lfs_rfw.c

168

(int)lfs_dino_getgen(fs, ip->i_din)));

sys/ufs/lfs/lfs_rfw.c

185

va.va_type = IFTOVT(lfs_dino_getmode(fs, dip));

sys/ufs/lfs/lfs_rfw.c

186

va.va_mode = lfs_dino_getmode(fs, dip) & ALLPERMS;

sys/ufs/lfs/lfs_rfw.c

189

error = vcache_new(fs->lfs_ivnode->v_mount, NULL, &va, NOCRED, NULL,

sys/ufs/lfs/lfs_rfw.c

198

update_inoblk_copy_dinode(fs, ip->i_din, dip);

sys/ufs/lfs/lfs_rfw.c

203

(int)lfs_dino_getblocks(fs, ip->i_din)));

sys/ufs/lfs/lfs_rfw.c

218

update_meta(struct lfs *fs, ino_t ino, int vers, daddr_t lbn,

sys/ufs/lfs/lfs_rfw.c

233

LFS_ASSERT_MAXINO(fs, ino);

sys/ufs/lfs/lfs_rfw.c

238

if ((error = lfs_rf_valloc(fs, ino, vers, l, &vp, NULL)) != 0)

sys/ufs/lfs/lfs_rfw.c

248

if ((error = lfs_balloc(vp, (lbn << lfs_sb_getbshift(fs)),

sys/ufs/lfs/lfs_rfw.c

257

lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));

sys/ufs/lfs/lfs_rfw.c

263

(int)lfs_dino_getblocks(fs, ip->i_din)));

sys/ufs/lfs/lfs_rfw.c

279

loff = lfs_lblktosize(fs, lbn);

sys/ufs/lfs/lfs_rfw.c

280

if (loff >= (ULFS_NDADDR << lfs_sb_getbshift(fs))) {

sys/ufs/lfs/lfs_rfw.c

285

newsize = loff + size - lfs_fsbtob(fs, 1) + 1;

sys/ufs/lfs/lfs_rfw.c

291

lfs_dino_setsize(fs, ip->i_din, newsize);

sys/ufs/lfs/lfs_rfw.c

300

lfs_update_single(fs, NULL, vp, lbn, ndaddr, size);

sys/ufs/lfs/lfs_rfw.c

302

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, ndaddr), bp);

sys/ufs/lfs/lfs_rfw.c

305

(intmax_t)lfs_dtosn(fs, ndaddr),

sys/ufs/lfs/lfs_rfw.c

311

LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, ndaddr), bp);

sys/ufs/lfs/lfs_rfw.c

315

if (!(ip->i_lfs_effnblks >= lfs_dino_getblocks(fs, ip->i_din))

sys/ufs/lfs/lfs_rfw.c

317

|| !(lfs_lblkno(fs, ip->i_size) > ULFS_NDADDR ||

sys/ufs/lfs/lfs_rfw.c

318

ip->i_lfs_effnblks == lfs_dino_getblocks(fs, ip->i_din))

sys/ufs/lfs/lfs_rfw.c

324

(intmax_t)lfs_dino_getblocks(fs, ip->i_din));

sys/ufs/lfs/lfs_rfw.c

326

KASSERT(ip->i_lfs_effnblks >= lfs_dino_getblocks(fs, ip->i_din));

sys/ufs/lfs/lfs_rfw.c

328

KASSERT(lfs_lblkno(fs, ip->i_size) > ULFS_NDADDR ||

sys/ufs/lfs/lfs_rfw.c

329

ip->i_lfs_effnblks == lfs_dino_getblocks(fs, ip->i_din));

sys/ufs/lfs/lfs_rfw.c

336

if (LFS_DBTOFSB(fs, odaddr) != ndaddr)

sys/ufs/lfs/lfs_rfw.c

348

update_inoblk_copy_dinode(struct lfs *fs,

sys/ufs/lfs/lfs_rfw.c

351

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_rfw.c

385

&& src->di_size < lfs_sb_getmaxsymlinklen(fs)) {

sys/ufs/lfs/lfs_rfw.c

404

&& src->di_size < lfs_sb_getmaxsymlinklen(fs)) {

sys/ufs/lfs/lfs_rfw.c

413

struct lfs *fs;

sys/ufs/lfs/lfs_rfw.c

427

fs = lifa->fs;

sys/ufs/lfs/lfs_rfw.c

430

devvp = VTOI(fs->lfs_ivnode)->i_devvp;

sys/ufs/lfs/lfs_rfw.c

436

error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),

sys/ufs/lfs/lfs_rfw.c

445

num = LFS_INOPB(fs);

sys/ufs/lfs/lfs_rfw.c

447

dip = DINO_IN_BLOCK(fs, buf, i);

sys/ufs/lfs/lfs_rfw.c

448

ino = lfs_dino_getinumber(fs, dip);

sys/ufs/lfs/lfs_rfw.c

452

LFS_ASSERT_MAXINO(fs, ino);

sys/ufs/lfs/lfs_rfw.c

455

LFS_IENTRY(ifp, fs, lfs_dino_getinumber(fs, dip), ibp);

sys/ufs/lfs/lfs_rfw.c

456

gen = lfs_if_getversion(fs, ifp);

sys/ufs/lfs/lfs_rfw.c

458

if (lfs_dino_getgen(fs, dip) < gen) {

sys/ufs/lfs/lfs_rfw.c

465

error = lfs_rf_valloc(fs, ino, lfs_dino_getgen(fs, dip),

sys/ufs/lfs/lfs_rfw.c

473

if (lfs_dino_getsize(fs, dip) != ip->i_size

sys/ufs/lfs/lfs_rfw.c

479

(intmax_t)lfs_dino_getsize(fs, dip)));

sys/ufs/lfs/lfs_rfw.c

480

lfs_truncate(vp, lfs_dino_getsize(fs, dip), 0,

sys/ufs/lfs/lfs_rfw.c

483

update_inoblk_copy_dinode(fs, ip->i_din, dip);

sys/ufs/lfs/lfs_rfw.c

485

ip->i_flags = lfs_dino_getflags(fs, dip);

sys/ufs/lfs/lfs_rfw.c

486

ip->i_gen = lfs_dino_getgen(fs, dip);

sys/ufs/lfs/lfs_rfw.c

487

ip->i_uid = lfs_dino_getuid(fs, dip);

sys/ufs/lfs/lfs_rfw.c

488

ip->i_gid = lfs_dino_getgid(fs, dip);

sys/ufs/lfs/lfs_rfw.c

490

ip->i_mode = lfs_dino_getmode(fs, dip);

sys/ufs/lfs/lfs_rfw.c

491

ip->i_nlink = lfs_dino_getnlink(fs, dip);

sys/ufs/lfs/lfs_rfw.c

492

ip->i_size = lfs_dino_getsize(fs, dip);

sys/ufs/lfs/lfs_rfw.c

501

lfs_update_iaddr(fs, ip, offset);

sys/ufs/lfs/lfs_rfw.c

517

struct lfs *fs;

sys/ufs/lfs/lfs_rfw.c

526

fs = lifa->fs;

sys/ufs/lfs/lfs_rfw.c

528

devvp = VTOI(fs->lfs_ivnode)->i_devvp;

sys/ufs/lfs/lfs_rfw.c

531

error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),

sys/ufs/lfs/lfs_rfw.c

539

num = LFS_INOPB(fs);

sys/ufs/lfs/lfs_rfw.c

541

dip = DINO_IN_BLOCK(fs, dbp->b_data, i);

sys/ufs/lfs/lfs_rfw.c

542

if (lfs_dino_getinumber(fs, dip) == LFS_IFILE_INUM)

sys/ufs/lfs/lfs_rfw.c

546

LFS_IENTRY(ifp, fs, lfs_dino_getinumber(fs, dip), ibp);

sys/ufs/lfs/lfs_rfw.c

547

if (lfs_if_getversion(fs, ifp) < lfs_dino_getgen(fs, dip))

sys/ufs/lfs/lfs_rfw.c

548

lfs_if_setversion(fs, ifp, lfs_dino_getgen(fs, dip));

sys/ufs/lfs/lfs_rfw.c

549

LFS_WRITEIENTRY(ifp, fs, lfs_dino_getinumber(fs, dip), ibp);

sys/ufs/lfs/lfs_rfw.c

561

struct lfs *fs;

sys/ufs/lfs/lfs_rfw.c

569

fs = lffa->fs;

sys/ufs/lfs/lfs_rfw.c

573

size = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_rfw.c

574

ino = lfs_fi_getino(fs, fip);

sys/ufs/lfs/lfs_rfw.c

575

LFS_ASSERT_MAXINO(fs, ino);

sys/ufs/lfs/lfs_rfw.c

576

for (j = 0; j < lfs_fi_getnblocks(fs, fip); ++j) {

sys/ufs/lfs/lfs_rfw.c

577

if (j == lfs_fi_getnblocks(fs, fip) - 1)

sys/ufs/lfs/lfs_rfw.c

578

size = lfs_fi_getlastlength(fs, fip);

sys/ufs/lfs/lfs_rfw.c

582

lfs_fi_getblock(fs, fip, j) >= 0) {

sys/ufs/lfs/lfs_rfw.c

583

update_meta(fs, ino,

sys/ufs/lfs/lfs_rfw.c

584

lfs_fi_getversion(fs, fip),

sys/ufs/lfs/lfs_rfw.c

585

lfs_fi_getblock(fs, fip, j),

sys/ufs/lfs/lfs_rfw.c

589

*offsetp += lfs_btofsb(fs, size);

sys/ufs/lfs/lfs_rfw.c

596

lfs_skip_superblock(struct lfs *fs, daddr_t *offsetp)

sys/ufs/lfs/lfs_rfw.c

607

if (offset == lfs_sb_gets0addr(fs)) {

sys/ufs/lfs/lfs_rfw.c

608

offset += lfs_btofsb(fs, LFS_LABELPAD);

sys/ufs/lfs/lfs_rfw.c

611

if (offset == lfs_sb_getsboff(fs, i)) {

sys/ufs/lfs/lfs_rfw.c

612

offset += lfs_btofsb(fs, LFS_SBPAD);

sys/ufs/lfs/lfs_rfw.c

632

lfs_parse_pseg(struct lfs *fs, daddr_t *offsetp, u_int64_t nextserial,

sys/ufs/lfs/lfs_rfw.c

651

KASSERT(fs != NULL);

sys/ufs/lfs/lfs_rfw.c

654

devvp = VTOI(fs->lfs_ivnode)->i_devvp;

sys/ufs/lfs/lfs_rfw.c

657

lifa.fs = fs;

sys/ufs/lfs/lfs_rfw.c

661

lifa.buf = malloc(lfs_sb_getbsize(fs), M_SEGMENT, M_WAITOK);

sys/ufs/lfs/lfs_rfw.c

665

lffa.fs = fs;

sys/ufs/lfs/lfs_rfw.c

673

lfs_skip_superblock(fs, offsetp);

sys/ufs/lfs/lfs_rfw.c

677

buf = malloc(lfs_sb_getsumsize(fs), M_SEGMENT, M_WAITOK);

sys/ufs/lfs/lfs_rfw.c

678

error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getsumsize(fs),

sys/ufs/lfs/lfs_rfw.c

687

if (lfs_ss_getmagic(fs, ssp) != SS_MAGIC) {

sys/ufs/lfs/lfs_rfw.c

697

sumstart = lfs_ss_getsumstart(fs);

sys/ufs/lfs/lfs_rfw.c

698

if (lfs_ss_getsumsum(fs, ssp) !=

sys/ufs/lfs/lfs_rfw.c

700

lfs_sb_getsumsize(fs) - sumstart)) {

sys/ufs/lfs/lfs_rfw.c

715

if (lfs_ss_getnfinfo(fs, ssp) == 0 &&

sys/ufs/lfs/lfs_rfw.c

716

lfs_ss_getninos(fs, ssp) == 0) {

sys/ufs/lfs/lfs_rfw.c

724

if (lfs_sb_getversion(fs) == 1) {

sys/ufs/lfs/lfs_rfw.c

725

if (lfs_ss_getcreate(fs, ssp) < lfs_sb_gettstamp(fs)) {

sys/ufs/lfs/lfs_rfw.c

732

&& lfs_ss_getserial(fs, ssp) != nextserial) {

sys/ufs/lfs/lfs_rfw.c

735

(intmax_t)lfs_ss_getserial(fs, ssp),

sys/ufs/lfs/lfs_rfw.c

740

if (lfs_ss_getident(fs, ssp) != lfs_sb_getident(fs)) {

sys/ufs/lfs/lfs_rfw.c

742

PRIx64 "\n", lfs_ss_getident(fs, ssp),

sys/ufs/lfs/lfs_rfw.c

743

lfs_sb_getident(fs), offset));

sys/ufs/lfs/lfs_rfw.c

750

if (lfs_ss_getnfinfo(fs, ssp) > lfs_sb_getssize(fs) / lfs_sb_getfsize(fs)) {

sys/ufs/lfs/lfs_rfw.c

753

(intmax_t)lfs_ss_getnfinfo(fs, ssp),

sys/ufs/lfs/lfs_rfw.c

754

(intmax_t)lfs_sb_getssize(fs) / lfs_sb_getfsize(fs));

sys/ufs/lfs/lfs_rfw.c

757

KASSERT(lfs_ss_getnfinfo(fs, ssp) <= lfs_sb_getssize(fs) / lfs_sb_getfsize(fs));

sys/ufs/lfs/lfs_rfw.c

759

if (lfs_ss_getnfinfo(fs, ssp) > lfs_sb_getfsize(fs) / sizeof(FINFO32)) {

sys/ufs/lfs/lfs_rfw.c

762

(intmax_t)lfs_ss_getnfinfo(fs, ssp),

sys/ufs/lfs/lfs_rfw.c

763

(intmax_t)lfs_sb_getssize(fs) / lfs_sb_getfsize(fs));

sys/ufs/lfs/lfs_rfw.c

766

KASSERT(lfs_ss_getnfinfo(fs, ssp) <= lfs_sb_getfsize(fs) / sizeof(FINFO32));

sys/ufs/lfs/lfs_rfw.c

769

*pseg_flags = lfs_ss_getflags(fs, ssp);

sys/ufs/lfs/lfs_rfw.c

770

ninos = howmany(lfs_ss_getninos(fs, ssp), LFS_INOPB(fs));

sys/ufs/lfs/lfs_rfw.c

771

iip = SEGSUM_IINFOSTART(fs, buf);

sys/ufs/lfs/lfs_rfw.c

772

fip = SEGSUM_FINFOBASE(fs, (SEGSUM *)buf);

sys/ufs/lfs/lfs_rfw.c

776

offset += lfs_btofsb(fs, lfs_sb_getsumsize(fs));

sys/ufs/lfs/lfs_rfw.c

777

for (i = 0; i < lfs_ss_getnfinfo(fs, ssp) || ninos; ++i) {

sys/ufs/lfs/lfs_rfw.c

779

if (ninos && lfs_ii_getblock(fs, iip) == offset) {

sys/ufs/lfs/lfs_rfw.c

782

error = bread(devvp, LFS_FSBTODB(fs, offset),

sys/ufs/lfs/lfs_rfw.c

783

lfs_sb_getbsize(fs), 0, &dbp);

sys/ufs/lfs/lfs_rfw.c

800

offset += lfs_btofsb(fs, lfs_sb_getibsize(fs));

sys/ufs/lfs/lfs_rfw.c

801

iip = NEXTLOWER_IINFO(fs, iip);

sys/ufs/lfs/lfs_rfw.c

808

size = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_rfw.c

810

for (j = 0; j < lfs_fi_getnblocks(fs, fip); ++j) {

sys/ufs/lfs/lfs_rfw.c

811

if (j == lfs_fi_getnblocks(fs, fip) - 1)

sys/ufs/lfs/lfs_rfw.c

812

size = lfs_fi_getlastlength(fs, fip);

sys/ufs/lfs/lfs_rfw.c

813

error = bread(devvp, LFS_FSBTODB(fs, offset),

sys/ufs/lfs/lfs_rfw.c

822

offset += lfs_btofsb(fs, size);

sys/ufs/lfs/lfs_rfw.c

829

int n = lfs_fi_getnblocks(fs, fip);

sys/ufs/lfs/lfs_rfw.c

830

size = lfs_fi_getlastlength(fs, fip);

sys/ufs/lfs/lfs_rfw.c

831

offset += lfs_btofsb(fs, lfs_sb_getbsize(fs) * (n - 1)

sys/ufs/lfs/lfs_rfw.c

834

fip = NEXT_FINFO(fs, fip);

sys/ufs/lfs/lfs_rfw.c

839

datasum = lfs_ss_getdatasum(fs, ssp);

sys/ufs/lfs/lfs_rfw.c

853

lfs_flush(fs, SEGM_CKP, 0);

sys/ufs/lfs/lfs_rfw.c

868

if (lfs_dtosn(fs, offset + lfs_sb_getfrag(fs))

sys/ufs/lfs/lfs_rfw.c

869

!= lfs_dtosn(fs, offset)) {

sys/ufs/lfs/lfs_rfw.c

870

if (lfs_dtosn(fs, offset) == lfs_dtosn(fs, lfs_ss_getnext(fs,

sys/ufs/lfs/lfs_rfw.c

875

offset = lfs_ss_getnext(fs, ssp);

sys/ufs/lfs/lfs_rfw.c

877

" -> segment %d\n", offset, lfs_dtosn(fs,offset)));

sys/ufs/lfs/lfs_rfw.c

880

lfs_sb_subavail(fs, offset - prevoffset);

sys/ufs/lfs/lfs_rfw.c

894

lfs_roll_forward(struct lfs *fs, struct mount *mp, struct lwp *l)

sys/ufs/lfs/lfs_rfw.c

917

if ((lfs_sb_getpflags(fs) & LFS_PF_CLEAN) || !lfs_do_rfw

sys/ufs/lfs/lfs_rfw.c

918

|| lfs_sb_getversion(fs) <= 1 || p == NULL)

sys/ufs/lfs/lfs_rfw.c

922

lfs_sb_getfsmnt(fs), (intmax_t)lfs_sb_getserial(fs)));

sys/ufs/lfs/lfs_rfw.c

923

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_rfw.c

93

static bool lfs_isseq(const struct lfs *fs, long int lbn1, long int lbn2);

sys/ufs/lfs/lfs_rfw.c

931

endpseg = startoffset = offset = lfs_sb_getoffset(fs);

sys/ufs/lfs/lfs_rfw.c

935

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, offset), bp);

sys/ufs/lfs/lfs_rfw.c

937

lfs_sb_subnclean(fs, 1);

sys/ufs/lfs/lfs_rfw.c

939

LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, offset), bp);

sys/ufs/lfs/lfs_rfw.c

941

startserial = lfs_sb_getserial(fs);

sys/ufs/lfs/lfs_rfw.c

946

lfs_parse_pseg(fs, &nextoffset, nextserial,

sys/ufs/lfs/lfs_rfw.c

950

if (lfs_sntod(fs, offset) != lfs_sntod(fs, nextoffset)) {

sys/ufs/lfs/lfs_rfw.c

951

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, offset),

sys/ufs/lfs/lfs_rfw.c

954

lfs_sb_subnclean(fs, 1);

sys/ufs/lfs/lfs_rfw.c

956

LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, offset), bp);

sys/ufs/lfs/lfs_rfw.c

986

if (lfs_sb_getversion(fs) > 1)

sys/ufs/lfs/lfs_rfw.c

987

lfs_sb_setserial(fs, endserial);

sys/ufs/lfs/lfs_rfw.c

993

lfs_sb_setoffset(fs, endpseg);

sys/ufs/lfs/lfs_rfw.c

994

lfs_sb_setcurseg(fs, lfs_sntod(fs, lfs_dtosn(fs, endpseg)));

sys/ufs/lfs/lfs_rfw.c

995

for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs));;) {

sys/ufs/lfs/lfs_rfw.c

996

sn = (sn + 1) % lfs_sb_getnseg(fs);

sys/ufs/lfs/lfs_segment.c

1004

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

1009

KASSERT(ip->i_number != LFS_IFILE_INUM || fs->lfs_writer > 0 ||

sys/ufs/lfs/lfs_segment.c

1019

while (vp == fs->lfs_ivnode) {

sys/ufs/lfs/lfs_segment.c

1024

(sp->seg_bytes_left < lfs_sb_getibsize(fs) ||

sys/ufs/lfs/lfs_segment.c

1025

sp->sum_bytes_left < IINFOSIZE(fs))) {

sys/ufs/lfs/lfs_segment.c

1026

(void) lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_segment.c

1032

LIST_FOREACH(bp, &fs->lfs_ivnode->v_dirtyblkhd, b_vnbufs) {

sys/ufs/lfs/lfs_segment.c

1053

lfs_dino_setinumber(fs, sp->idp, 0);

sys/ufs/lfs/lfs_segment.c

1055

lfs_sb_setidaddr(fs, 0x0);

sys/ufs/lfs/lfs_segment.c

1077

lfs_writefile(fs, sp, fs->lfs_ivnode);

sys/ufs/lfs/lfs_segment.c

1084

if (sp->seg_bytes_left < lfs_sb_getibsize(fs) ||

sys/ufs/lfs/lfs_segment.c

1085

sp->sum_bytes_left < IINFOSIZE(fs))

sys/ufs/lfs/lfs_segment.c

1086

(void) lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_segment.c

1089

daddr = lfs_sb_getoffset(fs);

sys/ufs/lfs/lfs_segment.c

1090

lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));

sys/ufs/lfs/lfs_segment.c

1092

getblk(VTOI(fs->lfs_ivnode)->i_devvp,

sys/ufs/lfs/lfs_segment.c

1093

LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs), 0, 0);

sys/ufs/lfs/lfs_segment.c

1097

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

sys/ufs/lfs/lfs_segment.c

1101

DINOSIZE(fs) * i);

sys/ufs/lfs/lfs_segment.c

1102

lfs_dino_setinumber(fs, tmpdi, 0);

sys/ufs/lfs/lfs_segment.c

1106

lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));

sys/ufs/lfs/lfs_segment.c

1108

sp->seg_bytes_left -= lfs_sb_getibsize(fs);

sys/ufs/lfs/lfs_segment.c

1109

sp->sum_bytes_left -= IINFOSIZE(fs);

sys/ufs/lfs/lfs_segment.c

1112

iip = NTH_IINFO(fs, sp->segsum, sp->ninodes / LFS_INOPB(fs));

sys/ufs/lfs/lfs_segment.c

1113

lfs_ii_setblock(fs, iip, daddr);

sys/ufs/lfs/lfs_segment.c

1119

lfs_ss_setflags(fs, ssp,

sys/ufs/lfs/lfs_segment.c

1120

lfs_ss_getflags(fs, ssp) | (SS_DIROP|SS_CONT));

sys/ufs/lfs/lfs_segment.c

1137

lfs_copy_dinode(fs, sp->idp, ip->i_din);

sys/ufs/lfs/lfs_segment.c

1143

cdp = DINO_IN_BLOCK(fs, bp->b_data, sp->ninodes % LFS_INOPB(fs));

sys/ufs/lfs/lfs_segment.c

1146

(intmax_t)LFS_DBTOFSB(fs, bp->b_blkno),

sys/ufs/lfs/lfs_segment.c

1147

(intmax_t)lfs_dtosn(fs, LFS_DBTOFSB(fs, bp->b_blkno))));

sys/ufs/lfs/lfs_segment.c

1148

lfs_copy_dinode(fs, cdp, ip->i_din);

sys/ufs/lfs/lfs_segment.c

1173

lfs_dino_setnlink(fs, cdp, ip->i_lfs_odnlink);

sys/ufs/lfs/lfs_segment.c

1175

lfs_dino_setsize(fs, cdp, ip->i_lfs_osize);

sys/ufs/lfs/lfs_segment.c

1178

ip->i_lfs_odnlink = lfs_dino_getnlink(fs, cdp);

sys/ufs/lfs/lfs_segment.c

1184

lfs_finalize_ino_seguse(fs, ip);

sys/ufs/lfs/lfs_segment.c

1200

if (((lfs_dino_getmode(fs, ip->i_din) & LFS_IFMT) == LFS_IFREG ||

sys/ufs/lfs/lfs_segment.c

1201

(lfs_dino_getmode(fs, ip->i_din) & LFS_IFMT) == LFS_IFDIR) &&

sys/ufs/lfs/lfs_segment.c

1202

ip->i_size > ((ip->i_lfs_hiblk + 1) << lfs_sb_getbshift(fs))) {

sys/ufs/lfs/lfs_segment.c

1203

lfs_dino_setsize(fs, cdp, (ip->i_lfs_hiblk + 1) << lfs_sb_getbshift(fs));

sys/ufs/lfs/lfs_segment.c

1205

PRId64 "\n", (int)ip->i_number, ip->i_size, lfs_dino_getsize(fs, cdp)));

sys/ufs/lfs/lfs_segment.c

1207

if (ip->i_lfs_effnblks != lfs_dino_getblocks(fs, ip->i_din)) {

sys/ufs/lfs/lfs_segment.c

121

#define LFS_PARTIAL_FITS(fs) \

sys/ufs/lfs/lfs_segment.c

1210

lfs_dino_getblocks(fs, ip->i_din), (uintmax_t)lfs_sb_getoffset(fs)));

sys/ufs/lfs/lfs_segment.c

1212

if (lfs_dino_getdb(fs, cdp, i) == UNWRITTEN) {

sys/ufs/lfs/lfs_segment.c

1214

lfs_dino_setdb(fs, cdp, i, 0);

sys/ufs/lfs/lfs_segment.c

1218

if (lfs_dino_getib(fs, cdp, i) == UNWRITTEN) {

sys/ufs/lfs/lfs_segment.c

122

(lfs_sb_getfsbpseg(fs) - \

sys/ufs/lfs/lfs_segment.c

1220

lfs_dino_setib(fs, cdp, i, 0);

sys/ufs/lfs/lfs_segment.c

123

(lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)) > \

sys/ufs/lfs/lfs_segment.c

1230

for (i = (lfs_dino_getsize(fs, cdp) + lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs);

sys/ufs/lfs/lfs_segment.c

1233

if ((lfs_dino_getmode(fs, cdp) & LFS_IFMT) == LFS_IFLNK)

sys/ufs/lfs/lfs_segment.c

1235

if (((lfs_dino_getmode(fs, cdp) & LFS_IFMT) == LFS_IFBLK ||

sys/ufs/lfs/lfs_segment.c

1236

(lfs_dino_getmode(fs, cdp) & LFS_IFMT) == LFS_IFCHR) && i == 0)

sys/ufs/lfs/lfs_segment.c

1238

if (lfs_dino_getdb(fs, cdp, i) != 0) {

sys/ufs/lfs/lfs_segment.c

124

lfs_sb_getfrag(fs))

sys/ufs/lfs/lfs_segment.c

1240

lfs_dump_dinode(fs, cdp);

sys/ufs/lfs/lfs_segment.c

1251

if (ip->i_lfs_effnblks == lfs_dino_getblocks(fs, ip->i_din))

sys/ufs/lfs/lfs_segment.c

1256

lfs_dino_getblocks(fs, ip->i_din), (intmax_t)ip->i_lfs_effnblks));

sys/ufs/lfs/lfs_segment.c

1262

sp->idp = DINO_IN_BLOCK(fs, bp, sp->ninodes % LFS_INOPB(fs));

sys/ufs/lfs/lfs_segment.c

1266

fs->lfs_flags &= ~LFS_IFDIRTY;

sys/ufs/lfs/lfs_segment.c

1280

lfs_ss_setninos(fs, ssp, lfs_ss_getninos(fs, ssp) + 1);

sys/ufs/lfs/lfs_segment.c

1283

if (++sp->ninodes % LFS_INOPB(fs) == 0)

sys/ufs/lfs/lfs_segment.c

1286

lfs_update_iaddr(fs, ip, LFS_DBTOFSB(fs, bp->b_blkno));

sys/ufs/lfs/lfs_segment.c

1294

struct lfs *fs;

sys/ufs/lfs/lfs_segment.c

1298

ASSERT_SEGLOCK(sp->fs);

sys/ufs/lfs/lfs_segment.c

130

#define LFS_SHOULD_CHECKPOINT(fs, flags) \

sys/ufs/lfs/lfs_segment.c

1315

fs = sp->fs;

sys/ufs/lfs/lfs_segment.c

1316

blksinblk = howmany(bp->b_bcount, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_segment.c

1317

if (sp->sum_bytes_left < LFS_BLKPTRSIZE(fs) * blksinblk ||

sys/ufs/lfs/lfs_segment.c

132

((fs->lfs_nactive > LFS_MAX_ACTIVE || \

sys/ufs/lfs/lfs_segment.c

1325

(long)lfs_sb_getoffset(fs)));

sys/ufs/lfs/lfs_segment.c

1327

vers = lfs_fi_getversion(fs, sp->fip);

sys/ufs/lfs/lfs_segment.c

1328

(void) lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_segment.c

1331

lfs_acquire_finfo(fs, VTOI(sp->vp)->i_number, vers);

sys/ufs/lfs/lfs_segment.c

134

lfs_sb_getnclean(fs) < LFS_MAX_ACTIVE)))

sys/ufs/lfs/lfs_segment.c

1342

(uintmax_t)lfs_fi_getino(fs, sp->fip), bp->b_lblkno));

sys/ufs/lfs/lfs_segment.c

1353

bn = lfs_fi_getnblocks(fs, sp->fip);

sys/ufs/lfs/lfs_segment.c

1354

lfs_fi_setnblocks(fs, sp->fip, bn+1);

sys/ufs/lfs/lfs_segment.c

1355

lfs_fi_setblock(fs, sp->fip, bn, bp->b_lblkno + j);

sys/ufs/lfs/lfs_segment.c

1360

sp->sum_bytes_left -= LFS_BLKPTRSIZE(fs) * blksinblk;

sys/ufs/lfs/lfs_segment.c

1370

lfs_ungather(struct lfs *fs, struct segment *sp, struct vnode *vp,

sys/ufs/lfs/lfs_segment.c

1384

if (!match(fs, bp))

sys/ufs/lfs/lfs_segment.c

140

int lfs_writevnodes(struct lfs *fs, struct mount *mp,

sys/ufs/lfs/lfs_segment.c

1403

lfs_gather(struct lfs *fs, struct segment *sp, struct vnode *vp,

sys/ufs/lfs/lfs_segment.c

1409

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

1443

!match(fs, bp)) {

sys/ufs/lfs/lfs_segment.c

1445

if (vp == fs->lfs_ivnode &&

sys/ufs/lfs/lfs_segment.c

1451

(uintmax_t)lfs_sb_getoffset(fs));

sys/ufs/lfs/lfs_segment.c

1469

LFS_DBTOFSB(fs, bp->b_blkno)));

sys/ufs/lfs/lfs_segment.c

1510

lfs_update_single(struct lfs *fs, struct segment *sp,

sys/ufs/lfs/lfs_segment.c

1521

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

1525

KASSERTMSG(sp == NULL || lfs_dtosn(fs, ndaddr)

sys/ufs/lfs/lfs_segment.c

1526

== lfs_dtosn(fs, lfs_sb_getoffset(fs)),

sys/ufs/lfs/lfs_segment.c

1533

KASSERT(daddr <= LFS_MAX_DADDR(fs));

sys/ufs/lfs/lfs_segment.c

1535

daddr = LFS_DBTOFSB(fs, daddr);

sys/ufs/lfs/lfs_segment.c

1537

bb = lfs_numfrags(fs, size);

sys/ufs/lfs/lfs_segment.c

1540

ooff = lfs_dino_getdb(fs, ip->i_din, lbn);

sys/ufs/lfs/lfs_segment.c

1543

lfs_dino_setblocks(fs, ip->i_din,

sys/ufs/lfs/lfs_segment.c

1544

lfs_dino_getblocks(fs, ip->i_din) + bb);

sys/ufs/lfs/lfs_segment.c

1547

obb = lfs_btofsb(fs, ip->i_lfs_fragsize[lbn]);

sys/ufs/lfs/lfs_segment.c

1548

lfs_dino_setblocks(fs, ip->i_din,

sys/ufs/lfs/lfs_segment.c

1549

lfs_dino_getblocks(fs, ip->i_din) + (bb-obb));

sys/ufs/lfs/lfs_segment.c

1551

lfs_dino_setdb(fs, ip->i_din, lbn, ndaddr);

sys/ufs/lfs/lfs_segment.c

1554

ooff = lfs_dino_getib(fs, ip->i_din, a[0].in_off);

sys/ufs/lfs/lfs_segment.c

1557

lfs_dino_setblocks(fs, ip->i_din,

sys/ufs/lfs/lfs_segment.c

1558

lfs_dino_getblocks(fs, ip->i_din) + bb);

sys/ufs/lfs/lfs_segment.c

1559

lfs_dino_setib(fs, ip->i_din, a[0].in_off, ndaddr);

sys/ufs/lfs/lfs_segment.c

1563

if (bread(vp, ap->in_lbn, lfs_sb_getbsize(fs),

sys/ufs/lfs/lfs_segment.c

1568

ooff = lfs_iblock_get(fs, bp->b_data, ap->in_off);

sys/ufs/lfs/lfs_segment.c

1571

lfs_dino_setblocks(fs, ip->i_din,

sys/ufs/lfs/lfs_segment.c

1572

lfs_dino_getblocks(fs, ip->i_din) + bb);

sys/ufs/lfs/lfs_segment.c

1573

lfs_iblock_set(fs, bp->b_data, ap->in_off, ndaddr);

sys/ufs/lfs/lfs_segment.c

1594

u_int32_t oldsn = lfs_dtosn(fs, daddr);

sys/ufs/lfs/lfs_segment.c

1596

KASSERT(oldsn < lfs_sb_getnseg(fs));

sys/ufs/lfs/lfs_segment.c

1600

osize = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_segment.c

1601

LFS_SEGENTRY(sup, fs, oldsn, bp);

sys/ufs/lfs/lfs_segment.c

1608

lfs_dtosn(fs, daddr),

sys/ufs/lfs/lfs_segment.c

1613

(intmax_t)lfs_dtosn(fs, daddr), (intmax_t)osize,

sys/ufs/lfs/lfs_segment.c

1619

fs->lfs_flags |= LFS_IFDIRTY;

sys/ufs/lfs/lfs_segment.c

1622

LFS_WRITESEGENTRY(sup, fs, oldsn, bp);

sys/ufs/lfs/lfs_segment.c

1641

struct lfs *fs;

sys/ufs/lfs/lfs_segment.c

1651

fs = sp->fs;

sys/ufs/lfs/lfs_segment.c

1653

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

1679

lfs_blocks_fromvoid(fs, &tmpptr, (void *)NEXT_FINFO(fs, sp->fip));

sys/ufs/lfs/lfs_segment.c

1680

nblocks = lfs_blocks_sub(fs, &tmpptr, &sp->start_lbp);

sys/ufs/lfs/lfs_segment.c

1698

num = howmany(sp->start_bpp[i]->b_bcount, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_segment.c

171

lfs_imtime(struct lfs *fs)

sys/ufs/lfs/lfs_segment.c

1720

lfs_shellsort(fs, sp->start_bpp, &sp->start_lbp, nblocks, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_segment.c

1734

lfs_sb_getbmask(fs)) + 1;

sys/ufs/lfs/lfs_segment.c

1735

lfs_fi_setlastlength(fs, sp->fip, lastlength);

sys/ufs/lfs/lfs_segment.c

1743

lbn = lfs_blocks_get(fs, &sp->start_lbp, 0);

sys/ufs/lfs/lfs_segment.c

1746

sbp->b_blkno = LFS_FSBTODB(fs, lfs_sb_getoffset(fs));

sys/ufs/lfs/lfs_segment.c

1755

if ((sbp->b_bcount & lfs_sb_getbmask(fs)) && i != 0)

sys/ufs/lfs/lfs_segment.c

176

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

1762

KASSERT(lbn >= 0 || sbp->b_bcount == lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_segment.c

1766

bytesleft -= lfs_sb_getbsize(fs)) {

sys/ufs/lfs/lfs_segment.c

1767

size = MIN(bytesleft, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_segment.c

1768

bb = lfs_numfrags(fs, size);

sys/ufs/lfs/lfs_segment.c

1769

lbn = lfs_blocks_get(fs, &sp->start_lbp, 0);

sys/ufs/lfs/lfs_segment.c

1770

lfs_blocks_inc(fs, &sp->start_lbp);

sys/ufs/lfs/lfs_segment.c

1771

lfs_update_single(fs, sp, sp->vp, lbn, lfs_sb_getoffset(fs),

sys/ufs/lfs/lfs_segment.c

1773

lfs_sb_addoffset(fs, bb);

sys/ufs/lfs/lfs_segment.c

178

ip = VTOI(fs->lfs_ivnode);

sys/ufs/lfs/lfs_segment.c

1786

lfs_rewind(struct lfs *fs, int newsn)

sys/ufs/lfs/lfs_segment.c

179

lfs_dino_setmtime(fs, ip->i_din, ts.tv_sec);

sys/ufs/lfs/lfs_segment.c

1792

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

1794

osn = lfs_dtosn(fs, lfs_sb_getoffset(fs));

sys/ufs/lfs/lfs_segment.c

1799

lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));

sys/ufs/lfs/lfs_segment.c

180

lfs_dino_setmtimensec(fs, ip->i_din, ts.tv_nsec);

sys/ufs/lfs/lfs_segment.c

1802

for (sn = 0; sn < lfs_sb_getnseg(fs); ++sn) {

sys/ufs/lfs/lfs_segment.c

1803

LFS_SEGENTRY(sup, fs, sn, bp);

sys/ufs/lfs/lfs_segment.c

1810

if (sn == lfs_sb_getnseg(fs))

sys/ufs/lfs/lfs_segment.c

1814

lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));

sys/ufs/lfs/lfs_segment.c

1815

lfs_newseg(fs);

sys/ufs/lfs/lfs_segment.c

1816

lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));

sys/ufs/lfs/lfs_segment.c

1828

lfs_initseg(struct lfs *fs, uint16_t flags)

sys/ufs/lfs/lfs_segment.c

1830

struct segment *sp = fs->lfs_sp;

sys/ufs/lfs/lfs_segment.c

1837

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

1839

if (!LFS_PARTIAL_FITS(fs)) {

sys/ufs/lfs/lfs_segment.c

1841

lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) -

sys/ufs/lfs/lfs_segment.c

1842

lfs_sb_getcurseg(fs)));

sys/ufs/lfs/lfs_segment.c

1844

lfs_wakeup_cleaner(fs);

sys/ufs/lfs/lfs_segment.c

1845

lfs_newseg(fs);

sys/ufs/lfs/lfs_segment.c

1847

lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));

sys/ufs/lfs/lfs_segment.c

1849

sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));

sys/ufs/lfs/lfs_segment.c

1850

sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs));

sys/ufs/lfs/lfs_segment.c

1856

LFS_SEGENTRY(sup, fs, sp->seg_number, bp);

sys/ufs/lfs/lfs_segment.c

1858

lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_SBPAD));

sys/ufs/lfs/lfs_segment.c

1863

if (lfs_sb_getversion(fs) > 1 && sp->seg_number == 0 &&

sys/ufs/lfs/lfs_segment.c

1864

lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD)) {

sys/ufs/lfs/lfs_segment.c

1865

lfs_sb_addoffset(fs,

sys/ufs/lfs/lfs_segment.c

1866

lfs_btofsb(fs, LFS_LABELPAD) - lfs_sb_gets0addr(fs));

sys/ufs/lfs/lfs_segment.c

1868

LFS_LABELPAD - lfs_fsbtob(fs, lfs_sb_gets0addr(fs));

sys/ufs/lfs/lfs_segment.c

1871

sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));

sys/ufs/lfs/lfs_segment.c

1872

sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs) -

sys/ufs/lfs/lfs_segment.c

1873

(lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));

sys/ufs/lfs/lfs_segment.c

1875

lfs_sb_setlastpseg(fs, lfs_sb_getoffset(fs));

sys/ufs/lfs/lfs_segment.c

1879

fs->lfs_cleanint[fs->lfs_cleanind] = lfs_sb_getoffset(fs);

sys/ufs/lfs/lfs_segment.c

1880

if (++fs->lfs_cleanind >= LFS_MAX_CLEANIND) {

sys/ufs/lfs/lfs_segment.c

1883

while (fs->lfs_iocount > 1) {

sys/ufs/lfs/lfs_segment.c

1884

mtsleep(&fs->lfs_iocount, PRIBIO + 1,

sys/ufs/lfs/lfs_segment.c

1888

fs->lfs_cleanind = 0;

sys/ufs/lfs/lfs_segment.c

1892

sp->fs = fs;

sys/ufs/lfs/lfs_segment.c

190

#define IS_FLUSHING(fs,vp) ((fs)->lfs_flushvp == (vp))

sys/ufs/lfs/lfs_segment.c

1900

sbp = lfs_newbuf(fs, VTOI(fs->lfs_ivnode)->i_devvp,

sys/ufs/lfs/lfs_segment.c

1901

LFS_FSBTODB(fs, lfs_sb_getoffset(fs)), lfs_sb_getsumsize(fs), LFS_NB_SUMMARY);

sys/ufs/lfs/lfs_segment.c

1906

lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));

sys/ufs/lfs/lfs_segment.c

1910

if ((fs->lfs_flags & LFS_NOTYET) && curproc->p_pid == fs->lfs_rfpid)

sys/ufs/lfs/lfs_segment.c

1915

memset(ssp, 0, lfs_sb_getsumsize(fs));

sys/ufs/lfs/lfs_segment.c

1916

lfs_ss_setnext(fs, ssp, lfs_sb_getnextseg(fs));

sys/ufs/lfs/lfs_segment.c

1917

lfs_ss_setnfinfo(fs, ssp, 0);

sys/ufs/lfs/lfs_segment.c

1918

lfs_ss_setninos(fs, ssp, 0);

sys/ufs/lfs/lfs_segment.c

1919

lfs_ss_setmagic(fs, ssp, SS_MAGIC);

sys/ufs/lfs/lfs_segment.c

1920

lfs_ss_setflags(fs, ssp, flags);

sys/ufs/lfs/lfs_segment.c

1923

sp->fip = SEGSUM_FINFOBASE(fs, sp->segsum);

sys/ufs/lfs/lfs_segment.c

1924

lfs_fi_setnblocks(fs, sp->fip, 0);

sys/ufs/lfs/lfs_segment.c

1925

lfs_fi_setlastlength(fs, sp->fip, 0);

sys/ufs/lfs/lfs_segment.c

1926

lfs_blocks_fromfinfo(fs, &sp->start_lbp, sp->fip);

sys/ufs/lfs/lfs_segment.c

1928

sp->seg_bytes_left -= lfs_sb_getsumsize(fs);

sys/ufs/lfs/lfs_segment.c

1929

sp->sum_bytes_left = lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs);

sys/ufs/lfs/lfs_segment.c

1935

lfs_invalidate(struct lfs *fs, int sn)

sys/ufs/lfs/lfs_segment.c

1940

LFS_SEGENTRY(sup, fs, sn, bp);

sys/ufs/lfs/lfs_segment.c

1943

lfs_seguse_clrflag_all(fs, SEGUSE_INVAL);

sys/ufs/lfs/lfs_segment.c

1955

lfs_newseg(struct lfs *fs)

sys/ufs/lfs/lfs_segment.c

196

struct lfs *fs;

sys/ufs/lfs/lfs_segment.c

1962

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

1966

while (lfs_sb_getnextseg(fs) < lfs_sb_getcurseg(fs) && fs->lfs_nowrap) {

sys/ufs/lfs/lfs_segment.c

1967

if (fs->lfs_wrappass) {

sys/ufs/lfs/lfs_segment.c

1969

lfs_sb_getfsmnt(fs), fs->lfs_wrappass);

sys/ufs/lfs/lfs_segment.c

1970

fs->lfs_wrappass = 0;

sys/ufs/lfs/lfs_segment.c

1973

fs->lfs_wrapstatus = LFS_WRAP_WAITING;

sys/ufs/lfs/lfs_segment.c

1974

wakeup(&fs->lfs_nowrap);

sys/ufs/lfs/lfs_segment.c

1975

log(LOG_NOTICE, "%s: waiting at log wrap\n", lfs_sb_getfsmnt(fs));

sys/ufs/lfs/lfs_segment.c

1976

mtsleep(&fs->lfs_wrappass, PVFS, "newseg", 10 * hz,

sys/ufs/lfs/lfs_segment.c

1979

fs->lfs_wrapstatus = LFS_WRAP_GOING;

sys/ufs/lfs/lfs_segment.c

1982

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);

sys/ufs/lfs/lfs_segment.c

1984

lfs_dtosn(fs, lfs_sb_getnextseg(fs))));

sys/ufs/lfs/lfs_segment.c

1991

LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);

sys/ufs/lfs/lfs_segment.c

1993

LFS_CLEANERINFO(cip, fs, bp);

sys/ufs/lfs/lfs_segment.c

1994

lfs_ci_shiftcleantodirty(fs, cip, 1);

sys/ufs/lfs/lfs_segment.c

1995

lfs_sb_setnclean(fs, lfs_ci_getclean(fs, cip));

sys/ufs/lfs/lfs_segment.c

1996

LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);

sys/ufs/lfs/lfs_segment.c

1998

lfs_sb_setlastseg(fs, lfs_sb_getcurseg(fs));

sys/ufs/lfs/lfs_segment.c

1999

lfs_sb_setcurseg(fs, lfs_sb_getnextseg(fs));

sys/ufs/lfs/lfs_segment.c

2001

for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + lfs_sb_getinterleave(fs);;) {

sys/ufs/lfs/lfs_segment.c

2002

sn = (sn + 1) % lfs_sb_getnseg(fs);

sys/ufs/lfs/lfs_segment.c

2010

LFS_SEGENTRY(sup, fs, sn, bp);

sys/ufs/lfs/lfs_segment.c

2018

lfs_seguse_clrflag_all(fs, SEGUSE_INVAL);

sys/ufs/lfs/lfs_segment.c

2020

++fs->lfs_nactive;

sys/ufs/lfs/lfs_segment.c

2021

lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));

sys/ufs/lfs/lfs_segment.c

2028

lfs_newclusterbuf(struct lfs *fs, struct vnode *vp, daddr_t addr,

sys/ufs/lfs/lfs_segment.c

2034

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2035

cl = (struct lfs_cluster *)pool_get(&fs->lfs_clpool, PR_WAITOK);

sys/ufs/lfs/lfs_segment.c

2036

bpp = (struct buf **)pool_get(&fs->lfs_bpppool, PR_WAITOK);

sys/ufs/lfs/lfs_segment.c

2038

cl->fs = fs;

sys/ufs/lfs/lfs_segment.c

204

fs = VFSTOULFS(vp->v_mount)->um_lfs;

sys/ufs/lfs/lfs_segment.c

2044

if (fs->lfs_sp->seg_flags & SEGM_SYNC) {

sys/ufs/lfs/lfs_segment.c

2046

cl->seg = fs->lfs_sp;

sys/ufs/lfs/lfs_segment.c

2061

lfs_writeseg(struct lfs *fs, struct segment *sp)

sys/ufs/lfs/lfs_segment.c

208

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2084

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2095

if ((lfs_ss_getflags(fs, ssp) & (SS_DIROP | SS_CONT)) != SS_DIROP)

sys/ufs/lfs/lfs_segment.c

2101

lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_CLEAN);

sys/ufs/lfs/lfs_segment.c

2105

lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_RECLAIM);

sys/ufs/lfs/lfs_segment.c

2106

lfs_ss_setreclino(fs, ssp, fs->lfs_reclino);

sys/ufs/lfs/lfs_segment.c

2109

oflags = lfs_ss_getflags(fs, ssp);

sys/ufs/lfs/lfs_segment.c

2111

devvp = VTOI(fs->lfs_ivnode)->i_devvp;

sys/ufs/lfs/lfs_segment.c

2114

LFS_SEGENTRY(sup, fs, sp->seg_number, bp);

sys/ufs/lfs/lfs_segment.c

2119

KASSERT(lfs_dtosn(fs, LFS_DBTOFSB(fs, (*bpp)->b_blkno)) == sp->seg_number);

sys/ufs/lfs/lfs_segment.c

2127

(intmax_t)LFS_DBTOFSB(fs, (*bpp)->b_blkno)));

sys/ufs/lfs/lfs_segment.c

2133

fip = SEGSUM_FINFOBASE(fs, ssp);

sys/ufs/lfs/lfs_segment.c

2134

for (findex = 0; findex < lfs_ss_getnfinfo(fs, ssp); findex++) {

sys/ufs/lfs/lfs_segment.c

2135

KDASSERT(lfs_fi_getnblocks(fs, fip) > 0);

sys/ufs/lfs/lfs_segment.c

2136

KDASSERT(lfs_fi_getversion(fs, fip) > 0);

sys/ufs/lfs/lfs_segment.c

2137

fip = NEXT_FINFO(fs, fip);

sys/ufs/lfs/lfs_segment.c

214

lfs_writer_enter(fs, "vfwriter");

sys/ufs/lfs/lfs_segment.c

2141

ninos = (lfs_ss_getninos(fs, ssp) + LFS_INOPB(fs) - 1) / LFS_INOPB(fs);

sys/ufs/lfs/lfs_segment.c

2142

if (lfs_sb_getversion(fs) == 1)

sys/ufs/lfs/lfs_segment.c

2148

lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));

sys/ufs/lfs/lfs_segment.c

2151

LFS_WRITESEGENTRY(sup, fs, sp->seg_number, bp); /* Ifile */

sys/ufs/lfs/lfs_segment.c

2187

lfs_dino_getblocks(fs, VTOI(bp->b_vp)->i_din) !=

sys/ufs/lfs/lfs_segment.c

2192

lfs_dino_getblocks(fs, VTOI(bp->b_vp)->i_din)));

sys/ufs/lfs/lfs_segment.c

2194

newbp = lfs_newbuf(fs, bp->b_vp, bp->b_lblkno,

sys/ufs/lfs/lfs_segment.c

2201

iblimit = newbp->b_bcount / LFS_BLKPTRSIZE(fs);

sys/ufs/lfs/lfs_segment.c

2203

if (lfs_iblock_get(fs, newbp->b_data, ibindex) == UNWRITTEN) {

sys/ufs/lfs/lfs_segment.c

2205

lfs_iblock_set(fs, newbp->b_data,

sys/ufs/lfs/lfs_segment.c

2234

lfs_sb_subavail(fs,

sys/ufs/lfs/lfs_segment.c

2235

lfs_btofsb(fs, bp->b_bcount));

sys/ufs/lfs/lfs_segment.c

2238

lfs_freebuf(fs, newbp);

sys/ufs/lfs/lfs_segment.c

2256

if (lfs_sb_getversion(fs) == 1)

sys/ufs/lfs/lfs_segment.c

2264

byteoffset += lfs_sb_getbsize(fs)) {

sys/ufs/lfs/lfs_segment.c

227

lfs_seglock(fs, SEGM_SYNC | ((error != 0) ? SEGM_RECLAIM : 0));

sys/ufs/lfs/lfs_segment.c

2283

if (lfs_sb_getversion(fs) == 1)

sys/ufs/lfs/lfs_segment.c

2284

lfs_ss_setocreate(fs, ssp, time_second);

sys/ufs/lfs/lfs_segment.c

2286

lfs_ss_setcreate(fs, ssp, time_second);

sys/ufs/lfs/lfs_segment.c

2287

lfs_sb_addserial(fs, 1);

sys/ufs/lfs/lfs_segment.c

2288

lfs_ss_setserial(fs, ssp, lfs_sb_getserial(fs));

sys/ufs/lfs/lfs_segment.c

2289

lfs_ss_setident(fs, ssp, lfs_sb_getident(fs));

sys/ufs/lfs/lfs_segment.c

229

fs->lfs_reclino = ip->i_number;

sys/ufs/lfs/lfs_segment.c

2291

lfs_ss_setdatasum(fs, ssp, lfs_cksum_fold(sum));

sys/ufs/lfs/lfs_segment.c

2292

sumstart = lfs_ss_getsumstart(fs);

sys/ufs/lfs/lfs_segment.c

2293

lfs_ss_setsumsum(fs, ssp, cksum((char *)ssp + sumstart,

sys/ufs/lfs/lfs_segment.c

2294

lfs_sb_getsumsize(fs) - sumstart));

sys/ufs/lfs/lfs_segment.c

2297

lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +

sys/ufs/lfs/lfs_segment.c

2298

lfs_btofsb(fs, lfs_sb_getsumsize(fs))));

sys/ufs/lfs/lfs_segment.c

2299

lfs_sb_adddmeta(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +

sys/ufs/lfs/lfs_segment.c

2300

lfs_btofsb(fs, lfs_sb_getsumsize(fs))));

sys/ufs/lfs/lfs_segment.c

2318

cbp = lfs_newclusterbuf(fs, devvp, (*bpp)->b_blkno, i);

sys/ufs/lfs/lfs_segment.c

2326

(lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs))

sys/ufs/lfs/lfs_segment.c

2327

/ LFS_BLKPTRSIZE(fs)),

sys/ufs/lfs/lfs_segment.c

2330

lfs_segsize(fs) / lfs_sb_getfsize(fs)),

sys/ufs/lfs/lfs_segment.c

2337

++fs->lfs_iocount;

sys/ufs/lfs/lfs_segment.c

2348

if (bp->b_bcount > lfs_sb_getbsize(fs)) {

sys/ufs/lfs/lfs_segment.c

2356

p = cbp->b_data = lfs_malloc(fs, CHUNKSIZE,

sys/ufs/lfs/lfs_segment.c

2360

KASSERTMSG((lfs_dtosn(fs, LFS_DBTOFSB(fs, bp->b_blkno +

sys/ufs/lfs/lfs_segment.c

2407

if (fs->lfs_sp->seg_flags & SEGM_SYNC)

sys/ufs/lfs/lfs_segment.c

2422

if (fs->lfs_sp->seg_flags & SEGM_SYNC)

sys/ufs/lfs/lfs_segment.c

2424

if (fs->lfs_sp->seg_flags & SEGM_CLEAN) {

sys/ufs/lfs/lfs_segment.c

2430

return (lfs_initseg(fs, oflags) || do_again);

sys/ufs/lfs/lfs_segment.c

2434

lfs_writesuper(struct lfs *fs, daddr_t daddr)

sys/ufs/lfs/lfs_segment.c

2437

struct vnode *devvp = VTOI(fs->lfs_ivnode)->i_devvp;

sys/ufs/lfs/lfs_segment.c

2439

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2440

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_segment.c

2441

KASSERT(fs->lfs_dlfs_u.u_64.dlfs_magic == LFS64_MAGIC);

sys/ufs/lfs/lfs_segment.c

2443

KASSERT(fs->lfs_dlfs_u.u_32.dlfs_magic == LFS_MAGIC);

sys/ufs/lfs/lfs_segment.c

2451

while (fs->lfs_sbactive) {

sys/ufs/lfs/lfs_segment.c

2452

mtsleep(&fs->lfs_sbactive, PRIBIO+1, "lfs sb", 0,

sys/ufs/lfs/lfs_segment.c

2455

fs->lfs_sbactive = daddr;

sys/ufs/lfs/lfs_segment.c

2459

if (lfs_sb_getversion(fs) == 1)

sys/ufs/lfs/lfs_segment.c

2460

lfs_sb_setotstamp(fs, time_second);

sys/ufs/lfs/lfs_segment.c

2461

lfs_sb_settstamp(fs, time_second);

sys/ufs/lfs/lfs_segment.c

2467

lfs_sb_setcksum(fs, lfs_sb_cksum(fs));

sys/ufs/lfs/lfs_segment.c

2468

bp = lfs_newbuf(fs, devvp,

sys/ufs/lfs/lfs_segment.c

2469

LFS_FSBTODB(fs, daddr), LFS_SBPAD, LFS_NB_SBLOCK);

sys/ufs/lfs/lfs_segment.c

2470

memcpy(bp->b_data, &fs->lfs_dlfs_u, sizeof(struct dlfs));

sys/ufs/lfs/lfs_segment.c

2482

if (fs->lfs_sp != NULL && fs->lfs_sp->seg_flags & SEGM_SYNC)

sys/ufs/lfs/lfs_segment.c

2493

++fs->lfs_iocount;

sys/ufs/lfs/lfs_segment.c

2503

lfs_match_fake(struct lfs *fs, struct buf *bp)

sys/ufs/lfs/lfs_segment.c

2506

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2512

lfs_match_real(struct lfs *fs, struct buf *bp)

sys/ufs/lfs/lfs_segment.c

2515

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2516

return (lfs_match_data(fs, bp) && !lfs_match_fake(fs, bp));

sys/ufs/lfs/lfs_segment.c

2521

lfs_match_data(struct lfs *fs, struct buf *bp)

sys/ufs/lfs/lfs_segment.c

2524

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2529

lfs_match_indir(struct lfs *fs, struct buf *bp)

sys/ufs/lfs/lfs_segment.c

253

lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));

sys/ufs/lfs/lfs_segment.c

2533

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2535

return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 0);

sys/ufs/lfs/lfs_segment.c

2539

lfs_match_dindir(struct lfs *fs, struct buf *bp)

sys/ufs/lfs/lfs_segment.c

254

wakeup(&fs->lfs_availsleep);

sys/ufs/lfs/lfs_segment.c

2543

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2545

return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 1);

sys/ufs/lfs/lfs_segment.c

2549

lfs_match_tindir(struct lfs *fs, struct buf *bp)

sys/ufs/lfs/lfs_segment.c

2553

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2555

return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 2);

sys/ufs/lfs/lfs_segment.c

2561

struct lfs *fs;

sys/ufs/lfs/lfs_segment.c

2563

fs = bp->b_private;

sys/ufs/lfs/lfs_segment.c

2564

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2565

lfs_freebuf(fs, bp);

sys/ufs/lfs/lfs_segment.c

2578

struct lfs *fs;

sys/ufs/lfs/lfs_segment.c

2580

fs = bp->b_private;

sys/ufs/lfs/lfs_segment.c

2581

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2586

lfs_freebuf(fs, bp);

sys/ufs/lfs/lfs_segment.c

2589

fs->lfs_sbactive = 0;

sys/ufs/lfs/lfs_segment.c

2590

if (--fs->lfs_iocount <= 1)

sys/ufs/lfs/lfs_segment.c

2591

wakeup(&fs->lfs_iocount);

sys/ufs/lfs/lfs_segment.c

2592

wakeup(&fs->lfs_sbactive);

sys/ufs/lfs/lfs_segment.c

2607

struct lfs *fs;

sys/ufs/lfs/lfs_segment.c

2617

fs = cl->fs;

sys/ufs/lfs/lfs_segment.c

2618

devvp = VTOI(fs->lfs_ivnode)->i_devvp;

sys/ufs/lfs/lfs_segment.c

2619

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

2639

if ((tbp)->b_vp == (fs)->lfs_ivnode)

sys/ufs/lfs/lfs_segment.c

2727

lfs_free(fs, bp->b_data, LFS_NB_CLUSTER);

sys/ufs/lfs/lfs_segment.c

2736

pool_put(&fs->lfs_bpppool, cl->bpp);

sys/ufs/lfs/lfs_segment.c

2738

pool_put(&fs->lfs_clpool, cl);

sys/ufs/lfs/lfs_segment.c

2741

KASSERTMSG((fs->lfs_iocount != 0),

sys/ufs/lfs/lfs_segment.c

2743

if (--fs->lfs_iocount <= 1)

sys/ufs/lfs/lfs_segment.c

2744

wakeup(&fs->lfs_iocount);

sys/ufs/lfs/lfs_segment.c

2765

lfs_shellsort(struct lfs *fs,

sys/ufs/lfs/lfs_segment.c

2777

if (lfs_blocks_get(fs, lb_array, incr++) != bp_array[t1]->b_lblkno + t2) {

sys/ufs/lfs/lfs_segment.c

278

lfs_segunlock(fs);

sys/ufs/lfs/lfs_segment.c

2793

(intmax_t)lfs_blocks_get(fs, lb_array, incr++));

sys/ufs/lfs/lfs_segment.c

2819

lfs_blocks_set(fs, lb_array, incr++,

sys/ufs/lfs/lfs_segment.c

2830

lfs_acquire_finfo(struct lfs *fs, ino_t ino, int vers)

sys/ufs/lfs/lfs_segment.c

2832

struct segment *sp = fs->lfs_sp;

sys/ufs/lfs/lfs_segment.c

2837

if (sp->seg_bytes_left < lfs_sb_getbsize(fs) ||

sys/ufs/lfs/lfs_segment.c

2838

sp->sum_bytes_left < FINFOSIZE(fs) + LFS_BLKPTRSIZE(fs))

sys/ufs/lfs/lfs_segment.c

2839

(void) lfs_writeseg(fs, fs->lfs_sp);

sys/ufs/lfs/lfs_segment.c

2841

sp->sum_bytes_left -= FINFOSIZE(fs);

sys/ufs/lfs/lfs_segment.c

2843

lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) + 1);

sys/ufs/lfs/lfs_segment.c

2844

lfs_fi_setnblocks(fs, sp->fip, 0);

sys/ufs/lfs/lfs_segment.c

2845

lfs_fi_setino(fs, sp->fip, ino);

sys/ufs/lfs/lfs_segment.c

2846

lfs_fi_setversion(fs, sp->fip, vers);

sys/ufs/lfs/lfs_segment.c

285

fs->lfs_flushvp = vp;

sys/ufs/lfs/lfs_segment.c

2854

lfs_release_finfo(struct lfs *fs)

sys/ufs/lfs/lfs_segment.c

2856

struct segment *sp = fs->lfs_sp;

sys/ufs/lfs/lfs_segment.c

2859

if (lfs_fi_getnblocks(fs, sp->fip) != 0) {

sys/ufs/lfs/lfs_segment.c

286

if (LFS_SHOULD_CHECKPOINT(fs, fs->lfs_sp->seg_flags)) {

sys/ufs/lfs/lfs_segment.c

2860

sp->fip = NEXT_FINFO(fs, sp->fip);

sys/ufs/lfs/lfs_segment.c

2861

lfs_blocks_fromfinfo(fs, &sp->start_lbp, sp->fip);

sys/ufs/lfs/lfs_segment.c

2864

sp->sum_bytes_left += FINFOSIZE(fs);

sys/ufs/lfs/lfs_segment.c

2866

lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) - 1);

sys/ufs/lfs/lfs_segment.c

288

fs->lfs_flushvp = NULL;

sys/ufs/lfs/lfs_segment.c

289

KASSERT(fs->lfs_flushvp_fakevref == 0);

sys/ufs/lfs/lfs_segment.c

290

lfs_segunlock(fs);

sys/ufs/lfs/lfs_segment.c

303

sp = fs->lfs_sp;

sys/ufs/lfs/lfs_segment.c

307

lfs_writevnodes(fs, vp->v_mount, sp, VN_EMPTY);

sys/ufs/lfs/lfs_segment.c

328

relock = lfs_writefile(fs, sp, vp);

sys/ufs/lfs/lfs_segment.c

329

if (relock && vp != fs->lfs_ivnode) {

sys/ufs/lfs/lfs_segment.c

337

lfs_writeinode(fs, sp, ip);

sys/ufs/lfs/lfs_segment.c

341

lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_segment.c

342

lfs_segunlock(fs);

sys/ufs/lfs/lfs_segment.c

343

lfs_segunlock_relock(fs);

sys/ufs/lfs/lfs_segment.c

360

if (vp == fs->lfs_ivnode) {

sys/ufs/lfs/lfs_segment.c

361

lfs_writefile(fs, sp, vp);

sys/ufs/lfs/lfs_segment.c

362

lfs_writefile(fs, sp, vp);

sys/ufs/lfs/lfs_segment.c

368

} while (lfs_writeinode(fs, sp, ip));

sys/ufs/lfs/lfs_segment.c

369

} while (lfs_writeseg(fs, sp) && ip->i_number == LFS_IFILE_INUM);

sys/ufs/lfs/lfs_segment.c

389

if (fs->lfs_seglock > 1) {

sys/ufs/lfs/lfs_segment.c

390

while (fs->lfs_iocount > 1)

sys/ufs/lfs/lfs_segment.c

391

(void)mtsleep(&fs->lfs_iocount, PRIBIO + 1,

sys/ufs/lfs/lfs_segment.c

396

lfs_segunlock(fs);

sys/ufs/lfs/lfs_segment.c

407

fs->lfs_flushvp = NULL;

sys/ufs/lfs/lfs_segment.c

408

KASSERT(fs->lfs_flushvp_fakevref == 0);

sys/ufs/lfs/lfs_segment.c

411

lfs_writer_leave(fs);

sys/ufs/lfs/lfs_segment.c

417

struct lfs *fs;

sys/ufs/lfs/lfs_segment.c

436

&& !IS_FLUSHING(c->fs, vp))

sys/ufs/lfs/lfs_segment.c

452

vp != c->fs->lfs_flushvp && !(ip->i_state & IN_CLEANING)) {

sys/ufs/lfs/lfs_segment.c

457

if (vp == c->fs->lfs_unlockvp) {

sys/ufs/lfs/lfs_segment.c

467

lfs_writevnodes(struct lfs *fs, struct mount *mp, struct segment *sp, int op)

sys/ufs/lfs/lfs_segment.c

482

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

485

ctx.fs = fs;

sys/ufs/lfs/lfs_segment.c

495

error = lfs_writefile(fs, sp, vp);

sys/ufs/lfs/lfs_segment.c

506

lfs_writeinode(fs, sp, ip);

sys/ufs/lfs/lfs_segment.c

507

lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_segment.c

530

(void) lfs_writeinode(fs, sp, ip);

sys/ufs/lfs/lfs_segment.c

547

struct lfs *fs;

sys/ufs/lfs/lfs_segment.c

559

fs = VFSTOULFS(mp)->um_lfs;

sys/ufs/lfs/lfs_segment.c

560

DLOG((DLOG_SEG, "lfs_segwrite(fs=%p, flags=%x)\n", fs, flags));

sys/ufs/lfs/lfs_segment.c

561

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

563

if (fs->lfs_ronly)

sys/ufs/lfs/lfs_segment.c

566

lfs_imtime(fs);

sys/ufs/lfs/lfs_segment.c

573

do_ckp = LFS_SHOULD_CHECKPOINT(fs, flags);

sys/ufs/lfs/lfs_segment.c

579

if (do_ckp && !LFS_SEGLOCK_HELD(fs)) {

sys/ufs/lfs/lfs_segment.c

580

lfs_writer_enter(fs, "ckpwriter");

sys/ufs/lfs/lfs_segment.c

588

lfs_seglock(fs, flags | (do_ckp ? SEGM_CKP : 0));

sys/ufs/lfs/lfs_segment.c

589

sp = fs->lfs_sp;

sys/ufs/lfs/lfs_segment.c

604

lfs_writevnodes(fs, mp, sp, VN_CLEAN);

sys/ufs/lfs/lfs_segment.c

607

um_error = lfs_writevnodes(fs, mp, sp, VN_REG);

sys/ufs/lfs/lfs_segment.c

609

lfs_sb_getcurseg(fs) != fs->lfs_startseg) {

sys/ufs/lfs/lfs_segment.c

610

DLOG((DLOG_SEG, "lfs_segwrite: breaking out of segment write at daddr 0x%jx\n", (uintmax_t)lfs_sb_getoffset(fs)));

sys/ufs/lfs/lfs_segment.c

615

(writer_set = lfs_writer_tryenter(fs)) != 0) {

sys/ufs/lfs/lfs_segment.c

616

KASSERT(fs->lfs_writer);

sys/ufs/lfs/lfs_segment.c

617

error = lfs_writevnodes(fs, mp, sp, VN_DIROP);

sys/ufs/lfs/lfs_segment.c

625

lfs_flush_dirops(fs);

sys/ufs/lfs/lfs_segment.c

627

lfs_ss_setflags(fs, ssp,

sys/ufs/lfs/lfs_segment.c

628

lfs_ss_getflags(fs, ssp) & ~(SS_CONT));

sys/ufs/lfs/lfs_segment.c

629

lfs_finalize_fs_seguse(fs);

sys/ufs/lfs/lfs_segment.c

632

lfs_segunlock_relock(fs);

sys/ufs/lfs/lfs_segment.c

633

sp = fs->lfs_sp;

sys/ufs/lfs/lfs_segment.c

642

if (do_ckp || fs->lfs_doifile) {

sys/ufs/lfs/lfs_segment.c

643

segleft = lfs_sb_getnseg(fs);

sys/ufs/lfs/lfs_segment.c

645

for (n = 0; n < lfs_sb_getsegtabsz(fs); n++) {

sys/ufs/lfs/lfs_segment.c

649

bread_error = bread(fs->lfs_ivnode,

sys/ufs/lfs/lfs_segment.c

650

lfs_sb_getcleansz(fs) + n,

sys/ufs/lfs/lfs_segment.c

651

lfs_sb_getbsize(fs), B_MODIFY, &bp);

sys/ufs/lfs/lfs_segment.c

657

maxseg = uimin(segleft, lfs_sb_getsepb(fs));

sys/ufs/lfs/lfs_segment.c

660

if (sn != lfs_dtosn(fs, lfs_sb_getcurseg(fs)) &&

sys/ufs/lfs/lfs_segment.c

663

--fs->lfs_nactive;

sys/ufs/lfs/lfs_segment.c

666

if (lfs_sb_getversion(fs) > 1)

sys/ufs/lfs/lfs_segment.c

677

segleft -= lfs_sb_getsepb(fs);

sys/ufs/lfs/lfs_segment.c

678

curseg += lfs_sb_getsepb(fs);

sys/ufs/lfs/lfs_segment.c

682

KASSERT(LFS_SEGLOCK_HELD(fs));

sys/ufs/lfs/lfs_segment.c

685

if (do_ckp || fs->lfs_doifile) {

sys/ufs/lfs/lfs_segment.c

686

vp = fs->lfs_ivnode;

sys/ufs/lfs/lfs_segment.c

698

fs->lfs_flags &= ~LFS_IFDIRTY;

sys/ufs/lfs/lfs_segment.c

708

lfs_writefile(fs, sp, vp);

sys/ufs/lfs/lfs_segment.c

731

redo += lfs_writeinode(fs, sp, ip);

sys/ufs/lfs/lfs_segment.c

732

redo += lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_segment.c

734

redo += (fs->lfs_flags & LFS_IFDIRTY);

sys/ufs/lfs/lfs_segment.c

761

if (bp->b_lblkno < lfs_sb_getcleansz(fs) +

sys/ufs/lfs/lfs_segment.c

762

lfs_sb_getsegtabsz(fs) &&

sys/ufs/lfs/lfs_segment.c

780

(void) lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_segment.c

784

fs->lfs_doifile = 0;

sys/ufs/lfs/lfs_segment.c

786

lfs_writer_leave(fs);

sys/ufs/lfs/lfs_segment.c

807

lfs_segunlock(fs);

sys/ufs/lfs/lfs_segment.c

817

lfs_writefile(struct lfs *fs, struct segment *sp, struct vnode *vp)

sys/ufs/lfs/lfs_segment.c

825

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

829

ifile = (vp == fs->lfs_ivnode);

sys/ufs/lfs/lfs_segment.c

830

rolling = (fs->lfs_flags & LFS_NOTYET)

sys/ufs/lfs/lfs_segment.c

831

&& curproc->p_pid == fs->lfs_rfpid;

sys/ufs/lfs/lfs_segment.c

835

lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);

sys/ufs/lfs/lfs_segment.c

839

lfs_ss_setflags(fs, ssp,

sys/ufs/lfs/lfs_segment.c

840

lfs_ss_getflags(fs, ssp) | (SS_DIROP|SS_CONT));

sys/ufs/lfs/lfs_segment.c

847

lfs_gather(fs, sp, vp, lfs_match_data);

sys/ufs/lfs/lfs_segment.c

854

lfs_ungather(fs, sp, vp, lfs_match_data);

sys/ufs/lfs/lfs_segment.c

855

} else if (IS_FLUSHING(fs, vp)) {

sys/ufs/lfs/lfs_segment.c

865

lfs_gather(fs, sp, vp, lfs_match_fake);

sys/ufs/lfs/lfs_segment.c

866

lfs_gather(fs, sp, vp, lfs_match_data);

sys/ufs/lfs/lfs_segment.c

871

lfs_gather(fs, sp, vp, lfs_match_fake);

sys/ufs/lfs/lfs_segment.c

876

lfs_gather(fs, sp, vp, lfs_match_data);

sys/ufs/lfs/lfs_segment.c

902

ip->i_lfs_fragsize[i] < lfs_sb_getbsize(fs))

sys/ufs/lfs/lfs_segment.c

907

if (IS_FLUSHING(fs, vp) || ifile ||

sys/ufs/lfs/lfs_segment.c

909

lfs_gather(fs, sp, vp, lfs_match_indir);

sys/ufs/lfs/lfs_segment.c

910

lfs_gather(fs, sp, vp, lfs_match_dindir);

sys/ufs/lfs/lfs_segment.c

911

lfs_gather(fs, sp, vp, lfs_match_tindir);

sys/ufs/lfs/lfs_segment.c

913

lfs_release_finfo(fs);

sys/ufs/lfs/lfs_segment.c

922

lfs_update_iaddr(struct lfs *fs, struct inode *ip, daddr_t ndaddr)

sys/ufs/lfs/lfs_segment.c

931

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_segment.c

934

newsn = (ndaddr == LFS_UNUSED_DADDR ? -1 : lfs_dtosn(fs, ndaddr));

sys/ufs/lfs/lfs_segment.c

938

odaddr = lfs_sb_getidaddr(fs);

sys/ufs/lfs/lfs_segment.c

939

oldsn = lfs_dtosn(fs, odaddr);

sys/ufs/lfs/lfs_segment.c

940

lfs_sb_setidaddr(fs, ndaddr);

sys/ufs/lfs/lfs_segment.c

942

LFS_IENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_segment.c

943

odaddr = lfs_if_getdaddr(fs, ifp);

sys/ufs/lfs/lfs_segment.c

945

: lfs_dtosn(fs, odaddr));

sys/ufs/lfs/lfs_segment.c

946

lfs_if_setdaddr(fs, ifp, ndaddr);

sys/ufs/lfs/lfs_segment.c

947

LFS_WRITEIENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_segment.c

959

LFS_SEGENTRY(sup, fs, oldsn, bp);

sys/ufs/lfs/lfs_segment.c

962

(intmax_t)DINOSIZE(fs),

sys/ufs/lfs/lfs_segment.c

964

KASSERTMSG(sup->su_nbytes >= DINOSIZE(fs),

sys/ufs/lfs/lfs_segment.c

968

(intmax_t)DINOSIZE(fs) - sup->su_nbytes);

sys/ufs/lfs/lfs_segment.c

969

sup->su_nbytes -= DINOSIZE(fs);

sys/ufs/lfs/lfs_segment.c

970

LFS_WRITESEGENTRY(sup, fs, oldsn, bp); /* Ifile */

sys/ufs/lfs/lfs_segment.c

975

LFS_SEGENTRY(sup, fs, newsn, bp);

sys/ufs/lfs/lfs_segment.c

978

(intmax_t)DINOSIZE(fs),

sys/ufs/lfs/lfs_segment.c

980

KASSERTMSG(sup->su_nbytes <= lfs_sb_getssize(fs),

sys/ufs/lfs/lfs_segment.c

984

(intmax_t)sup->su_nbytes + DINOSIZE(fs));

sys/ufs/lfs/lfs_segment.c

985

sup->su_nbytes += DINOSIZE(fs);

sys/ufs/lfs/lfs_segment.c

986

LFS_WRITESEGENTRY(sup, fs, oldsn, bp); /* Ifile */

sys/ufs/lfs/lfs_segment.c

992

lfs_writeinode(struct lfs *fs, struct segment *sp, struct inode *ip)

sys/ufs/lfs/lfs_subr.c

102

lfs_setup_resblks(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

107

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_subr.c

108

fs->lfs_resblk = malloc(LFS_N_TOTAL * sizeof(res_t), M_SEGMENT,

sys/ufs/lfs/lfs_subr.c

111

fs->lfs_resblk[i].inuse = 0;

sys/ufs/lfs/lfs_subr.c

112

fs->lfs_resblk[i].p = NULL;

sys/ufs/lfs/lfs_subr.c

115

LIST_INIT(fs->lfs_reshash + i);

sys/ufs/lfs/lfs_subr.c

122

fs->lfs_resblk[i].size = lfs_sb_getsumsize(fs);

sys/ufs/lfs/lfs_subr.c

124

fs->lfs_resblk[i].size = LFS_SBPAD;

sys/ufs/lfs/lfs_subr.c

126

fs->lfs_resblk[i].size = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_subr.c

128

fs->lfs_resblk[i].size = MAXPHYS;

sys/ufs/lfs/lfs_subr.c

130

fs->lfs_resblk[i].size = MAXPHYS;

sys/ufs/lfs/lfs_subr.c

132

fs->lfs_resblk[i].size = LFS_MARKV_MAXBLKCNT * sizeof(BLOCK_INFO);

sys/ufs/lfs/lfs_subr.c

135

fs->lfs_resblk[i].p = malloc(fs->lfs_resblk[i].size,

sys/ufs/lfs/lfs_subr.c

142

pool_init(&fs->lfs_clpool, sizeof(struct lfs_cluster), 0, 0, 0,

sys/ufs/lfs/lfs_subr.c

144

pool_init(&fs->lfs_segpool, sizeof(struct segment), 0, 0, 0,

sys/ufs/lfs/lfs_subr.c

147

maxbpp = ((lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs)) / sizeof(int32_t) + 2);

sys/ufs/lfs/lfs_subr.c

148

maxbpp = MIN(maxbpp, lfs_segsize(fs) / lfs_sb_getfsize(fs) + 2);

sys/ufs/lfs/lfs_subr.c

149

pool_init(&fs->lfs_bpppool, maxbpp * sizeof(struct buf *), 0, 0, 0,

sys/ufs/lfs/lfs_subr.c

154

lfs_free_resblks(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

158

pool_destroy(&fs->lfs_bpppool);

sys/ufs/lfs/lfs_subr.c

159

pool_destroy(&fs->lfs_segpool);

sys/ufs/lfs/lfs_subr.c

160

pool_destroy(&fs->lfs_clpool);

sys/ufs/lfs/lfs_subr.c

164

while (fs->lfs_resblk[i].inuse)

sys/ufs/lfs/lfs_subr.c

165

mtsleep(&fs->lfs_resblk, PRIBIO + 1, "lfs_free", 0,

sys/ufs/lfs/lfs_subr.c

167

if (fs->lfs_resblk[i].p != NULL)

sys/ufs/lfs/lfs_subr.c

168

free(fs->lfs_resblk[i].p, M_SEGMENT);

sys/ufs/lfs/lfs_subr.c

170

free(fs->lfs_resblk, M_SEGMENT);

sys/ufs/lfs/lfs_subr.c

185

lfs_malloc(struct lfs *fs, size_t size, int type)

sys/ufs/lfs/lfs_subr.c

192

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_subr.c

219

if (fs->lfs_resblk[start + i].inuse == 0) {

sys/ufs/lfs/lfs_subr.c

220

re = fs->lfs_resblk + start + i;

sys/ufs/lfs/lfs_subr.c

225

LIST_INSERT_HEAD(&fs->lfs_reshash[h], re, res);

sys/ufs/lfs/lfs_subr.c

232

mtsleep(&fs->lfs_resblk, PVM, "lfs_malloc", 0,

sys/ufs/lfs/lfs_subr.c

243

lfs_free(struct lfs *fs, void *p, int type)

sys/ufs/lfs/lfs_subr.c

248

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_subr.c

251

LIST_FOREACH(re, &fs->lfs_reshash[h], res) {

sys/ufs/lfs/lfs_subr.c

256

wakeup(&fs->lfs_resblk);

sys/ufs/lfs/lfs_subr.c

264

KDASSERTMSG(fs->lfs_resblk[i].p == p,

sys/ufs/lfs/lfs_subr.c

282

lfs_fraglock_enter(struct lfs *fs, int enter_exit)

sys/ufs/lfs/lfs_subr.c

284

lfs_prelock(fs, 0);

sys/ufs/lfs/lfs_subr.c

288

lfs_fraglock_held(struct lfs *fs, int read_write)

sys/ufs/lfs/lfs_subr.c

290

return lfs_prelock_held(fs);

sys/ufs/lfs/lfs_subr.c

294

lfs_fraglock_exit(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

296

lfs_preunlock(fs);

sys/ufs/lfs/lfs_subr.c

304

lfs_seglock(struct lfs *fs, unsigned long flags)

sys/ufs/lfs/lfs_subr.c

309

error = lfs_prelock(fs, flags);

sys/ufs/lfs/lfs_subr.c

313

if (fs->lfs_seglock) {

sys/ufs/lfs/lfs_subr.c

314

++fs->lfs_seglock;

sys/ufs/lfs/lfs_subr.c

315

fs->lfs_sp->seg_flags |= flags;

sys/ufs/lfs/lfs_subr.c

319

fs->lfs_seglock = 1;

sys/ufs/lfs/lfs_subr.c

320

fs->lfs_cleanind = 0;

sys/ufs/lfs/lfs_subr.c

324

sp = fs->lfs_sp = pool_get(&fs->lfs_segpool, PR_WAITOK);

sys/ufs/lfs/lfs_subr.c

325

sp->bpp = pool_get(&fs->lfs_bpppool, PR_WAITOK);

sys/ufs/lfs/lfs_subr.c

331

(void) lfs_initseg(fs, 0);

sys/ufs/lfs/lfs_subr.c

340

++fs->lfs_iocount;

sys/ufs/lfs/lfs_subr.c

341

fs->lfs_startseg = lfs_sb_getcurseg(fs);

sys/ufs/lfs/lfs_subr.c

373

lfs_unmark_dirop(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

379

KASSERT(fs != NULL);

sys/ufs/lfs/lfs_subr.c

380

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_subr.c

382

doit = !(fs->lfs_flags & LFS_UNDIROP);

sys/ufs/lfs/lfs_subr.c

384

fs->lfs_flags |= LFS_UNDIROP;

sys/ufs/lfs/lfs_subr.c

393

TAILQ_INSERT_HEAD(&fs->lfs_dchainhd, marker, i_lfs_dchain);

sys/ufs/lfs/lfs_subr.c

395

TAILQ_REMOVE(&fs->lfs_dchainhd, marker, i_lfs_dchain);

sys/ufs/lfs/lfs_subr.c

396

TAILQ_INSERT_AFTER(&fs->lfs_dchainhd, ip, marker,

sys/ufs/lfs/lfs_subr.c

403

--fs->lfs_dirvcount;

sys/ufs/lfs/lfs_subr.c

405

TAILQ_REMOVE(&fs->lfs_dchainhd, ip, i_lfs_dchain);

sys/ufs/lfs/lfs_subr.c

407

fs->lfs_unlockvp = vp;

sys/ufs/lfs/lfs_subr.c

411

fs->lfs_unlockvp = NULL;

sys/ufs/lfs/lfs_subr.c

415

TAILQ_REMOVE(&fs->lfs_dchainhd, marker, i_lfs_dchain);

sys/ufs/lfs/lfs_subr.c

416

fs->lfs_flags &= ~LFS_UNDIROP;

sys/ufs/lfs/lfs_subr.c

417

wakeup(&fs->lfs_flags);

sys/ufs/lfs/lfs_subr.c

424

lfs_auto_segclean(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

430

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_subr.c

438

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

sys/ufs/lfs/lfs_subr.c

440

LFS_SEGENTRY(sup, fs, i, bp);

sys/ufs/lfs/lfs_subr.c

459

while (waited == 0 && fs->lfs_sbactive)

sys/ufs/lfs/lfs_subr.c

460

mtsleep(&fs->lfs_sbactive, PRIBIO+1,

sys/ufs/lfs/lfs_subr.c

465

lfs_markclean(fs, i, sup, NOCRED, curlwp);

sys/ufs/lfs/lfs_subr.c

474

LFS_WRITESEGENTRY(sup, fs, i, bp);

sys/ufs/lfs/lfs_subr.c

481

lfs_seglock_held(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

483

return lfs_prelock_held(fs) && fs->lfs_seglock != 0;

sys/ufs/lfs/lfs_subr.c

491

lfs_segunlock(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

498

sp = fs->lfs_sp;

sys/ufs/lfs/lfs_subr.c

500

if (!LFS_SEGLOCK_HELD(fs))

sys/ufs/lfs/lfs_subr.c

503

if (fs->lfs_seglock == 1) {

sys/ufs/lfs/lfs_subr.c

513

lfs_sb_suboffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));

sys/ufs/lfs/lfs_subr.c

515

lfs_freebuf(fs, bp);

sys/ufs/lfs/lfs_subr.c

517

pool_put(&fs->lfs_bpppool, sp->bpp);

sys/ufs/lfs/lfs_subr.c

527

pool_put(&fs->lfs_segpool, sp);

sys/ufs/lfs/lfs_subr.c

528

fs->lfs_sp = NULL;

sys/ufs/lfs/lfs_subr.c

536

if (--fs->lfs_iocount <= 1)

sys/ufs/lfs/lfs_subr.c

537

wakeup(&fs->lfs_iocount);

sys/ufs/lfs/lfs_subr.c

548

--fs->lfs_seglock;

sys/ufs/lfs/lfs_subr.c

558

while (ckp && sync && fs->lfs_iocount) {

sys/ufs/lfs/lfs_subr.c

559

(void)mtsleep(&fs->lfs_iocount, PRIBIO + 1,

sys/ufs/lfs/lfs_subr.c

561

DLOG((DLOG_SEG, "sleeping on iocount %x == %d\n", fs, fs->lfs_iocount));

sys/ufs/lfs/lfs_subr.c

570

pool_put(&fs->lfs_segpool, sp);

sys/ufs/lfs/lfs_subr.c

573

fs->lfs_nactive = 0;

sys/ufs/lfs/lfs_subr.c

577

lfs_writesuper(fs, lfs_sb_getsboff(fs, fs->lfs_activesb));

sys/ufs/lfs/lfs_subr.c

578

lfs_writesuper(fs, lfs_sb_getsboff(fs, 1 - fs->lfs_activesb));

sys/ufs/lfs/lfs_subr.c

579

if (!(fs->lfs_ivnode->v_mount->mnt_iflag &

sys/ufs/lfs/lfs_subr.c

581

lfs_auto_segclean(fs);

sys/ufs/lfs/lfs_subr.c

584

lfs_auto_segclean(fs);

sys/ufs/lfs/lfs_subr.c

586

fs->lfs_activesb = 1 - fs->lfs_activesb;

sys/ufs/lfs/lfs_subr.c

590

--fs->lfs_seglock;

sys/ufs/lfs/lfs_subr.c

593

lfs_unmark_dirop(fs);

sys/ufs/lfs/lfs_subr.c

595

--fs->lfs_seglock;

sys/ufs/lfs/lfs_subr.c

596

KASSERT(fs->lfs_seglock != 0);

sys/ufs/lfs/lfs_subr.c

599

lfs_preunlock(fs);

sys/ufs/lfs/lfs_subr.c

606

lfs_cleanerlock(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

611

while (fs->lfs_cleanlock) {

sys/ufs/lfs/lfs_subr.c

612

printf("cleanlock=%p, waiting\n", fs->lfs_cleanlock);

sys/ufs/lfs/lfs_subr.c

613

error = cv_wait_sig(&fs->lfs_cleanercv, &lfs_lock);

sys/ufs/lfs/lfs_subr.c

618

fs->lfs_cleanlock = curlwp;

sys/ufs/lfs/lfs_subr.c

628

lfs_cleanerlock_held(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

633

retval = (fs->lfs_cleanlock == curlwp);

sys/ufs/lfs/lfs_subr.c

643

lfs_cleanerunlock(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

648

while ((ip = TAILQ_FIRST(&fs->lfs_cleanhd)) != NULL)

sys/ufs/lfs/lfs_subr.c

649

lfs_clrclean(fs, ITOV(ip));

sys/ufs/lfs/lfs_subr.c

652

fs->lfs_cleanlock = NULL;

sys/ufs/lfs/lfs_subr.c

653

cv_broadcast(&fs->lfs_cleanercv);

sys/ufs/lfs/lfs_subr.c

664

lfs_prelock(struct lfs *fs, unsigned long flags)

sys/ufs/lfs/lfs_subr.c

671

if (fs->lfs_prelock) {

sys/ufs/lfs/lfs_subr.c

672

if (fs->lfs_prelocklwp == curlwp) {

sys/ufs/lfs/lfs_subr.c

674

++fs->lfs_prelock;

sys/ufs/lfs/lfs_subr.c

682

while (fs->lfs_prelock) {

sys/ufs/lfs/lfs_subr.c

683

cv_wait(&fs->lfs_prelockcv, &lfs_lock);

sys/ufs/lfs/lfs_subr.c

689

fs->lfs_prelock = 1;

sys/ufs/lfs/lfs_subr.c

690

fs->lfs_prelocklwp = curlwp;

sys/ufs/lfs/lfs_subr.c

698

lfs_prelock_held(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

707

held = (fs->lfs_prelock && fs->lfs_prelocklwp == curlwp);

sys/ufs/lfs/lfs_subr.c

716

lfs_preunlock(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

719

if (--fs->lfs_prelock == 0) {

sys/ufs/lfs/lfs_subr.c

720

fs->lfs_prelocklwp = NULL;

sys/ufs/lfs/lfs_subr.c

721

cv_broadcast(&fs->lfs_prelockcv);

sys/ufs/lfs/lfs_subr.c

732

lfs_writer_enter(struct lfs *fs, const char *wmesg)

sys/ufs/lfs/lfs_subr.c

736

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_subr.c

740

fs->lfs_writer++;

sys/ufs/lfs/lfs_subr.c

742

while (fs->lfs_dirops > 0) {

sys/ufs/lfs/lfs_subr.c

743

++fs->lfs_diropwait;

sys/ufs/lfs/lfs_subr.c

744

error = mtsleep(&fs->lfs_writer, PRIBIO+1, wmesg, 0,

sys/ufs/lfs/lfs_subr.c

747

--fs->lfs_diropwait;

sys/ufs/lfs/lfs_subr.c

754

lfs_writer_tryenter(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

758

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_subr.c

760

writer_set = (fs->lfs_dirops == 0);

sys/ufs/lfs/lfs_subr.c

762

fs->lfs_writer++;

sys/ufs/lfs/lfs_subr.c

769

lfs_writer_leave(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

773

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_subr.c

775

dowakeup = !(--fs->lfs_writer);

sys/ufs/lfs/lfs_subr.c

777

cv_broadcast(&fs->lfs_diropscv);

sys/ufs/lfs/lfs_subr.c

787

lfs_segunlock_relock(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

789

int n = fs->lfs_seglock;

sys/ufs/lfs/lfs_subr.c

798

lfs_writeseg(fs, fs->lfs_sp);

sys/ufs/lfs/lfs_subr.c

802

fs->lfs_flags |= LFS_MUSTCLEAN;

sys/ufs/lfs/lfs_subr.c

804

LFS_CLEANERINFO(cip, fs, bp);

sys/ufs/lfs/lfs_subr.c

805

lfs_ci_setflags(fs, cip,

sys/ufs/lfs/lfs_subr.c

806

lfs_ci_getflags(fs, cip) | LFS_CLEANER_MUST_CLEAN);

sys/ufs/lfs/lfs_subr.c

807

LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);

sys/ufs/lfs/lfs_subr.c

810

seg_flags = fs->lfs_sp->seg_flags;

sys/ufs/lfs/lfs_subr.c

812

while(fs->lfs_seglock)

sys/ufs/lfs/lfs_subr.c

813

lfs_segunlock(fs);

sys/ufs/lfs/lfs_subr.c

816

lfs_wakeup_cleaner(fs);

sys/ufs/lfs/lfs_subr.c

818

while (LFS_STARVED_FOR_SEGS(fs))

sys/ufs/lfs/lfs_subr.c

819

mtsleep(&fs->lfs_availsleep, PRIBIO, "relock", 0,

sys/ufs/lfs/lfs_subr.c

825

lfs_seglock(fs, seg_flags);

sys/ufs/lfs/lfs_subr.c

829

fs->lfs_flags &= ~LFS_MUSTCLEAN;

sys/ufs/lfs/lfs_subr.c

831

LFS_CLEANERINFO(cip, fs, bp);

sys/ufs/lfs/lfs_subr.c

832

lfs_ci_setflags(fs, cip,

sys/ufs/lfs/lfs_subr.c

833

lfs_ci_getflags(fs, cip) & ~LFS_CLEANER_MUST_CLEAN);

sys/ufs/lfs/lfs_subr.c

834

LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);

sys/ufs/lfs/lfs_subr.c

843

lfs_wakeup_cleaner(struct lfs *fs)

sys/ufs/lfs/lfs_subr.c

845

if (fs->lfs_nowrap > 0)

sys/ufs/lfs/lfs_subr.c

848

cv_broadcast(&fs->lfs_nextsegsleep);

sys/ufs/lfs/lfs_subr.c

858

lfs_setclean(struct lfs *fs, struct vnode *vp)

sys/ufs/lfs/lfs_subr.c

862

KASSERT(lfs_cleanerlock_held(fs));

sys/ufs/lfs/lfs_subr.c

874

TAILQ_INSERT_HEAD(&fs->lfs_cleanhd, ip, i_lfs_clean);

sys/ufs/lfs/lfs_subr.c

886

lfs_clrclean(struct lfs *fs, struct vnode *vp)

sys/ufs/lfs/lfs_subr.c

890

KASSERT(lfs_cleanerlock_held(fs));

sys/ufs/lfs/lfs_subr.c

900

if (vp->v_type == VREG && vp != fs->lfs_ivnode)

sys/ufs/lfs/lfs_subr.c

901

lfs_ungather(fs, NULL, vp, lfs_match_data);

sys/ufs/lfs/lfs_subr.c

904

TAILQ_REMOVE(&fs->lfs_cleanhd, ip, i_lfs_clean);

sys/ufs/lfs/lfs_subr.c

914

lfs_seguse_clrflag_all(struct lfs *fs, uint32_t flag)

sys/ufs/lfs/lfs_subr.c

920

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

sys/ufs/lfs/lfs_subr.c

921

LFS_SEGENTRY(sup, fs, i, bp);

sys/ufs/lfs/lfs_subr.c

924

LFS_WRITESEGENTRY(sup, fs, i, bp);

sys/ufs/lfs/lfs_syscalls.c

1018

struct lfs *fs;

sys/ufs/lfs/lfs_syscalls.c

1022

fs = ump->um_lfs;

sys/ufs/lfs/lfs_syscalls.c

1023

fs->lfs_cleaner_hint = blkp;

sys/ufs/lfs/lfs_syscalls.c

1025

fs->lfs_cleaner_hint = NULL;

sys/ufs/lfs/lfs_syscalls.c

1044

lfs_fakebuf(struct lfs *fs, struct vnode *vp, daddr_t lbn, size_t size, void *uaddr)

sys/ufs/lfs/lfs_syscalls.c

1054

lfs_freebuf(fs, bp);

sys/ufs/lfs/lfs_syscalls.c

1061

++fs->lfs_iocount;

sys/ufs/lfs/lfs_syscalls.c

119

struct lfs *fs;

sys/ufs/lfs/lfs_syscalls.c

127

fs = VFSTOULFS(mntp)->um_lfs;

sys/ufs/lfs/lfs_syscalls.c

134

blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

143

lfs_free(fs, blkiov, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

160

struct lfs *fs;

sys/ufs/lfs/lfs_syscalls.c

168

fs = VFSTOULFS(mntp)->um_lfs;

sys/ufs/lfs/lfs_syscalls.c

175

blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

176

blkiov15 = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO_15), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

205

lfs_free(fs, blkiov, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

206

lfs_free(fs, blkiov15, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

222

struct lfs *fs;

sys/ufs/lfs/lfs_syscalls.c

247

fs = ump->um_lfs;

sys/ufs/lfs/lfs_syscalls.c

249

if (fs->lfs_ronly)

sys/ufs/lfs/lfs_syscalls.c

252

maxino = (lfs_fragstoblks(fs, lfs_dino_getblocks(fs, VTOI(fs->lfs_ivnode)->i_din)) -

sys/ufs/lfs/lfs_syscalls.c

253

lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);

sys/ufs/lfs/lfs_syscalls.c

263

lfs_cleanerlock(fs);

sys/ufs/lfs/lfs_syscalls.c

276

lfs_setclean(fs, vp);

sys/ufs/lfs/lfs_syscalls.c

293

lfs_seglock(fs, SEGM_CLEAN | SEGM_CKP | SEGM_SYNC);

sys/ufs/lfs/lfs_syscalls.c

336

lfs_dtosn(fs, blkp->bi_daddr)));

sys/ufs/lfs/lfs_syscalls.c

383

LFS_IENTRY(ifp, fs, blkp->bi_inode, bp);

sys/ufs/lfs/lfs_syscalls.c

384

if (lfs_if_getdaddr(fs, ifp) == blkp->bi_daddr) {

sys/ufs/lfs/lfs_syscalls.c

385

lfs_setclean(fs, vp);

sys/ufs/lfs/lfs_syscalls.c

394

LFS_DBTOFSB(fs, b_daddr) != blkp->bi_daddr)

sys/ufs/lfs/lfs_syscalls.c

396

if (lfs_dtosn(fs, LFS_DBTOFSB(fs, b_daddr)) ==

sys/ufs/lfs/lfs_syscalls.c

397

lfs_dtosn(fs, blkp->bi_daddr))

sys/ufs/lfs/lfs_syscalls.c

400

(intmax_t)blkp->bi_daddr, (intmax_t)LFS_DBTOFSB(fs, b_daddr)));

sys/ufs/lfs/lfs_syscalls.c

412

obsize = lfs_blksize(fs, ip, blkp->bi_lbn);

sys/ufs/lfs/lfs_syscalls.c

414

obsize = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_syscalls.c

438

bp = lfs_fakebuf(fs, vp, blkp->bi_lbn,

sys/ufs/lfs/lfs_syscalls.c

441

bp->b_blkno = LFS_FSBTODB(fs, blkp->bi_daddr);

sys/ufs/lfs/lfs_syscalls.c

444

if (blkp->bi_size != lfs_sb_getbsize(fs) &&

sys/ufs/lfs/lfs_syscalls.c

474

if (nblkwritten + lfs_lblkno(fs, ninowritten * DINOSIZE(fs))

sys/ufs/lfs/lfs_syscalls.c

504

lfs_segunlock(fs);

sys/ufs/lfs/lfs_syscalls.c

534

lfs_segunlock(fs);

sys/ufs/lfs/lfs_syscalls.c

563

struct lfs *fs;

sys/ufs/lfs/lfs_syscalls.c

571

fs = VFSTOULFS(mntp)->um_lfs;

sys/ufs/lfs/lfs_syscalls.c

579

blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

588

lfs_free(fs, blkiov, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

605

struct lfs *fs;

sys/ufs/lfs/lfs_syscalls.c

613

fs = VFSTOULFS(mntp)->um_lfs;

sys/ufs/lfs/lfs_syscalls.c

619

blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

620

blkiov15 = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO_15), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

649

lfs_free(fs, blkiov, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

650

lfs_free(fs, blkiov15, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_syscalls.c

663

struct lfs *fs;

sys/ufs/lfs/lfs_syscalls.c

684

fs = ump->um_lfs;

sys/ufs/lfs/lfs_syscalls.c

686

if (fs->lfs_cleaner_thread == NULL)

sys/ufs/lfs/lfs_syscalls.c

687

fs->lfs_cleaner_thread = curlwp;

sys/ufs/lfs/lfs_syscalls.c

688

KASSERT(fs->lfs_cleaner_thread == curlwp);

sys/ufs/lfs/lfs_syscalls.c

719

v_daddr = lfs_sb_getidaddr(fs);

sys/ufs/lfs/lfs_syscalls.c

721

LFS_IENTRY(ifp, fs, blkp->bi_inode, bp);

sys/ufs/lfs/lfs_syscalls.c

722

v_daddr = lfs_if_getdaddr(fs, ifp);

sys/ufs/lfs/lfs_syscalls.c

774

blkp->bi_daddr = LFS_DBTOFSB(fs, bi_daddr);

sys/ufs/lfs/lfs_syscalls.c

777

blkp->bi_size = lfs_blksize(fs, ip, blkp->bi_lbn);

sys/ufs/lfs/lfs_syscalls.c

779

blkp->bi_size = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_syscalls.c

814

struct lfs *fs;

sys/ufs/lfs/lfs_syscalls.c

830

fs = VFSTOULFS(mntp)->um_lfs;

sys/ufs/lfs/lfs_syscalls.c

837

lfs_prelock(fs, 0);

sys/ufs/lfs/lfs_syscalls.c

838

error = lfs_do_segclean(fs, segnum, l->l_cred, l);

sys/ufs/lfs/lfs_syscalls.c

839

lfs_preunlock(fs);

sys/ufs/lfs/lfs_syscalls.c

850

lfs_do_segclean(struct lfs *fs, unsigned long segnum, kauth_cred_t cred, struct lwp *l)

sys/ufs/lfs/lfs_syscalls.c

855

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_syscalls.c

857

if (lfs_dtosn(fs, lfs_sb_getcurseg(fs)) == segnum) {

sys/ufs/lfs/lfs_syscalls.c

861

LFS_SEGENTRY(sup, fs, segnum, bp);

sys/ufs/lfs/lfs_syscalls.c

881

lfs_markclean(fs, segnum, sup, cred, l);

sys/ufs/lfs/lfs_syscalls.c

882

LFS_WRITESEGENTRY(sup, fs, segnum, bp);

sys/ufs/lfs/lfs_syscalls.c

888

lfs_markclean(struct lfs *fs, unsigned long segnum, SEGUSE *sup,

sys/ufs/lfs/lfs_syscalls.c

895

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_syscalls.c

898

if (lfs_checkempty(fs, segnum, cred, l) == EEXIST)

sys/ufs/lfs/lfs_syscalls.c

902

lfs_sb_addavail(fs, lfs_segtod(fs, 1));

sys/ufs/lfs/lfs_syscalls.c

904

lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_SBPAD));

sys/ufs/lfs/lfs_syscalls.c

905

if (lfs_sb_getversion(fs) > 1 && segnum == 0 &&

sys/ufs/lfs/lfs_syscalls.c

906

lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))

sys/ufs/lfs/lfs_syscalls.c

907

lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_LABELPAD) - lfs_sb_gets0addr(fs));

sys/ufs/lfs/lfs_syscalls.c

909

lfs_sb_addbfree(fs, sup->su_nsums * lfs_btofsb(fs, lfs_sb_getsumsize(fs)) +

sys/ufs/lfs/lfs_syscalls.c

910

lfs_btofsb(fs, sup->su_ninos * lfs_sb_getibsize(fs)));

sys/ufs/lfs/lfs_syscalls.c

911

lfs_sb_subdmeta(fs, sup->su_nsums * lfs_btofsb(fs, lfs_sb_getsumsize(fs)) +

sys/ufs/lfs/lfs_syscalls.c

912

lfs_btofsb(fs, sup->su_ninos * lfs_sb_getibsize(fs)));

sys/ufs/lfs/lfs_syscalls.c

913

if (lfs_sb_getdmeta(fs) < 0)

sys/ufs/lfs/lfs_syscalls.c

914

lfs_sb_setdmeta(fs, 0);

sys/ufs/lfs/lfs_syscalls.c

920

LFS_CLEANERINFO(cip, fs, bp);

sys/ufs/lfs/lfs_syscalls.c

921

lfs_ci_shiftdirtytoclean(fs, cip, 1);

sys/ufs/lfs/lfs_syscalls.c

922

lfs_sb_setnclean(fs, lfs_ci_getclean(fs, cip));

sys/ufs/lfs/lfs_syscalls.c

924

lfs_ci_setbfree(fs, cip, lfs_sb_getbfree(fs));

sys/ufs/lfs/lfs_syscalls.c

925

lfs_ci_setavail(fs, cip, lfs_sb_getavail(fs)

sys/ufs/lfs/lfs_syscalls.c

926

- fs->lfs_ravail - fs->lfs_favail);

sys/ufs/lfs/lfs_syscalls.c

927

wakeup(&fs->lfs_availsleep);

sys/ufs/lfs/lfs_vfsops.c

1069

fs = kmem_zalloc(sizeof(struct lfs), KM_SLEEP);

sys/ufs/lfs/lfs_vfsops.c

1070

memcpy(&fs->lfs_dlfs_u.u_32, &thesb->lfs_dlfs_u.u_32,

sys/ufs/lfs/lfs_vfsops.c

1072

fs->lfs_is64 = thesb->lfs_is64;

sys/ufs/lfs/lfs_vfsops.c

1073

fs->lfs_dobyteswap = thesb->lfs_dobyteswap;

sys/ufs/lfs/lfs_vfsops.c

1074

fs->lfs_hasolddirfmt = false; /* set for real below */

sys/ufs/lfs/lfs_vfsops.c

1077

if (lfs_sb_getversion(fs) < 2) {

sys/ufs/lfs/lfs_vfsops.c

1078

lfs_sb_setsumsize(fs, LFS_V1_SUMMARY_SIZE);

sys/ufs/lfs/lfs_vfsops.c

1079

lfs_sb_setibsize(fs, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_vfsops.c

1080

lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 0));

sys/ufs/lfs/lfs_vfsops.c

1081

lfs_sb_settstamp(fs, lfs_sb_getotstamp(fs));

sys/ufs/lfs/lfs_vfsops.c

1082

lfs_sb_setfsbtodb(fs, 0);

sys/ufs/lfs/lfs_vfsops.c

1084

if (lfs_sb_getresvseg(fs) == 0)

sys/ufs/lfs/lfs_vfsops.c

1085

lfs_sb_setresvseg(fs, MIN(lfs_sb_getminfreeseg(fs) - 1, \

sys/ufs/lfs/lfs_vfsops.c

1086

MAX(MIN_RESV_SEGS, lfs_sb_getminfreeseg(fs) / 2 + 1)));

sys/ufs/lfs/lfs_vfsops.c

1092

if (lfs_fsbtob(fs, LFS_NRESERVE(fs)) > LFS_MAX_BYTES && !ronly) {

sys/ufs/lfs/lfs_vfsops.c

1097

lfs_fsbtob(fs, LFS_NRESERVE(fs))) >> PAGE_SHIFT)));

sys/ufs/lfs/lfs_vfsops.c

1098

kmem_free(fs, sizeof(struct lfs));

sys/ufs/lfs/lfs_vfsops.c

1105

fs->lfs_flags = LFS_NOTYET;

sys/ufs/lfs/lfs_vfsops.c

1106

fs->lfs_rfpid = l->l_proc->p_pid;

sys/ufs/lfs/lfs_vfsops.c

1110

ump->um_lfs = fs;

sys/ufs/lfs/lfs_vfsops.c

1111

ump->um_fstype = fs->lfs_is64 ? ULFS2 : ULFS1;

sys/ufs/lfs/lfs_vfsops.c

1120

fs->lfs_devbsize = DEV_BSIZE;

sys/ufs/lfs/lfs_vfsops.c

1121

fs->lfs_iocount = 0;

sys/ufs/lfs/lfs_vfsops.c

1122

fs->lfs_diropwait = 0;

sys/ufs/lfs/lfs_vfsops.c

1123

fs->lfs_activesb = 0;

sys/ufs/lfs/lfs_vfsops.c

1124

lfs_sb_setuinodes(fs, 0);

sys/ufs/lfs/lfs_vfsops.c

1125

fs->lfs_ravail = 0;

sys/ufs/lfs/lfs_vfsops.c

1126

fs->lfs_favail = 0;

sys/ufs/lfs/lfs_vfsops.c

1127

fs->lfs_sbactive = 0;

sys/ufs/lfs/lfs_vfsops.c

1130

fs->lfs_doifile = 0;

sys/ufs/lfs/lfs_vfsops.c

1131

fs->lfs_writer = 0;

sys/ufs/lfs/lfs_vfsops.c

1132

fs->lfs_dirops = 0;

sys/ufs/lfs/lfs_vfsops.c

1133

fs->lfs_nadirop = 0;

sys/ufs/lfs/lfs_vfsops.c

1134

fs->lfs_prelock = 0;

sys/ufs/lfs/lfs_vfsops.c

1135

fs->lfs_seglock = 0;

sys/ufs/lfs/lfs_vfsops.c

1136

fs->lfs_cleanlock = 0;

sys/ufs/lfs/lfs_vfsops.c

1137

fs->lfs_pdflush = 0;

sys/ufs/lfs/lfs_vfsops.c

1138

fs->lfs_sleepers = 0;

sys/ufs/lfs/lfs_vfsops.c

1139

fs->lfs_pages = 0;

sys/ufs/lfs/lfs_vfsops.c

1140

fs->lfs_prelocklwp = NULL;

sys/ufs/lfs/lfs_vfsops.c

1141

rw_init(&fs->lfs_fraglock);

sys/ufs/lfs/lfs_vfsops.c

1142

rw_init(&fs->lfs_iflock);

sys/ufs/lfs/lfs_vfsops.c

1143

cv_init(&fs->lfs_sleeperscv, "lfs_slp");

sys/ufs/lfs/lfs_vfsops.c

1144

cv_init(&fs->lfs_diropscv, "lfs_dirop");

sys/ufs/lfs/lfs_vfsops.c

1145

cv_init(&fs->lfs_stopcv, "lfsstop");

sys/ufs/lfs/lfs_vfsops.c

1146

cv_init(&fs->lfs_nextsegsleep, "segment");

sys/ufs/lfs/lfs_vfsops.c

1147

cv_init(&fs->lfs_cleanercv, "cleancv");

sys/ufs/lfs/lfs_vfsops.c

1148

cv_init(&fs->lfs_prelockcv, "prelockcv");

sys/ufs/lfs/lfs_vfsops.c

1149

cv_init(&fs->lfs_cleanquitcv, "cleanquit");

sys/ufs/lfs/lfs_vfsops.c

1152

fs->lfs_ronly = ronly;

sys/ufs/lfs/lfs_vfsops.c

1154

fs->lfs_fmod = 1;

sys/ufs/lfs/lfs_vfsops.c

1158

fs->lfs_dev = dev;

sys/ufs/lfs/lfs_vfsops.c

1159

fs->lfs_devvp = devvp;

sys/ufs/lfs/lfs_vfsops.c

1162

fs->um_flags = 0;

sys/ufs/lfs/lfs_vfsops.c

1163

fs->um_bptrtodb = lfs_sb_getffshift(fs) - DEV_BSHIFT;

sys/ufs/lfs/lfs_vfsops.c

1164

fs->um_seqinc = lfs_sb_getfrag(fs);

sys/ufs/lfs/lfs_vfsops.c

1165

fs->um_nindir = lfs_sb_getnindir(fs);

sys/ufs/lfs/lfs_vfsops.c

1166

fs->um_lognindir = ffs(lfs_sb_getnindir(fs)) - 1;

sys/ufs/lfs/lfs_vfsops.c

1167

fs->um_maxsymlinklen = lfs_sb_getmaxsymlinklen(fs);

sys/ufs/lfs/lfs_vfsops.c

1168

fs->um_dirblksiz = LFS_DIRBLKSIZ;

sys/ufs/lfs/lfs_vfsops.c

1169

fs->um_maxfilesize = lfs_sb_getmaxfilesize(fs);

sys/ufs/lfs/lfs_vfsops.c

1173

fs->lfs_use_quota2 = 0;

sys/ufs/lfs/lfs_vfsops.c

1174

fs->lfs_quota_magic = 0;

sys/ufs/lfs/lfs_vfsops.c

1175

fs->lfs_quota_flags = 0;

sys/ufs/lfs/lfs_vfsops.c

1176

fs->lfs_quotaino[0] = 0;

sys/ufs/lfs/lfs_vfsops.c

1177

fs->lfs_quotaino[1] = 0;

sys/ufs/lfs/lfs_vfsops.c

1185

mp->mnt_stat.f_iosize = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_vfsops.c

1188

mp->mnt_fs_bshift = lfs_sb_getbshift(fs);

sys/ufs/lfs/lfs_vfsops.c

1190

if (fs->um_maxsymlinklen > 0)

sys/ufs/lfs/lfs_vfsops.c

1193

fs->lfs_hasolddirfmt = true;

sys/ufs/lfs/lfs_vfsops.c

1201

lfs_setup_resblks(fs);

sys/ufs/lfs/lfs_vfsops.c

1203

TAILQ_INIT(&fs->lfs_dchainhd);

sys/ufs/lfs/lfs_vfsops.c

1205

TAILQ_INIT(&fs->lfs_cleanhd);

sys/ufs/lfs/lfs_vfsops.c

1207

TAILQ_INIT(&fs->lfs_pchainhd);

sys/ufs/lfs/lfs_vfsops.c

1209

rb_tree_init(&fs->lfs_segdhd, &lfs_rbtree_ops);

sys/ufs/lfs/lfs_vfsops.c

1221

fs->lfs_ivnode = vp;

sys/ufs/lfs/lfs_vfsops.c

1225

lfs_order_freelist(fs, &orphan, &norphan);

sys/ufs/lfs/lfs_vfsops.c

1228

fs->lfs_nactive = 0;

sys/ufs/lfs/lfs_vfsops.c

1229

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

sys/ufs/lfs/lfs_vfsops.c

1233

LFS_SEGENTRY(sup, fs, i, bp);

sys/ufs/lfs/lfs_vfsops.c

1252

LFS_WRITESEGENTRY(sup, fs, i, bp);

sys/ufs/lfs/lfs_vfsops.c

1257

fs->lfs_lastcleaned = (uint32_t)-1;

sys/ufs/lfs/lfs_vfsops.c

1260

lfs_free_orphans(fs, orphan, norphan);

sys/ufs/lfs/lfs_vfsops.c

1264

lfs_roll_forward(fs, mp, l);

sys/ufs/lfs/lfs_vfsops.c

1265

lfs_reset_avail(fs);

sys/ufs/lfs/lfs_vfsops.c

1267

fs->lfs_rfpid = 0;

sys/ufs/lfs/lfs_vfsops.c

1289

if (!ronly && fs->lfs_use_quota2) {

sys/ufs/lfs/lfs_vfsops.c

1310

if (!fs->lfs_ronly) {

sys/ufs/lfs/lfs_vfsops.c

1311

lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) & ~LFS_PF_CLEAN);

sys/ufs/lfs/lfs_vfsops.c

1312

lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));

sys/ufs/lfs/lfs_vfsops.c

1313

lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));

sys/ufs/lfs/lfs_vfsops.c

1317

fs->lfs_flags &= ~(LFS_NOTYET);

sys/ufs/lfs/lfs_vfsops.c

1318

wakeup(&fs->lfs_flags);

sys/ufs/lfs/lfs_vfsops.c

1327

LFS_CLEANERINFO(cip, fs, bp);

sys/ufs/lfs/lfs_vfsops.c

1328

lfs_ci_setclean(fs, cip, lfs_sb_getnclean(fs));

sys/ufs/lfs/lfs_vfsops.c

1329

lfs_ci_setdirty(fs, cip, lfs_sb_getnseg(fs) - lfs_sb_getnclean(fs));

sys/ufs/lfs/lfs_vfsops.c

1330

lfs_ci_setavail(fs, cip, lfs_sb_getavail(fs));

sys/ufs/lfs/lfs_vfsops.c

1331

lfs_ci_setbfree(fs, cip, lfs_sb_getbfree(fs));

sys/ufs/lfs/lfs_vfsops.c

1342

LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getoffset(fs)), bp);

sys/ufs/lfs/lfs_vfsops.c

1344

fs->lfs_nactive++;

sys/ufs/lfs/lfs_vfsops.c

1345

LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getoffset(fs)), bp); /* Ifile */

sys/ufs/lfs/lfs_vfsops.c

1379

lfs_reset_avail(struct lfs *fs)

sys/ufs/lfs/lfs_vfsops.c

1386

KASSERT(!fs->lfs_ronly);

sys/ufs/lfs/lfs_vfsops.c

1389

for (sn = 0; sn < lfs_sb_getnseg(fs); ++sn) {

sys/ufs/lfs/lfs_vfsops.c

1390

LFS_SEGENTRY(sup, fs, sn, bp);

sys/ufs/lfs/lfs_vfsops.c

1395

avail += lfs_segtod(fs, 1);

sys/ufs/lfs/lfs_vfsops.c

1400

if (sn == 0 && lfs_sb_getversion(fs) > 1

sys/ufs/lfs/lfs_vfsops.c

1401

&& lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))

sys/ufs/lfs/lfs_vfsops.c

1402

labelcorrect = lfs_btofsb(fs, LFS_LABELPAD)

sys/ufs/lfs/lfs_vfsops.c

1403

- lfs_sb_gets0addr(fs);

sys/ufs/lfs/lfs_vfsops.c

1410

sn = lfs_dtosn(fs, lfs_sb_getoffset(fs));

sys/ufs/lfs/lfs_vfsops.c

1411

curr = lfs_sntod(fs, sn + 1) - lfs_sb_getoffset(fs);

sys/ufs/lfs/lfs_vfsops.c

1413

mfs = lfs_segtod(fs, (lfs_sb_getminfreeseg(fs) -

sys/ufs/lfs/lfs_vfsops.c

1414

(lfs_sb_getminfreeseg(fs) / 2)));

sys/ufs/lfs/lfs_vfsops.c

1416

avail = nclean * lfs_segtod(fs, 1);

sys/ufs/lfs/lfs_vfsops.c

1417

avail -= nsb * lfs_btofsb(fs, LFS_SBPAD);

sys/ufs/lfs/lfs_vfsops.c

1424

(intmax_t)lfs_segtod(fs, 1),

sys/ufs/lfs/lfs_vfsops.c

1426

(intmax_t)lfs_btofsb(fs, LFS_SBPAD),

sys/ufs/lfs/lfs_vfsops.c

1432

lfs_sb_setavail(fs, avail);

sys/ufs/lfs/lfs_vfsops.c

1433

lfs_sb_setnclean(fs, nclean);

sys/ufs/lfs/lfs_vfsops.c

1443

struct lfs *fs;

sys/ufs/lfs/lfs_vfsops.c

1447

fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

1453

DEBUG_CHECK_FREELIST(fs);

sys/ufs/lfs/lfs_vfsops.c

1456

KASSERT(LIST_FIRST(&fs->lfs_ivnode->v_dirtyblkhd) == NULL);

sys/ufs/lfs/lfs_vfsops.c

1459

vgone(fs->lfs_ivnode);

sys/ufs/lfs/lfs_vfsops.c

1461

ronly = !fs->lfs_ronly;

sys/ufs/lfs/lfs_vfsops.c

1462

if (fs->lfs_devvp->v_type != VBAD)

sys/ufs/lfs/lfs_vfsops.c

1463

spec_node_setmountedfs(fs->lfs_devvp, NULL);

sys/ufs/lfs/lfs_vfsops.c

1464

vn_lock(fs->lfs_devvp, LK_EXCLUSIVE | LK_RETRY);

sys/ufs/lfs/lfs_vfsops.c

1465

error = VOP_CLOSE(fs->lfs_devvp,

sys/ufs/lfs/lfs_vfsops.c

1467

vput(fs->lfs_devvp);

sys/ufs/lfs/lfs_vfsops.c

1470

if (fs->lfs_pages > 0)

sys/ufs/lfs/lfs_vfsops.c

1472

fs->lfs_pages, lfs_subsys_pages);

sys/ufs/lfs/lfs_vfsops.c

1479

while (fs->lfs_iocount)

sys/ufs/lfs/lfs_vfsops.c

1480

mtsleep(&fs->lfs_iocount, PRIBIO + 1, "lfs_umount2", 0,

sys/ufs/lfs/lfs_vfsops.c

1485

free(fs->lfs_ino_bitmap, M_SEGMENT);

sys/ufs/lfs/lfs_vfsops.c

1486

lfs_free_resblks(fs);

sys/ufs/lfs/lfs_vfsops.c

1487

cv_destroy(&fs->lfs_sleeperscv);

sys/ufs/lfs/lfs_vfsops.c

1488

cv_destroy(&fs->lfs_diropscv);

sys/ufs/lfs/lfs_vfsops.c

1489

cv_destroy(&fs->lfs_stopcv);

sys/ufs/lfs/lfs_vfsops.c

1490

cv_destroy(&fs->lfs_nextsegsleep);

sys/ufs/lfs/lfs_vfsops.c

1492

rw_destroy(&fs->lfs_fraglock);

sys/ufs/lfs/lfs_vfsops.c

1493

rw_destroy(&fs->lfs_iflock);

sys/ufs/lfs/lfs_vfsops.c

1495

kmem_free(fs, sizeof(struct lfs));

sys/ufs/lfs/lfs_vfsops.c

1508

struct lfs *fs;

sys/ufs/lfs/lfs_vfsops.c

1513

fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

1516

if (!fs->lfs_ronly) {

sys/ufs/lfs/lfs_vfsops.c

1523

lfs_wakeup_cleaner(fs);

sys/ufs/lfs/lfs_vfsops.c

1525

while (fs->lfs_sleepers)

sys/ufs/lfs/lfs_vfsops.c

1526

cv_wait(&fs->lfs_sleeperscv, &lfs_lock);

sys/ufs/lfs/lfs_vfsops.c

1548

if ((error = vflush(mp, fs->lfs_ivnode, flags)) != 0)

sys/ufs/lfs/lfs_vfsops.c

1552

vp = fs->lfs_ivnode;

sys/ufs/lfs/lfs_vfsops.c

1559

if (!fs->lfs_ronly) {

sys/ufs/lfs/lfs_vfsops.c

1560

lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) | LFS_PF_CLEAN);

sys/ufs/lfs/lfs_vfsops.c

1561

lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));

sys/ufs/lfs/lfs_vfsops.c

1562

lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));

sys/ufs/lfs/lfs_vfsops.c

1565

while (fs->lfs_iocount)

sys/ufs/lfs/lfs_vfsops.c

1566

mtsleep(&fs->lfs_iocount, PRIBIO + 1, "lfs_umount", 0,

sys/ufs/lfs/lfs_vfsops.c

1582

struct lfs *fs;

sys/ufs/lfs/lfs_vfsops.c

1586

fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

1588

sbp->f_bsize = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_vfsops.c

1589

sbp->f_frsize = lfs_sb_getfsize(fs);

sys/ufs/lfs/lfs_vfsops.c

1590

sbp->f_iosize = lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_vfsops.c

1591

sbp->f_blocks = LFS_EST_NONMETA(fs) - VTOI(fs->lfs_ivnode)->i_lfs_effnblks;

sys/ufs/lfs/lfs_vfsops.c

1593

sbp->f_bfree = LFS_EST_BFREE(fs);

sys/ufs/lfs/lfs_vfsops.c

1602

KASSERT(sbp->f_bfree <= lfs_sb_getdsize(fs));

sys/ufs/lfs/lfs_vfsops.c

1608

sbp->f_bresvd = LFS_EST_RSVD(fs);

sys/ufs/lfs/lfs_vfsops.c

1615

sbp->f_files = lfs_sb_getbfree(fs) / lfs_btofsb(fs, lfs_sb_getibsize(fs))

sys/ufs/lfs/lfs_vfsops.c

1616

* LFS_INOPB(fs);

sys/ufs/lfs/lfs_vfsops.c

1617

sbp->f_ffree = sbp->f_files - lfs_sb_getnfiles(fs);

sys/ufs/lfs/lfs_vfsops.c

1633

struct lfs *fs;

sys/ufs/lfs/lfs_vfsops.c

1635

fs = VFSTOULFS(mp)->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

1636

if (fs->lfs_ronly)

sys/ufs/lfs/lfs_vfsops.c

1647

if (fs->lfs_nowrap && lfs_sb_getnextseg(fs) < lfs_sb_getcurseg(fs)) {

sys/ufs/lfs/lfs_vfsops.c

1653

lfs_writer_enter(fs, "lfs_wsync");

sys/ufs/lfs/lfs_vfsops.c

1656

(uintmax_t)lfs_sb_getoffset(fs)));

sys/ufs/lfs/lfs_vfsops.c

1667

lfs_writer_leave(fs);

sys/ufs/lfs/lfs_vfsops.c

1724

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

1728

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_vfsops.c

1740

ip->i_dev = fs->lfs_dev;

sys/ufs/lfs/lfs_vfsops.c

1741

lfs_dino_setinumber(fs, dp, ino);

sys/ufs/lfs/lfs_vfsops.c

1743

ip->i_lfs = fs;

sys/ufs/lfs/lfs_vfsops.c

1776

struct lfs *fs;

sys/ufs/lfs/lfs_vfsops.c

1793

fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

1800

while ((fs->lfs_flags & LFS_NOTYET) && curproc->p_pid != fs->lfs_rfpid)

sys/ufs/lfs/lfs_vfsops.c

1801

mtsleep(&fs->lfs_flags, PRIBIO+1, "lfs_notyet", 0,

sys/ufs/lfs/lfs_vfsops.c

1810

daddr = lfs_sb_getidaddr(fs);

sys/ufs/lfs/lfs_vfsops.c

1812

LFS_IENTRY(ifp, fs, ino, bp);

sys/ufs/lfs/lfs_vfsops.c

1813

daddr = lfs_if_getdaddr(fs, ifp);

sys/ufs/lfs/lfs_vfsops.c

1814

if (lfs_sb_getversion(fs) > 1) {

sys/ufs/lfs/lfs_vfsops.c

1815

ts.tv_sec = lfs_if_getatime_sec(fs, ifp);

sys/ufs/lfs/lfs_vfsops.c

1816

ts.tv_nsec = lfs_if_getatime_nsec(fs, ifp);

sys/ufs/lfs/lfs_vfsops.c

1829

if (curlwp == fs->lfs_cleaner_thread && fs->lfs_cleaner_hint != NULL &&

sys/ufs/lfs/lfs_vfsops.c

1830

fs->lfs_cleaner_hint->bi_lbn == LFS_UNUSED_LBN) {

sys/ufs/lfs/lfs_vfsops.c

1831

dip = fs->lfs_cleaner_hint->bi_bp;

sys/ufs/lfs/lfs_vfsops.c

1832

if (fs->lfs_is64) {

sys/ufs/lfs/lfs_vfsops.c

1850

error = bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr),

sys/ufs/lfs/lfs_vfsops.c

1851

(lfs_sb_getversion(fs) == 1 ? lfs_sb_getbsize(fs) : lfs_sb_getibsize(fs)),

sys/ufs/lfs/lfs_vfsops.c

1858

dip = lfs_ifind(fs, ino, bp);

sys/ufs/lfs/lfs_vfsops.c

1865

if (fs->lfs_iocount) {

sys/ufs/lfs/lfs_vfsops.c

1869

(void)mtsleep(&fs->lfs_iocount, PRIBIO + 1,

sys/ufs/lfs/lfs_vfsops.c

1880

if (fs->lfs_seglock > 0) {

sys/ufs/lfs/lfs_vfsops.c

1885

for (bpp = fs->lfs_sp->bpp;

sys/ufs/lfs/lfs_vfsops.c

1886

bpp != fs->lfs_sp->cbpp; ++bpp) {

sys/ufs/lfs/lfs_vfsops.c

1887

if ((*bpp)->b_vp == fs->lfs_ivnode &&

sys/ufs/lfs/lfs_vfsops.c

1888

bpp != fs->lfs_sp->bpp) {

sys/ufs/lfs/lfs_vfsops.c

1892

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

sys/ufs/lfs/lfs_vfsops.c

1893

dp = DINO_IN_BLOCK(fs,

sys/ufs/lfs/lfs_vfsops.c

1895

if (lfs_dino_getinumber(fs, dp))

sys/ufs/lfs/lfs_vfsops.c

1897

(uintmax_t)lfs_dino_getinumber(fs, dp));

sys/ufs/lfs/lfs_vfsops.c

1907

lfs_copy_dinode(fs, ip->i_din, dip);

sys/ufs/lfs/lfs_vfsops.c

1911

if (lfs_sb_getversion(fs) > 1) {

sys/ufs/lfs/lfs_vfsops.c

1912

lfs_dino_setatime(fs, ip->i_din, ts.tv_sec);

sys/ufs/lfs/lfs_vfsops.c

1913

lfs_dino_setatimensec(fs, ip->i_din, ts.tv_nsec);

sys/ufs/lfs/lfs_vfsops.c

1933

struct lfs *fs;

sys/ufs/lfs/lfs_vfsops.c

1937

fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

1940

KASSERT((fs->lfs_flags & LFS_NOTYET) ||

sys/ufs/lfs/lfs_vfsops.c

1954

error = lfs_valloc_fixed(fs, ino, gen);

sys/ufs/lfs/lfs_vfsops.c

1974

lfs_dino_setgen(fs, ip->i_din, gen);

sys/ufs/lfs/lfs_vfsops.c

2013

ULFS_MPNEEDSWAP(fs));

sys/ufs/lfs/lfs_vfsops.c

2016

ULFS_MPNEEDSWAP(fs));

sys/ufs/lfs/lfs_vfsops.c

2031

struct lfs *fs;

sys/ufs/lfs/lfs_vfsops.c

2040

fs = VFSTOULFS(mp)->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

2041

if (lfh.lfid_ident != lfs_sb_getident(fs))

sys/ufs/lfs/lfs_vfsops.c

2045

((lfs_dino_getsize(fs, VTOI(fs->lfs_ivnode)->i_din) >> lfs_sb_getbshift(fs)) -

sys/ufs/lfs/lfs_vfsops.c

2046

lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs))

sys/ufs/lfs/lfs_vfsops.c

2084

lfs_issequential_hole(const struct lfs *fs,

sys/ufs/lfs/lfs_vfsops.c

2087

(void)fs; /* not used */

sys/ufs/lfs/lfs_vfsops.c

2090

(0 <= daddr0 && daddr0 <= LFS_MAX_DADDR(fs)));

sys/ufs/lfs/lfs_vfsops.c

2092

(0 <= daddr1 && daddr1 <= LFS_MAX_DADDR(fs)));

sys/ufs/lfs/lfs_vfsops.c

2139

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/lfs_vfsops.c

2140

struct segment *sp = fs->lfs_sp;

sys/ufs/lfs/lfs_vfsops.c

2145

ASSERT_SEGLOCK(fs);

sys/ufs/lfs/lfs_vfsops.c

2148

KASSERT(vp != fs->lfs_ivnode);

sys/ufs/lfs/lfs_vfsops.c

2160

if (LFS_STARVED_FOR_SEGS(fs) && vdead_check(vp, VDEAD_NOWAIT) == 0) {

sys/ufs/lfs/lfs_vfsops.c

2183

if (!LFS_SEGLOCK_HELD(fs)) {

sys/ufs/lfs/lfs_vfsops.c

2191

if ((pgs[0]->offset & lfs_sb_getbmask(fs)) != 0) {

sys/ufs/lfs/lfs_vfsops.c

2240

if (startoffset & lfs_sb_getbmask(fs))

sys/ufs/lfs/lfs_vfsops.c

2242

startoffset, lfs_sb_getbmask(fs),

sys/ufs/lfs/lfs_vfsops.c

2243

startoffset & lfs_sb_getbmask(fs));

sys/ufs/lfs/lfs_vfsops.c

2244

KASSERT((startoffset & lfs_sb_getbmask(fs)) == 0);

sys/ufs/lfs/lfs_vfsops.c

2245

if (bytes & lfs_sb_getffmask(fs)) {

sys/ufs/lfs/lfs_vfsops.c

2257

(lfs_ss_getnfinfo(fs, ssp) < 1 ?

sys/ufs/lfs/lfs_vfsops.c

2261

lfs_release_finfo(fs);

sys/ufs/lfs/lfs_vfsops.c

2262

(void) lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_vfsops.c

2264

lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);

sys/ufs/lfs/lfs_vfsops.c

2311

sp->seg_bytes_left < (1 << lfs_sb_getbshift(fs))) {

sys/ufs/lfs/lfs_vfsops.c

2315

vers = lfs_fi_getversion(fs, sp->fip);

sys/ufs/lfs/lfs_vfsops.c

2316

lfs_release_finfo(fs);

sys/ufs/lfs/lfs_vfsops.c

2317

(void) lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_vfsops.c

2319

lfs_acquire_finfo(fs, ip->i_number, vers);

sys/ufs/lfs/lfs_vfsops.c

2361

bp->b_lblkno = lfs_lblkno(fs, offset);

sys/ufs/lfs/lfs_vfsops.c

2381

lfs_flush(fs, 0, 1);

sys/ufs/lfs/lfs_vfsops.c

2385

if ((sp->seg_flags & SEGM_SINGLE) && lfs_sb_getcurseg(fs) != fs->lfs_startseg)

sys/ufs/lfs/lfs_vfsops.c

2446

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

2449

ip->i_mode = lfs_dino_getmode(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2450

ip->i_nlink = lfs_dino_getnlink(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2451

ip->i_lfs_osize = ip->i_size = lfs_dino_getsize(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2452

ip->i_flags = lfs_dino_getflags(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2453

ip->i_gen = lfs_dino_getgen(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2454

ip->i_uid = lfs_dino_getuid(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2455

ip->i_gid = lfs_dino_getgid(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2457

ip->i_lfs_effnblks = lfs_dino_getblocks(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2458

ip->i_lfs_odnlink = lfs_dino_getnlink(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2470

for (i = (ip->i_size + lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs);

sys/ufs/lfs/lfs_vfsops.c

2475

if (lfs_dino_getdb(fs, ip->i_din, i) != 0) {

sys/ufs/lfs/lfs_vfsops.c

2476

lfs_dump_dinode(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2481

if (lfs_dino_getib(fs, ip->i_din, i - ULFS_NDADDR) != 0) {

sys/ufs/lfs/lfs_vfsops.c

2482

lfs_dump_dinode(fs, ip->i_din);

sys/ufs/lfs/lfs_vfsops.c

2488

if (lfs_dino_getdb(fs, ip->i_din, i) != 0)

sys/ufs/lfs/lfs_vfsops.c

2489

ip->i_lfs_fragsize[i] = lfs_blksize(fs, ip, i);

sys/ufs/lfs/lfs_vfsops.c

2501

ip->i_devvp = fs->lfs_devvp;

sys/ufs/lfs/lfs_vfsops.c

2519

lfs_resize_fs(struct lfs *fs, int newnsegs)

sys/ufs/lfs/lfs_vfsops.c

2532

if (lfs_sb_getversion(fs) < 2)

sys/ufs/lfs/lfs_vfsops.c

2536

oldnsegs = lfs_sb_getnseg(fs);

sys/ufs/lfs/lfs_vfsops.c

2541

if (newnsegs <= lfs_dtosn(fs, lfs_sb_getsboff(fs, 1)))

sys/ufs/lfs/lfs_vfsops.c

2544

ivp = fs->lfs_ivnode;

sys/ufs/lfs/lfs_vfsops.c

2549

lfs_seglock(fs, SEGM_CKP);

sys/ufs/lfs/lfs_vfsops.c

2553

lfs_rewind(fs, newnsegs);

sys/ufs/lfs/lfs_vfsops.c

2556

LFS_SEGENTRY(sup, fs, i, bp);

sys/ufs/lfs/lfs_vfsops.c

2560

if ((error = lfs_rewrite_segment(fs, i, NULL, NOCRED, curlwp)) != 0)

sys/ufs/lfs/lfs_vfsops.c

2564

lfs_invalidate(fs, i);

sys/ufs/lfs/lfs_vfsops.c

2576

LFS_SEGENTRY(sup, fs, i, bp);

sys/ufs/lfs/lfs_vfsops.c

2594

olast = lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs);

sys/ufs/lfs/lfs_vfsops.c

2595

nlast = howmany(newnsegs, lfs_sb_getsepb(fs)) + lfs_sb_getcleansz(fs);

sys/ufs/lfs/lfs_vfsops.c

2596

ilast = ivp->v_size >> lfs_sb_getbshift(fs);

sys/ufs/lfs/lfs_vfsops.c

2605

rw_enter(&fs->lfs_iflock, RW_WRITER);

sys/ufs/lfs/lfs_vfsops.c

2608

bread(ivp, i, lfs_sb_getbsize(fs), 0, &bp);

sys/ufs/lfs/lfs_vfsops.c

2614

if (lfs_balloc(ivp, i * lfs_sb_getbsize(fs),

sys/ufs/lfs/lfs_vfsops.c

2615

lfs_sb_getbsize(fs), NOCRED, 0,

sys/ufs/lfs/lfs_vfsops.c

2618

memset(bp->b_data, 0, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_vfsops.c

2628

ip->i_size += noff * lfs_sb_getbsize(fs);

sys/ufs/lfs/lfs_vfsops.c

2629

lfs_dino_setsize(fs, ip->i_din, ip->i_size);

sys/ufs/lfs/lfs_vfsops.c

2645

if (bread(ivp, i, lfs_sb_getbsize(fs),

sys/ufs/lfs/lfs_vfsops.c

2648

if (bread(ivp, i - noff, lfs_sb_getbsize(fs),

sys/ufs/lfs/lfs_vfsops.c

2651

memcpy(bp->b_data, obp->b_data, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_vfsops.c

2659

nexti = roundup(i + 1, lfs_sb_getsepb(fs));

sys/ufs/lfs/lfs_vfsops.c

2663

if ((error = bread(ivp, i / lfs_sb_getsepb(fs) +

sys/ufs/lfs/lfs_vfsops.c

2664

lfs_sb_getcleansz(fs),

sys/ufs/lfs/lfs_vfsops.c

2665

lfs_sb_getbsize(fs),

sys/ufs/lfs/lfs_vfsops.c

2668

sup = &((SEGUSE *)bp->b_data)[i % lfs_sb_getsepb(fs)];

sys/ufs/lfs/lfs_vfsops.c

2675

if (lfs_dtosn(fs, lfs_sb_getsboff(fs, i)) >= newnsegs)

sys/ufs/lfs/lfs_vfsops.c

2676

lfs_sb_setsboff(fs, i, 0x0);

sys/ufs/lfs/lfs_vfsops.c

2692

lfs_sb_setnseg(fs, newnsegs);

sys/ufs/lfs/lfs_vfsops.c

2693

lfs_sb_setsegtabsz(fs, nlast - lfs_sb_getcleansz(fs));

sys/ufs/lfs/lfs_vfsops.c

2694

lfs_sb_addsize(fs, gain * lfs_btofsb(fs, lfs_sb_getssize(fs)));

sys/ufs/lfs/lfs_vfsops.c

2695

lfs_sb_adddsize(fs, gain * lfs_btofsb(fs, lfs_sb_getssize(fs))

sys/ufs/lfs/lfs_vfsops.c

2696

+ lfs_btofsb(fs, sbbytes));

sys/ufs/lfs/lfs_vfsops.c

2697

lfs_sb_addbfree(fs, gain * lfs_btofsb(fs, lfs_sb_getssize(fs))

sys/ufs/lfs/lfs_vfsops.c

2698

+ lfs_btofsb(fs, sbbytes)

sys/ufs/lfs/lfs_vfsops.c

2700

- gain * lfs_btofsb(fs, lfs_sb_getbsize(fs) / 2)

sys/ufs/lfs/lfs_vfsops.c

2701

+ dirtysums * lfs_btofsb(fs, lfs_sb_getsumsize(fs))

sys/ufs/lfs/lfs_vfsops.c

2705

lfs_sb_addnclean(fs, gain);

sys/ufs/lfs/lfs_vfsops.c

2706

lfs_sb_addavail(fs, gain * lfs_btofsb(fs, lfs_sb_getssize(fs)));

sys/ufs/lfs/lfs_vfsops.c

2708

lfs_sb_subnclean(fs, cgain);

sys/ufs/lfs/lfs_vfsops.c

2709

lfs_sb_subavail(fs, cgain * lfs_btofsb(fs, lfs_sb_getssize(fs)) -

sys/ufs/lfs/lfs_vfsops.c

2710

lfs_btofsb(fs, csbbytes));

sys/ufs/lfs/lfs_vfsops.c

2716

lfs_truncate(ivp, ivp->v_size + (noff << lfs_sb_getbshift(fs)), 0,

sys/ufs/lfs/lfs_vfsops.c

2723

bread(ivp, 0, lfs_sb_getbsize(fs), B_MODIFY, &bp);

sys/ufs/lfs/lfs_vfsops.c

2725

lfs_ci_setclean(fs, cip, lfs_sb_getnclean(fs));

sys/ufs/lfs/lfs_vfsops.c

2726

lfs_ci_setdirty(fs, cip, lfs_sb_getnseg(fs) - lfs_sb_getnclean(fs));

sys/ufs/lfs/lfs_vfsops.c

2730

rw_exit(&fs->lfs_iflock);

sys/ufs/lfs/lfs_vfsops.c

2733

lfs_segunlock(fs);

sys/ufs/lfs/lfs_vfsops.c

424

struct lfs *fs;

sys/ufs/lfs/lfs_vfsops.c

488

fs = VFSTOULFS(mp)->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

493

ooffset = lfs_sb_getoffset(fs);

sys/ufs/lfs/lfs_vfsops.c

495

if (lfs_sb_getnextseg(fs) < lfs_sb_getcurseg(fs) && fs->lfs_nowrap) {

sys/ufs/lfs/lfs_vfsops.c

500

if (LFS_STARVED_FOR_SEGS(fs)) {

sys/ufs/lfs/lfs_vfsops.c

504

lfs_wakeup_cleaner(fs);

sys/ufs/lfs/lfs_vfsops.c

508

if ((fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) ||

sys/ufs/lfs/lfs_vfsops.c

510

fs->lfs_dirops == 0) {

sys/ufs/lfs/lfs_vfsops.c

514

lfs_flush_fs(fs, fsflags);

sys/ufs/lfs/lfs_vfsops.c

515

} else if (fs->lfs_pdflush) {

sys/ufs/lfs/lfs_vfsops.c

517

lfs_flush_fs(fs, fsflags);

sys/ufs/lfs/lfs_vfsops.c

518

} else if (!TAILQ_EMPTY(&fs->lfs_pchainhd)) {

sys/ufs/lfs/lfs_vfsops.c

521

lfs_writer_enter(fs, "wrdirop");

sys/ufs/lfs/lfs_vfsops.c

522

lfs_flush_pchain(fs);

sys/ufs/lfs/lfs_vfsops.c

523

lfs_writer_leave(fs);

sys/ufs/lfs/lfs_vfsops.c

526

if (lfs_sb_getoffset(fs) != ooffset)

sys/ufs/lfs/lfs_vfsops.c

620

struct lfs *fs = NULL; /* LFS */

sys/ufs/lfs/lfs_vfsops.c

642

fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

643

lfs_sb_setfsmnt(fs, mp->mnt_stat.f_mntonname);

sys/ufs/lfs/lfs_vfsops.c

662

struct lfs *fs = NULL; /* LFS */

sys/ufs/lfs/lfs_vfsops.c

712

fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

713

if (devvp != fs->lfs_devvp) {

sys/ufs/lfs/lfs_vfsops.c

714

if (devvp->v_rdev != fs->lfs_devvp->v_rdev)

sys/ufs/lfs/lfs_vfsops.c

718

devvp = fs->lfs_devvp;

sys/ufs/lfs/lfs_vfsops.c

730

fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

731

devvp = fs->lfs_devvp;

sys/ufs/lfs/lfs_vfsops.c

780

fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

794

fs = ump->um_lfs;

sys/ufs/lfs/lfs_vfsops.c

796

if (!fs->lfs_ronly && (mp->mnt_iflag & IMNT_WANTRDONLY)) {

sys/ufs/lfs/lfs_vfsops.c

806

fs->lfs_ronly = 1;

sys/ufs/lfs/lfs_vfsops.c

813

lfs_prelock(fs, 0);

sys/ufs/lfs/lfs_vfsops.c

815

while (fs->lfs_iocount > 1)

sys/ufs/lfs/lfs_vfsops.c

816

(void)mtsleep(&fs->lfs_iocount, PRIBIO + 1,

sys/ufs/lfs/lfs_vfsops.c

819

lfs_preunlock(fs);

sys/ufs/lfs/lfs_vfsops.c

820

} else if (fs->lfs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {

sys/ufs/lfs/lfs_vfsops.c

827

if (fs->lfs_use_quota2) {

sys/ufs/lfs/lfs_vfsops.c

847

fs->lfs_ronly = 0;

sys/ufs/lfs/lfs_vfsops.c

848

if (lfs_sb_getpflags(fs) & LFS_PF_CLEAN) {

sys/ufs/lfs/lfs_vfsops.c

849

lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) & ~LFS_PF_CLEAN);

sys/ufs/lfs/lfs_vfsops.c

850

lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));

sys/ufs/lfs/lfs_vfsops.c

851

lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));

sys/ufs/lfs/lfs_vfsops.c

862

lfs_sb_setfsmnt(fs, mp->mnt_stat.f_mntonname);

sys/ufs/lfs/lfs_vfsops.c

875

lfs_checkmagic(struct lfs *fs)

sys/ufs/lfs/lfs_vfsops.c

877

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

sys/ufs/lfs/lfs_vfsops.c

879

fs->lfs_is64 = false;

sys/ufs/lfs/lfs_vfsops.c

880

fs->lfs_dobyteswap = false;

sys/ufs/lfs/lfs_vfsops.c

883

fs->lfs_is64 = true;

sys/ufs/lfs/lfs_vfsops.c

884

fs->lfs_dobyteswap = false;

sys/ufs/lfs/lfs_vfsops.c

888

fs->lfs_is64 = false;

sys/ufs/lfs/lfs_vfsops.c

889

fs->lfs_dobyteswap = true;

sys/ufs/lfs/lfs_vfsops.c

892

fs->lfs_is64 = true;

sys/ufs/lfs/lfs_vfsops.c

893

fs->lfs_dobyteswap = true;

sys/ufs/lfs/lfs_vfsops.c

912

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

1021

lfs_unset_dirop(fs, dvp, "mkdir");

sys/ufs/lfs/lfs_vnops.c

1122

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

1131

fs = VFSTOULFS(dvp->v_mount)->um_lfs;

sys/ufs/lfs/lfs_vnops.c

1132

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_vnops.c

1133

if (fs->lfs_ronly) {

sys/ufs/lfs/lfs_vnops.c

1149

lfs_unset_dirop(fs, dvp, "link");

sys/ufs/lfs/lfs_vnops.c

1168

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

1173

fs = ip->i_lfs;

sys/ufs/lfs/lfs_vnops.c

1187

vap->va_rdev = (dev_t)lfs_dino_getrdev(fs, ip->i_din);

sys/ufs/lfs/lfs_vnops.c

1194

vap->va_atime.tv_sec = lfs_dino_getatime(fs, ip->i_din);

sys/ufs/lfs/lfs_vnops.c

1195

vap->va_atime.tv_nsec = lfs_dino_getatimensec(fs, ip->i_din);

sys/ufs/lfs/lfs_vnops.c

1196

vap->va_mtime.tv_sec = lfs_dino_getmtime(fs, ip->i_din);

sys/ufs/lfs/lfs_vnops.c

1197

vap->va_mtime.tv_nsec = lfs_dino_getmtimensec(fs, ip->i_din);

sys/ufs/lfs/lfs_vnops.c

1198

vap->va_ctime.tv_sec = lfs_dino_getctime(fs, ip->i_din);

sys/ufs/lfs/lfs_vnops.c

1199

vap->va_ctime.tv_nsec = lfs_dino_getctimensec(fs, ip->i_din);

sys/ufs/lfs/lfs_vnops.c

1209

vap->va_bytes = lfs_fsbtob(fs, ip->i_lfs_effnblks);

sys/ufs/lfs/lfs_vnops.c

1239

lfs_wrapgo(struct lfs *fs, struct inode *ip, int waitfor)

sys/ufs/lfs/lfs_vnops.c

1241

if (fs->lfs_stoplwp != curlwp)

sys/ufs/lfs/lfs_vnops.c

1244

fs->lfs_stoplwp = NULL;

sys/ufs/lfs/lfs_vnops.c

1245

cv_signal(&fs->lfs_stopcv);

sys/ufs/lfs/lfs_vnops.c

1247

KASSERT(fs->lfs_nowrap > 0);

sys/ufs/lfs/lfs_vnops.c

1248

if (fs->lfs_nowrap <= 0) {

sys/ufs/lfs/lfs_vnops.c

1252

if (--fs->lfs_nowrap == 0) {

sys/ufs/lfs/lfs_vnops.c

1254

lfs_sb_getfsmnt(fs));

sys/ufs/lfs/lfs_vnops.c

1255

wakeup(&fs->lfs_wrappass);

sys/ufs/lfs/lfs_vnops.c

1256

lfs_wakeup_cleaner(fs);

sys/ufs/lfs/lfs_vnops.c

1259

cv_wait_sig(&fs->lfs_nextsegsleep, &lfs_lock);

sys/ufs/lfs/lfs_vnops.c

1281

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

1286

fs = ip->i_lfs;

sys/ufs/lfs/lfs_vnops.c

1289

fs->lfs_stoplwp == curlwp) {

sys/ufs/lfs/lfs_vnops.c

1292

lfs_wrapgo(fs, ip, 0);

sys/ufs/lfs/lfs_vnops.c

1298

lfs_orphan(fs, vp);

sys/ufs/lfs/lfs_vnops.c

1376

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

1382

fs = ip->i_lfs;

sys/ufs/lfs/lfs_vnops.c

1407

lfs_sb_getfsmnt(fs));

sys/ufs/lfs/lfs_vnops.c

1409

TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);

sys/ufs/lfs/lfs_vnops.c

1449

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

1459

fs = ip->i_lfs;

sys/ufs/lfs/lfs_vnops.c

1488

while (slept && fs->lfs_seglock) {

sys/ufs/lfs/lfs_vnops.c

1497

tbn = LFS_DBTOFSB(fs, bp->b_blkno);

sys/ufs/lfs/lfs_vnops.c

1498

sn = lfs_dtosn(fs, tbn);

sys/ufs/lfs/lfs_vnops.c

1500

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

sys/ufs/lfs/lfs_vnops.c

1501

if (sn == lfs_dtosn(fs, fs->lfs_cleanint[i]) &&

sys/ufs/lfs/lfs_vnops.c

1502

tbn >= fs->lfs_cleanint[i]) {

sys/ufs/lfs/lfs_vnops.c

1509

lfs_dtosn(fs, fs->lfs_cleanint[i]),

sys/ufs/lfs/lfs_vnops.c

1510

fs->lfs_cleanint[i], sn, tbn));

sys/ufs/lfs/lfs_vnops.c

1517

if (LFS_SEGLOCK_HELD(fs) && fs->lfs_iocount) {

sys/ufs/lfs/lfs_vnops.c

1525

mtsleep(&fs->lfs_iocount,

sys/ufs/lfs/lfs_vnops.c

1532

} else if (fs->lfs_seglock) {

sys/ufs/lfs/lfs_vnops.c

1533

mtsleep(&fs->lfs_seglock,

sys/ufs/lfs/lfs_vnops.c

1561

lfs_flush_dirops(struct lfs *fs)

sys/ufs/lfs/lfs_vnops.c

1571

ASSERT_MAYBE_SEGLOCK(fs);

sys/ufs/lfs/lfs_vnops.c

1572

KASSERT(fs->lfs_nadirop == 0); /* stable during lfs_writer */

sys/ufs/lfs/lfs_vnops.c

1573

KASSERT(fs->lfs_dirops == 0); /* stable during lfs_writer */

sys/ufs/lfs/lfs_vnops.c

1575

if (fs->lfs_ronly)

sys/ufs/lfs/lfs_vnops.c

1579

if (TAILQ_FIRST(&fs->lfs_dchainhd) == NULL) {

sys/ufs/lfs/lfs_vnops.c

1594

lfs_imtime(fs);

sys/ufs/lfs/lfs_vnops.c

1595

lfs_seglock(fs, flags);

sys/ufs/lfs/lfs_vnops.c

1596

sp = fs->lfs_sp;

sys/ufs/lfs/lfs_vnops.c

1612

KASSERT(fs->lfs_writer);

sys/ufs/lfs/lfs_vnops.c

1613

TAILQ_INSERT_HEAD(&fs->lfs_dchainhd, marker, i_lfs_dchain);

sys/ufs/lfs/lfs_vnops.c

1615

TAILQ_REMOVE(&fs->lfs_dchainhd, marker, i_lfs_dchain);

sys/ufs/lfs/lfs_vnops.c

1616

TAILQ_INSERT_AFTER(&fs->lfs_dchainhd, ip, marker,

sys/ufs/lfs/lfs_vnops.c

1658

error = lfs_writefile(fs, sp, vp);

sys/ufs/lfs/lfs_vnops.c

1673

error = lfs_writeinode(fs, sp, ip);

sys/ufs/lfs/lfs_vnops.c

1696

TAILQ_REMOVE(&fs->lfs_dchainhd, marker, i_lfs_dchain);

sys/ufs/lfs/lfs_vnops.c

1701

lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) & ~(SS_CONT));

sys/ufs/lfs/lfs_vnops.c

1702

lfs_finalize_fs_seguse(fs);

sys/ufs/lfs/lfs_vnops.c

1703

(void) lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_vnops.c

1704

lfs_segunlock(fs);

sys/ufs/lfs/lfs_vnops.c

1720

lfs_flush_pchain(struct lfs *fs)

sys/ufs/lfs/lfs_vnops.c

1728

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_vnops.c

1729

KASSERT(fs->lfs_writer);

sys/ufs/lfs/lfs_vnops.c

1731

if (fs->lfs_ronly)

sys/ufs/lfs/lfs_vnops.c

1735

if (TAILQ_FIRST(&fs->lfs_pchainhd) == NULL) {

sys/ufs/lfs/lfs_vnops.c

1742

if ((error = lfs_flush_dirops(fs)) != 0)

sys/ufs/lfs/lfs_vnops.c

1751

lfs_imtime(fs);

sys/ufs/lfs/lfs_vnops.c

1752

lfs_seglock(fs, 0);

sys/ufs/lfs/lfs_vnops.c

1753

sp = fs->lfs_sp;

sys/ufs/lfs/lfs_vnops.c

1763

for (ip = TAILQ_FIRST(&fs->lfs_pchainhd); ip != NULL; ip = nip) {

sys/ufs/lfs/lfs_vnops.c

1793

error = lfs_writefile(fs, sp, vp);

sys/ufs/lfs/lfs_vnops.c

1801

error2 = lfs_writeinode(fs, sp, ip);

sys/ufs/lfs/lfs_vnops.c

1807

lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_vnops.c

1814

(void) lfs_writeseg(fs, sp);

sys/ufs/lfs/lfs_vnops.c

1815

lfs_segunlock(fs);

sys/ufs/lfs/lfs_vnops.c

1881

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

1908

fs = VTOI(ap->a_vp)->i_lfs;

sys/ufs/lfs/lfs_vnops.c

1911

maxino = ((VTOI(fs->lfs_ivnode)->i_size >> lfs_sb_getbshift(fs))

sys/ufs/lfs/lfs_vnops.c

1912

- lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs))

sys/ufs/lfs/lfs_vnops.c

1913

* lfs_sb_getifpb(fs);

sys/ufs/lfs/lfs_vnops.c

1935

++fs->lfs_sleepers;

sys/ufs/lfs/lfs_vnops.c

1941

if (--fs->lfs_sleepers == 0)

sys/ufs/lfs/lfs_vnops.c

1942

cv_broadcast(&fs->lfs_sleeperscv);

sys/ufs/lfs/lfs_vnops.c

1953

blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

1954

blkiov70 = lfs_malloc(fs, sizeof(BLOCK_INFO_70), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

1959

lfs_free(fs, blkiov70, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

1960

lfs_free(fs, blkiov, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

1967

++fs->lfs_sleepers;

sys/ufs/lfs/lfs_vnops.c

1984

if (--fs->lfs_sleepers == 0)

sys/ufs/lfs/lfs_vnops.c

1985

cv_broadcast(&fs->lfs_sleeperscv);

sys/ufs/lfs/lfs_vnops.c

1987

lfs_free(fs, blkiov, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

1997

blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2000

lfs_free(fs, blkiov, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2005

++fs->lfs_sleepers;

sys/ufs/lfs/lfs_vnops.c

2015

if (--fs->lfs_sleepers == 0)

sys/ufs/lfs/lfs_vnops.c

2016

cv_broadcast(&fs->lfs_sleeperscv);

sys/ufs/lfs/lfs_vnops.c

2018

lfs_free(fs, blkiov, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2026

lfs_writer_enter(fs, "pndirop");

sys/ufs/lfs/lfs_vnops.c

2027

off = lfs_sb_getoffset(fs);

sys/ufs/lfs/lfs_vnops.c

2028

lfs_prelock(fs, 0);

sys/ufs/lfs/lfs_vnops.c

2029

lfs_flush_dirops(fs);

sys/ufs/lfs/lfs_vnops.c

2030

LFS_CLEANERINFO(cip, fs, bp);

sys/ufs/lfs/lfs_vnops.c

2031

oclean = lfs_ci_getclean(fs, cip);

sys/ufs/lfs/lfs_vnops.c

2032

LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);

sys/ufs/lfs/lfs_vnops.c

2037

lws.offset = lfs_btofsb(fs, fs->lfs_sp->bytes_written);

sys/ufs/lfs/lfs_vnops.c

2040

lfs_preunlock(fs);

sys/ufs/lfs/lfs_vnops.c

2041

lfs_writer_leave(fs);

sys/ufs/lfs/lfs_vnops.c

2044

LFS_CLEANERINFO(cip, fs, bp);

sys/ufs/lfs/lfs_vnops.c

2047

lfs_sb_getoffset(fs) - off,

sys/ufs/lfs/lfs_vnops.c

2048

lfs_ci_getclean(fs, cip) - oclean,

sys/ufs/lfs/lfs_vnops.c

2049

fs->lfs_activesb));

sys/ufs/lfs/lfs_vnops.c

2050

LFS_SYNC_CLEANERINFO(cip, fs, bp, 0);

sys/ufs/lfs/lfs_vnops.c

2067

return lfs_vptofh(fs->lfs_ivnode, &(fhp->fh_fid), &fh_size);

sys/ufs/lfs/lfs_vnops.c

2076

return lfs_vptofh(fs->lfs_ivnode, &(fhp->fh_fid), &fh_size);

sys/ufs/lfs/lfs_vnops.c

2080

return lfs_rewind(fs, *(int *)ap->a_data);

sys/ufs/lfs/lfs_vnops.c

2084

return lfs_invalidate(fs, *(int *)ap->a_data);

sys/ufs/lfs/lfs_vnops.c

2088

return lfs_resize_fs(fs, *(int *)ap->a_data);

sys/ufs/lfs/lfs_vnops.c

2099

if (fs->lfs_stoplwp == curlwp)

sys/ufs/lfs/lfs_vnops.c

2103

while (fs->lfs_stoplwp != NULL)

sys/ufs/lfs/lfs_vnops.c

2104

cv_wait(&fs->lfs_stopcv, &lfs_lock);

sys/ufs/lfs/lfs_vnops.c

2105

fs->lfs_stoplwp = curlwp;

sys/ufs/lfs/lfs_vnops.c

2106

if (fs->lfs_nowrap == 0)

sys/ufs/lfs/lfs_vnops.c

2108

lfs_sb_getfsmnt(fs));

sys/ufs/lfs/lfs_vnops.c

2109

++fs->lfs_nowrap;

sys/ufs/lfs/lfs_vnops.c

2113

error = mtsleep(&fs->lfs_nowrap, PCATCH | PUSER,

sys/ufs/lfs/lfs_vnops.c

2117

lfs_wrapgo(fs, VTOI(ap->a_vp), 0);

sys/ufs/lfs/lfs_vnops.c

2131

error = lfs_wrapgo(fs, VTOI(ap->a_vp),

sys/ufs/lfs/lfs_vnops.c

2141

if (fs->lfs_stoplwp != curlwp) {

sys/ufs/lfs/lfs_vnops.c

2145

if (fs->lfs_nowrap == 0) {

sys/ufs/lfs/lfs_vnops.c

2149

fs->lfs_wrappass = 1;

sys/ufs/lfs/lfs_vnops.c

2150

wakeup(&fs->lfs_wrappass);

sys/ufs/lfs/lfs_vnops.c

2156

error = mtsleep(&fs->lfs_nowrap, PCATCH | PUSER,

sys/ufs/lfs/lfs_vnops.c

2167

*(int *)ap->a_data = fs->lfs_wrapstatus;

sys/ufs/lfs/lfs_vnops.c

2179

fss = lfs_malloc(fs, lfr.len * sizeof(*fss), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2182

lfs_free(fs, fss, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2187

error = lfs_filestats(fs, lfr.ino + i, &fss[i]);

sys/ufs/lfs/lfs_vnops.c

2197

lfs_free(fs, fss, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2205

sna = lfs_malloc(fs, snap.len * sizeof(int), LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2208

lfs_free(fs, sna, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2213

if (sna[i] < 0 || sna[i] >= lfs_sb_getnseg(fs))

sys/ufs/lfs/lfs_vnops.c

2217

error = lfs_rewrite_segments(fs, sna, snap.len, &direct,

sys/ufs/lfs/lfs_vnops.c

2219

lfs_free(fs, sna, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2236

inoa = lfs_malloc(fs, inotbl.len * sizeof(ino_t),

sys/ufs/lfs/lfs_vnops.c

2240

lfs_free(fs, inoa, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2250

error = lfs_rewrite_file(fs, inoa, inotbl.len, scramble,

sys/ufs/lfs/lfs_vnops.c

2252

lfs_free(fs, inoa, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2268

ci.clean = lfs_sb_getnclean(fs);

sys/ufs/lfs/lfs_vnops.c

2269

ci.dirty = lfs_sb_getnseg(fs) - lfs_sb_getnclean(fs);

sys/ufs/lfs/lfs_vnops.c

2270

ci.bfree = lfs_sb_getbfree(fs);

sys/ufs/lfs/lfs_vnops.c

2271

ci.avail = lfs_sb_getavail(fs) - fs->lfs_ravail

sys/ufs/lfs/lfs_vnops.c

2272

- fs->lfs_favail;

sys/ufs/lfs/lfs_vnops.c

2273

ci.flags = (fs->lfs_flags & LFS_MUSTCLEAN)

sys/ufs/lfs/lfs_vnops.c

2283

if (lfs_sb_getversion(fs) == 1)

sys/ufs/lfs/lfs_vnops.c

2289

|| suap.start >= lfs_sb_getnseg(fs))

sys/ufs/lfs/lfs_vnops.c

2291

if (suap.start + suap.len >= lfs_sb_getnseg(fs)) {

sys/ufs/lfs/lfs_vnops.c

2292

suap.len = lfs_sb_getnseg(fs) - suap.start;

sys/ufs/lfs/lfs_vnops.c

2295

sua = lfs_malloc(fs, suap.len * sizeof *sua, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2298

LFS_SEGENTRY(sup, fs, suap.start + i, bp);

sys/ufs/lfs/lfs_vnops.c

2304

lfs_free(fs, sua, LFS_NB_BLKIOV);

sys/ufs/lfs/lfs_vnops.c

2317

return lfs_cleanctl(fs, &params);

sys/ufs/lfs/lfs_vnops.c

2346

lfs_filestats(struct lfs *fs, ino_t ino, struct lfs_filestats *lfp)

sys/ufs/lfs/lfs_vnops.c

2357

step = lfs_sb_getbsize(fs) >> DEV_BSHIFT;

sys/ufs/lfs/lfs_vnops.c

2359

error = VFS_VGET(fs->lfs_ivnode->v_mount, ino, LK_SHARED, &vp);

sys/ufs/lfs/lfs_vnops.c

2365

hiblk = lfs_lblkno(fs, ip->i_size + lfs_sb_getbsize(fs) - 1) - 1;

sys/ufs/lfs/lfs_vnops.c

2409

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/lfs_vnops.c

2412

olbn = lfs_lblkno(fs, ip->i_size);

sys/ufs/lfs/lfs_vnops.c

2413

nlbn = lfs_lblkno(fs, size);

sys/ufs/lfs/lfs_vnops.c

2415

*eobp = lfs_fragroundup(fs, size);

sys/ufs/lfs/lfs_vnops.c

2417

*eobp = lfs_blkroundup(fs, size);

sys/ufs/lfs/lfs_vnops.c

2435

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/lfs_vnops.c

2440

lfs_dump_dinode(fs, ip->i_din);

sys/ufs/lfs/lfs_vnops.c

396

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/lfs_vnops.c

402

if (fs->lfs_ronly)

sys/ufs/lfs/lfs_vnops.c

418

TAILQ_INSERT_TAIL(&fs->lfs_pchainhd, ip,

sys/ufs/lfs/lfs_vnops.c

437

mtsleep(&fs->lfs_availsleep, PCATCH | PUSER,

sys/ufs/lfs/lfs_vnops.c

507

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

513

fs = VTOI(dvp)->i_lfs;

sys/ufs/lfs/lfs_vnops.c

515

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_vnops.c

520

if ((error = lfs_reserve(fs, dvp, vp, LFS_NRESERVE(fs))) != 0)

sys/ufs/lfs/lfs_vnops.c

525

if (fs->lfs_dirops == 0) {

sys/ufs/lfs/lfs_vnops.c

530

while (fs->lfs_writer) {

sys/ufs/lfs/lfs_vnops.c

531

error = cv_wait_sig(&fs->lfs_diropscv, &lfs_lock);

sys/ufs/lfs/lfs_vnops.c

537

if (lfs_dirvcount > LFS_MAX_DIROP && fs->lfs_dirops == 0) {

sys/ufs/lfs/lfs_vnops.c

546

"dirvcount=%d\n", fs->lfs_dirops, lfs_dirvcount));

sys/ufs/lfs/lfs_vnops.c

557

++fs->lfs_dirops;

sys/ufs/lfs/lfs_vnops.c

572

lfs_reserve(fs, dvp, vp, -LFS_NRESERVE(fs));

sys/ufs/lfs/lfs_vnops.c

581

lfs_unset_dirop(struct lfs *fs, struct vnode *dvp, const char *str)

sys/ufs/lfs/lfs_vnops.c

584

--fs->lfs_dirops;

sys/ufs/lfs/lfs_vnops.c

585

if (!fs->lfs_dirops) {

sys/ufs/lfs/lfs_vnops.c

586

if (fs->lfs_nadirop) {

sys/ufs/lfs/lfs_vnops.c

589

fs->lfs_nadirop);

sys/ufs/lfs/lfs_vnops.c

591

wakeup(&fs->lfs_writer);

sys/ufs/lfs/lfs_vnops.c

597

lfs_reserve(fs, dvp, NULL, -LFS_NRESERVE(fs));

sys/ufs/lfs/lfs_vnops.c

604

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/lfs_vnops.c

613

++fs->lfs_dirvcount;

sys/ufs/lfs/lfs_vnops.c

614

TAILQ_INSERT_TAIL(&fs->lfs_dchainhd, ip, i_lfs_dchain);

sys/ufs/lfs/lfs_vnops.c

617

++fs->lfs_nadirop;

sys/ufs/lfs/lfs_vnops.c

649

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

668

fs = VFSTOULFS(dvp->v_mount)->um_lfs;

sys/ufs/lfs/lfs_vnops.c

669

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_vnops.c

670

if (fs->lfs_ronly) {

sys/ufs/lfs/lfs_vnops.c

719

lfs_unset_dirop(fs, dvp, "symlink");

sys/ufs/lfs/lfs_vnops.c

734

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

754

fs = VFSTOULFS(dvp->v_mount)->um_lfs;

sys/ufs/lfs/lfs_vnops.c

755

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_vnops.c

756

if (fs->lfs_ronly) {

sys/ufs/lfs/lfs_vnops.c

769

lfs_unset_dirop(fs, dvp, "mknod");

sys/ufs/lfs/lfs_vnops.c

814

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

832

fs = VFSTOULFS(dvp->v_mount)->um_lfs;

sys/ufs/lfs/lfs_vnops.c

833

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_vnops.c

834

if (fs->lfs_ronly) {

sys/ufs/lfs/lfs_vnops.c

856

lfs_unset_dirop(fs, dvp, "create");

sys/ufs/lfs/lfs_vnops.c

871

struct lfs *fs;

sys/ufs/lfs/lfs_vnops.c

901

fs = VFSTOULFS(dvp->v_mount)->um_lfs;

sys/ufs/lfs/lfs_vnops.c

902

ASSERT_NO_SEGLOCK(fs);

sys/ufs/lfs/lfs_vnops.c

903

if (fs->lfs_ronly) {

sys/ufs/lfs/lfs_vnops.c

911

dirblksiz = fs->um_dirblksiz;

sys/ufs/lfs/lfs_vnops.c

971

lfs_dir_setino(fs, dirp, ip->i_number);

sys/ufs/lfs/lfs_vnops.c

972

lfs_dir_setreclen(fs, dirp, LFS_DIRECTSIZ(fs, 1));

sys/ufs/lfs/lfs_vnops.c

973

lfs_dir_settype(fs, dirp, LFS_DT_DIR);

sys/ufs/lfs/lfs_vnops.c

974

lfs_dir_setnamlen(fs, dirp, 1);

sys/ufs/lfs/lfs_vnops.c

975

lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), ".", 1,

sys/ufs/lfs/lfs_vnops.c

976

LFS_DIRECTSIZ(fs, 1));

sys/ufs/lfs/lfs_vnops.c

977

dirp = LFS_NEXTDIR(fs, dirp);

sys/ufs/lfs/lfs_vnops.c

979

lfs_dir_setino(fs, dirp, dp->i_number);

sys/ufs/lfs/lfs_vnops.c

980

lfs_dir_setreclen(fs, dirp, dirblksiz - LFS_DIRECTSIZ(fs, 1));

sys/ufs/lfs/lfs_vnops.c

981

lfs_dir_settype(fs, dirp, LFS_DT_DIR);

sys/ufs/lfs/lfs_vnops.c

982

lfs_dir_setnamlen(fs, dirp, 2);

sys/ufs/lfs/lfs_vnops.c

983

lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), "..", 2,

sys/ufs/lfs/lfs_vnops.c

984

dirblksiz - LFS_DIRECTSIZ(fs, 1));

sys/ufs/lfs/ulfs_bmap.c

141

struct lfs *fs;

sys/ufs/lfs/ulfs_bmap.c

151

fs = ip->i_lfs;

sys/ufs/lfs/ulfs_bmap.c

171

ULFS_MPNEEDSWAP(fs)));

sys/ufs/lfs/ulfs_bmap.c

174

ULFS_MPNEEDSWAP(fs));

sys/ufs/lfs/ulfs_bmap.c

175

*bnp = blkptrtodb(fs, daddr);

sys/ufs/lfs/ulfs_bmap.c

186

daddr < fs->um_seqinc) {

sys/ufs/lfs/ulfs_bmap.c

191

*bnp = blkptrtodb(fs, bn * fs->um_seqinc);

sys/ufs/lfs/ulfs_bmap.c

198

is_sequential(fs,

sys/ufs/lfs/ulfs_bmap.c

200

ULFS_MPNEEDSWAP(fs))),

sys/ufs/lfs/ulfs_bmap.c

202

ULFS_MPNEEDSWAP(fs))));

sys/ufs/lfs/ulfs_bmap.c

206

is_sequential(fs,

sys/ufs/lfs/ulfs_bmap.c

208

ULFS_MPNEEDSWAP(fs)),

sys/ufs/lfs/ulfs_bmap.c

210

ULFS_MPNEEDSWAP(fs)));

sys/ufs/lfs/ulfs_bmap.c

229

ULFS_MPNEEDSWAP(fs)));

sys/ufs/lfs/ulfs_bmap.c

232

ULFS_MPNEEDSWAP(fs));

sys/ufs/lfs/ulfs_bmap.c

277

bp->b_blkno = blkptrtodb(fs, daddr);

sys/ufs/lfs/ulfs_bmap.c

289

ULFS_MPNEEDSWAP(fs)));

sys/ufs/lfs/ulfs_bmap.c

292

bn < MNINDIR(fs) && *runp < maxrun &&

sys/ufs/lfs/ulfs_bmap.c

293

is_sequential(fs,

sys/ufs/lfs/ulfs_bmap.c

295

ULFS_MPNEEDSWAP(fs))),

sys/ufs/lfs/ulfs_bmap.c

297

ULFS_MPNEEDSWAP(fs))));

sys/ufs/lfs/ulfs_bmap.c

302

ULFS_MPNEEDSWAP(fs));

sys/ufs/lfs/ulfs_bmap.c

305

bn < MNINDIR(fs) && *runp < maxrun &&

sys/ufs/lfs/ulfs_bmap.c

306

is_sequential(fs,

sys/ufs/lfs/ulfs_bmap.c

308

ULFS_MPNEEDSWAP(fs)),

sys/ufs/lfs/ulfs_bmap.c

310

ULFS_MPNEEDSWAP(fs)));

sys/ufs/lfs/ulfs_bmap.c

326

&& daddr > 0 && daddr < fs->um_seqinc) {

sys/ufs/lfs/ulfs_bmap.c

330

*bnp = blkptrtodb(fs, daddr);

sys/ufs/lfs/ulfs_bmap.c

334

*bnp = blkptrtodb(fs, bn * fs->um_seqinc);

sys/ufs/lfs/ulfs_bmap.c

356

struct lfs *fs;

sys/ufs/lfs/ulfs_bmap.c

362

fs = ump->um_lfs;

sys/ufs/lfs/ulfs_bmap.c

383

lbc += fs->um_lognindir;

sys/ufs/lfs/ulfs_bmap.c

408

lbc -= fs->um_lognindir;

sys/ufs/lfs/ulfs_bmap.c

409

off = (bn >> lbc) & (MNINDIR(fs) - 1);

sys/ufs/lfs/ulfs_bmap.c

61

ulfs_issequential(const struct lfs *fs, daddr_t daddr0, daddr_t daddr1)

sys/ufs/lfs/ulfs_bmap.c

68

return (daddr0 + fs->um_seqinc == daddr1);

sys/ufs/lfs/ulfs_bswap.h

41

#define ULFS_FSNEEDSWAP(fs) ((fs)->fs_flags & FS_SWAPPED)

sys/ufs/lfs/ulfs_bswap.h

45

#define ULFS_FSNEEDSWAP(fs) (__USE(fs), 0)

sys/ufs/lfs/ulfs_dirhash.c

1030

ulfsdirhash_getprev(struct lfs *fs, LFS_DIRHEADER *dirp,

sys/ufs/lfs/ulfs_dirhash.c

1051

reclen = lfs_dir_getreclen(fs, dp);

sys/ufs/lfs/ulfs_dirhash.c

129

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/ulfs_dirhash.c

165

nslots = ip->i_size / LFS_DIRECTSIZ(fs, 1);

sys/ufs/lfs/ulfs_dirhash.c

243

if (lfs_dir_getreclen(fs, ep) == 0 || lfs_dir_getreclen(fs, ep) >

sys/ufs/lfs/ulfs_dirhash.c

249

if (lfs_dir_getino(fs, ep) != 0) {

sys/ufs/lfs/ulfs_dirhash.c

251

slot = ulfsdirhash_hash(dh, lfs_dir_nameptr(fs, ep),

sys/ufs/lfs/ulfs_dirhash.c

252

lfs_dir_getnamlen(fs, ep));

sys/ufs/lfs/ulfs_dirhash.c

257

ulfsdirhash_adjfree(dh, pos, -LFS_DIRSIZ(fs, ep),

sys/ufs/lfs/ulfs_dirhash.c

260

pos += lfs_dir_getreclen(fs, ep);

sys/ufs/lfs/ulfs_dirhash.c

342

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/ulfs_dirhash.c

441

if (lfs_dir_getreclen(fs, dp) == 0 || lfs_dir_getreclen(fs, dp) >

sys/ufs/lfs/ulfs_dirhash.c

448

if (lfs_dir_getnamlen(fs, dp) == namelen &&

sys/ufs/lfs/ulfs_dirhash.c

449

memcmp(lfs_dir_nameptr(fs, dp), name, namelen) == 0) {

sys/ufs/lfs/ulfs_dirhash.c

453

prevoff = ulfsdirhash_getprev(fs, dp,

sys/ufs/lfs/ulfs_dirhash.c

467

dh->dh_seqoff = offset + LFS_DIRSIZ(fs, dp);

sys/ufs/lfs/ulfs_dirhash.c

516

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/ulfs_dirhash.c

554

if (lfs_dir_getreclen(fs, dp) == 0) {

sys/ufs/lfs/ulfs_dirhash.c

559

if (lfs_dir_getino(fs, dp) == 0 || lfs_dir_getreclen(fs, dp) > LFS_DIRSIZ(fs, dp))

sys/ufs/lfs/ulfs_dirhash.c

561

i += lfs_dir_getreclen(fs, dp);

sys/ufs/lfs/ulfs_dirhash.c

562

dp = LFS_NEXTDIR(fs, dp);

sys/ufs/lfs/ulfs_dirhash.c

574

freebytes += lfs_dir_getreclen(fs, dp);

sys/ufs/lfs/ulfs_dirhash.c

575

if (lfs_dir_getino(fs, dp) != 0)

sys/ufs/lfs/ulfs_dirhash.c

576

freebytes -= LFS_DIRSIZ(fs, dp);

sys/ufs/lfs/ulfs_dirhash.c

577

if (lfs_dir_getreclen(fs, dp) == 0) {

sys/ufs/lfs/ulfs_dirhash.c

582

i += lfs_dir_getreclen(fs, dp);

sys/ufs/lfs/ulfs_dirhash.c

583

dp = LFS_NEXTDIR(fs, dp);

sys/ufs/lfs/ulfs_dirhash.c

639

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/ulfs_dirhash.c

666

slot = ulfsdirhash_hash(dh, lfs_dir_nameptr(fs, dirp),

sys/ufs/lfs/ulfs_dirhash.c

667

lfs_dir_getnamlen(fs, dirp));

sys/ufs/lfs/ulfs_dirhash.c

675

ulfsdirhash_adjfree(dh, offset, -LFS_DIRSIZ(fs, dirp), dirblksiz);

sys/ufs/lfs/ulfs_dirhash.c

687

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/ulfs_dirhash.c

704

slot = ulfsdirhash_findslot(dh, lfs_dir_nameptr(fs, dirp),

sys/ufs/lfs/ulfs_dirhash.c

705

lfs_dir_getnamlen(fs, dirp), offset);

sys/ufs/lfs/ulfs_dirhash.c

711

ulfsdirhash_adjfree(dh, offset, LFS_DIRSIZ(fs, dirp), dirblksiz);

sys/ufs/lfs/ulfs_dirhash.c

723

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/ulfs_dirhash.c

739

slot = ulfsdirhash_findslot(dh, lfs_dir_nameptr(fs, dirp),

sys/ufs/lfs/ulfs_dirhash.c

740

lfs_dir_getnamlen(fs, dirp), oldoff);

sys/ufs/lfs/ulfs_dirhash.c

845

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/ulfs_dirhash.c

868

for (i = 0; i < dirblksiz; i += lfs_dir_getreclen(fs, dp)) {

sys/ufs/lfs/ulfs_dirhash.c

870

if (lfs_dir_getreclen(fs, dp) == 0 || i + lfs_dir_getreclen(fs, dp) > dirblksiz)

sys/ufs/lfs/ulfs_dirhash.c

873

if (lfs_dir_getino(fs, dp) == 0) {

sys/ufs/lfs/ulfs_dirhash.c

88

static doff_t ulfsdirhash_getprev(struct lfs *fs, LFS_DIRHEADER *dp,

sys/ufs/lfs/ulfs_dirhash.c

884

nfree += lfs_dir_getreclen(fs, dp);

sys/ufs/lfs/ulfs_dirhash.c

889

ulfsdirhash_findslot(dh, lfs_dir_nameptr(fs, dp),

sys/ufs/lfs/ulfs_dirhash.c

890

lfs_dir_getnamlen(fs, dp),

sys/ufs/lfs/ulfs_dirhash.c

893

nfree += lfs_dir_getreclen(fs, dp) - LFS_DIRSIZ(fs, dp);

sys/ufs/lfs/ulfs_inode.h

163

#define S_INDIR(fs) -ULFS_NDADDR

sys/ufs/lfs/ulfs_inode.h

164

#define D_INDIR(fs) (S_INDIR(fs) - LFS_NINDIR(fs) - 1)

sys/ufs/lfs/ulfs_inode.h

165

#define T_INDIR(fs) (D_INDIR(fs) - LFS_NINDIR(fs) * LFS_NINDIR(fs) - 1)

sys/ufs/lfs/ulfs_inode.h

79

#define SIZEOF_DIROP(fs) (2 * (lfs_sb_getbsize(fs) + DINOSIZE(fs)))

sys/ufs/lfs/ulfs_inode.h

80

#define LFS_MAX_FSDIROP(fs) \

sys/ufs/lfs/ulfs_inode.h

81

(lfs_sb_getnclean(fs) <= lfs_sb_getresvseg(fs) ? 0 : \

sys/ufs/lfs/ulfs_inode.h

82

((lfs_sb_getnclean(fs) - lfs_sb_getresvseg(fs)) * lfs_sb_getssize(fs)) / \

sys/ufs/lfs/ulfs_inode.h

83

(2 * SIZEOF_DIROP(fs)))

sys/ufs/lfs/ulfs_inode.h

96

#define LFS_STARVED_FOR_SEGS(fs) (lfs_sb_getnclean(fs) < lfs_sb_getresvseg(fs))

sys/ufs/lfs/ulfs_lookup.c

1010

lfs_dir_setino(fs, ep, ULFS_WINO);

sys/ufs/lfs/ulfs_lookup.c

1011

lfs_dir_settype(fs, ep, LFS_DT_WHT);

sys/ufs/lfs/ulfs_lookup.c

1026

LFS_NEXTDIR(fs, ep), ulr->ulr_offset);

sys/ufs/lfs/ulfs_lookup.c

1033

lfs_dir_setino(fs, ep, 0);

sys/ufs/lfs/ulfs_lookup.c

1038

lfs_dir_setreclen(fs, ep,

sys/ufs/lfs/ulfs_lookup.c

1039

lfs_dir_getreclen(fs, ep) + ulr->ulr_reclen);

sys/ufs/lfs/ulfs_lookup.c

1098

struct lfs *fs = dp->i_lfs;

sys/ufs/lfs/ulfs_lookup.c

1107

lfs_dir_setino(fs, ep, newinum);

sys/ufs/lfs/ulfs_lookup.c

1108

lfs_dir_settype(fs, ep, newtype);

sys/ufs/lfs/ulfs_lookup.c

1136

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/ulfs_lookup.c

1146

for (off = 0; off < ip->i_size; off += lfs_dir_getreclen(fs, dp)) {

sys/ufs/lfs/ulfs_lookup.c

1156

if (lfs_dir_getreclen(fs, dp) == 0)

sys/ufs/lfs/ulfs_lookup.c

1159

if (lfs_dir_getino(fs, dp) == 0 ||

sys/ufs/lfs/ulfs_lookup.c

1160

lfs_dir_getino(fs, dp) == ULFS_WINO)

sys/ufs/lfs/ulfs_lookup.c

1163

namlen = lfs_dir_getnamlen(fs, dp);

sys/ufs/lfs/ulfs_lookup.c

1164

name = lfs_dir_nameptr(fs, dp);

sys/ufs/lfs/ulfs_lookup.c

1174

if (namlen == 1 && lfs_dir_getino(fs, dp) == ip->i_number)

sys/ufs/lfs/ulfs_lookup.c

1176

if (name[1] == '.' && lfs_dir_getino(fs, dp) == parentino)

sys/ufs/lfs/ulfs_lookup.c

151

struct lfs *fs = dp->i_lfs;

sys/ufs/lfs/ulfs_lookup.c

152

int dirblksiz = fs->um_dirblksiz;

sys/ufs/lfs/ulfs_lookup.c

225

slotneeded = LFS_DIRECTSIZ(fs, cnp->cn_namelen);

sys/ufs/lfs/ulfs_lookup.c

332

if (lfs_dir_getreclen(fs, ep) == 0 ||

sys/ufs/lfs/ulfs_lookup.c

350

int size = lfs_dir_getreclen(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

352

if (lfs_dir_getino(fs, ep) != 0)

sys/ufs/lfs/ulfs_lookup.c

353

size -= LFS_DIRSIZ(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

358

slotsize = lfs_dir_getreclen(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

366

lfs_dir_getreclen(fs, ep) -

sys/ufs/lfs/ulfs_lookup.c

376

if (lfs_dir_getino(fs, ep)) {

sys/ufs/lfs/ulfs_lookup.c

379

namlen = lfs_dir_getnamlen(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

381

!memcmp(cnp->cn_nameptr, lfs_dir_nameptr(fs, ep),

sys/ufs/lfs/ulfs_lookup.c

390

if (!FSFMT(vdp) && lfs_dir_gettype(fs, ep) == LFS_DT_WHT) {

sys/ufs/lfs/ulfs_lookup.c

393

slotsize = lfs_dir_getreclen(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

417

foundino = lfs_dir_getino(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

418

results->ulr_reclen = lfs_dir_getreclen(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

423

results->ulr_offset += lfs_dir_getreclen(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

424

entryoffsetinblock += lfs_dir_getreclen(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

425

if (lfs_dir_getino(fs, ep))

sys/ufs/lfs/ulfs_lookup.c

519

if (results->ulr_offset + LFS_DIRSIZ(fs, ep) > dp->i_size) {

sys/ufs/lfs/ulfs_lookup.c

522

results->ulr_offset + LFS_DIRSIZ(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

666

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_lookup.c

667

int dirblksiz = fs->um_dirblksiz;

sys/ufs/lfs/ulfs_lookup.c

670

namlen = lfs_dir_getnamlen(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

671

reclen = lfs_dir_getreclen(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

674

reclen < LFS_DIRSIZ(fs, ep) || namlen > LFS_MAXNAMLEN) {

sys/ufs/lfs/ulfs_lookup.c

678

lfs_dir_getreclen(fs, ep),

sys/ufs/lfs/ulfs_lookup.c

679

(u_long)LFS_DIRSIZ(fs, ep),

sys/ufs/lfs/ulfs_lookup.c

684

if (lfs_dir_getino(fs, ep) == 0)

sys/ufs/lfs/ulfs_lookup.c

686

name = lfs_dir_nameptr(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

715

ulfs_direntry_assign(struct lfs *fs, LFS_DIRHEADER *dirp,

sys/ufs/lfs/ulfs_lookup.c

719

lfs_dir_setino(fs, dirp, inum);

sys/ufs/lfs/ulfs_lookup.c

720

lfs_dir_setnamlen(fs, dirp, namlen);

sys/ufs/lfs/ulfs_lookup.c

721

lfs_dir_settype(fs, dirp, dtype);

sys/ufs/lfs/ulfs_lookup.c

722

memcpy(lfs_dir_nameptr(fs, dirp), name, namlen);

sys/ufs/lfs/ulfs_lookup.c

723

lfs_dir_nameptr(fs, dirp)[namlen] = '\0';

sys/ufs/lfs/ulfs_lookup.c

772

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_lookup.c

773

int dirblksiz = fs->um_dirblksiz;

sys/ufs/lfs/ulfs_lookup.c

786

newentrysize = LFS_DIRECTSIZ(fs, namlen);

sys/ufs/lfs/ulfs_lookup.c

807

ulfs_direntry_assign(fs, ep, name, namlen, inum, dtype);

sys/ufs/lfs/ulfs_lookup.c

808

lfs_dir_setreclen(fs, ep, dirblksiz);

sys/ufs/lfs/ulfs_lookup.c

864

dsize = (lfs_dir_getino(fs, ep) != 0) ? LFS_DIRSIZ(fs, ep) : 0;

sys/ufs/lfs/ulfs_lookup.c

865

spacefree = lfs_dir_getreclen(fs, ep) - dsize;

sys/ufs/lfs/ulfs_lookup.c

866

for (loc = lfs_dir_getreclen(fs, ep); loc < ulr->ulr_count; ) {

sys/ufs/lfs/ulfs_lookup.c

870

lfs_dir_setreclen(fs, ep, dsize);

sys/ufs/lfs/ulfs_lookup.c

871

ep = LFS_NEXTDIR(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

873

reclen = lfs_dir_getreclen(fs, nep);

sys/ufs/lfs/ulfs_lookup.c

875

if (lfs_dir_getino(fs, nep) == 0) {

sys/ufs/lfs/ulfs_lookup.c

885

lfs_dir_setino(fs, ep, 0);

sys/ufs/lfs/ulfs_lookup.c

889

dsize = LFS_DIRSIZ(fs, nep);

sys/ufs/lfs/ulfs_lookup.c

908

if (lfs_dir_getino(fs, ep) == 0 ||

sys/ufs/lfs/ulfs_lookup.c

909

(lfs_dir_getino(fs, ep) == ULFS_WINO &&

sys/ufs/lfs/ulfs_lookup.c

910

memcmp(lfs_dir_nameptr(fs, ep), name, namlen) == 0)) {

sys/ufs/lfs/ulfs_lookup.c

915

dohashadd = (lfs_dir_getino(fs, ep) == 0);

sys/ufs/lfs/ulfs_lookup.c

921

lfs_dir_setreclen(fs, ep, dsize);

sys/ufs/lfs/ulfs_lookup.c

922

ep = LFS_NEXTDIR(fs, ep);

sys/ufs/lfs/ulfs_lookup.c

928

ulfs_direntry_assign(fs, ep, name, namlen, inum, dtype);

sys/ufs/lfs/ulfs_lookup.c

929

lfs_dir_setreclen(fs, ep, reclen);

sys/ufs/lfs/ulfs_lookup.c

997

struct lfs *fs = dp->i_lfs;

sys/ufs/lfs/ulfs_quota.c

232

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

236

if ((fs->um_flags & (ULFS_QUOTA|ULFS_QUOTA2)) == 0)

sys/ufs/lfs/ulfs_quota.c

240

if (fs->um_flags & ULFS_QUOTA) {

sys/ufs/lfs/ulfs_quota.c

253

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

271

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

280

if ((fs->um_flags & (ULFS_QUOTA|ULFS_QUOTA2)) == 0)

sys/ufs/lfs/ulfs_quota.c

305

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

315

if ((fs->um_flags & (ULFS_QUOTA|ULFS_QUOTA2)) == 0)

sys/ufs/lfs/ulfs_quota.c

353

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

360

if ((fs->um_flags & (ULFS_QUOTA|ULFS_QUOTA2)) == 0)

sys/ufs/lfs/ulfs_quota.c

367

if (fs->um_flags & ULFS_QUOTA) {

sys/ufs/lfs/ulfs_quota.c

373

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

391

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

399

if ((fs->um_flags & (ULFS_QUOTA|ULFS_QUOTA2)) == 0)

sys/ufs/lfs/ulfs_quota.c

415

if (fs->um_flags & ULFS_QUOTA) {

sys/ufs/lfs/ulfs_quota.c

421

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

440

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

453

if ((fs->um_flags & ULFS_QUOTA2) == 0)

sys/ufs/lfs/ulfs_quota.c

464

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

484

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

489

if ((fs->um_flags & ULFS_QUOTA2) == 0)

sys/ufs/lfs/ulfs_quota.c

498

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

520

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

533

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

549

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

561

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

577

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

584

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

601

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

608

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

625

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

632

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

647

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

652

if ((fs->um_flags & ULFS_QUOTA2) != 0)

sys/ufs/lfs/ulfs_quota.c

676

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

681

if ((fs->um_flags & ULFS_QUOTA2) != 0)

sys/ufs/lfs/ulfs_quota.c

809

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

817

if ((fs->um_flags & (ULFS_QUOTA|ULFS_QUOTA2)) == 0) {

sys/ufs/lfs/ulfs_quota.c

824

if (fs->um_flags & ULFS_QUOTA) {

sys/ufs/lfs/ulfs_quota.c

833

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota.c

893

if (fs->um_flags & ULFS_QUOTA)

sys/ufs/lfs/ulfs_quota.c

897

if (fs->um_flags & ULFS_QUOTA2)

sys/ufs/lfs/ulfs_quota.c

972

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota.c

976

(void)fs;

sys/ufs/lfs/ulfs_quota.c

979

if (fs->um_flags & ULFS_QUOTA)

sys/ufs/lfs/ulfs_quota.c

983

if (fs->um_flags & ULFS_QUOTA2)

sys/ufs/lfs/ulfs_quota1.c

280

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota1.c

283

if ((fs->um_flags & ULFS_QUOTA) == 0)

sys/ufs/lfs/ulfs_quota1.c

309

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota1.c

316

if (fs->um_flags & ULFS_QUOTA2) {

sys/ufs/lfs/ulfs_quota1.c

397

fs->um_flags |= ULFS_QUOTA;

sys/ufs/lfs/ulfs_quota1.c

411

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota1.c

428

fs->um_flags &= ~ULFS_QUOTA;

sys/ufs/lfs/ulfs_quota2.c

1100

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

1101

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

1126

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

1127

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

145

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

146

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

1511

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

1512

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

1565

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

1570

if ((fs->lfs_use_quota2) == 0)

sys/ufs/lfs/ulfs_quota2.c

1573

fs->um_flags |= ULFS_QUOTA2;

sys/ufs/lfs/ulfs_quota2.c

1574

ump->umq2_bsize = lfs_sb_getbsize(fs);

sys/ufs/lfs/ulfs_quota2.c

1575

ump->umq2_bmask = lfs_sb_getbmask(fs);

sys/ufs/lfs/ulfs_quota2.c

1576

if (fs->lfs_quota_magic != Q2_HEAD_MAGIC) {

sys/ufs/lfs/ulfs_quota2.c

1583

if ((fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_USRQUOTA)) &&

sys/ufs/lfs/ulfs_quota2.c

1584

fs->lfs_quotaino[ULFS_USRQUOTA] == 0) {

sys/ufs/lfs/ulfs_quota2.c

1589

if ((fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_GRPQUOTA)) &&

sys/ufs/lfs/ulfs_quota2.c

1590

fs->lfs_quotaino[ULFS_GRPQUOTA] == 0) {

sys/ufs/lfs/ulfs_quota2.c

1598

if (fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_USRQUOTA) &&

sys/ufs/lfs/ulfs_quota2.c

1600

error = VFS_VGET(mp, fs->lfs_quotaino[ULFS_USRQUOTA],

sys/ufs/lfs/ulfs_quota2.c

1614

if (fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_GRPQUOTA) &&

sys/ufs/lfs/ulfs_quota2.c

1616

error = VFS_VGET(mp, fs->lfs_quotaino[ULFS_GRPQUOTA],

sys/ufs/lfs/ulfs_quota2.c

198

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

199

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

272

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

274

if ((fs->um_flags & ULFS_QUOTA2) == 0)

sys/ufs/lfs/ulfs_quota2.c

301

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

302

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

448

struct lfs *fs = ip->i_lfs;

sys/ufs/lfs/ulfs_quota2.c

450

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

586

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

587

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

662

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

663

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

798

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

799

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

834

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

835

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_quota2.c

873

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_quota2.c

874

const int needswap = ULFS_MPNEEDSWAP(fs);

sys/ufs/lfs/ulfs_readwrite.c

125

FS *fs;

sys/ufs/lfs/ulfs_readwrite.c

138

fs = ip->I_FS;

sys/ufs/lfs/ulfs_readwrite.c

141

KASSERT(vp->v_type != VLNK || ip->i_size >= fs->um_maxsymlinklen);

sys/ufs/lfs/ulfs_readwrite.c

142

KASSERT(vp->v_type != VLNK || fs->um_maxsymlinklen != 0 ||

sys/ufs/lfs/ulfs_readwrite.c

144

KASSERT(vp->v_type != VREG || vp == fs->lfs_ivnode);

sys/ufs/lfs/ulfs_readwrite.c

147

if (uio->uio_offset > fs->um_maxfilesize)

sys/ufs/lfs/ulfs_readwrite.c

160

lbn = lfs_lblkno(fs, uio->uio_offset);

sys/ufs/lfs/ulfs_readwrite.c

162

size = lfs_blksize(fs, ip, lbn);

sys/ufs/lfs/ulfs_readwrite.c

163

blkoffset = lfs_blkoff(fs, uio->uio_offset);

sys/ufs/lfs/ulfs_readwrite.c

164

xfersize = MIN(MIN(fs_sb_getbsize(fs) - blkoffset, uio->uio_resid),

sys/ufs/lfs/ulfs_readwrite.c

167

if (lfs_lblktosize(fs, nextlbn) >= ip->i_size)

sys/ufs/lfs/ulfs_readwrite.c

170

int nextsize = lfs_blksize(fs, ip, nextlbn);

sys/ufs/lfs/ulfs_readwrite.c

237

FS *fs;

sys/ufs/lfs/ulfs_readwrite.c

260

fs = ip->I_FS;

sys/ufs/lfs/ulfs_readwrite.c

262

(u_int64_t)uio->uio_offset + uio->uio_resid > fs->um_maxfilesize)

sys/ufs/lfs/ulfs_readwrite.c

266

if (vp == fs->lfs_ivnode)

sys/ufs/lfs/ulfs_readwrite.c

281

lfs_availwait(fs, lfs_btofsb(fs, uio->uio_resid));

sys/ufs/lfs/ulfs_readwrite.c

284

preallocoff = round_page(lfs_blkroundup(fs, MAX(osize, uio->uio_offset)));

sys/ufs/lfs/ulfs_readwrite.c

287

endallocoff = nsize - lfs_blkoff(fs, nsize);

sys/ufs/lfs/ulfs_readwrite.c

294

if (nsize > osize && lfs_lblkno(fs, osize) < ULFS_NDADDR &&

sys/ufs/lfs/ulfs_readwrite.c

295

lfs_lblkno(fs, osize) != lfs_lblkno(fs, nsize) &&

sys/ufs/lfs/ulfs_readwrite.c

296

lfs_blkroundup(fs, osize) != osize) {

sys/ufs/lfs/ulfs_readwrite.c

299

eob = lfs_blkroundup(fs, osize);

sys/ufs/lfs/ulfs_readwrite.c

306

VOP_PUTPAGES(vp, trunc_page(osize & lfs_sb_getbmask(fs)),

sys/ufs/lfs/ulfs_readwrite.c

322

blkoffset = lfs_blkoff(fs, uio->uio_offset);

sys/ufs/lfs/ulfs_readwrite.c

323

bytelen = MIN(fs_sb_getbsize(fs) - blkoffset, uio->uio_resid);

sys/ufs/lfs/ulfs_readwrite.c

338

lfs_blkoff(fs, uio->uio_offset) == 0 &&

sys/ufs/lfs/ulfs_readwrite.c

343

len -= lfs_blkoff(fs, len);

sys/ufs/lfs/ulfs_readwrite.c

400

error = VOP_PUTPAGES(vp, trunc_page(origoff & lfs_sb_getbmask(fs)),

sys/ufs/lfs/ulfs_readwrite.c

401

round_page(lfs_blkroundup(fs, uio->uio_offset)),

sys/ufs/lfs/ulfs_readwrite.c

419

FS *fs;

sys/ufs/lfs/ulfs_readwrite.c

435

fs = ip->I_FS;

sys/ufs/lfs/ulfs_readwrite.c

440

uio->uio_resid > fs->um_maxfilesize ||

sys/ufs/lfs/ulfs_readwrite.c

441

uio->uio_offset > (fs->um_maxfilesize - uio->uio_resid))

sys/ufs/lfs/ulfs_readwrite.c

443

KASSERT(vp != fs->lfs_ivnode);

sys/ufs/lfs/ulfs_readwrite.c

454

lfs_availwait(fs, lfs_btofsb(fs, uio->uio_resid));

sys/ufs/lfs/ulfs_readwrite.c

46

#define fs_sb_getbsize(fs) lfs_sb_getbsize(fs)

sys/ufs/lfs/ulfs_readwrite.c

460

lbn = lfs_lblkno(fs, uio->uio_offset);

sys/ufs/lfs/ulfs_readwrite.c

461

blkoffset = lfs_blkoff(fs, uio->uio_offset);

sys/ufs/lfs/ulfs_readwrite.c

462

xfersize = MIN(fs_sb_getbsize(fs) - blkoffset, uio->uio_resid);

sys/ufs/lfs/ulfs_readwrite.c

463

if (fs_sb_getbsize(fs) > xfersize)

sys/ufs/lfs/ulfs_readwrite.c

468

error = lfs_reserve(fs, vp, NULL,

sys/ufs/lfs/ulfs_readwrite.c

469

lfs_btofsb(fs, (ULFS_NIADDR + 1) << lfs_sb_getbshift(fs)));

sys/ufs/lfs/ulfs_readwrite.c

483

size = lfs_blksize(fs, ip, lbn) - bp->b_resid;

sys/ufs/lfs/ulfs_readwrite.c

499

lfs_reserve(fs, vp, NULL,

sys/ufs/lfs/ulfs_readwrite.c

500

-lfs_btofsb(fs, (ULFS_NIADDR + 1) << lfs_sb_getbshift(fs)));

sys/ufs/lfs/ulfs_readwrite.c

506

lfs_reserve(fs, vp, NULL,

sys/ufs/lfs/ulfs_readwrite.c

507

-lfs_btofsb(fs, (ULFS_NIADDR + 1) << lfs_sb_getbshift(fs)));

sys/ufs/lfs/ulfs_readwrite.c

69

FS *fs;

sys/ufs/lfs/ulfs_readwrite.c

75

fs = ip->I_FS;

sys/ufs/lfs/ulfs_readwrite.c

89

if ((u_int64_t)uio->uio_offset > fs->um_maxfilesize)

sys/ufs/lfs/ulfs_vnops.c

247

struct lfs *fs;

sys/ufs/lfs/ulfs_vnops.c

264

fs = ip->i_lfs;

sys/ufs/lfs/ulfs_vnops.c

392

lfs_dino_setbirthtime(fs, ip->i_din,

sys/ufs/lfs/ulfs_vnops.c

632

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_vnops.c

645

if (fs->um_maxsymlinklen > 0)

sys/ufs/lfs/ulfs_vnops.c

651

KASSERTMSG((fs->um_maxsymlinklen > 0),

sys/ufs/lfs/ulfs_vnops.c

660

KASSERTMSG((fs->um_maxsymlinklen > 0),

sys/ufs/lfs/ulfs_vnops.c

783

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_vnops.c

820

physstart = startoffset & ~(off_t)(fs->um_dirblksiz - 1);

sys/ufs/lfs/ulfs_vnops.c

821

physend = endoffset & ~(off_t)(fs->um_dirblksiz - 1);

sys/ufs/lfs/ulfs_vnops.c

825

if (callerbytes - dropend < LFS_DIRECTSIZ(fs, 0)) {

sys/ufs/lfs/ulfs_vnops.c

865

maxcookies = rawbytes / LFS_DIRECTSIZ(fs, 1);

sys/ufs/lfs/ulfs_vnops.c

879

if (lfs_dir_getreclen(fs, rawdp) <= skipstart) {

sys/ufs/lfs/ulfs_vnops.c

880

skipstart -= lfs_dir_getreclen(fs, rawdp);

sys/ufs/lfs/ulfs_vnops.c

881

rawdp = LFS_NEXTDIR(fs, rawdp);

sys/ufs/lfs/ulfs_vnops.c

888

if (lfs_dir_getreclen(fs, rawdp) == 0) {

sys/ufs/lfs/ulfs_vnops.c

898

dirent->d_type = lfs_dir_gettype(fs, rawdp);

sys/ufs/lfs/ulfs_vnops.c

899

dirent->d_namlen = lfs_dir_getnamlen(fs, rawdp);

sys/ufs/lfs/ulfs_vnops.c

908

dirent->d_fileno = lfs_dir_getino(fs, rawdp);

sys/ufs/lfs/ulfs_vnops.c

909

(void)memcpy(dirent->d_name, lfs_dir_nameptr(fs, rawdp),

sys/ufs/lfs/ulfs_vnops.c

916

curoffset += lfs_dir_getreclen(fs, rawdp);

sys/ufs/lfs/ulfs_vnops.c

922

rawdp = LFS_NEXTDIR(fs, rawdp);

sys/ufs/lfs/ulfs_vnops.c

961

struct lfs *fs = ump->um_lfs;

sys/ufs/lfs/ulfs_vnops.c

973

if (isize < fs->um_maxsymlinklen ||

sys/ufs/lfs/ulfs_vnops.c

974

(fs->um_maxsymlinklen == 0 && DIP(ip, blocks) == 0)) {

sys/ufs/mfs/mfs_miniroot.c

52

struct fs *fs = (struct fs *)((char *)base + SBLOCK_UFS1);

sys/ufs/mfs/mfs_miniroot.c

60

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

sys/ufs/mfs/mfs_miniroot.c

61

fs->fs_bsize < sizeof(struct fs))

sys/ufs/mfs/mfs_miniroot.c

65

mfs_rootsize = fs->fs_fsize * fs->fs_size;

sys/ufs/mfs/mfs_vfsops.c

191

struct fs *fs;

sys/ufs/mfs/mfs_vfsops.c

225

fs = ump->um_fs;

sys/ufs/mfs/mfs_vfsops.c

226

(void) copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);

sys/ufs/mfs/mfs_vfsops.c

245

struct fs *fs;

sys/ufs/mfs/mfs_vfsops.c

295

fs = ump->um_fs;

sys/ufs/mfs/mfs_vfsops.c

296

if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {

sys/ufs/mfs/mfs_vfsops.c

304

if (fs->fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR))

sys/ufs/mfs/mfs_vfsops.c

305

fs->fs_ronly = 0;

sys/ufs/mfs/mfs_vfsops.c

339

fs = ump->um_fs;

sys/ufs/mfs/mfs_vfsops.c

344

(void)strncpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname,

sys/ufs/mfs/mfs_vfsops.c

345

sizeof(fs->fs_fsmnt));

sys/ufs/mfs/mfs_vfsops.c

346

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

sys/ufs/ufs/inode.h

107

struct fs *fs; /* FFS */

sys/ufs/ufs/inode.h

111

#define i_fs inode_u.fs

sys/ufs/ufs/ufs_bswap.h

40

#define UFS_FSNEEDSWAP(fs) ((fs)->fs_flags & FS_SWAPPED)

sys/ufs/ufs/ufs_bswap.h

44

#define UFS_FSNEEDSWAP(fs) ((void)(fs), 0)

sys/ufs/ufs/ufs_readwrite.c

130

FS *fs;

sys/ufs/ufs/ufs_readwrite.c

143

fs = ip->I_FS;

sys/ufs/ufs/ufs_readwrite.c

164

lbn = ufs_lblkno(fs, uio->uio_offset);

sys/ufs/ufs/ufs_readwrite.c

166

size = ufs_blksize(fs, ip, lbn);

sys/ufs/ufs/ufs_readwrite.c

167

blkoffset = ufs_blkoff(fs, uio->uio_offset);

sys/ufs/ufs/ufs_readwrite.c

168

xfersize = MIN(MIN(fs->fs_bsize - blkoffset, uio->uio_resid),

sys/ufs/ufs/ufs_readwrite.c

171

if (ufs_lblktosize(fs, nextlbn) >= ip->i_size)

sys/ufs/ufs/ufs_readwrite.c

174

int nextsize = ufs_blksize(fs, ip, nextlbn);

sys/ufs/ufs/ufs_readwrite.c

246

FS *fs;

sys/ufs/ufs/ufs_readwrite.c

274

fs = ip->I_FS;

sys/ufs/ufs/ufs_readwrite.c

323

preallocoff = round_page(ufs_blkroundup(fs, MAX(osize, uio->uio_offset)));

sys/ufs/ufs/ufs_readwrite.c

326

endallocoff = nsize - ufs_blkoff(fs, nsize);

sys/ufs/ufs/ufs_readwrite.c

333

if (nsize > osize && ufs_lblkno(fs, osize) < UFS_NDADDR &&

sys/ufs/ufs/ufs_readwrite.c

334

ufs_lblkno(fs, osize) != ufs_lblkno(fs, nsize) &&

sys/ufs/ufs/ufs_readwrite.c

335

ufs_blkroundup(fs, osize) != osize) {

sys/ufs/ufs/ufs_readwrite.c

338

eob = ufs_blkroundup(fs, osize);

sys/ufs/ufs/ufs_readwrite.c

345

VOP_PUTPAGES(vp, trunc_page(osize & fs->fs_bmask),

sys/ufs/ufs/ufs_readwrite.c

361

blkoffset = ufs_blkoff(fs, uio->uio_offset);

sys/ufs/ufs/ufs_readwrite.c

362

bytelen = MIN(fs->fs_bsize - blkoffset, uio->uio_resid);

sys/ufs/ufs/ufs_readwrite.c

377

ufs_blkoff(fs, uio->uio_offset) == 0 &&

sys/ufs/ufs/ufs_readwrite.c

382

len -= ufs_blkoff(fs, len);

sys/ufs/ufs/ufs_readwrite.c

40

#define FS struct fs

sys/ufs/ufs/ufs_readwrite.c

446

error = VOP_PUTPAGES(vp, trunc_page(origoff & fs->fs_bmask),

sys/ufs/ufs/ufs_readwrite.c

447

round_page(ufs_blkroundup(fs, uio->uio_offset)),

sys/ufs/ufs/ufs_readwrite.c

467

FS *fs;

sys/ufs/ufs/ufs_readwrite.c

485

fs = ip->I_FS;

sys/ufs/ufs/ufs_readwrite.c

507

lbn = ufs_lblkno(fs, uio->uio_offset);

sys/ufs/ufs/ufs_readwrite.c

508

blkoffset = ufs_blkoff(fs, uio->uio_offset);

sys/ufs/ufs/ufs_readwrite.c

509

xfersize = MIN(fs->fs_bsize - blkoffset, uio->uio_resid);

sys/ufs/ufs/ufs_readwrite.c

510

if (fs->fs_bsize > xfersize)

sys/ufs/ufs/ufs_readwrite.c

525

size = ufs_blksize(fs, ip, lbn) - bp->b_resid;

sys/ufs/ufs/ufs_readwrite.c

542

else if (xfersize + blkoffset == fs->fs_bsize)

sys/ufs/ufs/ufsmount.h

82

struct fs *fs; /* FFS */

sys/ufs/ufs/ufsmount.h

87

#define um_fs ufsmount_u.fs

tests/fs/common/h_fsmacros.h

110

#define ATF_TC_FSADD(fs,type,func,desc) \

tests/fs/common/h_fsmacros.h

111

ATF_TC(fs##_##func); \

tests/fs/common/h_fsmacros.h

112

ATF_TC_HEAD(fs##_##func,tc) \

tests/fs/common/h_fsmacros.h

115

atf_tc_set_md_var(tc, "X-fs.type", #fs); \

tests/fs/common/h_fsmacros.h

118

void *fs##func##tmp; \

tests/fs/common/h_fsmacros.h

120

ATF_TC_BODY(fs##_##func,tc) \

tests/fs/common/h_fsmacros.h

122

if (!atf_check_fstype(tc, #fs)) \

tests/fs/common/h_fsmacros.h

124

FSTEST_CONSTRUCTOR(tc,fs,fs##func##tmp); \

tests/fs/common/h_fsmacros.h

126

if (fs##_fstest_unmount(tc, FSTEST_MNTNAME, 0) != 0) { \

tests/fs/common/h_fsmacros.h

160

#define ATF_TP_FSADD(fs,func) \

tests/fs/common/h_fsmacros.h

161

ATF_TP_ADD_TC(tp,fs##_##func)

tests/fs/common/h_fsmacros.h

244

atf_check_fstype(const atf_tc_t *tc, const char *fs)

tests/fs/common/h_fsmacros.h

249

if (strcmp(fs, "zfs") == 0) {

tests/fs/common/h_fsmacros.h

260

if (strcmp(fstype, fs) == 0)

tests/fs/puffs/h_dtfs/dtfs.c

184

PUFFSOP_SET(pops, dtfs, fs, statvfs);

tests/fs/puffs/h_dtfs/dtfs.c

185

PUFFSOP_SET(pops, dtfs, fs, unmount);

tests/fs/puffs/h_dtfs/dtfs.c

187

PUFFSOP_SET(pops, dtfs, fs, fhtonode);

tests/fs/puffs/h_dtfs/dtfs.c

188

PUFFSOP_SET(pops, dtfs, fs, nodetofh);

tests/fs/puffs/t_basic.c

34

syncbar(const char *fs)

tests/fs/puffs/t_basic.c

38

if (rump_sys_statvfs1(fs, &svb, ST_WAIT) == -1)

tests/lib/libc/c063/t_utimensat.c

105

RL(statvfs(FILE, &fs));

tests/lib/libc/c063/t_utimensat.c

106

checkstattime(&st, &fs);

tests/lib/libc/c063/t_utimensat.c

119

struct statvfs fs;

tests/lib/libc/c063/t_utimensat.c

129

RL(statvfs(BASEFILE, &fs));

tests/lib/libc/c063/t_utimensat.c

130

checkstattime(&st, &fs);

tests/lib/libc/c063/t_utimensat.c

208

struct statvfs fs;

tests/lib/libc/c063/t_utimensat.c

222

RL(statvfs(DIR, &fs)); /* XXX should do lstatvfs(LINK, &fs) */

tests/lib/libc/c063/t_utimensat.c

223

checkstattime(&st, &fs);

tests/lib/libc/c063/t_utimensat.c

64

checkstattime(const struct stat *st, const struct statvfs *fs)

tests/lib/libc/c063/t_utimensat.c

67

if ((fs->f_flag & ST_NOATIME) == 0) {

tests/lib/libc/c063/t_utimensat.c

94

struct statvfs fs;

tests/usr.bin/xlint/lint1/msg_347.c

19

void function_parameter(void *fs, double *fn(void *, int));

usr.bin/compress/compress.c

387

setfile(const char *name, struct stat *fs)

usr.bin/compress/compress.c

391

fs->st_mode &= S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO;

usr.bin/compress/compress.c

393

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

usr.bin/compress/compress.c

394

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

usr.bin/compress/compress.c

404

if (chown(name, fs->st_uid, fs->st_gid)) {

usr.bin/compress/compress.c

407

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

usr.bin/compress/compress.c

409

if (chmod(name, fs->st_mode))

usr.bin/compress/compress.c

417

if (fs->st_flags != 0 && chflags(name, fs->st_flags))

usr.bin/config/main.c

629

struct nvlist *fs;

usr.bin/config/main.c

635

fs = find_declared_fs_option(name);

usr.bin/config/main.c

636

if (fs != NULL) {

usr.bin/config/main.c

637

do_depends(fs->nv_ptr);

usr.bin/config/main.c

941

struct nvlist *fs;

usr.bin/config/main.c

943

if ((fs = nvhash_lookup(deffstab, name)) != NULL) {

usr.bin/config/main.c

944

return fs;

usr.bin/config/main.c

958

struct nvlist *fs;

usr.bin/config/main.c

965

if ((fs = nvhash_lookup(deffstab, name)) != NULL) {

usr.bin/config/main.c

966

return &fs->nv_where;

usr.bin/hexdump/display.c

71

FS *fs;

usr.bin/hexdump/display.c

81

for (fs = fshead, savebp = bp, saveaddress = address; fs;

usr.bin/hexdump/display.c

82

fs = fs->nextfs, bp = savebp, address = saveaddress)

usr.bin/hexdump/display.c

83

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

166

size(FS *fs)

usr.bin/hexdump/parse.c

174

for (cursize = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

219

rewrite(FS *fs)

usr.bin/hexdump/parse.c

229

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

452

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/hexdump/parse.c

453

if (!fu->nextfu && fs->bcnt < blocksize &&

usr.bin/hexdump/parse.c

455

fu->reps += (blocksize - fs->bcnt) / fu->bcnt;

usr.bin/hexdump/parse.c

469

for (fu = fs->nextfu; fu; fu = fu->nextfu) {

usr.bin/make/meta.c

817

struct stat fs;

usr.bin/make/meta.c

829

if (fstat(fileno(fp), &fs) == 0) {

usr.bin/make/meta.c

833

newsz = ROUNDUP(((size_t)fs.st_size / 2), BUFSIZ);

usr.bin/make/meta.c

835

newsz = ROUNDUP((size_t)fs.st_size, BUFSIZ);

usr.bin/quota/quotautil.c

103

(void)snprintf(buf, len, "%s/%s.%s", fs->fs_file, qfname,

usr.bin/quota/quotautil.c

74

hasquota(char *buf, size_t len, struct fstab *fs, int type)

usr.bin/quota/quotautil.c

88

strlcpy(optbuf, fs->fs_mntops, sizeof(optbuf));

usr.bin/xlint/lint1/decl.c

186

dcs_add_function_specifier(function_specifier fs)

usr.bin/xlint/lint1/decl.c

188

if (fs == FS_INLINE) {

usr.bin/xlint/lint1/decl.c

194

if (fs == FS_NORETURN)

usr.sbin/dumpfs/dumpfs.c

114

static int print_superblock(struct fs *, uint16_t *, const char *, int, off_t);

usr.sbin/dumpfs/dumpfs.c

128

static void fix_superblock(struct fs *, uint16_t *);

usr.sbin/dumpfs/dumpfs.c

255

fix_superblock(struct fs *fs, uint16_t *opostbl)

usr.sbin/dumpfs/dumpfs.c

258

(((int32_t)bswap32(fs->fs_old_postblformat) == FS_42POSTBLFMT) ||

usr.sbin/dumpfs/dumpfs.c

259

(bswap32(fs->fs_old_postbloff) == offsetof(struct fs, fs_old_postbl_start)))) {

usr.sbin/dumpfs/dumpfs.c

261

memcpy(opostbl, &fs->fs_old_postbl_start, 512);

usr.sbin/dumpfs/dumpfs.c

265

((fs->fs_old_postblformat == FS_42POSTBLFMT) ||

usr.sbin/dumpfs/dumpfs.c

266

(fs->fs_old_postbloff == offsetof(struct fs, fs_old_postbl_start)))) {

usr.sbin/dumpfs/dumpfs.c

267

memcpy(opostbl, &fs->fs_old_postbl_start, 512);

usr.sbin/dumpfs/dumpfs.c

271

ffs_sb_swap(fs, fs);

usr.sbin/dumpfs/dumpfs.c

273

printold = (fs->fs_magic == FS_UFS1_MAGIC &&

usr.sbin/dumpfs/dumpfs.c

274

(fs->fs_old_flags & FS_FLAGS_UPDATED) == 0);

usr.sbin/dumpfs/dumpfs.c

276

fs->fs_sblockloc = SBLOCK_UFS1;

usr.sbin/dumpfs/dumpfs.c

277

fs->fs_flags = fs->fs_old_flags;

usr.sbin/dumpfs/dumpfs.c

278

fs->fs_maxbsize = fs->fs_bsize;

usr.sbin/dumpfs/dumpfs.c

279

fs->fs_time = fs->fs_old_time;

usr.sbin/dumpfs/dumpfs.c

280

fs->fs_size = fs->fs_old_size;

usr.sbin/dumpfs/dumpfs.c

281

fs->fs_dsize = fs->fs_old_dsize;

usr.sbin/dumpfs/dumpfs.c

282

fs->fs_csaddr = fs->fs_old_csaddr;

usr.sbin/dumpfs/dumpfs.c

283

fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;

usr.sbin/dumpfs/dumpfs.c

284

fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;

usr.sbin/dumpfs/dumpfs.c

285

fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;

usr.sbin/dumpfs/dumpfs.c

286

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

usr.sbin/dumpfs/dumpfs.c

289

if (printold && fs->fs_old_postblformat == FS_42POSTBLFMT)

usr.sbin/dumpfs/dumpfs.c

290

fs->fs_old_nrpos = 8;

usr.sbin/dumpfs/dumpfs.c

294

print_superblock(struct fs *fs, uint16_t *opostbl,

usr.sbin/dumpfs/dumpfs.c

302

fs->fs_magic == FS_UFS2EA_MAGIC ? "ea" : "");

usr.sbin/dumpfs/dumpfs.c

311

t = fs->fs_time;

usr.sbin/dumpfs/dumpfs.c

316

fs->fs_magic, ctime(&t));

usr.sbin/dumpfs/dumpfs.c

322

if (fs->fs_old_postblformat != FS_42POSTBLFMT) {

usr.sbin/dumpfs/dumpfs.c

324

if (fs->fs_old_inodefmt >= FS_44INODEFMT) {

usr.sbin/dumpfs/dumpfs.c

328

max = fs->fs_maxcontig;

usr.sbin/dumpfs/dumpfs.c

329

size = fs->fs_contigsumsize;

usr.sbin/dumpfs/dumpfs.c

334

if (fs->fs_old_flags & FS_FLAGS_UPDATED) {

usr.sbin/dumpfs/dumpfs.c

339

if (!printold || fs->fs_sblockloc != SBLOCK_UFS1 ||

usr.sbin/dumpfs/dumpfs.c

340

fs->fs_id[0] || fs->fs_id[1])

usr.sbin/dumpfs/dumpfs.c

342

(intmax_t)fs->fs_sblockloc, fs->fs_id[0], fs->fs_id[1]);

usr.sbin/dumpfs/dumpfs.c

349

(long long)fs->fs_cstotal.cs_nbfree,

usr.sbin/dumpfs/dumpfs.c

350

(long long)fs->fs_cstotal.cs_ndir,

usr.sbin/dumpfs/dumpfs.c

351

(long long)fs->fs_cstotal.cs_nifree,

usr.sbin/dumpfs/dumpfs.c

352

(long long)fs->fs_cstotal.cs_nffree);

usr.sbin/dumpfs/dumpfs.c

355

fs->fs_ncg, fs->fs_old_ncyl, (long long)fs->fs_size, (long long)fs->fs_dsize);

usr.sbin/dumpfs/dumpfs.c

358

fs->fs_ncg, (long long)fs->fs_size, (long long)fs->fs_dsize);

usr.sbin/dumpfs/dumpfs.c

360

fs->fs_bsize, fs->fs_bshift, fs->fs_bmask);

usr.sbin/dumpfs/dumpfs.c

362

fs->fs_fsize, fs->fs_fshift, fs->fs_fmask);

usr.sbin/dumpfs/dumpfs.c

364

fs->fs_frag, fs->fs_fragshift, fs->fs_fsbtodb);

usr.sbin/dumpfs/dumpfs.c

366

printf("cpg\t%d\t", fs->fs_old_cpg);

usr.sbin/dumpfs/dumpfs.c

368

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

usr.sbin/dumpfs/dumpfs.c

370

fs->fs_minfree, fs->fs_optim == FS_OPTSPACE ? "space" : "time",

usr.sbin/dumpfs/dumpfs.c

371

fs->fs_maxcontig, fs->fs_maxbpg);

usr.sbin/dumpfs/dumpfs.c

374

fs->fs_old_rotdelay, fs->fs_old_headswitch,

usr.sbin/dumpfs/dumpfs.c

375

fs->fs_old_trkseek, fs->fs_old_rps);

usr.sbin/dumpfs/dumpfs.c

377

fs->fs_spare2, fs->fs_old_nsect, fs->fs_old_npsect,

usr.sbin/dumpfs/dumpfs.c

378

fs->fs_old_spc);

usr.sbin/dumpfs/dumpfs.c

380

printf("symlinklen %d\t", fs->fs_maxsymlinklen);

usr.sbin/dumpfs/dumpfs.c

383

fs->fs_old_trackskew, fs->fs_old_interleave);

usr.sbin/dumpfs/dumpfs.c

384

printf("contigsumsize %d\n", fs->fs_contigsumsize);

usr.sbin/dumpfs/dumpfs.c

386

(unsigned long long)fs->fs_maxfilesize);

usr.sbin/dumpfs/dumpfs.c

388

printf("nindir\t%d\tinopb\t%d\tnspf\t%d\n", fs->fs_nindir,

usr.sbin/dumpfs/dumpfs.c

389

fs->fs_inopb, fs->fs_old_nspf);

usr.sbin/dumpfs/dumpfs.c

391

printf("nindir\t%d\tinopb\t%d\n", fs->fs_nindir, fs->fs_inopb);

usr.sbin/dumpfs/dumpfs.c

392

if (!printold || (fs->fs_avgfilesize > 0) || (fs->fs_avgfpdir > 0))

usr.sbin/dumpfs/dumpfs.c

394

fs->fs_avgfilesize, fs->fs_avgfpdir);

usr.sbin/dumpfs/dumpfs.c

396

fs->fs_sblkno, fs->fs_cblkno, fs->fs_iblkno, fs->fs_dblkno);

usr.sbin/dumpfs/dumpfs.c

397

printf("sbsize\t%d\tcgsize\t%d", fs->fs_sbsize, fs->fs_cgsize);

usr.sbin/dumpfs/dumpfs.c

400

fs->fs_old_cgoffset, fs->fs_old_cgmask);

usr.sbin/dumpfs/dumpfs.c

402

(long long)fs->fs_csaddr, fs->fs_cssize);

usr.sbin/dumpfs/dumpfs.c

405

fs->fs_old_csshift, fs->fs_old_csmask);

usr.sbin/dumpfs/dumpfs.c

407

fs->fs_cgrotor, fs->fs_fmod, fs->fs_ronly, fs->fs_clean);

usr.sbin/dumpfs/dumpfs.c

409

fs->fs_journal_version, fs->fs_journal_location,

usr.sbin/dumpfs/dumpfs.c

410

fs->fs_journal_flags);

usr.sbin/dumpfs/dumpfs.c

412

fs->fs_journallocs[0], fs->fs_journallocs[1]);

usr.sbin/dumpfs/dumpfs.c

414

fs->fs_journallocs[2], fs->fs_journallocs[3]);

usr.sbin/dumpfs/dumpfs.c

417

printf(" %u", fs->fs_snapinum[s]);

usr.sbin/dumpfs/dumpfs.c

421

fs->fs_quotafile[USRQUOTA], fs->fs_quotafile[GRPQUOTA]);

usr.sbin/dumpfs/dumpfs.c

423

if (fs->fs_flags == 0)

usr.sbin/dumpfs/dumpfs.c

425

if (fs->fs_flags & FS_UNCLEAN)

usr.sbin/dumpfs/dumpfs.c

427

if (fs->fs_flags & FS_DOSOFTDEP)

usr.sbin/dumpfs/dumpfs.c

429

if (fs->fs_flags & FS_NEEDSFSCK)

usr.sbin/dumpfs/dumpfs.c

431

if (fs->fs_flags & FS_SUJ)

usr.sbin/dumpfs/dumpfs.c

433

if (fs->fs_flags & FS_POSIX1EACLS)

usr.sbin/dumpfs/dumpfs.c

435

if (fs->fs_flags & FS_NFS4ACLS)

usr.sbin/dumpfs/dumpfs.c

437

if (fs->fs_flags & FS_MULTILABEL)

usr.sbin/dumpfs/dumpfs.c

439

if (fs->fs_flags & FS_GJOURNAL)

usr.sbin/dumpfs/dumpfs.c

441

if (fs->fs_flags & FS_FLAGS_UPDATED)

usr.sbin/dumpfs/dumpfs.c

443

if (fs->fs_flags & FS_DOWAPBL)

usr.sbin/dumpfs/dumpfs.c

445

if (fs->fs_flags & FS_DOQUOTA2)

usr.sbin/dumpfs/dumpfs.c

447

if (fs->fs_flags & FS_TRIM)

usr.sbin/dumpfs/dumpfs.c

449

fsflags = fs->fs_flags & ~(FS_UNCLEAN | FS_DOSOFTDEP | FS_NEEDSFSCK |

usr.sbin/dumpfs/dumpfs.c

454

if (fs->fs_flags & FS_INDEXDIRS)

usr.sbin/dumpfs/dumpfs.c

460

printf("\nfsmnt\t%s\n", fs->fs_fsmnt);

usr.sbin/dumpfs/dumpfs.c

463

fs->fs_volname, (uintmax_t)fs->fs_swuid);

usr.sbin/dumpfs/dumpfs.c

467

if (fs->fs_old_cpc != 0)

usr.sbin/dumpfs/dumpfs.c

469

"positions\n", fs->fs_old_nrpos);

usr.sbin/dumpfs/dumpfs.c

477

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

usr.sbin/dumpfs/dumpfs.c

479

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

usr.sbin/dumpfs/dumpfs.c

558

fix_superblock(&alt.fs, alt_opostblsave);

usr.sbin/dumpfs/dumpfs.c

559

if (print_superblock(&alt.fs, alt_opostblsave, name, fd, loc)) {

usr.sbin/dumpfs/dumpfs.c

73

struct fs fs;

usr.sbin/dumpfs/dumpfs.c

76

#define afs fsun.fs

usr.sbin/dumplfs/dumplfs.c

115

t = (lfs_sb_getversion(fs) == 1 ? sp->su_olastmod : sp->su_lastmod);

usr.sbin/dumplfs/dumplfs.c

153

identify(struct lfs *fs)

usr.sbin/dumplfs/dumplfs.c

157

magic = fs->lfs_dlfs_u.u_32.dlfs_magic;

usr.sbin/dumplfs/dumplfs.c

160

fs->lfs_is64 = false;

usr.sbin/dumplfs/dumplfs.c

161

fs->lfs_dobyteswap = false;

usr.sbin/dumplfs/dumplfs.c

164

fs->lfs_is64 = false;

usr.sbin/dumplfs/dumplfs.c

165

fs->lfs_dobyteswap = true;

usr.sbin/dumplfs/dumplfs.c

168

fs->lfs_is64 = true;

usr.sbin/dumplfs/dumplfs.c

169

fs->lfs_dobyteswap = false;

usr.sbin/dumplfs/dumplfs.c

172

fs->lfs_is64 = true;

usr.sbin/dumplfs/dumplfs.c

173

fs->lfs_dobyteswap = true;

usr.sbin/dumplfs/dumplfs.c

178

fs->lfs_is64 = false;

usr.sbin/dumplfs/dumplfs.c

179

fs->lfs_dobyteswap = false;

usr.sbin/dumplfs/dumplfs.c

184

#define fsbtobyte(fs, b) lfs_fsbtob((fs), (off_t)((b)))

usr.sbin/dumplfs/dumplfs.c

554

dump_dinode(struct lfs *fs, union lfs_dinode *dip)

usr.sbin/dumplfs/dumplfs.c

559

at = lfs_dino_getatime(fs, dip);

usr.sbin/dumplfs/dumplfs.c

560

mt = lfs_dino_getmtime(fs, dip);

usr.sbin/dumplfs/dumplfs.c

561

ct = lfs_dino_getctime(fs, dip);

usr.sbin/dumplfs/dumplfs.c

564

"mode ", lfs_dino_getmode(fs, dip),

usr.sbin/dumplfs/dumplfs.c

565

"nlink ", lfs_dino_getnlink(fs, dip),

usr.sbin/dumplfs/dumplfs.c

566

"uid ", lfs_dino_getuid(fs, dip),

usr.sbin/dumplfs/dumplfs.c

567

"gid ", lfs_dino_getgid(fs, dip),

usr.sbin/dumplfs/dumplfs.c

568

"size ", (uintmax_t)lfs_dino_getsize(fs, dip));

usr.sbin/dumplfs/dumplfs.c

573

(uintmax_t)lfs_dino_getinumber(fs, dip),

usr.sbin/dumplfs/dumplfs.c

574

(uintmax_t)lfs_dino_getblocks(fs, dip));

usr.sbin/dumplfs/dumplfs.c

577

(void)printf("\t0x%jx", (intmax_t)lfs_dino_getdb(fs, dip, i));

usr.sbin/dumplfs/dumplfs.c

583

(void)printf("\t0x%jx", (intmax_t)lfs_dino_getib(fs, dip, i));

usr.sbin/dumplfs/dumplfs.c

95

print_suentry(int i, SEGUSE *sp, struct lfs *fs)

usr.sbin/edquota/edquota.c

1117

replicate(const char *fs, int idtype, const char *protoname,

usr.sbin/edquota/edquota.c

1127

protoprivs = getprivs(protoid, 0, idtype, fs);

usr.sbin/edquota/edquota.c

1145

assign(const char *fs, int idtype,

usr.sbin/edquota/edquota.c

1199

curprivs = getprivs(id, dflag, idtype, fs);

usr.sbin/edquota/edquota.c

1235

clear(const char *fs, int idtype, char **names, int numnames)

usr.sbin/edquota/edquota.c

1237

clearpriv(numnames, names, fs, idtype);

usr.sbin/edquota/edquota.c

1241

editone(const char *fs, int idtype, const char *name,

usr.sbin/edquota/edquota.c

1257

curprivs = getprivs(id, dflag, idtype, fs);

usr.sbin/edquota/edquota.c

1275

edit(const char *fs, int idtype, char **names, int numnames)

usr.sbin/edquota/edquota.c

1284

editone(fs, idtype, names[i], tmpfd, tmppath);

usr.sbin/edquota/edquota.c

1319

char *fs = NULL;

usr.sbin/edquota/edquota.c

1362

fs = optarg;

usr.sbin/edquota/edquota.c

1374

replicate(fs, idtype, protoname, argv, argc);

usr.sbin/edquota/edquota.c

1382

assign(fs, idtype, soft, hard, grace, argv, argc);

usr.sbin/edquota/edquota.c

1386

clear(fs, idtype, argv, argc);

usr.sbin/edquota/edquota.c

1392

edit(fs, idtype, argv, argc);

usr.sbin/edquota/edquota.c

331

struct fstab *fs;

usr.sbin/edquota/edquota.c

339

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

usr.sbin/edquota/edquota.c

340

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

usr.sbin/edquota/edquota.c

342

fsspec = getfsspecname(xbuf, sizeof(xbuf), fs->fs_spec);

usr.sbin/edquota/edquota.c

348

strcmp(fs->fs_file, filesys) == 0)

usr.sbin/edquota/edquota.c

351

if (fs == NULL)

usr.sbin/edquota/edquota.c

354

if (!hasquota(qfpathname, sizeof(qfpathname), fs,

usr.sbin/edquota/edquota.c

359

strcpy(qup->fsname, fs->fs_file);

usr.sbin/fstyp/ext2fs.c

63

e2sb_t *fs;

usr.sbin/fstyp/ext2fs.c

66

fs = read_buf(fp, EXT2FS_SB_OFFSET, 512);

usr.sbin/fstyp/ext2fs.c

67

if (fs == NULL)

usr.sbin/fstyp/ext2fs.c

71

if (fs->s_magic == EXT2_SUPER_MAGIC &&

usr.sbin/fstyp/ext2fs.c

72

fs->s_rev_level == EXT2_DYNAMIC_REV) {

usr.sbin/fstyp/ext2fs.c

76

free(fs);

usr.sbin/fstyp/ext2fs.c

80

s_volume_name = fs->s_volume_name;

usr.sbin/fstyp/ext2fs.c

82

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

usr.sbin/fstyp/ext2fs.c

88

free(fs);

usr.sbin/fstyp/ufs.c

102

free(fs);

usr.sbin/fstyp/ufs.c

107

if (fs->fs_sblockloc != superblock || fs->fs_ncg < 1 ||

usr.sbin/fstyp/ufs.c

108

fs->fs_bsize < MINBSIZE ||

usr.sbin/fstyp/ufs.c

109

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

usr.sbin/fstyp/ufs.c

110

free(fs);

usr.sbin/fstyp/ufs.c

114

strlcpy(label, (char*)fs->fs_volname, labelsize);

usr.sbin/fstyp/ufs.c

116

free(fs);

usr.sbin/fstyp/ufs.c

57

struct fs *fs;

usr.sbin/fstyp/ufs.c

67

fs = (struct fs *)read_buf(fp, superblock, SBLOCKSIZE);

usr.sbin/fstyp/ufs.c

68

if (fs == NULL)

usr.sbin/fstyp/ufs.c

71

if (fs->fs_magic == FS_UFS2EA_MAGIC)

usr.sbin/fstyp/ufs.c

72

fs->fs_magic = FS_UFS2_MAGIC;

usr.sbin/fstyp/ufs.c

73

else if (fs->fs_magic == FS_UFS2EA_MAGIC_SWAPPED)

usr.sbin/fstyp/ufs.c

74

fs->fs_magic = FS_UFS2_MAGIC_SWAPPED;

usr.sbin/fstyp/ufs.c

84

if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_fsize > 0 &&

usr.sbin/fstyp/ufs.c

85

((pp->mediasize / fs->fs_fsize == fs->fs_old_size) ||

usr.sbin/fstyp/ufs.c

86

(pp->mediasize / fs->fs_fsize == fs->fs_providersize))) {

usr.sbin/fstyp/ufs.c

88

} else if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_fsize > 0 &&

usr.sbin/fstyp/ufs.c

89

((pp->mediasize / fs->fs_fsize == fs->fs_size) ||

usr.sbin/fstyp/ufs.c

90

(pp->mediasize / fs->fs_fsize == fs->fs_providersize))) {

usr.sbin/fstyp/ufs.c

93

g_free(fs);

usr.sbin/fstyp/ufs.c

97

if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_fsize > 0) {

usr.sbin/fstyp/ufs.c

99

} else if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_fsize > 0) {

usr.sbin/fwctl/fwdv.c

201

lsystem = ciph->fdf.dv.fs;

usr.sbin/installboot/ext2fs.c

126

ext2fs_read_sblock(ib_params *params, struct m_ext2fs *fs)

usr.sbin/installboot/ext2fs.c

133

e2fs_sbload((void *)sbbuf, &fs->e2fs);

usr.sbin/installboot/ext2fs.c

135

if (fs->e2fs.e2fs_magic != E2FS_MAGIC)

usr.sbin/installboot/ext2fs.c

138

if (fs->e2fs.e2fs_rev > E2FS_REV1 ||

usr.sbin/installboot/ext2fs.c

139

(fs->e2fs.e2fs_rev == E2FS_REV1 &&

usr.sbin/installboot/ext2fs.c

140

(fs->e2fs.e2fs_first_ino != EXT2_FIRSTINO ||

usr.sbin/installboot/ext2fs.c

141

fs->e2fs.e2fs_inode_size != EXT2_DINODE_SIZE ||

usr.sbin/installboot/ext2fs.c

142

(fs->e2fs.e2fs_features_incompat & ~EXT2F_INCOMPAT_SUPP) != 0)))

usr.sbin/installboot/ext2fs.c

145

fs->e2fs_ncg =

usr.sbin/installboot/ext2fs.c

146

howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,

usr.sbin/installboot/ext2fs.c

147

fs->e2fs.e2fs_bpg);

usr.sbin/installboot/ext2fs.c

149

fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + 1;

usr.sbin/installboot/ext2fs.c

150

fs->e2fs_bsize = MINBSIZE << fs->e2fs.e2fs_log_bsize;

usr.sbin/installboot/ext2fs.c

151

fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize;

usr.sbin/installboot/ext2fs.c

152

fs->e2fs_qbmask = fs->e2fs_bsize - 1;

usr.sbin/installboot/ext2fs.c

153

fs->e2fs_bmask = ~fs->e2fs_qbmask;

usr.sbin/installboot/ext2fs.c

154

fs->e2fs_ngdb =

usr.sbin/installboot/ext2fs.c

155

howmany(fs->e2fs_ncg, fs->e2fs_bsize / sizeof(struct ext2_gd));

usr.sbin/installboot/ext2fs.c

156

fs->e2fs_ipb = fs->e2fs_bsize / EXT2_DINODE_SIZE;

usr.sbin/installboot/ext2fs.c

157

fs->e2fs_itpg = fs->e2fs.e2fs_ipg / fs->e2fs_ipb;

usr.sbin/installboot/ext2fs.c

163

ext2fs_read_gdblock(ib_params *params, struct m_ext2fs *fs)

usr.sbin/installboot/ext2fs.c

169

gdpb = fs->e2fs_bsize / sizeof(struct ext2_gd);

usr.sbin/installboot/ext2fs.c

171

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

usr.sbin/installboot/ext2fs.c

172

if (ext2fs_read_disk_block(params, EXT2_FSBTODB(fs,

usr.sbin/installboot/ext2fs.c

173

fs->e2fs.e2fs_first_dblock + 1 /* superblock */ + i),

usr.sbin/installboot/ext2fs.c

177

e2fs_cgload((struct ext2_gd *)gdbuf, &fs->e2fs_gd[gdpb * i],

usr.sbin/installboot/ext2fs.c

178

(i == (fs->e2fs_ngdb - 1)) ?

usr.sbin/installboot/ext2fs.c

179

(fs->e2fs_ncg - gdpb * i) * sizeof(struct ext2_gd):

usr.sbin/installboot/ext2fs.c

180

fs->e2fs_bsize);

usr.sbin/installboot/ext2fs.c

197

struct m_ext2fs *fs;

usr.sbin/installboot/ext2fs.c

216

fs = (void *)sbbuf;

usr.sbin/installboot/ext2fs.c

217

if (ext2fs_read_sblock(params, fs) == 0)

usr.sbin/installboot/ext2fs.c

220

fs->e2fs_gd = malloc(sizeof(struct ext2_gd) * fs->e2fs_ncg);

usr.sbin/installboot/ext2fs.c

221

if (fs->e2fs_gd == NULL) {

usr.sbin/installboot/ext2fs.c

226

if (ext2fs_read_gdblock(params, fs) == 0) {

usr.sbin/installboot/ext2fs.c

231

if (fs->e2fs_ipb <= 0) {

usr.sbin/installboot/ext2fs.c

233

fs->e2fs_ipb, params->filesystem);

usr.sbin/installboot/ext2fs.c

239

EXT2_FSBTODB(fs, ino_to_fsba(fs, ino)) + params->fstype->offset,

usr.sbin/installboot/ext2fs.c

240

fs->e2fs_bsize, inodebuf))

usr.sbin/installboot/ext2fs.c

243

e2fs_iload(&inode[ino_to_fsbo(fs, ino)], &inode_store);

usr.sbin/installboot/ext2fs.c

247

nblk = howmany(inode->e2di_size, fs->e2fs_bsize);

usr.sbin/installboot/ext2fs.c

291

EXT2_FSBTODB(fs, blk) + params->fstype->offset,

usr.sbin/installboot/ext2fs.c

292

fs->e2fs_bsize, level[level_i].diskbuf) == 0)

usr.sbin/installboot/ext2fs.c

297

level[level_i].blkcount = EXT2_NINDIR(fs);

usr.sbin/installboot/ext2fs.c

304

EXT2_FSBTODB(fs, blk), ext2_sblksize(fs, inode->di_size, lblk));

usr.sbin/installboot/ext2fs.c

307

EXT2_FSBTODB(fs, blk) + params->fstype->offset, fs->e2fs_bsize);

usr.sbin/installboot/ext2fs.c

403

struct m_ext2fs *fs;

usr.sbin/installboot/ext2fs.c

409

fs = (void *)sbbuf;

usr.sbin/installboot/ext2fs.c

410

if (ext2fs_read_sblock(params, fs) == 0)

usr.sbin/installboot/ext2fs.c

414

params->fstype->blocksize = fs->e2fs_bsize;

usr.sbin/installboot/ext2fs.c

88

static int ext2fs_read_sblock(ib_params *, struct m_ext2fs *fs);

usr.sbin/installboot/ext2fs.c

89

static int ext2fs_read_gdblock(ib_params *, struct m_ext2fs *fs);

usr.sbin/installboot/ffs.c

125

struct fs *fs;

usr.sbin/installboot/ffs.c

147

fs = (struct fs *)sbbuf;

usr.sbin/installboot/ffs.c

150

ffs_sb_swap(fs, fs);

usr.sbin/installboot/ffs.c

153

if (fs->fs_inopb <= 0) {

usr.sbin/installboot/ffs.c

155

fs->fs_inopb, params->filesystem);

usr.sbin/installboot/ffs.c

161

FFS_FSBTODB(fs, ino_to_fsba(fs, ino)) + params->fstype->offset,

usr.sbin/installboot/ffs.c

162

fs->fs_bsize, inodebuf))

usr.sbin/installboot/ffs.c

165

inode += ino_to_fsbo(fs, ino);

usr.sbin/installboot/ffs.c

172

nblk = howmany(inode->di_size, fs->fs_bsize);

usr.sbin/installboot/ffs.c

218

FFS_FSBTODB(fs, blk) + params->fstype->offset,

usr.sbin/installboot/ffs.c

219

fs->fs_bsize, level[level_i].diskbuf))

usr.sbin/installboot/ffs.c

224

level[level_i].blkcount = FFS_NINDIR(fs);

usr.sbin/installboot/ffs.c

231

FFS_FSBTODB(fs, blk), ffs_sblksize(fs, inode->di_size, lblk));

usr.sbin/installboot/ffs.c

234

FFS_FSBTODB(fs, blk) + params->fstype->offset,

usr.sbin/installboot/ffs.c

235

ffs_sblksize(fs, (int64_t)inode->di_size, lblk));

usr.sbin/installboot/ffs.c

262

struct fs *fs;

usr.sbin/installboot/ffs.c

284

fs = (struct fs *)sbbuf;

usr.sbin/installboot/ffs.c

287

ffs_sb_swap(fs, fs);

usr.sbin/installboot/ffs.c

290

if (fs->fs_inopb <= 0) {

usr.sbin/installboot/ffs.c

292

fs->fs_inopb, params->filesystem);

usr.sbin/installboot/ffs.c

298

FFS_FSBTODB(fs, ino_to_fsba(fs, ino)) + params->fstype->offset,

usr.sbin/installboot/ffs.c

299

fs->fs_bsize, inodebuf))

usr.sbin/installboot/ffs.c

302

inode += ino_to_fsbo(fs, ino);

usr.sbin/installboot/ffs.c

309

nblk = howmany(inode->di_size, fs->fs_bsize);

usr.sbin/installboot/ffs.c

355

FFS_FSBTODB(fs, blk) + params->fstype->offset,

usr.sbin/installboot/ffs.c

356

fs->fs_bsize, level[level_i].diskbuf))

usr.sbin/installboot/ffs.c

360

level[level_i].blkcount = FFS_NINDIR(fs);

usr.sbin/installboot/ffs.c

367

FFS_FSBTODB(fs, blk), ffs_sblksize(fs, inode->di_size, lblk));

usr.sbin/installboot/ffs.c

370

FFS_FSBTODB(fs, blk) + params->fstype->offset,

usr.sbin/installboot/ffs.c

371

ffs_sblksize(fs, (int64_t)inode->di_size, lblk));

usr.sbin/installboot/ffs.c

491

struct fs *fs;

usr.sbin/installboot/ffs.c

498

fs = (struct fs *)sbbuf;

usr.sbin/installboot/ffs.c

503

switch (fs->fs_magic) {

usr.sbin/installboot/ffs.c

510

params->fstype->blocksize = fs->fs_bsize;

usr.sbin/installboot/ffs.c

521

params->fstype->blocksize = bswap32(fs->fs_bsize);

usr.sbin/ldpd/conffile.c

120

struct stat fs;

usr.sbin/ldpd/conffile.c

128

if (confh == -1 || fstat(confh, &fs) == -1 ||

usr.sbin/ldpd/conffile.c

129

(mapped = mmap(NULL, fs.st_size, PROT_READ, MAP_SHARED, confh, 0))

usr.sbin/ldpd/conffile.c

136

mapsize = fs.st_size;

usr.sbin/makefs/ffs.c

1099

struct fs *fs;

usr.sbin/makefs/ffs.c

1111

fs = (struct fs *)fsopts->superblock;

usr.sbin/makefs/ffs.c

1112

cg = ino_to_cg(fs, ino);

usr.sbin/makefs/ffs.c

1113

cgino = ino % fs->fs_ipg;

usr.sbin/makefs/ffs.c

1118

ffs_rdfs(FFS_FSBTODB(fs, cgtod(fs, cg)), (int)fs->fs_cgsize, &sbbuf,

usr.sbin/makefs/ffs.c

1127

buf = emalloc(fs->fs_bsize);

usr.sbin/makefs/ffs.c

1131

if (fs->fs_cstotal.cs_nifree == 0)

usr.sbin/makefs/ffs.c

1134

if (fs->fs_cs(fs, cg).cs_nifree == 0)

usr.sbin/makefs/ffs.c

1140

fs->fs_cstotal.cs_nifree--;

usr.sbin/makefs/ffs.c

1141

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

usr.sbin/makefs/ffs.c

1144

fs->fs_cstotal.cs_ndir++;

usr.sbin/makefs/ffs.c

1145

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

usr.sbin/makefs/ffs.c

1153

(uint32_t)(cgino + FFS_INOPB(fs)) > initediblk &&

usr.sbin/makefs/ffs.c

1155

memset(buf, 0, fs->fs_bsize);

usr.sbin/makefs/ffs.c

1157

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

usr.sbin/makefs/ffs.c

1161

ffs_wtfs(FFS_FSBTODB(fs, ino_to_fsba(fs,

usr.sbin/makefs/ffs.c

1162

cg * fs->fs_ipg + initediblk)),

usr.sbin/makefs/ffs.c

1163

fs->fs_bsize, buf, fsopts);

usr.sbin/makefs/ffs.c

1164

initediblk += FFS_INOPB(fs);

usr.sbin/makefs/ffs.c

1169

ffs_wtfs(FFS_FSBTODB(fs, cgtod(fs, cg)), (int)fs->fs_cgsize, &sbbuf,

usr.sbin/makefs/ffs.c

1173

d = FFS_FSBTODB(fs, ino_to_fsba(fs, ino));

usr.sbin/makefs/ffs.c

1174

ffs_rdfs(d, fs->fs_bsize, buf, fsopts);

usr.sbin/makefs/ffs.c

1178

&dp1[ino_to_fsbo(fs, ino)]);

usr.sbin/makefs/ffs.c

1181

&dp2[ino_to_fsbo(fs, ino)]);

usr.sbin/makefs/ffs.c

1184

dp1[ino_to_fsbo(fs, ino)] = dp->ffs1_din;

usr.sbin/makefs/ffs.c

1186

dp2[ino_to_fsbo(fs, ino)] = dp->ffs2_din;

usr.sbin/makefs/ffs.c

1188

ffs_wtfs(d, fs->fs_bsize, buf, fsopts);

usr.sbin/makefs/ffs.c

264

struct fs *superblock;

usr.sbin/makefs/ffs.c

445

ffs_opt_t *fs = f->fs_specific;

usr.sbin/makefs/ffs.c

461

fs->bsize, fs->fsize, fs->cpg, fs->density);

usr.sbin/makefs/ffs.c

463

fs->nsectors, fs->rpm, fs->minfree);

usr.sbin/makefs/ffs.c

465

fs->maxcontig, fs->maxbpg);

usr.sbin/makefs/ffs.c

467

fs->optimization == FS_OPTSPACE ? "space" : "time");

usr.sbin/makefs/ffs.c

477

struct fs *fs;

usr.sbin/makefs/ffs.c

554

fs = ffs_mkfs(image, fsopts, tstamp);

usr.sbin/makefs/ffs.c

555

fsopts->superblock = (void *)fs;

usr.sbin/makefs/ffs.c

559

t = (time_t)((struct fs *)fsopts->superblock)->fs_time;

usr.sbin/makefs/ffs.c

563

(long long)fs->fs_cstotal.cs_nbfree,

usr.sbin/makefs/ffs.c

564

(long long)fs->fs_cstotal.cs_nffree,

usr.sbin/makefs/ffs.c

565

(long long)fs->fs_cstotal.cs_nifree,

usr.sbin/makefs/ffs.c

566

(long long)fs->fs_cstotal.cs_ndir);

usr.sbin/makefs/ffs.c

569

if ((off_t)(fs->fs_cstotal.cs_nifree + UFS_ROOTINO) < fsopts->inodes) {

usr.sbin/makefs/ffs.c

573

(long long)(fs->fs_cstotal.cs_nifree + UFS_ROOTINO),

usr.sbin/makefs/ffs.c

901

in.i_fs = (struct fs *)fsopts->superblock;

usr.sbin/makefs/ffs/buf.c

153

fsinfo_t *fs = bp->b_fs;

usr.sbin/makefs/ffs/buf.c

156

offset = bp->b_blkno * fs->sectorsize + fs->offset;

usr.sbin/makefs/ffs/buf.c

228

bp->b_fs = vp->fs;

usr.sbin/makefs/ffs/buf.c

68

fsinfo_t *fs = vp->fs;

usr.sbin/makefs/ffs/buf.c

77

offset = (*bpp)->b_blkno * fs->sectorsize + fs->offset;

usr.sbin/makefs/ffs/buf.h

61

struct makefs_fsinfo *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

104

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

109

if (size > fs->fs_bsize || ffs_fragoff(fs, size) != 0) {

usr.sbin/makefs/ffs/ffs_alloc.c

111

fs->fs_bsize, size);

usr.sbin/makefs/ffs/ffs_alloc.c

113

if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)

usr.sbin/makefs/ffs/ffs_alloc.c

115

if (bpref >= fs->fs_size)

usr.sbin/makefs/ffs/ffs_alloc.c

118

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

usr.sbin/makefs/ffs/ffs_alloc.c

120

cg = dtog(fs, bpref);

usr.sbin/makefs/ffs/ffs_alloc.c

161

struct fs *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

165

fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

166

if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {

usr.sbin/makefs/ffs/ffs_alloc.c

167

if (lbn < UFS_NDADDR + FFS_NINDIR(fs)) {

usr.sbin/makefs/ffs/ffs_alloc.c

168

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

usr.sbin/makefs/ffs/ffs_alloc.c

169

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

177

ino_to_cg(fs, ip->i_number) + lbn / fs->fs_maxbpg;

usr.sbin/makefs/ffs/ffs_alloc.c

179

startcg = dtog(fs,

usr.sbin/makefs/ffs/ffs_alloc.c

180

ufs_rw32(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + 1);

usr.sbin/makefs/ffs/ffs_alloc.c

181

startcg %= fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

182

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

183

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

usr.sbin/makefs/ffs/ffs_alloc.c

184

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree)

usr.sbin/makefs/ffs/ffs_alloc.c

185

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

187

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree)

usr.sbin/makefs/ffs/ffs_alloc.c

188

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

194

return ufs_rw32(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + fs->fs_frag;

usr.sbin/makefs/ffs/ffs_alloc.c

200

struct fs *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

204

fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

205

if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {

usr.sbin/makefs/ffs/ffs_alloc.c

206

if (lbn < UFS_NDADDR + FFS_NINDIR(fs)) {

usr.sbin/makefs/ffs/ffs_alloc.c

207

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

usr.sbin/makefs/ffs/ffs_alloc.c

208

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

216

ino_to_cg(fs, ip->i_number) + lbn / fs->fs_maxbpg;

usr.sbin/makefs/ffs/ffs_alloc.c

218

startcg = dtog(fs,

usr.sbin/makefs/ffs/ffs_alloc.c

219

ufs_rw64(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + 1);

usr.sbin/makefs/ffs/ffs_alloc.c

220

startcg %= fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

221

avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

222

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

usr.sbin/makefs/ffs/ffs_alloc.c

223

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

usr.sbin/makefs/ffs/ffs_alloc.c

224

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

227

if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {

usr.sbin/makefs/ffs/ffs_alloc.c

228

return (fs->fs_fpg * cg + fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

235

return ufs_rw64(bap[indx - 1], UFS_FSNEEDSWAP(fs)) + fs->fs_frag;

usr.sbin/makefs/ffs/ffs_alloc.c

253

struct fs *fs;

usr.sbin/makefs/ffs/ffs_alloc.c

257

fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

267

for (i = 1; i < fs->fs_ncg; i *= 2) {

usr.sbin/makefs/ffs/ffs_alloc.c

269

if (cg >= fs->fs_ncg)

usr.sbin/makefs/ffs/ffs_alloc.c

270

cg -= fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

280

cg = (icg + 2) % fs->fs_ncg;

usr.sbin/makefs/ffs/ffs_alloc.c

281

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

usr.sbin/makefs/ffs/ffs_alloc.c

286

if (cg == fs->fs_ncg)

usr.sbin/makefs/ffs/ffs_alloc.c

305

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

306

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

308

if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)

usr.sbin/makefs/ffs/ffs_alloc.c

310

error = bread(ip->i_devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),

usr.sbin/makefs/ffs/ffs_alloc.c

311

(int)fs->fs_cgsize, 0, &bp);

usr.sbin/makefs/ffs/ffs_alloc.c

317

(cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize)) {

usr.sbin/makefs/ffs/ffs_alloc.c

321

if (size == fs->fs_bsize) {

usr.sbin/makefs/ffs/ffs_alloc.c

331

frags = ffs_numfrags(fs, size);

usr.sbin/makefs/ffs/ffs_alloc.c

332

for (allocsiz = frags; allocsiz < fs->fs_frag; allocsiz++)

usr.sbin/makefs/ffs/ffs_alloc.c

335

if (allocsiz == fs->fs_frag) {

usr.sbin/makefs/ffs/ffs_alloc.c

345

bpref = dtogd(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

346

for (i = frags; i < fs->fs_frag; i++)

usr.sbin/makefs/ffs/ffs_alloc.c

348

i = fs->fs_frag - frags;

usr.sbin/makefs/ffs/ffs_alloc.c

350

fs->fs_cstotal.cs_nffree += i;

usr.sbin/makefs/ffs/ffs_alloc.c

351

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

usr.sbin/makefs/ffs/ffs_alloc.c

352

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

357

bno = ffs_mapsearch(fs, cgp, bpref, allocsiz);

usr.sbin/makefs/ffs/ffs_alloc.c

361

fs->fs_cstotal.cs_nffree -= frags;

usr.sbin/makefs/ffs/ffs_alloc.c

362

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

usr.sbin/makefs/ffs/ffs_alloc.c

363

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

367

blkno = cg * fs->fs_fpg + bno;

usr.sbin/makefs/ffs/ffs_alloc.c

389

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

390

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

395

if (bpref == 0 || dtog(fs, bpref) != ufs_rw32(cgp->cg_cgx, needswap)) {

usr.sbin/makefs/ffs/ffs_alloc.c

398

bpref = ffs_blknum(fs, bpref);

usr.sbin/makefs/ffs/ffs_alloc.c

399

bno = dtogd(fs, bpref);

usr.sbin/makefs/ffs/ffs_alloc.c

403

if (ffs_isblock(fs, blksfree, ffs_fragstoblks(fs, bno)))

usr.sbin/makefs/ffs/ffs_alloc.c

409

bno = ffs_mapsearch(fs, cgp, bpref, (int)fs->fs_frag);

usr.sbin/makefs/ffs/ffs_alloc.c

414

blkno = ffs_fragstoblks(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

415

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

usr.sbin/makefs/ffs/ffs_alloc.c

416

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

usr.sbin/makefs/ffs/ffs_alloc.c

418

fs->fs_cstotal.cs_nbfree--;

usr.sbin/makefs/ffs/ffs_alloc.c

419

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

usr.sbin/makefs/ffs/ffs_alloc.c

420

if ((fs->fs_magic == FS_UFS1_MAGIC) &&

usr.sbin/makefs/ffs/ffs_alloc.c

421

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

usr.sbin/makefs/ffs/ffs_alloc.c

423

cylno = old_cbtocylno(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

424

ufs_add16(old_cg_blks(fs, cgp, cylno,

usr.sbin/makefs/ffs/ffs_alloc.c

425

needswap)[old_cbtorpos(fs, bno)], -1, needswap);

usr.sbin/makefs/ffs/ffs_alloc.c

428

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

429

blkno = ufs_rw32(cgp->cg_cgx, needswap) * fs->fs_fpg + bno;

usr.sbin/makefs/ffs/ffs_alloc.c

447

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_alloc.c

448

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

450

if (size > fs->fs_bsize || ffs_fragoff(fs, size) != 0 ||

usr.sbin/makefs/ffs/ffs_alloc.c

451

ffs_fragnum(fs, bno) + ffs_numfrags(fs, size) > fs->fs_frag) {

usr.sbin/makefs/ffs/ffs_alloc.c

453

"size %ld", __func__, (long long)bno, fs->fs_bsize, size);

usr.sbin/makefs/ffs/ffs_alloc.c

455

cg = dtog(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

456

if (bno >= fs->fs_size) {

usr.sbin/makefs/ffs/ffs_alloc.c

461

error = bread(ip->i_devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),

usr.sbin/makefs/ffs/ffs_alloc.c

462

(int)fs->fs_cgsize, 0, &bp);

usr.sbin/makefs/ffs/ffs_alloc.c

471

cgbno = dtogd(fs, bno);

usr.sbin/makefs/ffs/ffs_alloc.c

472

if (size == fs->fs_bsize) {

usr.sbin/makefs/ffs/ffs_alloc.c

473

fragno = ffs_fragstoblks(fs, cgbno);

usr.sbin/makefs/ffs/ffs_alloc.c

474

if (!ffs_isfreeblock(fs, cg_blksfree(cgp, needswap), fragno)) {

usr.sbin/makefs/ffs/ffs_alloc.c

478

ffs_setblock(fs, cg_blksfree(cgp, needswap), fragno);

usr.sbin/makefs/ffs/ffs_alloc.c

479

ffs_clusteracct(fs, cgp, fragno, 1);

usr.sbin/makefs/ffs/ffs_alloc.c

481

fs->fs_cstotal.cs_nbfree++;

usr.sbin/makefs/ffs/ffs_alloc.c

482

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

usr.sbin/makefs/ffs/ffs_alloc.c

483

if ((fs->fs_magic == FS_UFS1_MAGIC) &&

usr.sbin/makefs/ffs/ffs_alloc.c

484

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

usr.sbin/makefs/ffs/ffs_alloc.c

485

i = old_cbtocylno(fs, cgbno);

usr.sbin/makefs/ffs/ffs_alloc.c

486

ufs_add16(old_cg_blks(fs, cgp, i,

usr.sbin/makefs/ffs/ffs_alloc.c

487

needswap)[old_cbtorpos(fs, cgbno)], 1, needswap);

usr.sbin/makefs/ffs/ffs_alloc.c

491

bbase = cgbno - ffs_fragnum(fs, cgbno);

usr.sbin/makefs/ffs/ffs_alloc.c

495

blk = blkmap(fs, cg_blksfree(cgp, needswap), bbase);

usr.sbin/makefs/ffs/ffs_alloc.c

496

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

usr.sbin/makefs/ffs/ffs_alloc.c

500

frags = ffs_numfrags(fs, size);

usr.sbin/makefs/ffs/ffs_alloc.c

510

fs->fs_cstotal.cs_nffree += i;

usr.sbin/makefs/ffs/ffs_alloc.c

511

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

usr.sbin/makefs/ffs/ffs_alloc.c

515

blk = blkmap(fs, cg_blksfree(cgp, needswap), bbase);

usr.sbin/makefs/ffs/ffs_alloc.c

516

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

usr.sbin/makefs/ffs/ffs_alloc.c

520

fragno = ffs_fragstoblks(fs, bbase);

usr.sbin/makefs/ffs/ffs_alloc.c

521

if (ffs_isblock(fs, cg_blksfree(cgp, needswap), fragno)) {

usr.sbin/makefs/ffs/ffs_alloc.c

522

ufs_add32(cgp->cg_cs.cs_nffree, -fs->fs_frag, needswap);

usr.sbin/makefs/ffs/ffs_alloc.c

523

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

usr.sbin/makefs/ffs/ffs_alloc.c

524

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

usr.sbin/makefs/ffs/ffs_alloc.c

525

ffs_clusteracct(fs, cgp, fragno, 1);

usr.sbin/makefs/ffs/ffs_alloc.c

527

fs->fs_cstotal.cs_nbfree++;

usr.sbin/makefs/ffs/ffs_alloc.c

528

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

usr.sbin/makefs/ffs/ffs_alloc.c

529

if ((fs->fs_magic == FS_UFS1_MAGIC) &&

usr.sbin/makefs/ffs/ffs_alloc.c

530

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

usr.sbin/makefs/ffs/ffs_alloc.c

531

i = old_cbtocylno(fs, bbase);

usr.sbin/makefs/ffs/ffs_alloc.c

532

ufs_add16(old_cg_blks(fs, cgp, i,

usr.sbin/makefs/ffs/ffs_alloc.c

533

needswap)[old_cbtorpos(fs, bbase)], 1,

usr.sbin/makefs/ffs/ffs_alloc.c

540

fs->fs_fmod = 1;

usr.sbin/makefs/ffs/ffs_alloc.c

562

ffs_mapsearch(struct fs *fs, struct cg *cgp, daddr_t bpref, int allocsiz)

usr.sbin/makefs/ffs/ffs_alloc.c

568

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_alloc.c

575

start = dtogd(fs, bpref) / NBBY;

usr.sbin/makefs/ffs/ffs_alloc.c

578

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

usr.sbin/makefs/ffs/ffs_alloc.c

583

(const u_char *)fragtbl[fs->fs_frag],

usr.sbin/makefs/ffs/ffs_alloc.c

584

(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

usr.sbin/makefs/ffs/ffs_alloc.c

590

(const u_char *)fragtbl[fs->fs_frag],

usr.sbin/makefs/ffs/ffs_alloc.c

591

(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

usr.sbin/makefs/ffs/ffs_alloc.c

606

for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {

usr.sbin/makefs/ffs/ffs_alloc.c

607

blk = blkmap(fs, cg_blksfree(cgp, needswap), bno);

usr.sbin/makefs/ffs/ffs_alloc.c

611

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

usr.sbin/makefs/ffs/ffs_alloc.c

75

static int32_t ffs_mapsearch(struct fs *, struct cg *, daddr_t, int);

usr.sbin/makefs/ffs/ffs_balloc.c

100

lbn = ffs_lblkno(fs, offset);

usr.sbin/makefs/ffs/ffs_balloc.c

101

size = ffs_blkoff(fs, offset) + bufsize;

usr.sbin/makefs/ffs/ffs_balloc.c

106

assert(size <= fs->fs_bsize);

usr.sbin/makefs/ffs/ffs_balloc.c

116

lastlbn = ffs_lblkno(fs, ip->i_ffs1_size);

usr.sbin/makefs/ffs/ffs_balloc.c

119

osize = ffs_blksize(fs, ip, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

120

if (osize < fs->fs_bsize && osize > 0) {

usr.sbin/makefs/ffs/ffs_balloc.c

132

if (nb != 0 && ip->i_ffs1_size >= ffs_lblktosize(fs, lbn + 1)) {

usr.sbin/makefs/ffs/ffs_balloc.c

142

error = bread(ip->i_devvp, lbn, fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

156

osize = ffs_fragroundup(fs, ffs_blkoff(fs, ip->i_ffs1_size));

usr.sbin/makefs/ffs/ffs_balloc.c

157

nsize = ffs_fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

185

if (ip->i_ffs1_size < ffs_lblktosize(fs, lbn + 1))

usr.sbin/makefs/ffs/ffs_balloc.c

186

nsize = ffs_fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

188

nsize = fs->fs_bsize;

usr.sbin/makefs/ffs/ffs_balloc.c

197

bp->b_blkno = FFS_FSBTODB(fs, newb);

usr.sbin/makefs/ffs/ffs_balloc.c

229

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

234

bp = getblk(ip->i_devvp, indirs[1].in_lbn, fs->fs_bsize, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

235

bp->b_blkno = FFS_FSBTODB(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

252

error = bread(ip->i_devvp, indirs[i].in_lbn, fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

268

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

275

nbp = getblk(ip->i_devvp, indirs[i].in_lbn, fs->fs_bsize, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

276

nbp->b_blkno = FFS_FSBTODB(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

298

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

306

nbp = getblk(ip->i_devvp, lbn, fs->fs_bsize, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

307

nbp->b_blkno = FFS_FSBTODB(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

322

error = bread(ip->i_devvp, lbn, (int)fs->fs_bsize, 0, &nbp);

usr.sbin/makefs/ffs/ffs_balloc.c

337

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_balloc.c

344

const int needswap = UFS_FSNEEDSWAP(fs);

usr.sbin/makefs/ffs/ffs_balloc.c

346

lbn = ffs_lblkno(fs, offset);

usr.sbin/makefs/ffs/ffs_balloc.c

347

size = ffs_blkoff(fs, offset) + bufsize;

usr.sbin/makefs/ffs/ffs_balloc.c

352

assert(size <= fs->fs_bsize);

usr.sbin/makefs/ffs/ffs_balloc.c

362

lastlbn = ffs_lblkno(fs, ip->i_ffs2_size);

usr.sbin/makefs/ffs/ffs_balloc.c

365

osize = ffs_blksize(fs, ip, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

366

if (osize < fs->fs_bsize && osize > 0) {

usr.sbin/makefs/ffs/ffs_balloc.c

378

if (nb != 0 && ip->i_ffs2_size >= ffs_lblktosize(fs, lbn + 1)) {

usr.sbin/makefs/ffs/ffs_balloc.c

388

error = bread(ip->i_devvp, lbn, fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

402

osize = ffs_fragroundup(fs, ffs_blkoff(fs, ip->i_ffs2_size));

usr.sbin/makefs/ffs/ffs_balloc.c

403

nsize = ffs_fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

431

if (ip->i_ffs2_size < ffs_lblktosize(fs, lbn + 1))

usr.sbin/makefs/ffs/ffs_balloc.c

432

nsize = ffs_fragroundup(fs, size);

usr.sbin/makefs/ffs/ffs_balloc.c

434

nsize = fs->fs_bsize;

usr.sbin/makefs/ffs/ffs_balloc.c

443

bp->b_blkno = FFS_FSBTODB(fs, newb);

usr.sbin/makefs/ffs/ffs_balloc.c

475

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

480

bp = getblk(ip->i_devvp, indirs[1].in_lbn, fs->fs_bsize, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

481

bp->b_blkno = FFS_FSBTODB(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

498

error = bread(ip->i_devvp, indirs[i].in_lbn, fs->fs_bsize,

usr.sbin/makefs/ffs/ffs_balloc.c

514

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

521

nbp = getblk(ip->i_devvp, indirs[i].in_lbn, fs->fs_bsize, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

522

nbp->b_blkno = FFS_FSBTODB(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

544

error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb);

usr.sbin/makefs/ffs/ffs_balloc.c

552

nbp = getblk(ip->i_devvp, lbn, fs->fs_bsize, 0, 0);

usr.sbin/makefs/ffs/ffs_balloc.c

553

nbp->b_blkno = FFS_FSBTODB(fs, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

568

error = bread(ip->i_devvp, lbn, (int)fs->fs_bsize, 0,

usr.sbin/makefs/ffs/ffs_balloc.c

91

struct fs *fs = ip->i_fs;

usr.sbin/makefs/ffs/ffs_balloc.c

98

const int needswap = UFS_FSNEEDSWAP(fs);

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(const 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, uint32_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/mkfs.c

106

struct fs fs;

usr.sbin/makefs/ffs/mkfs.c

130

ffs_sb_copy(struct fs *o, const struct fs *i, size_t l, const fsinfo_t *fsopts)

usr.sbin/makefs/ffs/mkfs.c

140

struct fs *

usr.sbin/makefs/ffs/mkfs.c

448

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

usr.sbin/makefs/ffs/mkfs.c

530

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

usr.sbin/makefs/ffs/mkfs.c

566

ffs_write_superblock(struct fs *fs, const fsinfo_t *fsopts)

usr.sbin/makefs/ffs/mkfs.c

573

saveflag = fs->fs_flags & FS_INTERNAL;

usr.sbin/makefs/ffs/mkfs.c

574

fs->fs_flags &= ~FS_INTERNAL;

usr.sbin/makefs/ffs/mkfs.c

576

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

usr.sbin/makefs/ffs/mkfs.c

577

ffs_wtfs(fs->fs_sblockloc / sectorsize, sbsize, writebuf, fsopts);

usr.sbin/makefs/ffs/mkfs.c

580

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

usr.sbin/makefs/ffs/mkfs.c

581

ffs_wtfs(FFS_FSBTODB(fs, cgsblock(fs, cylno)),

usr.sbin/makefs/ffs/mkfs.c

585

size = fs->fs_cssize;

usr.sbin/makefs/ffs/mkfs.c

586

blks = howmany(size, fs->fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

587

space = (void *)fs->fs_csp;

usr.sbin/makefs/ffs/mkfs.c

589

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

usr.sbin/makefs/ffs/mkfs.c

590

size = fs->fs_bsize;

usr.sbin/makefs/ffs/mkfs.c

591

if (i + fs->fs_frag > blks)

usr.sbin/makefs/ffs/mkfs.c

592

size = (blks - i) * fs->fs_fsize;

usr.sbin/makefs/ffs/mkfs.c

598

ffs_wtfs(FFS_FSBTODB(fs, fs->fs_csaddr + i), size, wrbuf, fsopts);

usr.sbin/makefs/ffs/mkfs.c

602

fs->fs_flags |= saveflag;

usr.sbin/makefs/ffs/mkfs.c

90

struct fs fs;

usr.sbin/makefs/ffs/mkfs.c

93

#define sblock fsun.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_inode.h

48

struct fs *i_fs; /* File system */

usr.sbin/makefs/makefs.h

200

#define DECLARE_FUN(fs) \

usr.sbin/makefs/makefs.h

201

void fs ## _prep_opts(fsinfo_t *); \

usr.sbin/makefs/makefs.h

202

int fs ## _parse_opts(const char *, fsinfo_t *); \

usr.sbin/makefs/makefs.h

203

void fs ## _cleanup_opts(fsinfo_t *); \

usr.sbin/makefs/makefs.h

204

void fs ## _makefs(const char *, const char *, fsnode *, fsinfo_t *)

usr.sbin/makefs/msdos.c

184

vp.fs = fsopts;

usr.sbin/makefs/msdos/msdosfs_vfsops.c

95

struct msdos_options *m = devvp->fs->fs_specific;

usr.sbin/makefs/v7fs/v7fs_populate.c

100

if ((error = v7fs_inode_load(fs, inode, ino))) {

usr.sbin/makefs/v7fs/v7fs_populate.c

115

copy_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)

usr.sbin/makefs/v7fs/v7fs_populate.c

123

if (!fs->io.write(fs->io.cookie, p->buf, blk)) {

usr.sbin/makefs/v7fs/v7fs_populate.c

133

file_copy(struct v7fs_self *fs, struct v7fs_inode *parent_inode, fsnode *node,

usr.sbin/makefs/v7fs/v7fs_populate.c

144

if ((error = v7fs_inode_load(fs, &inode, fnode->ino))) {

usr.sbin/makefs/v7fs/v7fs_populate.c

148

if ((error = v7fs_file_link(fs, parent_inode, &inode,

usr.sbin/makefs/v7fs/v7fs_populate.c

157

if ((error = allocate(fs, parent_inode, node, 0, &inode))) {

usr.sbin/makefs/v7fs/v7fs_populate.c

161

if ((error = v7fs_datablock_expand(fs, &inode, fnode->st.st_size))) {

usr.sbin/makefs/v7fs/v7fs_populate.c

173

error = v7fs_datablock_foreach(fs, &inode, copy_subr,

usr.sbin/makefs/v7fs/v7fs_populate.c

194

populate_walk(struct v7fs_self *fs, struct v7fs_inode *parent_inode,

usr.sbin/makefs/v7fs/v7fs_populate.c

212

if ((error = allocate(fs, parent_inode, cur,

usr.sbin/makefs/v7fs/v7fs_populate.c

222

if ((error = allocate(fs, parent_inode, cur, 0,

usr.sbin/makefs/v7fs/v7fs_populate.c

230

error = populate_walk(fs, &inode, cur->child,

usr.sbin/makefs/v7fs/v7fs_populate.c

238

error = file_copy(fs, parent_inode, cur, srcpath);

usr.sbin/makefs/v7fs/v7fs_populate.c

241

if ((error = allocate(fs, parent_inode, cur, 0,

usr.sbin/makefs/v7fs/v7fs_populate.c

246

v7fs_file_symlink(fs, &inode, cur->symlink);

usr.sbin/makefs/v7fs/v7fs_populate.c

264

struct v7fs_self *fs;

usr.sbin/makefs/v7fs/v7fs_populate.c

267

if ((error = v7fs_io_init(&fs, device, V7FS_BSIZE))) {

usr.sbin/makefs/v7fs/v7fs_populate.c

272

fs->endian = device->endian;

usr.sbin/makefs/v7fs/v7fs_populate.c

273

v7fs_endian_init(fs);

usr.sbin/makefs/v7fs/v7fs_populate.c

275

if ((error = v7fs_superblock_load(fs))) {

usr.sbin/makefs/v7fs/v7fs_populate.c

280

fsopts->superblock = &fs->superblock; /* not used. */

usr.sbin/makefs/v7fs/v7fs_populate.c

282

if ((error = v7fs_inode_load(fs, &root_inode, V7FS_ROOT_INODE))) {

usr.sbin/makefs/v7fs/v7fs_populate.c

292

error = populate_walk(fs, &root_inode, root, path);

usr.sbin/makefs/v7fs/v7fs_populate.c

294

v7fs_inode_writeback(fs, &root_inode);

usr.sbin/makefs/v7fs/v7fs_populate.c

295

v7fs_superblock_writeback(fs);

usr.sbin/makefs/v7fs/v7fs_populate.c

81

allocate(struct v7fs_self *fs, struct v7fs_inode *parent_inode, fsnode *node,

usr.sbin/makefs/v7fs/v7fs_populate.c

92

if ((error = v7fs_file_allocate(fs, parent_inode, node->name,

usr.sbin/puffs/mount_9p/ninepuffs.c

225

PUFFSOP_SET(pops, puffs9p, fs, unmount);

usr.sbin/puffs/mount_psshfs/psshfs.c

251

PUFFSOP_SET(pops, psshfs, fs, unmount);

usr.sbin/puffs/mount_psshfs/psshfs.c

253

PUFFSOP_SET(pops, psshfs, fs, statvfs);

usr.sbin/puffs/mount_psshfs/psshfs.c

254

PUFFSOP_SET(pops, psshfs, fs, nodetofh);

usr.sbin/puffs/mount_psshfs/psshfs.c

255

PUFFSOP_SET(pops, psshfs, fs, fhtonode);

usr.sbin/puffs/mount_sysctlfs/sysctlfs.c

282

PUFFSOP_SET(pops, sysctlfs, fs, nodetofh);

usr.sbin/puffs/mount_sysctlfs/sysctlfs.c

283

PUFFSOP_SET(pops, sysctlfs, fs, fhtonode);

usr.sbin/quot/quot.c

104

static int virtualblocks(struct fs *, union dinode *);

usr.sbin/quot/quot.c

108

get_inode(int fd, struct fs *super, ino_t ino)

usr.sbin/quot/quot.c

141

#define actualblocks(fs, dp) (int)(DIP(fs, dp, blocks) / 2)

usr.sbin/quot/quot.c

143

#define actualblocks(fs, dp) (int)(DIP(fs, dp, blocks))

usr.sbin/quot/quot.c

147

virtualblocks(struct fs *super, union dinode *dp)

usr.sbin/quot/quot.c

179

isfree(fs, dp)

usr.sbin/quot/quot.c

180

struct fs *fs;

usr.sbin/quot/quot.c

184

return (DIP(fs, dp, mode) & IFMT) == 0;

usr.sbin/quot/quot.c

186

switch (DIP(fs, dp, mode) & IFMT) {

usr.sbin/quot/quot.c

342

dofsizes(int fd, struct fs *super, const char *name)

usr.sbin/quot/quot.c

413

douser(int fd, struct fs *super, const char *name)

usr.sbin/quot/quot.c

450

donames(int fd, struct fs *super, const char *name)

usr.sbin/quot/quot.c

520

ffs_oldfscompat(struct fs *fs)

usr.sbin/quot/quot.c

524

if (fs->fs_magic == FS_UFS1_MAGIC &&

usr.sbin/quot/quot.c

525

fs->fs_old_inodefmt < FS_44INODEFMT) {

usr.sbin/quot/quot.c

526

quad_t sizepb = fs->fs_bsize;

usr.sbin/quot/quot.c

528

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

usr.sbin/quot/quot.c

530

sizepb *= FFS_NINDIR(fs);

usr.sbin/quot/quot.c

531

fs->fs_maxfilesize += sizepb;

usr.sbin/quot/quot.c

533

fs->fs_qbmask = ~fs->fs_bmask;

usr.sbin/quot/quot.c

534

fs->fs_qfmask = ~fs->fs_fmask;

usr.sbin/quot/quot.c

549

struct fs *fs;

usr.sbin/quot/quot.c

569

fs = (struct fs *)superblock;

usr.sbin/quot/quot.c

571

if (fs->fs_magic != FS_UFS1_MAGIC &&

usr.sbin/quot/quot.c

572

fs->fs_magic != FS_UFS2_MAGIC &&

usr.sbin/quot/quot.c

573

fs->fs_magic != FS_UFS2EA_MAGIC)

usr.sbin/quot/quot.c

576

if (fs->fs_magic == FS_UFS2_MAGIC

usr.sbin/quot/quot.c

577

|| fs->fs_magic == FS_UFS2EA_MAGIC

usr.sbin/quot/quot.c

578

|| fs->fs_old_flags & FS_FLAGS_UPDATED) {

usr.sbin/quot/quot.c

58

static void (*func)(int, struct fs *, const char *);

usr.sbin/quot/quot.c

580

if (fs->fs_sblockloc != sbloc)

usr.sbin/quot/quot.c

588

if (fs->fs_bsize > MAXBSIZE ||

usr.sbin/quot/quot.c

589

(size_t)fs->fs_bsize < sizeof(struct fs))

usr.sbin/quot/quot.c

594

ffs_oldfscompat((struct fs *)superblock);

usr.sbin/quot/quot.c

599

(*func)(fd, fs, name);

usr.sbin/quot/quot.c

76

#define INOCNT(fs) ((fs)->fs_ipg)

usr.sbin/quot/quot.c

77

#define INOSZ(fs) \

usr.sbin/quot/quot.c

78

(((fs)->fs_magic == FS_UFS1_MAGIC ? sizeof(struct ufs1_dinode) : \

usr.sbin/quot/quot.c

79

sizeof(struct ufs2_dinode)) * INOCNT(fs))

usr.sbin/quot/quot.c

85

#define DIP(fs, dp, field) \

usr.sbin/quot/quot.c

86

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

usr.sbin/quot/quot.c

91

static void dofsizes(int, struct fs *, const char *);

usr.sbin/quot/quot.c

92

static void donames(int, struct fs *, const char *);

usr.sbin/quot/quot.c

93

static void douser(int, struct fs *, const char *);

usr.sbin/quot/quot.c

94

static union dinode *get_inode(int, struct fs *, ino_t);

usr.sbin/quot/quot.c

95

static void ffs_oldfscompat(struct fs *);

usr.sbin/quot/quot.c

98

static int isfree(struct fs *, union dinode *);

usr.sbin/quotacheck/quotacheck.c

174

struct fstab *fs;

usr.sbin/quotacheck/quotacheck.c

226

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

usr.sbin/quotacheck/quotacheck.c

227

if (needchk(fs))

usr.sbin/quotacheck/quotacheck.c

251

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

usr.sbin/quotacheck/quotacheck.c

254

fsspec = getfsspecname(buf, sizeof(buf), fs->fs_spec);

usr.sbin/quotacheck/quotacheck.c

259

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

usr.sbin/quotacheck/quotacheck.c

261

(auxdata = needchk(fs)) &&

usr.sbin/quotacheck/quotacheck.c

264

errs += chkquota(fs->fs_type, name, fs->fs_file,

usr.sbin/quotacheck/quotacheck.c

285

needchk(struct fstab *fs)

usr.sbin/quotacheck/quotacheck.c

290

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

usr.sbin/quotacheck/quotacheck.c

291

strcmp(fs->fs_type, FSTAB_RW))

usr.sbin/quotacheck/quotacheck.c

296

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

usr.sbin/quotacheck/quotacheck.c

300

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

usr.sbin/quotacheck/quotacheck.c

97

struct fs sblk;

usr.sbin/quotaon/quotaon.c

137

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

usr.sbin/quotaon/quotaon.c

140

if ((strcmp(fs->fs_vfstype, "ffs") &&

usr.sbin/quotaon/quotaon.c

141

strcmp(fs->fs_vfstype, "lfs")) ||

usr.sbin/quotaon/quotaon.c

142

strcmp(fs->fs_type, FSTAB_RW))

usr.sbin/quotaon/quotaon.c

145

fsspec = getfsspecname(buf, sizeof(buf), fs->fs_spec);

usr.sbin/quotaon/quotaon.c

151

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

usr.sbin/quotaon/quotaon.c

158

qh = quota_open(fs->fs_file);

usr.sbin/quotaon/quotaon.c

172

warn("%s", fs->fs_file);

usr.sbin/quotaon/quotaon.c

188

errs += quotaonoff(fs, qh, offmode, GRPQUOTA, 0, fsspec);

usr.sbin/quotaon/quotaon.c

189

errs += quotaonoff(fs, qh, offmode, USRQUOTA, 0, fsspec);

usr.sbin/quotaon/quotaon.c

192

errs += quotaonoff(fs, qh, offmode, GRPQUOTA, 1, fsspec);

usr.sbin/quotaon/quotaon.c

195

errs += quotaonoff(fs, qh, offmode, USRQUOTA, 1, fsspec);

usr.sbin/quotaon/quotaon.c

216

quotaonoff(struct fstab *fs, struct quotahandle *qh, int offmode, int idtype,

usr.sbin/quotaon/quotaon.c

222

if (strcmp(fs->fs_file, "/") && readonly(fs, fsspec)) {

usr.sbin/quotaon/quotaon.c

230

warn("quota%s for %s", mode, fs->fs_file);

usr.sbin/quotaon/quotaon.c

237

warn("quota%s for %s", mode, fs->fs_file);

usr.sbin/quotaon/quotaon.c

246

fs->fs_file, type, mode);

usr.sbin/quotaon/quotaon.c

255

readonly(struct fstab *fs, const char *fsspec)

usr.sbin/quotaon/quotaon.c

259

if (statvfs(fs->fs_file, &fsbuf) < 0 ||

usr.sbin/quotaon/quotaon.c

260

strcmp(fsbuf.f_mntonname, fs->fs_file) ||

usr.sbin/quotaon/quotaon.c

262

printf("%s: not mounted\n", fs->fs_file);

usr.sbin/quotaon/quotaon.c

266

printf("%s: mounted read-only\n", fs->fs_file);

usr.sbin/quotaon/quotaon.c

80

struct fstab *fs;

usr.sbin/sysinst/disks.c

1897

struct fs fs;

usr.sbin/sysinst/disks.c

1900

struct fs *fs = &sblk.fs;

usr.sbin/sysinst/disks.c

1912

if (fs->fs_magic != FS_UFS1_MAGIC &&

usr.sbin/sysinst/disks.c

1913

fs->fs_magic != FS_UFS1_MAGIC_SWAPPED)

usr.sbin/sysinst/disks.c

1916

if (fs->fs_old_flags & FS_FLAGS_UPDATED)

usr.sbin/sysinst/disks.c

1919

if (fs->fs_bsize != fs->fs_maxbsize)

usr.sbin/sysinst/disks_lfs.c

39

fs_is_lfs(void *fs)

usr.sbin/sysinst/disks_lfs.c

41

struct dlfs *dlfs = (struct dlfs *)fs;

usr.sbin/sysinst/label.c

1972

struct fs *SB = (struct fs *)sblk;