fs 419 arch/i386/i386/vm86.c DOVREG(fs);
fs 116 arch/i386/include/asm.h #define CPUVAR(var) %fs:__CONCAT(CPU_INFO_,var)
fs 332 arch/i386/stand/installboot/installboot.c struct fs *fs;
fs 398 arch/i386/stand/installboot/installboot.c fs = (struct fs *)sblock;
fs 401 arch/i386/stand/installboot/installboot.c if (fs->fs_magic != FS_MAGIC)
fs 403 arch/i386/stand/installboot/installboot.c if (fs->fs_inopb <= 0)
fs 404 arch/i386/stand/installboot/installboot.c err(1, "Bad inopb=%d in superblock", fs->fs_inopb);
fs 407 arch/i386/stand/installboot/installboot.c if ((buf = malloc(fs->fs_bsize)) == NULL)
fs 410 arch/i386/stand/installboot/installboot.c blk = fsbtodb(fs, ino_to_fsba(fs, statbuf.st_ino));
fs 412 arch/i386/stand/installboot/installboot.c devread(devfd, buf, pl->p_offset + blk, fs->fs_bsize, "inode");
fs 413 arch/i386/stand/installboot/installboot.c ip = (struct ufs1_dinode *)(buf) + ino_to_fsbo(fs, statbuf.st_ino);
fs 419 arch/i386/stand/installboot/installboot.c ndb = howmany(ip->di_size, fs->fs_bsize);
fs 427 arch/i386/stand/installboot/installboot.c sym_set_value(pbr_symbols, "_fs_bsize_p", (fs->fs_bsize / 16));
fs 428 arch/i386/stand/installboot/installboot.c sym_set_value(pbr_symbols, "_fs_bsize_s", (fs->fs_bsize / 512));
fs 429 arch/i386/stand/installboot/installboot.c sym_set_value(pbr_symbols, "_fsbtodb", fs->fs_fsbtodb);
fs 432 arch/i386/stand/installboot/installboot.c ino_to_fsba(fs, statbuf.st_ino));
fs 440 arch/i386/stand/installboot/installboot.c boot, ndb, fs->fs_bsize);
fs 443 arch/i386/stand/installboot/installboot.c fs->fs_fsbtodb, pl->p_offset,
fs 444 arch/i386/stand/installboot/installboot.c ino_to_fsba(fs, statbuf.st_ino),
fs 1197 compat/svr4/svr4_misc.c struct statfs *fs = stackgap_alloc(&sg, sizeof(struct statfs));
fs 1204 compat/svr4/svr4_misc.c SCARG(&fs_args, buf) = fs;
fs 1209 compat/svr4/svr4_misc.c if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0)
fs 1214 compat/svr4/svr4_misc.c return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
fs 1227 compat/svr4/svr4_misc.c struct statfs *fs = stackgap_alloc(&sg, sizeof(struct statfs));
fs 1233 compat/svr4/svr4_misc.c SCARG(&fs_args, buf) = fs;
fs 1238 compat/svr4/svr4_misc.c if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0)
fs 1243 compat/svr4/svr4_misc.c return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
fs 1256 compat/svr4/svr4_misc.c struct statfs *fs = stackgap_alloc(&sg, sizeof(struct statfs));
fs 1262 compat/svr4/svr4_misc.c SCARG(&fs_args, buf) = fs;
fs 1267 compat/svr4/svr4_misc.c if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0)
fs 1272 compat/svr4/svr4_misc.c return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
fs 224 compat/svr4/svr4_syscallargs.h syscallarg(struct svr4_statvfs *) fs;
fs 229 compat/svr4/svr4_syscallargs.h syscallarg(struct svr4_statvfs *) fs;
fs 418 compat/svr4/svr4_syscallargs.h syscallarg(struct svr4_statvfs64 *) fs;
fs 1238 dev/isa/ad1848.c u_char fs;
fs 1250 dev/isa/ad1848.c fs = sc->speed_bits | (sc->format_bits << 5);
fs 1253 dev/isa/ad1848.c fs |= FMT_STEREO;
fs 1255 dev/isa/ad1848.c ad_write(sc, SP_CLOCK_DATA_FORMAT, fs);
fs 1273 dev/isa/ad1848.c ad_write(sc, CS_REC_FORMAT, fs);
fs 118 dev/midisyn.c struct midisyn_methods *fs;
fs 122 dev/midisyn.c fs = ms->mets;
fs 125 dev/midisyn.c fs->noteoff(ms, v, 0, 0);
fs 128 dev/midisyn.c if (fs->close)
fs 129 dev/midisyn.c fs->close(ms);
fs 249 dev/midisyn.c struct midisyn_methods *fs;
fs 253 dev/midisyn.c fs = ms->mets;
fs 257 dev/midisyn.c if (fs->sysex)
fs 258 dev/midisyn.c fs->sysex(ms, b);
fs 279 dev/midisyn.c fs->noteoff(ms, voice, note, vel);
fs 284 dev/midisyn.c voice = fs->allocv(ms, chan, ms->buf[1]);
fs 285 dev/midisyn.c fs->noteon(ms, voice, note, vel);
fs 288 dev/midisyn.c if (fs->keypres) {
fs 291 dev/midisyn.c fs->keypres(ms, voice, note, vel);
fs 295 dev/midisyn.c if (fs->ctlchg)
fs 296 dev/midisyn.c fs->ctlchg(ms, chan, ms->buf[1], vel);
fs 299 dev/midisyn.c if (fs->pgmchg)
fs 300 dev/midisyn.c fs->pgmchg(ms, chan, ms->buf[1]);
fs 303 dev/midisyn.c if (fs->chnpres) {
fs 306 dev/midisyn.c fs->chnpres(ms, voice, note);
fs 310 dev/midisyn.c if (fs->pitchb) {
fs 313 dev/midisyn.c fs->pitchb(ms, chan, note, vel);
fs 317 dev/midisyn.c if (fs->sysex)
fs 318 dev/midisyn.c fs->sysex(ms, status);
fs 1262 dev/pci/tga.c int fs, height, width;
fs 1274 dev/pci/tga.c fs = ri->ri_font->stride;
fs 1304 dev/pci/tga.c fr += fs;
fs 99 dev/rasops/rasops1.c u_int fs, rs, fb, bg, fg, lmask, rmask;
fs 130 dev/rasops/rasops1.c fs = 0; /* shutup gcc */
fs 134 dev/rasops/rasops1.c fs = ri->ri_font->stride;
fs 158 dev/rasops/rasops1.c fr += fs;
fs 168 dev/rasops/rasops1.c fr += fs;
fs 207 dev/rasops/rasops1.c fr += fs;
fs 221 dev/rasops/rasops1.c fr += fs;
fs 247 dev/rasops/rasops1.c int height, fs, rs, bg, fg;
fs 278 dev/rasops/rasops1.c fs = ri->ri_font->stride;
fs 284 dev/rasops/rasops1.c fr += fs;
fs 290 dev/rasops/rasops1.c fr += fs;
fs 312 dev/rasops/rasops1.c int height, fs, rs, bg, fg;
fs 343 dev/rasops/rasops1.c fs = ri->ri_font->stride;
fs 350 dev/rasops/rasops1.c fr += fs;
fs 357 dev/rasops/rasops1.c fr += fs;
fs 227 dev/rasops/rasops15.c int height, so, fs;
fs 268 dev/rasops/rasops15.c fs = ri->ri_font->stride;
fs 279 dev/rasops/rasops15.c fr += fs;
fs 306 dev/rasops/rasops15.c int height, so, fs;
fs 347 dev/rasops/rasops15.c fs = ri->ri_font->stride;
fs 362 dev/rasops/rasops15.c fr += fs;
fs 389 dev/rasops/rasops15.c int height, so, fs;
fs 431 dev/rasops/rasops15.c fs = ri->ri_font->stride;
fs 451 dev/rasops/rasops15.c fr += fs;
fs 133 dev/rasops/rasops2.c int height, width, fs, rs, bg, fg, lmask, rmask;
fs 164 dev/rasops/rasops2.c fs = 0; /* shutup gcc */
fs 168 dev/rasops/rasops2.c fs = ri->ri_font->stride;
fs 189 dev/rasops/rasops2.c fr += fs;
fs 223 dev/rasops/rasops2.c fr += fs;
fs 271 dev/rasops/rasops2.c int height, fs, rs;
fs 313 dev/rasops/rasops2.c fs = ri->ri_font->stride;
fs 318 dev/rasops/rasops2.c fr += fs;
fs 341 dev/rasops/rasops2.c int height, fs, rs;
fs 383 dev/rasops/rasops2.c fs = ri->ri_font->stride;
fs 389 dev/rasops/rasops2.c fr += fs;
fs 414 dev/rasops/rasops2.c int height, fs, rs;
fs 456 dev/rasops/rasops2.c fs = ri->ri_font->stride;
fs 463 dev/rasops/rasops2.c fr += fs;
fs 257 dev/rasops/rasops24.c int height, so, fs;
fs 298 dev/rasops/rasops24.c fs = ri->ri_font->stride;
fs 311 dev/rasops/rasops24.c fr += fs;
fs 338 dev/rasops/rasops24.c int height, so, fs;
fs 380 dev/rasops/rasops24.c fs = ri->ri_font->stride;
fs 398 dev/rasops/rasops24.c fr += fs;
fs 426 dev/rasops/rasops24.c int height, so, fs;
fs 469 dev/rasops/rasops24.c fs = ri->ri_font->stride;
fs 493 dev/rasops/rasops24.c fr += fs;
fs 80 dev/rasops/rasops32.c int width, height, cnt, fs, fb, clr[2];
fs 115 dev/rasops/rasops32.c fs = ri->ri_font->stride;
fs 121 dev/rasops/rasops32.c fr += fs;
fs 113 dev/rasops/rasops4.c int height, width, fs, rs, fb, bg, fg, lmask, rmask;
fs 143 dev/rasops/rasops4.c fs = 0; /* shutup gcc */
fs 147 dev/rasops/rasops4.c fs = ri->ri_font->stride;
fs 203 dev/rasops/rasops4.c fr += fs;
fs 273 dev/rasops/rasops4.c int height, fs, rs;
fs 317 dev/rasops/rasops4.c fs = ri->ri_font->stride;
fs 322 dev/rasops/rasops4.c fr += fs;
fs 348 dev/rasops/rasops4.c int height, fs, rs;
fs 393 dev/rasops/rasops4.c fs = ri->ri_font->stride;
fs 399 dev/rasops/rasops4.c fr += fs;
fs 426 dev/rasops/rasops4.c int height, fs, rs;
fs 472 dev/rasops/rasops4.c fs = ri->ri_font->stride;
fs 479 dev/rasops/rasops4.c fr += fs;
fs 110 dev/rasops/rasops8.c int width, height, cnt, fs, fb;
fs 144 dev/rasops/rasops8.c fs = ri->ri_font->stride;
fs 149 dev/rasops/rasops8.c fr += fs;
fs 216 dev/rasops/rasops8.c int height, fs;
fs 256 dev/rasops/rasops8.c fs = ri->ri_font->stride;
fs 262 dev/rasops/rasops8.c fr += fs;
fs 287 dev/rasops/rasops8.c int height, fs;
fs 329 dev/rasops/rasops8.c fs = ri->ri_font->stride;
fs 336 dev/rasops/rasops8.c fr += fs;
fs 361 dev/rasops/rasops8.c int height, fs;
fs 399 dev/rasops/rasops8.c fs = ri->ri_font->stride;
fs 407 dev/rasops/rasops8.c fr += fs;
fs 656 dev/sbus/cs4231.c u_int8_t r, fs;
fs 661 dev/sbus/cs4231.c fs = sc->sc_speed_bits | (sc->sc_format_bits << 5);
fs 663 dev/sbus/cs4231.c fs |= FMT_STEREO;
fs 673 dev/sbus/cs4231.c CS_WRITE(sc, AD1848_IDATA, fs);
fs 684 dev/sbus/cs4231.c CS_WRITE(sc, AD1848_IDATA, fs);
fs 761 dev/sbus/zx.c int fs, i, fg, bg, ul;
fs 793 dev/sbus/zx.c fs = font->stride;
fs 807 dev/sbus/zx.c fb += fs;
fs 813 dev/sbus/zx.c fb += fs;
fs 82 lib/libsa/ufs.c struct fs *f_fs; /* pointer to super-block */
fs 102 lib/libsa/ufs.c static void ffs_oldfscompat(struct fs *);
fs 112 lib/libsa/ufs.c struct fs *fs = fp->f_fs;
fs 120 lib/libsa/ufs.c buf = alloc(fs->fs_bsize);
fs 123 lib/libsa/ufs.c fsbtodb(fs, ino_to_fsba(fs, inumber)), fs->fs_bsize,
fs 127 lib/libsa/ufs.c if (rsize != (size_t)fs->fs_bsize) {
fs 136 lib/libsa/ufs.c fp->f_di = dp[ino_to_fsbo(fs, inumber)];
fs 151 lib/libsa/ufs.c free(buf, fs->fs_bsize);
fs 164 lib/libsa/ufs.c struct fs *fs = fp->f_fs;
fs 225 lib/libsa/ufs.c alloc(fs->fs_bsize);
fs 228 lib/libsa/ufs.c fsbtodb(fp->f_fs, ind_block_num), fs->fs_bsize,
fs 232 lib/libsa/ufs.c if (fp->f_blksize[level] != (size_t)fs->fs_bsize)
fs 260 lib/libsa/ufs.c struct fs *fs = fp->f_fs;
fs 266 lib/libsa/ufs.c off = blkoff(fs, fp->f_seekp);
fs 267 lib/libsa/ufs.c file_block = lblkno(fs, fp->f_seekp);
fs 268 lib/libsa/ufs.c block_size = dblksize(fs, &fp->f_di, file_block);
fs 276 lib/libsa/ufs.c fp->f_buf = alloc(fs->fs_bsize);
fs 284 lib/libsa/ufs.c fsbtodb(fs, disk_block),
fs 367 lib/libsa/ufs.c struct fs *fs;
fs 375 lib/libsa/ufs.c fs = alloc(SBSIZE);
fs 376 lib/libsa/ufs.c fp->f_fs = fs;
fs 379 lib/libsa/ufs.c SBLOCK, SBSIZE, (char *)fs, &buf_size);
fs 383 lib/libsa/ufs.c if (buf_size != SBSIZE || fs->fs_magic != FS_MAGIC ||
fs 384 lib/libsa/ufs.c fs->fs_bsize > MAXBSIZE || fs->fs_bsize < sizeof(struct fs)) {
fs 389 lib/libsa/ufs.c ffs_oldfscompat(fs);
fs 401 lib/libsa/ufs.c mult *= NINDIR(fs);
fs 480 lib/libsa/ufs.c if (link_len < fs->fs_maxsymlinklen) {
fs 489 lib/libsa/ufs.c struct fs *fs = fp->f_fs;
fs 492 lib/libsa/ufs.c buf = alloc(fs->fs_bsize);
fs 499 lib/libsa/ufs.c F_READ, fsbtodb(fs, disk_block),
fs 500 lib/libsa/ufs.c fs->fs_bsize, buf, &buf_size);
fs 528 lib/libsa/ufs.c free(buf, fs->fs_bsize);
fs 689 lib/libsa/ufs.c ffs_oldfscompat(struct fs *fs)
fs 693 lib/libsa/ufs.c fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect); /* XXX */
fs 694 lib/libsa/ufs.c fs->fs_interleave = max(fs->fs_interleave, 1); /* XXX */
fs 695 lib/libsa/ufs.c if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
fs 696 lib/libsa/ufs.c fs->fs_nrpos = 8; /* XXX */
fs 697 lib/libsa/ufs.c if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
fs 698 lib/libsa/ufs.c quad_t sizepb = fs->fs_bsize; /* XXX */
fs 700 lib/libsa/ufs.c fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */
fs 702 lib/libsa/ufs.c sizepb *= NINDIR(fs); /* XXX */
fs 703 lib/libsa/ufs.c fs->fs_maxfilesize += sizepb; /* XXX */
fs 705 lib/libsa/ufs.c fs->fs_qbmask = ~fs->fs_bmask; /* XXX */
fs 706 lib/libsa/ufs.c fs->fs_qfmask = ~fs->fs_fmask; /* XXX */
fs 265 ufs/ext2fs/ext2fs.h #define fsbtodb(fs, b) ((b) << (fs)->e2fs_fsbtodb)
fs 266 ufs/ext2fs/ext2fs.h #define dbtofsb(fs, b) ((b) >> (fs)->e2fs_fsbtodb)
fs 274 ufs/ext2fs/ext2fs.h #define ino_to_cg(fs, x) (((x) - 1) / (fs)->e2fs.e2fs_ipg)
fs 275 ufs/ext2fs/ext2fs.h #define ino_to_fsba(fs, x) \
fs 276 ufs/ext2fs/ext2fs.h ((fs)->e2fs_gd[ino_to_cg(fs, x)].ext2bgd_i_tables + \
fs 277 ufs/ext2fs/ext2fs.h (((x)-1) % (fs)->e2fs.e2fs_ipg)/(fs)->e2fs_ipb)
fs 278 ufs/ext2fs/ext2fs.h #define ino_to_fsbo(fs, x) (((x)-1) % (fs)->e2fs_ipb)
fs 284 ufs/ext2fs/ext2fs.h #define dtog(fs, d) (((d) - (fs)->e2fs.e2fs_first_dblock) / (fs)->e2fs.e2fs_fpg)
fs 285 ufs/ext2fs/ext2fs.h #define dtogd(fs, d) \
fs 286 ufs/ext2fs/ext2fs.h (((d) - (fs)->e2fs.e2fs_first_dblock) % (fs)->e2fs.e2fs_fpg)
fs 293 ufs/ext2fs/ext2fs.h #define blkoff(fs, loc) /* calculates (loc % fs->e2fs_bsize) */ \
fs 294 ufs/ext2fs/ext2fs.h ((loc) & (fs)->e2fs_qbmask)
fs 295 ufs/ext2fs/ext2fs.h #define lblktosize(fs, blk) /* calculates (blk * fs->e2fs_bsize) */ \
fs 296 ufs/ext2fs/ext2fs.h ((blk) << (fs)->e2fs_bshift)
fs 297 ufs/ext2fs/ext2fs.h #define lblkno(fs, loc) /* calculates (loc / fs->e2fs_bsize) */ \
fs 298 ufs/ext2fs/ext2fs.h ((loc) >> (fs)->e2fs_bshift)
fs 299 ufs/ext2fs/ext2fs.h #define blkroundup(fs, size) /* calculates roundup(size, fs->e2fs_bsize) */ \
fs 300 ufs/ext2fs/ext2fs.h (((size) + (fs)->e2fs_qbmask) & (fs)->e2fs_bmask)
fs 301 ufs/ext2fs/ext2fs.h #define fragroundup(fs, size) /* calculates roundup(size, fs->e2fs_bsize) */ \
fs 302 ufs/ext2fs/ext2fs.h (((size) + (fs)->e2fs_qbmask) & (fs)->e2fs_bmask)
fs 307 ufs/ext2fs/ext2fs.h #define freespace(fs) \
fs 308 ufs/ext2fs/ext2fs.h ((fs)->e2fs.e2fs_fbcount - (fs)->e2fs.e2fs_rbcount)
fs 313 ufs/ext2fs/ext2fs.h #define NINDIR(fs) ((fs)->e2fs_bsize / sizeof(u_int32_t))
fs 85 ufs/ext2fs/ext2fs_alloc.c struct m_ext2fs *fs;
fs 90 ufs/ext2fs/ext2fs_alloc.c fs = ip->i_e2fs;
fs 95 ufs/ext2fs/ext2fs_alloc.c if (fs->e2fs.e2fs_fbcount == 0)
fs 97 ufs/ext2fs/ext2fs_alloc.c if (cred->cr_uid != 0 && freespace(fs) <= 0)
fs 99 ufs/ext2fs/ext2fs_alloc.c if (bpref >= fs->e2fs.e2fs_bcount)
fs 102 ufs/ext2fs/ext2fs_alloc.c cg = ino_to_cg(fs, ip->i_number);
fs 104 ufs/ext2fs/ext2fs_alloc.c cg = dtog(fs, bpref);
fs 105 ufs/ext2fs/ext2fs_alloc.c bno = (int32_t)ext2fs_hashalloc(ip, cg, bpref, fs->e2fs_bsize,
fs 108 ufs/ext2fs/ext2fs_alloc.c ip->i_e2fs_nblock += btodb(fs->e2fs_bsize);
fs 114 ufs/ext2fs/ext2fs_alloc.c ext2fs_fserr(fs, cred->cr_uid, "file system full");
fs 115 ufs/ext2fs/ext2fs_alloc.c uprintf("\n%s: write failed, file system is full\n", fs->e2fs_fsmnt);
fs 139 ufs/ext2fs/ext2fs_alloc.c struct m_ext2fs *fs;
fs 146 ufs/ext2fs/ext2fs_alloc.c fs = pip->i_e2fs;
fs 147 ufs/ext2fs/ext2fs_alloc.c if (fs->e2fs.e2fs_ficount == 0)
fs 151 ufs/ext2fs/ext2fs_alloc.c cg = ext2fs_dirpref(fs);
fs 153 ufs/ext2fs/ext2fs_alloc.c cg = ino_to_cg(fs, pip->i_number);
fs 154 ufs/ext2fs/ext2fs_alloc.c ipref = cg * fs->e2fs.e2fs_ipg + 1;
fs 166 ufs/ext2fs/ext2fs_alloc.c ip->i_e2fs_mode, ip->i_e2fs_nlink, ip->i_number, fs->e2fs_fsmnt);
fs 180 ufs/ext2fs/ext2fs_alloc.c ext2fs_fserr(fs, cred->cr_uid, "out of inodes");
fs 181 ufs/ext2fs/ext2fs_alloc.c uprintf("\n%s: create/symlink failed, no inodes free\n", fs->e2fs_fsmnt);
fs 193 ufs/ext2fs/ext2fs_alloc.c ext2fs_dirpref(struct m_ext2fs *fs)
fs 197 ufs/ext2fs/ext2fs_alloc.c avgifree = fs->e2fs.e2fs_ficount / fs->e2fs_ncg;
fs 200 ufs/ext2fs/ext2fs_alloc.c for (cg = 0; cg < fs->e2fs_ncg; cg++)
fs 201 ufs/ext2fs/ext2fs_alloc.c if ( fs->e2fs_gd[cg].ext2bgd_nifree >= avgifree) {
fs 202 ufs/ext2fs/ext2fs_alloc.c if (mincg == -1 || fs->e2fs_gd[cg].ext2bgd_nbfree > maxspace) {
fs 204 ufs/ext2fs/ext2fs_alloc.c maxspace = fs->e2fs_gd[cg].ext2bgd_nbfree;
fs 224 ufs/ext2fs/ext2fs_alloc.c struct m_ext2fs *fs;
fs 227 ufs/ext2fs/ext2fs_alloc.c fs = ip->i_e2fs;
fs 252 ufs/ext2fs/ext2fs_alloc.c cg = ino_to_cg(fs, ip->i_number);
fs 253 ufs/ext2fs/ext2fs_alloc.c return fs->e2fs.e2fs_bpg * cg + fs->e2fs.e2fs_first_dblock + 1;
fs 268 ufs/ext2fs/ext2fs_alloc.c struct m_ext2fs *fs;
fs 272 ufs/ext2fs/ext2fs_alloc.c fs = ip->i_e2fs;
fs 282 ufs/ext2fs/ext2fs_alloc.c for (i = 1; i < fs->e2fs_ncg; i *= 2) {
fs 284 ufs/ext2fs/ext2fs_alloc.c if (cg >= fs->e2fs_ncg)
fs 285 ufs/ext2fs/ext2fs_alloc.c cg -= fs->e2fs_ncg;
fs 295 ufs/ext2fs/ext2fs_alloc.c cg = (icg + 2) % fs->e2fs_ncg;
fs 296 ufs/ext2fs/ext2fs_alloc.c for (i = 2; i < fs->e2fs_ncg; i++) {
fs 301 ufs/ext2fs/ext2fs_alloc.c if (cg == fs->e2fs_ncg)
fs 317 ufs/ext2fs/ext2fs_alloc.c struct m_ext2fs *fs;
fs 322 ufs/ext2fs/ext2fs_alloc.c fs = ip->i_e2fs;
fs 323 ufs/ext2fs/ext2fs_alloc.c if (fs->e2fs_gd[cg].ext2bgd_nbfree == 0)
fs 325 ufs/ext2fs/ext2fs_alloc.c error = bread(ip->i_devvp, fsbtodb(fs,
fs 326 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_gd[cg].ext2bgd_b_bitmap),
fs 327 ufs/ext2fs/ext2fs_alloc.c (int)fs->e2fs_bsize, NOCRED, &bp);
fs 328 ufs/ext2fs/ext2fs_alloc.c if (error || fs->e2fs_gd[cg].ext2bgd_nbfree == 0) {
fs 334 ufs/ext2fs/ext2fs_alloc.c if (dtog(fs, bpref) != cg)
fs 337 ufs/ext2fs/ext2fs_alloc.c bpref = dtogd(fs, bpref);
fs 353 ufs/ext2fs/ext2fs_alloc.c start = dtogd(fs, bpref) / NBBY;
fs 356 ufs/ext2fs/ext2fs_alloc.c end = howmany(fs->e2fs.e2fs_fpg, NBBY) - start;
fs 370 ufs/ext2fs/ext2fs_alloc.c bno = ext2fs_mapsearch(fs, bbp, bpref);
fs 377 ufs/ext2fs/ext2fs_alloc.c cg, bno, fs->e2fs_fsmnt);
fs 382 ufs/ext2fs/ext2fs_alloc.c fs->e2fs.e2fs_fbcount--;
fs 383 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_gd[cg].ext2bgd_nbfree--;
fs 384 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_fmod = 1;
fs 386 ufs/ext2fs/ext2fs_alloc.c return (cg * fs->e2fs.e2fs_fpg + fs->e2fs.e2fs_first_dblock + bno);
fs 401 ufs/ext2fs/ext2fs_alloc.c struct m_ext2fs *fs;
fs 407 ufs/ext2fs/ext2fs_alloc.c fs = ip->i_e2fs;
fs 408 ufs/ext2fs/ext2fs_alloc.c if (fs->e2fs_gd[cg].ext2bgd_nifree == 0)
fs 410 ufs/ext2fs/ext2fs_alloc.c error = bread(ip->i_devvp, fsbtodb(fs,
fs 411 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_gd[cg].ext2bgd_i_bitmap),
fs 412 ufs/ext2fs/ext2fs_alloc.c (int)fs->e2fs_bsize, NOCRED, &bp);
fs 419 ufs/ext2fs/ext2fs_alloc.c ipref %= fs->e2fs.e2fs_ipg;
fs 424 ufs/ext2fs/ext2fs_alloc.c len = howmany(fs->e2fs.e2fs_ipg - ipref, NBBY);
fs 432 ufs/ext2fs/ext2fs_alloc.c cg, ipref, fs->e2fs_fsmnt);
fs 445 ufs/ext2fs/ext2fs_alloc.c printf("fs = %s\n", fs->e2fs_fsmnt);
fs 450 ufs/ext2fs/ext2fs_alloc.c fs->e2fs.e2fs_ficount--;
fs 451 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_gd[cg].ext2bgd_nifree--;
fs 452 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_fmod = 1;
fs 454 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_gd[cg].ext2bgd_ndirs++;
fs 457 ufs/ext2fs/ext2fs_alloc.c return (cg * fs->e2fs.e2fs_ipg + ipref +1);
fs 469 ufs/ext2fs/ext2fs_alloc.c struct m_ext2fs *fs;
fs 474 ufs/ext2fs/ext2fs_alloc.c fs = ip->i_e2fs;
fs 475 ufs/ext2fs/ext2fs_alloc.c cg = dtog(fs, bno);
fs 476 ufs/ext2fs/ext2fs_alloc.c if ((u_int)bno >= fs->e2fs.e2fs_bcount) {
fs 478 ufs/ext2fs/ext2fs_alloc.c ext2fs_fserr(fs, ip->i_e2fs_uid, "bad block");
fs 482 ufs/ext2fs/ext2fs_alloc.c fsbtodb(fs, fs->e2fs_gd[cg].ext2bgd_b_bitmap),
fs 483 ufs/ext2fs/ext2fs_alloc.c (int)fs->e2fs_bsize, NOCRED, &bp);
fs 489 ufs/ext2fs/ext2fs_alloc.c bno = dtogd(fs, bno);
fs 492 ufs/ext2fs/ext2fs_alloc.c ip->i_dev, bno, fs->e2fs_fsmnt);
fs 496 ufs/ext2fs/ext2fs_alloc.c fs->e2fs.e2fs_fbcount++;
fs 497 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_gd[cg].ext2bgd_nbfree++;
fs 499 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_fmod = 1;
fs 511 ufs/ext2fs/ext2fs_alloc.c struct m_ext2fs *fs;
fs 516 ufs/ext2fs/ext2fs_alloc.c fs = pip->i_e2fs;
fs 517 ufs/ext2fs/ext2fs_alloc.c if ((u_int)ino > fs->e2fs.e2fs_icount || (u_int)ino < EXT2_FIRSTINO)
fs 519 ufs/ext2fs/ext2fs_alloc.c pip->i_dev, ino, fs->e2fs_fsmnt);
fs 520 ufs/ext2fs/ext2fs_alloc.c cg = ino_to_cg(fs, ino);
fs 522 ufs/ext2fs/ext2fs_alloc.c fsbtodb(fs, fs->e2fs_gd[cg].ext2bgd_i_bitmap),
fs 523 ufs/ext2fs/ext2fs_alloc.c (int)fs->e2fs_bsize, NOCRED, &bp);
fs 529 ufs/ext2fs/ext2fs_alloc.c ino = (ino - 1) % fs->e2fs.e2fs_ipg;
fs 532 ufs/ext2fs/ext2fs_alloc.c pip->i_dev, ino, fs->e2fs_fsmnt);
fs 533 ufs/ext2fs/ext2fs_alloc.c if (fs->e2fs_ronly == 0)
fs 537 ufs/ext2fs/ext2fs_alloc.c fs->e2fs.e2fs_ficount++;
fs 538 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_gd[cg].ext2bgd_nifree++;
fs 540 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_gd[cg].ext2bgd_ndirs--;
fs 542 ufs/ext2fs/ext2fs_alloc.c fs->e2fs_fmod = 1;
fs 555 ufs/ext2fs/ext2fs_alloc.c ext2fs_mapsearch(struct m_ext2fs *fs, char *bbp, int32_t bpref)
fs 565 ufs/ext2fs/ext2fs_alloc.c start = dtogd(fs, bpref) / NBBY;
fs 568 ufs/ext2fs/ext2fs_alloc.c len = howmany(fs->e2fs.e2fs_fpg, NBBY) - start;
fs 576 ufs/ext2fs/ext2fs_alloc.c start, len, fs->e2fs_fsmnt);
fs 588 ufs/ext2fs/ext2fs_alloc.c printf("fs = %s\n", fs->e2fs_fsmnt);
fs 600 ufs/ext2fs/ext2fs_alloc.c ext2fs_fserr(struct m_ext2fs *fs, uid_t uid, char *cp)
fs 603 ufs/ext2fs/ext2fs_alloc.c log(LOG_ERR, "uid %u on %s: %s\n", uid, fs->e2fs_fsmnt, cp);
fs 62 ufs/ext2fs/ext2fs_balloc.c struct m_ext2fs *fs;
fs 76 ufs/ext2fs/ext2fs_balloc.c fs = ip->i_e2fs;
fs 85 ufs/ext2fs/ext2fs_balloc.c error = bread(vp, bn, fs->e2fs_bsize, NOCRED, &bp);
fs 106 ufs/ext2fs/ext2fs_balloc.c bp = getblk(vp, bn, fs->e2fs_bsize, 0, 0);
fs 107 ufs/ext2fs/ext2fs_balloc.c bp->b_blkno = fsbtodb(fs, newb);
fs 138 ufs/ext2fs/ext2fs_balloc.c bp = getblk(vp, indirs[1].in_lbn, fs->e2fs_bsize, 0, 0);
fs 139 ufs/ext2fs/ext2fs_balloc.c bp->b_blkno = fsbtodb(fs, newb);
fs 157 ufs/ext2fs/ext2fs_balloc.c indirs[i].in_lbn, (int)fs->e2fs_bsize, NOCRED, &bp);
fs 180 ufs/ext2fs/ext2fs_balloc.c nbp = getblk(vp, indirs[i].in_lbn, fs->e2fs_bsize, 0, 0);
fs 181 ufs/ext2fs/ext2fs_balloc.c nbp->b_blkno = fsbtodb(fs, nb);
fs 228 ufs/ext2fs/ext2fs_balloc.c nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0);
fs 229 ufs/ext2fs/ext2fs_balloc.c nbp->b_blkno = fsbtodb(fs, nb);
fs 237 ufs/ext2fs/ext2fs_balloc.c error = bread(vp, lbn, (int)fs->e2fs_bsize, NOCRED, &nbp);
fs 243 ufs/ext2fs/ext2fs_balloc.c nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0);
fs 244 ufs/ext2fs/ext2fs_balloc.c nbp->b_blkno = fsbtodb(fs, nb);
fs 256 ufs/ext2fs/ext2fs_balloc.c deallocated += fs->e2fs_bsize;
fs 265 ufs/ext2fs/ext2fs_balloc.c (int)fs->e2fs_bsize, NOCRED, &bp);
fs 279 ufs/ext2fs/ext2fs_balloc.c bp = getblk(vp, indirs[i].in_lbn, (int)fs->e2fs_bsize,
fs 82 ufs/ext2fs/ext2fs_inode.c struct m_ext2fs *fs = ip->i_e2fs;
fs 84 ufs/ext2fs/ext2fs_inode.c if (fs->e2fs.e2fs_rev <= E2FS_REV0) {
fs 88 ufs/ext2fs/ext2fs_inode.c if (!(fs->e2fs.e2fs_features_rocompat
fs 90 ufs/ext2fs/ext2fs_inode.c fs->e2fs.e2fs_features_rocompat |=
fs 92 ufs/ext2fs/ext2fs_inode.c fs->e2fs_fmod = 1;
fs 165 ufs/ext2fs/ext2fs_inode.c struct m_ext2fs *fs;
fs 180 ufs/ext2fs/ext2fs_inode.c fs = ip->i_e2fs;
fs 182 ufs/ext2fs/ext2fs_inode.c fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
fs 183 ufs/ext2fs/ext2fs_inode.c (int)fs->e2fs_bsize, NOCRED, &bp);
fs 190 ufs/ext2fs/ext2fs_inode.c (ino_to_fsbo(fs, ip->i_number) * EXT2_DINODE_SIZE);
fs 225 ufs/ext2fs/ext2fs_inode.c struct m_ext2fs *fs;
fs 260 ufs/ext2fs/ext2fs_inode.c fs = oip->i_e2fs;
fs 269 ufs/ext2fs/ext2fs_inode.c if (length > fs->fs_maxfilesize)
fs 272 ufs/ext2fs/ext2fs_inode.c offset = blkoff(fs, length - 1);
fs 273 ufs/ext2fs/ext2fs_inode.c lbn = lblkno(fs, length - 1);
fs 298 ufs/ext2fs/ext2fs_inode.c offset = blkoff(fs, length);
fs 302 ufs/ext2fs/ext2fs_inode.c lbn = lblkno(fs, length);
fs 311 ufs/ext2fs/ext2fs_inode.c size = fs->e2fs_bsize;
fs 327 ufs/ext2fs/ext2fs_inode.c lastblock = lblkno(fs, length + fs->e2fs_bsize - 1) - 1;
fs 329 ufs/ext2fs/ext2fs_inode.c lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
fs 330 ufs/ext2fs/ext2fs_inode.c lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
fs 331 ufs/ext2fs/ext2fs_inode.c nblocks = btodb(fs->e2fs_bsize);
fs 365 ufs/ext2fs/ext2fs_inode.c indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) -1;
fs 366 ufs/ext2fs/ext2fs_inode.c indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;
fs 371 ufs/ext2fs/ext2fs_inode.c fsbtodb(fs, bn), lastiblock[level], level, &count);
fs 394 ufs/ext2fs/ext2fs_inode.c blocksreleased += btodb(fs->e2fs_bsize);
fs 437 ufs/ext2fs/ext2fs_inode.c struct m_ext2fs *fs = ip->i_e2fs;
fs 452 ufs/ext2fs/ext2fs_inode.c factor *= NINDIR(fs);
fs 456 ufs/ext2fs/ext2fs_inode.c nblocks = btodb(fs->e2fs_bsize);
fs 466 ufs/ext2fs/ext2fs_inode.c bp = getblk(vp, lbn, (int)fs->e2fs_bsize, 0, 0);
fs 484 ufs/ext2fs/ext2fs_inode.c MALLOC(copy, int32_t *, fs->e2fs_bsize, M_TEMP, M_WAITOK);
fs 485 ufs/ext2fs/ext2fs_inode.c memcpy((caddr_t)copy, (caddr_t)bap, (u_int)fs->e2fs_bsize);
fs 487 ufs/ext2fs/ext2fs_inode.c (u_int)(NINDIR(fs) - (last + 1)) * sizeof (u_int32_t));
fs 497 ufs/ext2fs/ext2fs_inode.c for (i = NINDIR(fs) - 1,
fs 504 ufs/ext2fs/ext2fs_inode.c error = ext2fs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
fs 522 ufs/ext2fs/ext2fs_inode.c error = ext2fs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
fs 134 ufs/ext2fs/ext2fs_lookup.c struct m_ext2fs *fs = VTOI(vp)->i_e2fs;
fs 150 ufs/ext2fs/ext2fs_lookup.c entries = (uio->uio_offset + e2fs_count) & (fs->e2fs_bsize - 1);
fs 71 ufs/ext2fs/ext2fs_readwrite.c struct m_ext2fs *fs;
fs 94 ufs/ext2fs/ext2fs_readwrite.c fs = ip->i_e2fs;
fs 96 ufs/ext2fs/ext2fs_readwrite.c ((u_int64_t)0x80000000 * fs->e2fs_bsize - 1))
fs 104 ufs/ext2fs/ext2fs_readwrite.c lbn = lblkno(fs, uio->uio_offset);
fs 106 ufs/ext2fs/ext2fs_readwrite.c size = fs->e2fs_bsize;
fs 107 ufs/ext2fs/ext2fs_readwrite.c blkoffset = blkoff(fs, uio->uio_offset);
fs 108 ufs/ext2fs/ext2fs_readwrite.c xfersize = fs->e2fs_bsize - blkoffset;
fs 114 ufs/ext2fs/ext2fs_readwrite.c if (lblktosize(fs, nextlbn) >= ext2fs_size(ip))
fs 117 ufs/ext2fs/ext2fs_readwrite.c int nextsize = fs->e2fs_bsize;
fs 163 ufs/ext2fs/ext2fs_readwrite.c struct m_ext2fs *fs;
fs 205 ufs/ext2fs/ext2fs_readwrite.c fs = ip->i_e2fs;
fs 208 ufs/ext2fs/ext2fs_readwrite.c ((u_int64_t)0x80000000 * fs->e2fs_bsize - 1))
fs 227 ufs/ext2fs/ext2fs_readwrite.c lbn = lblkno(fs, uio->uio_offset);
fs 228 ufs/ext2fs/ext2fs_readwrite.c blkoffset = blkoff(fs, uio->uio_offset);
fs 229 ufs/ext2fs/ext2fs_readwrite.c xfersize = fs->e2fs_bsize - blkoffset;
fs 232 ufs/ext2fs/ext2fs_readwrite.c if (fs->e2fs_bsize > xfersize)
fs 249 ufs/ext2fs/ext2fs_readwrite.c size = fs->e2fs_bsize - bp->b_resid;
fs 257 ufs/ext2fs/ext2fs_readwrite.c else if (xfersize + blkoffset == fs->e2fs_bsize) {
fs 83 ufs/ext2fs/ext2fs_subr.c struct m_ext2fs *fs;
fs 89 ufs/ext2fs/ext2fs_subr.c fs = ip->i_e2fs;
fs 90 ufs/ext2fs/ext2fs_subr.c lbn = lblkno(fs, offset);
fs 93 ufs/ext2fs/ext2fs_subr.c if ((error = bread(vp, lbn, fs->e2fs_bsize, NOCRED, &bp)) != 0) {
fs 98 ufs/ext2fs/ext2fs_subr.c *res = (char *)bp->b_data + blkoff(fs, offset);
fs 129 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs;
fs 156 ufs/ext2fs/ext2fs_vfsops.c fs = ump->um_e2fs;
fs 157 ufs/ext2fs/ext2fs_vfsops.c bzero(fs->e2fs_fsmnt, sizeof(fs->e2fs_fsmnt));
fs 158 ufs/ext2fs/ext2fs_vfsops.c (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt,
fs 159 ufs/ext2fs/ext2fs_vfsops.c sizeof(fs->e2fs_fsmnt) - 1, 0);
fs 160 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs.e2fs_rev > E2FS_REV0) {
fs 161 ufs/ext2fs/ext2fs_vfsops.c bzero(fs->e2fs.e2fs_fsmnt, sizeof(fs->e2fs.e2fs_fsmnt));
fs 162 ufs/ext2fs/ext2fs_vfsops.c (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt,
fs 163 ufs/ext2fs/ext2fs_vfsops.c sizeof(fs->e2fs.e2fs_fsmnt) - 1, 0);
fs 167 ufs/ext2fs/ext2fs_vfsops.c inittodr(fs->e2fs.e2fs_wtime);
fs 183 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs;
fs 197 ufs/ext2fs/ext2fs_vfsops.c fs = ump->um_e2fs;
fs 198 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
fs 205 ufs/ext2fs/ext2fs_vfsops.c (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
fs 206 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs.e2fs_state = E2FS_ISCLEAN;
fs 211 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_ronly = 1;
fs 218 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) {
fs 234 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_ronly = 0;
fs 235 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs.e2fs_state == E2FS_ISCLEAN)
fs 236 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs.e2fs_state = 0;
fs 238 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs.e2fs_state = E2FS_ERRORS;
fs 239 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_fmod = 1;
fs 295 ufs/ext2fs/ext2fs_vfsops.c fs = ump->um_e2fs;
fs 296 ufs/ext2fs/ext2fs_vfsops.c (void) copyinstr(path, fs->e2fs_fsmnt, sizeof(fs->e2fs_fsmnt) - 1,
fs 298 ufs/ext2fs/ext2fs_vfsops.c bzero(fs->e2fs_fsmnt + size, sizeof(fs->e2fs_fsmnt) - size);
fs 299 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs.e2fs_rev > E2FS_REV0) {
fs 300 ufs/ext2fs/ext2fs_vfsops.c (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt,
fs 301 ufs/ext2fs/ext2fs_vfsops.c sizeof(fs->e2fs.e2fs_fsmnt) - 1, &size);
fs 302 ufs/ext2fs/ext2fs_vfsops.c bzero(fs->e2fs.e2fs_fsmnt, sizeof(fs->e2fs.e2fs_fsmnt) - size);
fs 304 ufs/ext2fs/ext2fs_vfsops.c bcopy(fs->e2fs_fsmnt, mp->mnt_stat.f_mntonname, MNAMELEN);
fs 308 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs_fmod != 0) { /* XXX */
fs 309 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_fmod = 0;
fs 310 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs.e2fs_state == 0)
fs 311 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs.e2fs_wtime = time_second;
fs 323 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs;
fs 359 ufs/ext2fs/ext2fs_vfsops.c fsbtodb(era->fs, ino_to_fsba(era->fs, ip->i_number)),
fs 360 ufs/ext2fs/ext2fs_vfsops.c (int)era->fs->e2fs_bsize, NOCRED, &bp);
fs 366 ufs/ext2fs/ext2fs_vfsops.c (ino_to_fsbo(era->fs, ip->i_number) * EXT2_DINODE_SIZE);
fs 391 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs;
fs 425 ufs/ext2fs/ext2fs_vfsops.c fs = VFSTOUFS(mountp)->um_e2fs;
fs 429 ufs/ext2fs/ext2fs_vfsops.c e2fs_sbload(newfs, &fs->e2fs);
fs 430 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_ncg =
fs 431 ufs/ext2fs/ext2fs_vfsops.c howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,
fs 432 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs.e2fs_bpg);
fs 434 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + 1;
fs 435 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_bsize = 1024 << fs->e2fs.e2fs_log_bsize;
fs 436 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize;
fs 437 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_qbmask = fs->e2fs_bsize - 1;
fs 438 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_bmask = ~fs->e2fs_qbmask;
fs 439 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_ngdb = howmany(fs->e2fs_ncg,
fs 440 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_bsize / sizeof(struct ext2_gd));
fs 441 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_ipb = fs->e2fs_bsize / EXT2_DINODE_SIZE;
fs 442 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_itpg = fs->e2fs.e2fs_ipg/fs->e2fs_ipb;
fs 448 ufs/ext2fs/ext2fs_vfsops.c for (i=0; i < fs->e2fs_ngdb; i++) {
fs 450 ufs/ext2fs/ext2fs_vfsops.c fsbtodb(fs, ((fs->e2fs_bsize>1024)? 0 : 1) + i + 1),
fs 451 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_bsize, NOCRED, &bp);
fs 457 ufs/ext2fs/ext2fs_vfsops.c &fs->e2fs_gd[i* fs->e2fs_bsize / sizeof(struct ext2_gd)],
fs 458 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_bsize);
fs 464 ufs/ext2fs/ext2fs_vfsops.c era.fs = fs;
fs 480 ufs/ext2fs/ext2fs_vfsops.c struct ext2fs *fs;
fs 521 ufs/ext2fs/ext2fs_vfsops.c fs = (struct ext2fs *)bp->b_data;
fs 522 ufs/ext2fs/ext2fs_vfsops.c error = ext2fs_checksb(fs, ronly);
fs 610 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs;
fs 619 ufs/ext2fs/ext2fs_vfsops.c fs = ump->um_e2fs;
fs 620 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs_ronly == 0 &&
fs 622 ufs/ext2fs/ext2fs_vfsops.c (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
fs 623 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs.e2fs_state = E2FS_ISCLEAN;
fs 630 ufs/ext2fs/ext2fs_vfsops.c error = VOP_CLOSE(ump->um_devvp, fs->e2fs_ronly ? FREAD : FREAD|FWRITE,
fs 633 ufs/ext2fs/ext2fs_vfsops.c free(fs->e2fs_gd, M_UFSMNT);
fs 634 ufs/ext2fs/ext2fs_vfsops.c free(fs, M_UFSMNT);
fs 672 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs;
fs 677 ufs/ext2fs/ext2fs_vfsops.c fs = ump->um_e2fs;
fs 678 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs.e2fs_magic != E2FS_MAGIC)
fs 686 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_itpg;
fs 687 ufs/ext2fs/ext2fs_vfsops.c overhead = fs->e2fs.e2fs_first_dblock +
fs 688 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_ncg * overhead_per_group;
fs 689 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs.e2fs_rev > E2FS_REV0 &&
fs 690 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSESUPER) {
fs 691 ufs/ext2fs/ext2fs_vfsops.c for (i = 0, ngroups = 0; i < fs->e2fs_ncg; i++) {
fs 696 ufs/ext2fs/ext2fs_vfsops.c ngroups = fs->e2fs_ncg;
fs 698 ufs/ext2fs/ext2fs_vfsops.c overhead += ngroups * (1 + fs->e2fs_ngdb);
fs 700 ufs/ext2fs/ext2fs_vfsops.c sbp->f_bsize = fs->e2fs_bsize;
fs 701 ufs/ext2fs/ext2fs_vfsops.c sbp->f_iosize = fs->e2fs_bsize;
fs 702 ufs/ext2fs/ext2fs_vfsops.c sbp->f_blocks = fs->e2fs.e2fs_bcount - overhead;
fs 703 ufs/ext2fs/ext2fs_vfsops.c sbp->f_bfree = fs->e2fs.e2fs_fbcount;
fs 704 ufs/ext2fs/ext2fs_vfsops.c sbp->f_bavail = sbp->f_bfree - fs->e2fs.e2fs_rbcount;
fs 705 ufs/ext2fs/ext2fs_vfsops.c sbp->f_files = fs->e2fs.e2fs_icount;
fs 706 ufs/ext2fs/ext2fs_vfsops.c sbp->f_ffree = fs->e2fs.e2fs_ficount;
fs 758 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs;
fs 762 ufs/ext2fs/ext2fs_vfsops.c fs = ump->um_e2fs;
fs 763 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs_ronly != 0) { /* XXX */
fs 764 ufs/ext2fs/ext2fs_vfsops.c printf("fs = %s\n", fs->e2fs_fsmnt);
fs 792 ufs/ext2fs/ext2fs_vfsops.c if (fs->e2fs_fmod != 0) {
fs 793 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_fmod = 0;
fs 794 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs.e2fs_wtime = time_second;
fs 810 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs;
fs 838 ufs/ext2fs/ext2fs_vfsops.c ip->i_e2fs = fs = ump->um_e2fs;
fs 862 ufs/ext2fs/ext2fs_vfsops.c error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
fs 863 ufs/ext2fs/ext2fs_vfsops.c (int)fs->e2fs_bsize, NOCRED, &bp);
fs 877 ufs/ext2fs/ext2fs_vfsops.c dp = (struct ext2fs_dinode *) bp->b_data + ino_to_fsbo(fs, ino);
fs 949 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs;
fs 952 ufs/ext2fs/ext2fs_vfsops.c fs = VFSTOUFS(mp)->um_e2fs;
fs 954 ufs/ext2fs/ext2fs_vfsops.c ufhp->ufid_ino > fs->e2fs_ncg * fs->e2fs.e2fs_ipg)
fs 1007 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs = mp->um_e2fs;
fs 1012 ufs/ext2fs/ext2fs_vfsops.c e2fs_sbsave(&fs->e2fs, (struct ext2fs *) bp->b_data);
fs 1023 ufs/ext2fs/ext2fs_vfsops.c struct m_ext2fs *fs = mp->um_e2fs;
fs 1028 ufs/ext2fs/ext2fs_vfsops.c for (i = 0; i < fs->e2fs_ngdb; i++) {
fs 1029 ufs/ext2fs/ext2fs_vfsops.c bp = getblk(mp->um_devvp, fsbtodb(fs, ((fs->e2fs_bsize>1024)?0:1)+i+1),
fs 1030 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_bsize, 0, 0);
fs 1031 ufs/ext2fs/ext2fs_vfsops.c e2fs_cgsave(&fs->e2fs_gd[i* fs->e2fs_bsize / sizeof(struct ext2_gd)], (struct ext2_gd*)bp->b_data, fs->e2fs_bsize);
fs 1044 ufs/ext2fs/ext2fs_vfsops.c ext2fs_checksb(struct ext2fs *fs, int ronly)
fs 1046 ufs/ext2fs/ext2fs_vfsops.c if (fs2h16(fs->e2fs_magic) != E2FS_MAGIC) {
fs 1049 ufs/ext2fs/ext2fs_vfsops.c if (fs2h32(fs->e2fs_rev) > E2FS_REV1) {
fs 1052 ufs/ext2fs/ext2fs_vfsops.c fs2h32(fs->e2fs_rev));
fs 1056 ufs/ext2fs/ext2fs_vfsops.c if (fs2h32(fs->e2fs_log_bsize) > 2) { /* block size = 1024|2048|4096 */
fs 1059 ufs/ext2fs/ext2fs_vfsops.c fs2h32(fs->e2fs_log_bsize));
fs 1063 ufs/ext2fs/ext2fs_vfsops.c if (fs2h32(fs->e2fs_rev) > E2FS_REV0) {
fs 1064 ufs/ext2fs/ext2fs_vfsops.c if (fs2h32(fs->e2fs_first_ino) != EXT2_FIRSTINO ||
fs 1065 ufs/ext2fs/ext2fs_vfsops.c fs2h16(fs->e2fs_inode_size) != EXT2_DINODE_SIZE) {
fs 1069 ufs/ext2fs/ext2fs_vfsops.c if (fs2h32(fs->e2fs_features_incompat) &
fs 1074 ufs/ext2fs/ext2fs_vfsops.c if (!ronly && fs2h32(fs->e2fs_features_rocompat) &
fs 66 ufs/ffs/ffs_alloc.c #define ffs_fserr(fs, uid, cp) do { \
fs 68 ufs/ffs/ffs_alloc.c (fs)->fs_fsmnt, (cp)); \
fs 79 ufs/ffs/ffs_alloc.c daddr_t ffs_mapsearch(struct fs *, struct cg *, daddr_t, int);
fs 113 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 119 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 121 ufs/ffs/ffs_alloc.c if ((u_int)size > fs->fs_bsize || fragoff(fs, size) != 0) {
fs 123 ufs/ffs/ffs_alloc.c ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt);
fs 129 ufs/ffs/ffs_alloc.c if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)
fs 131 ufs/ffs/ffs_alloc.c if (cred->cr_uid != 0 && freespace(fs, fs->fs_minfree) <= 0)
fs 142 ufs/ffs/ffs_alloc.c if (bpref >= fs->fs_size)
fs 145 ufs/ffs/ffs_alloc.c cg = ino_to_cg(fs, ip->i_number);
fs 147 ufs/ffs/ffs_alloc.c cg = dtog(fs, bpref);
fs 163 ufs/ffs/ffs_alloc.c ffs_fserr(fs, cred->cr_uid, "file system full");
fs 164 ufs/ffs/ffs_alloc.c uprintf("\n%s: write failed, file system is full\n", fs->fs_fsmnt);
fs 180 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 188 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 190 ufs/ffs/ffs_alloc.c if ((u_int)osize > fs->fs_bsize || fragoff(fs, osize) != 0 ||
fs 191 ufs/ffs/ffs_alloc.c (u_int)nsize > fs->fs_bsize || fragoff(fs, nsize) != 0) {
fs 194 ufs/ffs/ffs_alloc.c ip->i_dev, fs->fs_bsize, osize, nsize, fs->fs_fsmnt);
fs 200 ufs/ffs/ffs_alloc.c if (cred->cr_uid != 0 && freespace(fs, fs->fs_minfree) <= 0)
fs 207 ufs/ffs/ffs_alloc.c ip->i_dev, fs->fs_bsize, bprev, fs->fs_fsmnt);
fs 215 ufs/ffs/ffs_alloc.c if ((error = bread(ITOV(ip), lbprev, fs->fs_bsize,
fs 230 ufs/ffs/ffs_alloc.c cg = dtog(fs, bprev);
fs 235 ufs/ffs/ffs_alloc.c if (bp->b_blkno != fsbtodb(fs, bno))
fs 254 ufs/ffs/ffs_alloc.c if (bpref >= fs->fs_size)
fs 256 ufs/ffs/ffs_alloc.c switch (fs->fs_optim) {
fs 266 ufs/ffs/ffs_alloc.c if (fs->fs_minfree < 5 ||
fs 267 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nffree >
fs 268 ufs/ffs/ffs_alloc.c fs->fs_dsize * fs->fs_minfree / (2 * 100))
fs 270 ufs/ffs/ffs_alloc.c fs->fs_optim = FS_OPTTIME;
fs 283 ufs/ffs/ffs_alloc.c request = fs->fs_bsize;
fs 284 ufs/ffs/ffs_alloc.c if (fs->fs_cstotal.cs_nffree <
fs 285 ufs/ffs/ffs_alloc.c fs->fs_dsize * (fs->fs_minfree - 2) / 100)
fs 287 ufs/ffs/ffs_alloc.c fs->fs_optim = FS_OPTSPACE;
fs 291 ufs/ffs/ffs_alloc.c ip->i_dev, fs->fs_optim, fs->fs_fsmnt);
fs 304 ufs/ffs/ffs_alloc.c ffs_blkfree(ip, bno + numfrags(fs, nsize),
fs 309 ufs/ffs/ffs_alloc.c bp->b_blkno = fsbtodb(fs, bno);
fs 328 ufs/ffs/ffs_alloc.c ffs_fserr(fs, cred->cr_uid, "file system full");
fs 329 ufs/ffs/ffs_alloc.c uprintf("\n%s: write failed, file system is full\n", fs->fs_fsmnt);
fs 370 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 382 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 383 ufs/ffs/ffs_alloc.c if (fs->fs_contigsumsize <= 0)
fs 393 ufs/ffs/ffs_alloc.c dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))
fs 401 ufs/ffs/ffs_alloc.c ssize = fsbtodb(fs, fs->fs_frag);
fs 411 ufs/ffs/ffs_alloc.c if (dtog(fs, dbtofsb(fs, buflist->bs_children[0]->b_blkno)) !=
fs 412 ufs/ffs/ffs_alloc.c dtog(fs, dbtofsb(fs, buflist->bs_children[len - 1]->b_blkno)))
fs 425 ufs/ffs/ffs_alloc.c if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &sbp)) {
fs 448 ufs/ffs/ffs_alloc.c if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &ebp))
fs 455 ufs/ffs/ffs_alloc.c if ((newblk = (daddr_t)ffs_hashalloc(ip, dtog(fs, pref), (long)pref,
fs 471 ufs/ffs/ffs_alloc.c for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->fs_frag) {
fs 478 ufs/ffs/ffs_alloc.c dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))
fs 480 ufs/ffs/ffs_alloc.c if (dbtofsb(fs, buflist->bs_children[i]->b_blkno) != *bap)
fs 490 ufs/ffs/ffs_alloc.c blkno, *bap, fs->fs_bsize, fs->fs_bsize,
fs 538 ufs/ffs/ffs_alloc.c for (blkno = newblk, i = 0; i < len; i++, blkno += fs->fs_frag) {
fs 541 ufs/ffs/ffs_alloc.c dbtofsb(fs, buflist->bs_children[i]->b_blkno),
fs 542 ufs/ffs/ffs_alloc.c fs->fs_bsize);
fs 543 ufs/ffs/ffs_alloc.c buflist->bs_children[i]->b_blkno = fsbtodb(fs, blkno);
fs 546 ufs/ffs/ffs_alloc.c dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))
fs 573 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 587 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 590 ufs/ffs/ffs_alloc.c if (fs->fs_contigsumsize <= 0)
fs 601 ufs/ffs/ffs_alloc.c dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))
fs 609 ufs/ffs/ffs_alloc.c ssize = fsbtodb(fs, fs->fs_frag);
fs 621 ufs/ffs/ffs_alloc.c if (dtog(fs, dbtofsb(fs, buflist->bs_children[0]->b_blkno)) !=
fs 622 ufs/ffs/ffs_alloc.c dtog(fs, dbtofsb(fs, buflist->bs_children[len - 1]->b_blkno)))
fs 636 ufs/ffs/ffs_alloc.c if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &sbp)) {
fs 655 ufs/ffs/ffs_alloc.c if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &ebp))
fs 668 ufs/ffs/ffs_alloc.c if ((newblk = ffs_hashalloc(ip, dtog(fs, pref), pref,
fs 687 ufs/ffs/ffs_alloc.c for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->fs_frag) {
fs 694 ufs/ffs/ffs_alloc.c dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))
fs 696 ufs/ffs/ffs_alloc.c if (dbtofsb(fs, buflist->bs_children[i]->b_blkno) != *bap)
fs 706 ufs/ffs/ffs_alloc.c blkno, *bap, fs->fs_bsize, fs->fs_bsize,
fs 755 ufs/ffs/ffs_alloc.c for (blkno = newblk, i = 0; i < len; i++, blkno += fs->fs_frag) {
fs 757 ufs/ffs/ffs_alloc.c ffs_blkfree(ip, dbtofsb(fs,
fs 758 ufs/ffs/ffs_alloc.c buflist->bs_children[i]->b_blkno), fs->fs_bsize);
fs 759 ufs/ffs/ffs_alloc.c buflist->bs_children[i]->b_blkno = fsbtodb(fs, blkno);
fs 762 ufs/ffs/ffs_alloc.c dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))
fs 828 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 834 ufs/ffs/ffs_alloc.c fs = pip->i_fs;
fs 835 ufs/ffs/ffs_alloc.c if (fs->fs_cstotal.cs_nifree == 0)
fs 842 ufs/ffs/ffs_alloc.c if (ipref >= fs->fs_ncg * fs->fs_ipg)
fs 844 ufs/ffs/ffs_alloc.c cg = ino_to_cg(fs, ipref);
fs 851 ufs/ffs/ffs_alloc.c if (fs->fs_contigdirs[cg] < 255)
fs 852 ufs/ffs/ffs_alloc.c fs->fs_contigdirs[cg]++;
fs 854 ufs/ffs/ffs_alloc.c if (fs->fs_contigdirs[cg] > 0)
fs 855 ufs/ffs/ffs_alloc.c fs->fs_contigdirs[cg]--;
fs 870 ufs/ffs/ffs_alloc.c DIP(ip, mode), ip->i_number, fs->fs_fsmnt);
fs 876 ufs/ffs/ffs_alloc.c fs->fs_fsmnt, ino, DIP(ip, blocks));
fs 896 ufs/ffs/ffs_alloc.c ffs_fserr(fs, cred->cr_uid, "out of inodes");
fs 897 ufs/ffs/ffs_alloc.c uprintf("\n%s: create/symlink failed, no inodes free\n", fs->fs_fsmnt);
fs 917 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 924 ufs/ffs/ffs_alloc.c fs = pip->i_fs;
fs 926 ufs/ffs/ffs_alloc.c avgifree = fs->fs_cstotal.cs_nifree / fs->fs_ncg;
fs 927 ufs/ffs/ffs_alloc.c avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
fs 928 ufs/ffs/ffs_alloc.c avgndir = fs->fs_cstotal.cs_ndir / fs->fs_ncg;
fs 935 ufs/ffs/ffs_alloc.c prefcg = (arc4random() & INT_MAX) % fs->fs_ncg;
fs 937 ufs/ffs/ffs_alloc.c minndir = fs->fs_ipg;
fs 938 ufs/ffs/ffs_alloc.c for (cg = prefcg; cg < fs->fs_ncg; cg++)
fs 939 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_ndir < minndir &&
fs 940 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nifree >= avgifree &&
fs 941 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
fs 943 ufs/ffs/ffs_alloc.c minndir = fs->fs_cs(fs, cg).cs_ndir;
fs 946 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_ndir < minndir &&
fs 947 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nifree >= avgifree &&
fs 948 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
fs 950 ufs/ffs/ffs_alloc.c minndir = fs->fs_cs(fs, cg).cs_ndir;
fs 955 ufs/ffs/ffs_alloc.c prefcg = ino_to_cg(fs, pip->i_number);
fs 957 ufs/ffs/ffs_alloc.c prefcg = ino_to_cg(fs, pip->i_number);
fs 965 ufs/ffs/ffs_alloc.c maxndir = min(avgndir + fs->fs_ipg / 16, fs->fs_ipg);
fs 966 ufs/ffs/ffs_alloc.c minifree = avgifree - fs->fs_ipg / 4;
fs 969 ufs/ffs/ffs_alloc.c minbfree = avgbfree - fs->fs_fpg / fs->fs_frag / 4;
fs 973 ufs/ffs/ffs_alloc.c maxndir = avgndir + (fs->fs_ipg - avgndir) / 16;
fs 977 ufs/ffs/ffs_alloc.c cgsize = fs->fs_fsize * fs->fs_fpg;
fs 978 ufs/ffs/ffs_alloc.c dirsize = fs->fs_avgfilesize * fs->fs_avgfpdir;
fs 979 ufs/ffs/ffs_alloc.c curdirsize = avgndir ? (cgsize - avgbfree * fs->fs_bsize) / avgndir : 0;
fs 983 ufs/ffs/ffs_alloc.c if (fs->fs_avgfpdir > 0)
fs 985 ufs/ffs/ffs_alloc.c fs->fs_ipg / fs->fs_avgfpdir);
fs 994 ufs/ffs/ffs_alloc.c for (cg = prefcg; cg < fs->fs_ncg; cg++)
fs 995 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_ndir < maxndir &&
fs 996 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nifree >= minifree &&
fs 997 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nbfree >= minbfree) {
fs 998 ufs/ffs/ffs_alloc.c if (fs->fs_contigdirs[cg] < maxcontigdirs)
fs 1002 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_ndir < maxndir &&
fs 1003 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nifree >= minifree &&
fs 1004 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nbfree >= minbfree) {
fs 1005 ufs/ffs/ffs_alloc.c if (fs->fs_contigdirs[cg] < maxcontigdirs)
fs 1011 ufs/ffs/ffs_alloc.c for (cg = prefcg; cg < fs->fs_ncg; cg++)
fs 1012 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_nifree >= avgifree)
fs 1015 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_nifree >= avgifree)
fs 1018 ufs/ffs/ffs_alloc.c return ((ino_t)(fs->fs_ipg * cg));
fs 1043 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1046 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 1047 ufs/ffs/ffs_alloc.c if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {
fs 1048 ufs/ffs/ffs_alloc.c if (lbn < NDADDR + NINDIR(fs)) {
fs 1049 ufs/ffs/ffs_alloc.c cg = ino_to_cg(fs, ip->i_number);
fs 1050 ufs/ffs/ffs_alloc.c return (fs->fs_fpg * cg + fs->fs_frag);
fs 1058 ufs/ffs/ffs_alloc.c ino_to_cg(fs, ip->i_number) + lbn / fs->fs_maxbpg;
fs 1060 ufs/ffs/ffs_alloc.c startcg = dtog(fs, bap[indx - 1]) + 1;
fs 1061 ufs/ffs/ffs_alloc.c startcg %= fs->fs_ncg;
fs 1062 ufs/ffs/ffs_alloc.c avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
fs 1063 ufs/ffs/ffs_alloc.c for (cg = startcg; cg < fs->fs_ncg; cg++)
fs 1064 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
fs 1065 ufs/ffs/ffs_alloc.c fs->fs_cgrotor = cg;
fs 1066 ufs/ffs/ffs_alloc.c return (fs->fs_fpg * cg + fs->fs_frag);
fs 1069 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
fs 1070 ufs/ffs/ffs_alloc.c fs->fs_cgrotor = cg;
fs 1071 ufs/ffs/ffs_alloc.c return (fs->fs_fpg * cg + fs->fs_frag);
fs 1076 ufs/ffs/ffs_alloc.c return (bap[indx - 1] + fs->fs_frag);
fs 1086 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1089 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 1091 ufs/ffs/ffs_alloc.c if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {
fs 1092 ufs/ffs/ffs_alloc.c if (lbn < NDADDR + NINDIR(fs)) {
fs 1093 ufs/ffs/ffs_alloc.c cg = ino_to_cg(fs, ip->i_number);
fs 1094 ufs/ffs/ffs_alloc.c return (fs->fs_fpg * cg + fs->fs_frag);
fs 1102 ufs/ffs/ffs_alloc.c startcg = ino_to_cg(fs, ip->i_number) +
fs 1103 ufs/ffs/ffs_alloc.c lbn / fs->fs_maxbpg;
fs 1105 ufs/ffs/ffs_alloc.c startcg = dtog(fs, bap[indx - 1] + 1);
fs 1107 ufs/ffs/ffs_alloc.c startcg %= fs->fs_ncg;
fs 1108 ufs/ffs/ffs_alloc.c avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
fs 1110 ufs/ffs/ffs_alloc.c for (cg = startcg; cg < fs->fs_ncg; cg++)
fs 1111 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree)
fs 1112 ufs/ffs/ffs_alloc.c return (fs->fs_fpg * cg + fs->fs_frag);
fs 1115 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree)
fs 1116 ufs/ffs/ffs_alloc.c return (fs->fs_fpg * cg + fs->fs_frag);
fs 1124 ufs/ffs/ffs_alloc.c return (bap[indx - 1] + fs->fs_frag);
fs 1141 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1145 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 1155 ufs/ffs/ffs_alloc.c for (i = 1; i < fs->fs_ncg; i *= 2) {
fs 1157 ufs/ffs/ffs_alloc.c if (cg >= fs->fs_ncg)
fs 1158 ufs/ffs/ffs_alloc.c cg -= fs->fs_ncg;
fs 1168 ufs/ffs/ffs_alloc.c cg = (icg + 2) % fs->fs_ncg;
fs 1169 ufs/ffs/ffs_alloc.c for (i = 2; i < fs->fs_ncg; i++) {
fs 1174 ufs/ffs/ffs_alloc.c if (cg == fs->fs_ncg)
fs 1189 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1196 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 1197 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_nffree < numfrags(fs, nsize - osize))
fs 1199 ufs/ffs/ffs_alloc.c frags = numfrags(fs, nsize);
fs 1200 ufs/ffs/ffs_alloc.c bbase = fragnum(fs, bprev);
fs 1201 ufs/ffs/ffs_alloc.c if (bbase > fragnum(fs, (bprev + frags - 1))) {
fs 1205 ufs/ffs/ffs_alloc.c error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
fs 1206 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
fs 1219 ufs/ffs/ffs_alloc.c bno = dtogd(fs, bprev);
fs 1220 ufs/ffs/ffs_alloc.c for (i = numfrags(fs, osize); i < frags; i++)
fs 1231 ufs/ffs/ffs_alloc.c for (i = frags; i < fs->fs_frag - bbase; i++)
fs 1234 ufs/ffs/ffs_alloc.c cgp->cg_frsum[i - numfrags(fs, osize)]--;
fs 1237 ufs/ffs/ffs_alloc.c for (i = numfrags(fs, osize); i < frags; i++) {
fs 1240 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nffree--;
fs 1241 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nffree--;
fs 1243 ufs/ffs/ffs_alloc.c fs->fs_fmod = 1;
fs 1245 ufs/ffs/ffs_alloc.c softdep_setup_blkmapdep(bp, fs, bprev);
fs 1260 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1266 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 1267 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)
fs 1270 ufs/ffs/ffs_alloc.c error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
fs 1271 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
fs 1278 ufs/ffs/ffs_alloc.c (cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize)) {
fs 1285 ufs/ffs/ffs_alloc.c if (size == fs->fs_bsize) {
fs 1296 ufs/ffs/ffs_alloc.c frags = numfrags(fs, size);
fs 1297 ufs/ffs/ffs_alloc.c for (allocsiz = frags; allocsiz < fs->fs_frag; allocsiz++)
fs 1300 ufs/ffs/ffs_alloc.c if (allocsiz == fs->fs_frag) {
fs 1310 ufs/ffs/ffs_alloc.c bpref = dtogd(fs, bno);
fs 1311 ufs/ffs/ffs_alloc.c for (i = frags; i < fs->fs_frag; i++)
fs 1313 ufs/ffs/ffs_alloc.c i = fs->fs_frag - frags;
fs 1315 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nffree += i;
fs 1316 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nffree += i;
fs 1317 ufs/ffs/ffs_alloc.c fs->fs_fmod = 1;
fs 1322 ufs/ffs/ffs_alloc.c bno = ffs_mapsearch(fs, cgp, bpref, allocsiz);
fs 1331 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nffree -= frags;
fs 1332 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nffree -= frags;
fs 1333 ufs/ffs/ffs_alloc.c fs->fs_fmod = 1;
fs 1338 ufs/ffs/ffs_alloc.c blkno = cg * fs->fs_fpg + bno;
fs 1340 ufs/ffs/ffs_alloc.c softdep_setup_blkmapdep(bp, fs, blkno);
fs 1353 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1359 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 1363 ufs/ffs/ffs_alloc.c if (bpref == 0 || dtog(fs, bpref) != cgp->cg_cgx)
fs 1366 ufs/ffs/ffs_alloc.c bpref = blknum(fs, bpref);
fs 1367 ufs/ffs/ffs_alloc.c bno = dtogd(fs, bpref);
fs 1371 ufs/ffs/ffs_alloc.c if (ffs_isblock(fs, blksfree, fragstoblks(fs, bno)))
fs 1378 ufs/ffs/ffs_alloc.c bno = ffs_mapsearch(fs, cgp, bpref, (int) fs->fs_frag);
fs 1385 ufs/ffs/ffs_alloc.c blkno = fragstoblks(fs, bno);
fs 1386 ufs/ffs/ffs_alloc.c ffs_clrblock(fs, blksfree, (long) blkno);
fs 1387 ufs/ffs/ffs_alloc.c ffs_clusteracct(fs, cgp, blkno, -1);
fs 1389 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nbfree--;
fs 1390 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--;
fs 1392 ufs/ffs/ffs_alloc.c if (fs->fs_magic != FS_UFS2_MAGIC) {
fs 1393 ufs/ffs/ffs_alloc.c cylno = cbtocylno(fs, bno);
fs 1394 ufs/ffs/ffs_alloc.c cg_blks(fs, cgp, cylno)[cbtorpos(fs, bno)]--;
fs 1398 ufs/ffs/ffs_alloc.c fs->fs_fmod = 1;
fs 1399 ufs/ffs/ffs_alloc.c blkno = cgp->cg_cgx * fs->fs_fpg + bno;
fs 1402 ufs/ffs/ffs_alloc.c softdep_setup_blkmapdep(bp, fs, blkno);
fs 1417 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1424 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 1425 ufs/ffs/ffs_alloc.c if (fs->fs_maxcluster[cg] < len)
fs 1427 ufs/ffs/ffs_alloc.c if (bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize,
fs 1438 ufs/ffs/ffs_alloc.c for (i = len; i <= fs->fs_contigsumsize; i++)
fs 1441 ufs/ffs/ffs_alloc.c if (i > fs->fs_contigsumsize) {
fs 1453 ufs/ffs/ffs_alloc.c fs->fs_maxcluster[cg] = i;
fs 1467 ufs/ffs/ffs_alloc.c if (dtog(fs, bpref) != cg)
fs 1470 ufs/ffs/ffs_alloc.c bpref = fragstoblks(fs, dtogd(fs, blknum(fs, bpref)));
fs 1498 ufs/ffs/ffs_alloc.c if (!ffs_isblock(fs, cg_blksfree(cgp), got - run + i))
fs 1501 ufs/ffs/ffs_alloc.c bno = cg * fs->fs_fpg + blkstofrags(fs, got - run + 1);
fs 1503 ufs/ffs/ffs_alloc.c if (dtog(fs, bno) != cg)
fs 1507 ufs/ffs/ffs_alloc.c len = blkstofrags(fs, len);
fs 1508 ufs/ffs/ffs_alloc.c for (i = 0; i < len; i += fs->fs_frag)
fs 1523 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1537 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 1538 ufs/ffs/ffs_alloc.c if (fs->fs_cs(fs, cg).cs_nifree == 0)
fs 1541 ufs/ffs/ffs_alloc.c error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
fs 1542 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
fs 1564 ufs/ffs/ffs_alloc.c ipref %= fs->fs_ipg;
fs 1574 ufs/ffs/ffs_alloc.c len = howmany(fs->fs_ipg - cgp->cg_irotor, NBBY);
fs 1591 ufs/ffs/ffs_alloc.c cg, cgp->cg_irotor, fs->fs_fsmnt);
fs 1614 ufs/ffs/ffs_alloc.c printf("fs = %s\n", fs->fs_fsmnt);
fs 1627 ufs/ffs/ffs_alloc.c if (fs->fs_magic == FS_UFS2_MAGIC &&
fs 1629 ufs/ffs/ffs_alloc.c ipref + INOPB(fs) > cgp->cg_initediblk &&
fs 1633 ufs/ffs/ffs_alloc.c ibp = getblk(ip->i_devvp, fsbtodb(fs,
fs 1634 ufs/ffs/ffs_alloc.c ino_to_fsba(fs, cg * fs->fs_ipg + cgp->cg_initediblk)),
fs 1635 ufs/ffs/ffs_alloc.c (int)fs->fs_bsize, 0, 0);
fs 1637 ufs/ffs/ffs_alloc.c bzero(ibp->b_data, (int)fs->fs_bsize);
fs 1641 ufs/ffs/ffs_alloc.c for (i = 0; i < INOPB(fs); i++) {
fs 1647 ufs/ffs/ffs_alloc.c cgp->cg_initediblk += INOPB(fs);
fs 1652 ufs/ffs/ffs_alloc.c softdep_setup_inomapdep(bp, ip, cg * fs->fs_ipg + ipref);
fs 1658 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nifree--;
fs 1659 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nifree--;
fs 1660 ufs/ffs/ffs_alloc.c fs->fs_fmod = 1; /* file system was modified */
fs 1665 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_ndir++;
fs 1666 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_ndir++;
fs 1677 ufs/ffs/ffs_alloc.c return (cg * fs->fs_ipg + ipref);
fs 1690 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1696 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 1697 ufs/ffs/ffs_alloc.c if ((u_int)size > fs->fs_bsize || fragoff(fs, size) != 0 ||
fs 1698 ufs/ffs/ffs_alloc.c fragnum(fs, bno) + numfrags(fs, size) > fs->fs_frag) {
fs 1700 ufs/ffs/ffs_alloc.c ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt);
fs 1703 ufs/ffs/ffs_alloc.c cg = dtog(fs, bno);
fs 1704 ufs/ffs/ffs_alloc.c if ((u_int)bno >= fs->fs_size) {
fs 1706 ufs/ffs/ffs_alloc.c ffs_fserr(fs, DIP(ip, uid), "bad block");
fs 1709 ufs/ffs/ffs_alloc.c error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
fs 1710 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
fs 1723 ufs/ffs/ffs_alloc.c bno = dtogd(fs, bno);
fs 1724 ufs/ffs/ffs_alloc.c if (size == fs->fs_bsize) {
fs 1725 ufs/ffs/ffs_alloc.c blkno = fragstoblks(fs, bno);
fs 1726 ufs/ffs/ffs_alloc.c if (!ffs_isfreeblock(fs, cg_blksfree(cgp), blkno)) {
fs 1728 ufs/ffs/ffs_alloc.c ip->i_dev, bno, fs->fs_fsmnt);
fs 1731 ufs/ffs/ffs_alloc.c ffs_setblock(fs, cg_blksfree(cgp), blkno);
fs 1732 ufs/ffs/ffs_alloc.c ffs_clusteracct(fs, cgp, blkno, 1);
fs 1734 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nbfree++;
fs 1735 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nbfree++;
fs 1737 ufs/ffs/ffs_alloc.c if (fs->fs_magic != FS_UFS2_MAGIC) {
fs 1738 ufs/ffs/ffs_alloc.c i = cbtocylno(fs, bno);
fs 1739 ufs/ffs/ffs_alloc.c cg_blks(fs, cgp, i)[cbtorpos(fs, bno)]++;
fs 1744 ufs/ffs/ffs_alloc.c bbase = bno - fragnum(fs, bno);
fs 1748 ufs/ffs/ffs_alloc.c blk = blkmap(fs, cg_blksfree(cgp), bbase);
fs 1749 ufs/ffs/ffs_alloc.c ffs_fragacct(fs, blk, cgp->cg_frsum, -1);
fs 1753 ufs/ffs/ffs_alloc.c frags = numfrags(fs, size);
fs 1757 ufs/ffs/ffs_alloc.c ip->i_dev, bno + i, fs->fs_fsmnt);
fs 1763 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nffree += i;
fs 1764 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nffree += i;
fs 1768 ufs/ffs/ffs_alloc.c blk = blkmap(fs, cg_blksfree(cgp), bbase);
fs 1769 ufs/ffs/ffs_alloc.c ffs_fragacct(fs, blk, cgp->cg_frsum, 1);
fs 1773 ufs/ffs/ffs_alloc.c blkno = fragstoblks(fs, bbase);
fs 1774 ufs/ffs/ffs_alloc.c if (ffs_isblock(fs, cg_blksfree(cgp), blkno)) {
fs 1775 ufs/ffs/ffs_alloc.c cgp->cg_cs.cs_nffree -= fs->fs_frag;
fs 1776 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nffree -= fs->fs_frag;
fs 1777 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nffree -= fs->fs_frag;
fs 1778 ufs/ffs/ffs_alloc.c ffs_clusteracct(fs, cgp, blkno, 1);
fs 1780 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nbfree++;
fs 1781 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nbfree++;
fs 1783 ufs/ffs/ffs_alloc.c if (fs->fs_magic != FS_UFS2_MAGIC) {
fs 1784 ufs/ffs/ffs_alloc.c i = cbtocylno(fs, bbase);
fs 1785 ufs/ffs/ffs_alloc.c cg_blks(fs, cgp, i)[cbtorpos(fs, bbase)]++;
fs 1790 ufs/ffs/ffs_alloc.c fs->fs_fmod = 1;
fs 1814 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1819 ufs/ffs/ffs_alloc.c fs = pip->i_fs;
fs 1820 ufs/ffs/ffs_alloc.c if ((u_int)ino >= fs->fs_ipg * fs->fs_ncg)
fs 1822 ufs/ffs/ffs_alloc.c pip->i_dev, ino, fs->fs_fsmnt);
fs 1823 ufs/ffs/ffs_alloc.c cg = ino_to_cg(fs, ino);
fs 1824 ufs/ffs/ffs_alloc.c error = bread(pip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
fs 1825 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
fs 1838 ufs/ffs/ffs_alloc.c ino %= fs->fs_ipg;
fs 1841 ufs/ffs/ffs_alloc.c pip->i_dev, ino, fs->fs_fsmnt);
fs 1842 ufs/ffs/ffs_alloc.c if (fs->fs_ronly == 0)
fs 1849 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_nifree++;
fs 1850 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_nifree++;
fs 1853 ufs/ffs/ffs_alloc.c fs->fs_cstotal.cs_ndir--;
fs 1854 ufs/ffs/ffs_alloc.c fs->fs_cs(fs, cg).cs_ndir--;
fs 1856 ufs/ffs/ffs_alloc.c fs->fs_fmod = 1;
fs 1869 ufs/ffs/ffs_alloc.c struct fs *fs;
fs 1874 ufs/ffs/ffs_alloc.c fs = ip->i_fs;
fs 1875 ufs/ffs/ffs_alloc.c if ((u_int)size > fs->fs_bsize || fragoff(fs, size) != 0) {
fs 1877 ufs/ffs/ffs_alloc.c fs->fs_bsize, size, fs->fs_fsmnt);
fs 1880 ufs/ffs/ffs_alloc.c if ((u_int)bno >= fs->fs_size)
fs 1882 ufs/ffs/ffs_alloc.c error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, dtog(fs, bno))),
fs 1883 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
fs 1895 ufs/ffs/ffs_alloc.c bno = dtogd(fs, bno);
fs 1896 ufs/ffs/ffs_alloc.c if (size == fs->fs_bsize) {
fs 1897 ufs/ffs/ffs_alloc.c free = ffs_isblock(fs, cg_blksfree(cgp), fragstoblks(fs, bno));
fs 1899 ufs/ffs/ffs_alloc.c frags = numfrags(fs, size);
fs 1919 ufs/ffs/ffs_alloc.c ffs_mapsearch(struct fs *fs, struct cg *cgp, daddr_t bpref, int allocsiz)
fs 1930 ufs/ffs/ffs_alloc.c start = dtogd(fs, bpref) / NBBY;
fs 1933 ufs/ffs/ffs_alloc.c len = howmany(fs->fs_fpg, NBBY) - start;
fs 1935 ufs/ffs/ffs_alloc.c (u_char *)fragtbl[fs->fs_frag],
fs 1936 ufs/ffs/ffs_alloc.c (u_char)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
fs 1941 ufs/ffs/ffs_alloc.c (u_char *)fragtbl[fs->fs_frag],
fs 1942 ufs/ffs/ffs_alloc.c (u_char)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
fs 1945 ufs/ffs/ffs_alloc.c start, len, fs->fs_fsmnt);
fs 1956 ufs/ffs/ffs_alloc.c for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {
fs 1957 ufs/ffs/ffs_alloc.c blk = blkmap(fs, cg_blksfree(cgp), bno);
fs 1961 ufs/ffs/ffs_alloc.c for (pos = 0; pos <= fs->fs_frag - allocsiz; pos++) {
fs 1968 ufs/ffs/ffs_alloc.c printf("bno = %d, fs = %s\n", bno, fs->fs_fsmnt);
fs 1979 ufs/ffs/ffs_alloc.c ffs_clusteracct(struct fs *fs, struct cg *cgp, daddr_t blkno, int cnt)
fs 1986 ufs/ffs/ffs_alloc.c if (fs->fs_contigsumsize <= 0)
fs 2001 ufs/ffs/ffs_alloc.c end = start + fs->fs_contigsumsize;
fs 2022 ufs/ffs/ffs_alloc.c end = start - fs->fs_contigsumsize;
fs 2044 ufs/ffs/ffs_alloc.c if (i > fs->fs_contigsumsize)
fs 2045 ufs/ffs/ffs_alloc.c i = fs->fs_contigsumsize;
fs 2054 ufs/ffs/ffs_alloc.c lp = &sump[fs->fs_contigsumsize];
fs 2055 ufs/ffs/ffs_alloc.c for (i = fs->fs_contigsumsize; i > 0; i--)
fs 2058 ufs/ffs/ffs_alloc.c fs->fs_maxcluster[cgp->cg_cgx] = i;
fs 77 ufs/ffs/ffs_balloc.c struct fs *fs;
fs 89 ufs/ffs/ffs_balloc.c fs = ip->i_fs;
fs 91 ufs/ffs/ffs_balloc.c lbn = lblkno(fs, startoffset);
fs 92 ufs/ffs/ffs_balloc.c size = blkoff(fs, startoffset) + size;
fs 93 ufs/ffs/ffs_balloc.c if (size > fs->fs_bsize)
fs 105 ufs/ffs/ffs_balloc.c nb = lblkno(fs, ip->i_ffs1_size);
fs 107 ufs/ffs/ffs_balloc.c osize = blksize(fs, ip, nb);
fs 108 ufs/ffs/ffs_balloc.c if (osize < fs->fs_bsize && osize > 0) {
fs 111 ufs/ffs/ffs_balloc.c osize, (int)fs->fs_bsize, cred, bpp, &newb);
fs 116 ufs/ffs/ffs_balloc.c ip->i_ffs1_db[nb], fs->fs_bsize, osize,
fs 119 ufs/ffs/ffs_balloc.c ip->i_ffs1_size = lblktosize(fs, nb + 1);
fs 136 ufs/ffs/ffs_balloc.c if (nb != 0 && ip->i_ffs1_size >= lblktosize(fs, lbn + 1)) {
fs 145 ufs/ffs/ffs_balloc.c error = bread(vp, lbn, fs->fs_bsize, NOCRED,
fs 158 ufs/ffs/ffs_balloc.c osize = fragroundup(fs, blkoff(fs, ip->i_ffs1_size));
fs 159 ufs/ffs/ffs_balloc.c nsize = fragroundup(fs, size);
fs 167 ufs/ffs/ffs_balloc.c error = bread(vp, lbn, fs->fs_bsize,
fs 198 ufs/ffs/ffs_balloc.c if (ip->i_ffs1_size < lblktosize(fs, lbn + 1))
fs 199 ufs/ffs/ffs_balloc.c nsize = fragroundup(fs, size);
fs 201 ufs/ffs/ffs_balloc.c nsize = fs->fs_bsize;
fs 208 ufs/ffs/ffs_balloc.c *bpp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
fs 209 ufs/ffs/ffs_balloc.c if (nsize < fs->fs_bsize)
fs 211 ufs/ffs/ffs_balloc.c (*bpp)->b_blkno = fsbtodb(fs, newb);
fs 244 ufs/ffs/ffs_balloc.c error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,
fs 251 ufs/ffs/ffs_balloc.c bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0);
fs 252 ufs/ffs/ffs_balloc.c bp->b_blkno = fsbtodb(fs, nb);
fs 257 ufs/ffs/ffs_balloc.c newb, 0, fs->fs_bsize, 0, bp);
fs 277 ufs/ffs/ffs_balloc.c indirs[i].in_lbn, (int)fs->fs_bsize, NOCRED, &bp);
fs 293 ufs/ffs/ffs_balloc.c error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred,
fs 301 ufs/ffs/ffs_balloc.c nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0);
fs 302 ufs/ffs/ffs_balloc.c nbp->b_blkno = fsbtodb(fs, nb);
fs 337 ufs/ffs/ffs_balloc.c error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred,
fs 346 ufs/ffs/ffs_balloc.c nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
fs 347 ufs/ffs/ffs_balloc.c nbp->b_blkno = fsbtodb(fs, nb);
fs 370 ufs/ffs/ffs_balloc.c error = bread(vp, lbn, (int)fs->fs_bsize, NOCRED, &nbp);
fs 376 ufs/ffs/ffs_balloc.c nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
fs 377 ufs/ffs/ffs_balloc.c nbp->b_blkno = fsbtodb(fs, nb);
fs 402 ufs/ffs/ffs_balloc.c ffs_blkfree(ip, *blkp, fs->fs_bsize);
fs 403 ufs/ffs/ffs_balloc.c deallocated += fs->fs_bsize;
fs 411 ufs/ffs/ffs_balloc.c (int)fs->fs_bsize, NOCRED, &bp);
fs 446 ufs/ffs/ffs_balloc.c struct fs *fs;
fs 451 ufs/ffs/ffs_balloc.c fs = ip->i_fs;
fs 455 ufs/ffs/ffs_balloc.c lbn = lblkno(fs, off);
fs 456 ufs/ffs/ffs_balloc.c size = blkoff(fs, off) + size;
fs 458 ufs/ffs/ffs_balloc.c if (size > fs->fs_bsize)
fs 472 ufs/ffs/ffs_balloc.c lastlbn = lblkno(fs, ip->i_ffs2_size);
fs 475 ufs/ffs/ffs_balloc.c osize = blksize(fs, ip, nb);
fs 476 ufs/ffs/ffs_balloc.c if (osize < fs->fs_bsize && osize > 0) {
fs 479 ufs/ffs/ffs_balloc.c (int) fs->fs_bsize, cred, bpp, &newb);
fs 485 ufs/ffs/ffs_balloc.c ip->i_ffs2_db[nb], fs->fs_bsize, osize,
fs 488 ufs/ffs/ffs_balloc.c ip->i_ffs2_size = lblktosize(fs, nb + 1);
fs 509 ufs/ffs/ffs_balloc.c if (nb != 0 && ip->i_ffs2_size >= lblktosize(fs, lbn + 1)) {
fs 516 ufs/ffs/ffs_balloc.c error = bread(vp, lbn, fs->fs_bsize, NOCRED,
fs 531 ufs/ffs/ffs_balloc.c osize = fragroundup(fs, blkoff(fs, ip->i_ffs2_size));
fs 532 ufs/ffs/ffs_balloc.c nsize = fragroundup(fs, size);
fs 540 ufs/ffs/ffs_balloc.c error = bread(vp, lbn, fs->fs_bsize,
fs 572 ufs/ffs/ffs_balloc.c if (ip->i_ffs2_size < lblktosize(fs, lbn + 1))
fs 573 ufs/ffs/ffs_balloc.c nsize = fragroundup(fs, size);
fs 575 ufs/ffs/ffs_balloc.c nsize = fs->fs_bsize;
fs 583 ufs/ffs/ffs_balloc.c bp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
fs 584 ufs/ffs/ffs_balloc.c if (nsize < fs->fs_bsize)
fs 586 ufs/ffs/ffs_balloc.c bp->b_blkno = fsbtodb(fs, newb);
fs 626 ufs/ffs/ffs_balloc.c error = ffs_alloc(ip, lbn, pref, (int) fs->fs_bsize, cred,
fs 633 ufs/ffs/ffs_balloc.c bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0);
fs 634 ufs/ffs/ffs_balloc.c bp->b_blkno = fsbtodb(fs, nb);
fs 639 ufs/ffs/ffs_balloc.c newb, 0, fs->fs_bsize, 0, bp);
fs 661 ufs/ffs/ffs_balloc.c error = bread(vp, indirs[i].in_lbn, (int) fs->fs_bsize,
fs 684 ufs/ffs/ffs_balloc.c error = ffs_alloc(ip, lbn, pref, (int) fs->fs_bsize, cred,
fs 693 ufs/ffs/ffs_balloc.c nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0);
fs 694 ufs/ffs/ffs_balloc.c nbp->b_blkno = fsbtodb(fs, nb);
fs 734 ufs/ffs/ffs_balloc.c error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred,
fs 745 ufs/ffs/ffs_balloc.c nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
fs 746 ufs/ffs/ffs_balloc.c nbp->b_blkno = fsbtodb(fs, nb);
fs 777 ufs/ffs/ffs_balloc.c error = bread(vp, lbn, (int)fs->fs_bsize, NOCRED, &nbp);
fs 783 ufs/ffs/ffs_balloc.c nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
fs 784 ufs/ffs/ffs_balloc.c nbp->b_blkno = fsbtodb(fs, nb);
fs 822 ufs/ffs/ffs_balloc.c bp = getblk(vp, indirs[i].in_lbn, (int) fs->fs_bsize,
fs 825 ufs/ffs/ffs_balloc.c nb = fsbtodb(fs, cgtod(fs, dtog(fs,
fs 826 ufs/ffs/ffs_balloc.c dbtofsb(fs, bp->b_blkno))));
fs 829 ufs/ffs/ffs_balloc.c (int) fs->fs_cgsize, 0, 0);
fs 858 ufs/ffs/ffs_balloc.c (int) fs->fs_bsize, NOCRED, &bp);
fs 868 ufs/ffs/ffs_balloc.c bp = getblk(vp, indirs[i].in_lbn, (int)fs->fs_bsize, 0,
fs 876 ufs/ffs/ffs_balloc.c ffs_blkfree(ip, *blkp, fs->fs_bsize);
fs 877 ufs/ffs/ffs_balloc.c deallocated += fs->fs_bsize;
fs 81 ufs/ffs/ffs_extern.h struct fs;
fs 114 ufs/ffs/ffs_extern.h void ffs_clusteracct(struct fs *, struct cg *, daddr_t, int);
fs 126 ufs/ffs/ffs_extern.h void ffs_fragacct(struct fs *, int, int32_t[], int);
fs 130 ufs/ffs/ffs_extern.h int ffs_isfreeblock(struct fs *, unsigned char *, daddr_t);
fs 131 ufs/ffs/ffs_extern.h int ffs_isblock(struct fs *, unsigned char *, daddr_t);
fs 132 ufs/ffs/ffs_extern.h void ffs_clrblock(struct fs *, u_char *, daddr_t);
fs 133 ufs/ffs/ffs_extern.h void ffs_setblock(struct fs *, unsigned char *, daddr_t);
fs 141 ufs/ffs/ffs_extern.h int ffs_oldfscompat(struct fs *);
fs 170 ufs/ffs/ffs_extern.h int softdep_mount(struct vnode *, struct mount *, struct fs *,
fs 179 ufs/ffs/ffs_extern.h void softdep_setup_blkmapdep(struct buf *, struct fs *, daddr_t);
fs 72 ufs/ffs/ffs_inode.c struct fs *fs;
fs 113 ufs/ffs/ffs_inode.c fs = ip->i_fs;
fs 119 ufs/ffs/ffs_inode.c if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_inodefmt < FS_44INODEFMT) {
fs 124 ufs/ffs/ffs_inode.c error = bread(ip->i_devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
fs 125 ufs/ffs/ffs_inode.c (int)fs->fs_bsize, NOCRED, &bp);
fs 139 ufs/ffs/ffs_inode.c ino_to_fsbo(fs, ip->i_number)) = *ip->i_din2;
fs 143 ufs/ffs/ffs_inode.c ino_to_fsbo(fs, ip->i_number)) = *ip->i_din1;
fs 168 ufs/ffs/ffs_inode.c struct fs *fs;
fs 232 ufs/ffs/ffs_inode.c fs = oip->i_fs;
fs 240 ufs/ffs/ffs_inode.c if (length > fs->fs_maxfilesize)
fs 269 ufs/ffs/ffs_inode.c offset = blkoff(fs, length);
fs 273 ufs/ffs/ffs_inode.c lbn = lblkno(fs, length);
fs 290 ufs/ffs/ffs_inode.c fragroundup(fs, blkoff(fs, length)) < fs->fs_bsize &&
fs 294 ufs/ffs/ffs_inode.c size = blksize(fs, oip, lbn);
fs 311 ufs/ffs/ffs_inode.c lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;
fs 313 ufs/ffs/ffs_inode.c lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
fs 314 ufs/ffs/ffs_inode.c lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
fs 315 ufs/ffs/ffs_inode.c nblocks = btodb(fs->fs_bsize);
fs 365 ufs/ffs/ffs_inode.c indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;
fs 366 ufs/ffs/ffs_inode.c indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;
fs 371 ufs/ffs/ffs_inode.c fsbtodb(fs, bn), lastiblock[level], level, &count);
fs 377 ufs/ffs/ffs_inode.c ffs_blkfree(oip, bn, fs->fs_bsize);
fs 396 ufs/ffs/ffs_inode.c bsize = blksize(fs, oip, i);
fs 415 ufs/ffs/ffs_inode.c oldspace = blksize(fs, oip, lastblock);
fs 417 ufs/ffs/ffs_inode.c newspace = blksize(fs, oip, lastblock);
fs 426 ufs/ffs/ffs_inode.c bn += numfrags(fs, newspace);
fs 473 ufs/ffs/ffs_inode.c struct fs *fs = ip->i_fs;
fs 492 ufs/ffs/ffs_inode.c factor *= NINDIR(fs);
fs 496 ufs/ffs/ffs_inode.c nblocks = btodb(fs->fs_bsize);
fs 506 ufs/ffs/ffs_inode.c bp = getblk(vp, lbn, (int)fs->fs_bsize, 0, 0);
fs 530 ufs/ffs/ffs_inode.c MALLOC(copy, void *, fs->fs_bsize, M_TEMP, M_WAITOK);
fs 531 ufs/ffs/ffs_inode.c bcopy(bp->b_data, copy, (u_int) fs->fs_bsize);
fs 533 ufs/ffs/ffs_inode.c for (i = last + 1; i < NINDIR(fs); i++)
fs 555 ufs/ffs/ffs_inode.c for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;
fs 561 ufs/ffs/ffs_inode.c error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
fs 568 ufs/ffs/ffs_inode.c ffs_blkfree(ip, nb, fs->fs_bsize);
fs 579 ufs/ffs/ffs_inode.c error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
fs 123 ufs/ffs/ffs_softdep.c STATIC int flush_inodedep_deps(struct fs *, ino_t);
fs 159 ufs/ffs/ffs_softdep.c STATIC int newblk_lookup(struct fs *, daddr_t, int,
fs 161 ufs/ffs/ffs_softdep.c STATIC int inodedep_lookup(struct fs *, ino_t, int, struct inodedep **);
fs 1053 ufs/ffs/ffs_softdep.c #define INODEDEP_HASH(fs, inum) \
fs 1054 ufs/ffs/ffs_softdep.c (&inodedep_hashtbl[((((register_t)(fs)) >> 13) + (inum)) & inodedep_hash])
fs 1064 ufs/ffs/ffs_softdep.c inodedep_lookup(fs, inum, flags, inodedeppp)
fs 1065 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 1081 ufs/ffs/ffs_softdep.c inodedephd = INODEDEP_HASH(fs, inum);
fs 1084 ufs/ffs/ffs_softdep.c if (inum == inodedep->id_ino && fs == inodedep->id_fs)
fs 1109 ufs/ffs/ffs_softdep.c inodedep->id_fs = fs;
fs 1133 ufs/ffs/ffs_softdep.c #define NEWBLK_HASH(fs, inum) \
fs 1134 ufs/ffs/ffs_softdep.c (&newblk_hashtbl[((((register_t)(fs)) >> 13) + (inum)) & newblk_hash])
fs 1143 ufs/ffs/ffs_softdep.c newblk_lookup(fs, newblkno, flags, newblkpp)
fs 1144 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 1152 ufs/ffs/ffs_softdep.c newblkhd = NEWBLK_HASH(fs, newblkno);
fs 1155 ufs/ffs/ffs_softdep.c if (newblkno == newblk->nb_newblkno && fs == newblk->nb_fs)
fs 1169 ufs/ffs/ffs_softdep.c newblk->nb_fs = fs;
fs 1243 ufs/ffs/ffs_softdep.c softdep_mount(devvp, mp, fs, cred)
fs 1246 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 1259 ufs/ffs/ffs_softdep.c if ((fs->fs_flags & FS_UNCLEAN) == 0)
fs 1262 ufs/ffs/ffs_softdep.c for (cyl = 0; cyl < fs->fs_ncg; cyl++) {
fs 1263 ufs/ffs/ffs_softdep.c if ((error = bread(devvp, fsbtodb(fs, cgtod(fs, cyl)),
fs 1264 ufs/ffs/ffs_softdep.c fs->fs_cgsize, cred, &bp)) != 0) {
fs 1273 ufs/ffs/ffs_softdep.c fs->fs_cs(fs, cyl) = cgp->cg_cs;
fs 1277 ufs/ffs/ffs_softdep.c if (bcmp(&cstotal, &fs->fs_cstotal, sizeof cstotal))
fs 1280 ufs/ffs/ffs_softdep.c bcopy(&cstotal, &fs->fs_cstotal, sizeof cstotal);
fs 1352 ufs/ffs/ffs_softdep.c softdep_setup_blkmapdep(bp, fs, newblkno)
fs 1354 ufs/ffs/ffs_softdep.c struct fs *fs; /* filesystem doing allocation */
fs 1365 ufs/ffs/ffs_softdep.c if (newblk_lookup(fs, newblkno, DEPALLOC, &newblk) != 0)
fs 1626 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 1630 ufs/ffs/ffs_softdep.c fs = ip->i_fs;
fs 1631 ufs/ffs/ffs_softdep.c if (fragnum(fs, blkno) + numfrags(fs, size) > fs->fs_frag)
fs 1925 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 1928 ufs/ffs/ffs_softdep.c fs = ip->i_fs;
fs 1962 ufs/ffs/ffs_softdep.c fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
fs 1963 ufs/ffs/ffs_softdep.c (int)fs->fs_bsize, NOCRED, &bp)) != 0)
fs 1968 ufs/ffs/ffs_softdep.c ino_to_fsbo(fs, ip->i_number)) = *ip->i_din1;
fs 1971 ufs/ffs/ffs_softdep.c ino_to_fsbo(fs, ip->i_number)) = *ip->i_din2;
fs 1977 ufs/ffs/ffs_softdep.c (void) inodedep_lookup(fs, ip->i_number, DEPALLOC, &inodedep);
fs 2018 ufs/ffs/ffs_softdep.c (void) inodedep_lookup(fs, ip->i_number, 0, &inodedep);
fs 2025 ufs/ffs/ffs_softdep.c if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) != 0)
fs 2396 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 2407 ufs/ffs/ffs_softdep.c tip.i_fs = fs = VFSTOUFS(freeblks->fb_mnt)->um_fs;
fs 2417 ufs/ffs/ffs_softdep.c tmpval *= NINDIR(fs);
fs 2420 ufs/ffs/ffs_softdep.c nblocks = btodb(fs->fs_bsize);
fs 2428 ufs/ffs/ffs_softdep.c if ((error = indir_trunc(&tip, fsbtodb(fs, bn), level,
fs 2431 ufs/ffs/ffs_softdep.c ffs_blkfree(&tip, bn, fs->fs_bsize);
fs 2440 ufs/ffs/ffs_softdep.c bsize = blksize(fs, &tip, i);
fs 2471 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 2477 ufs/ffs/ffs_softdep.c fs = ip->i_fs;
fs 2480 ufs/ffs/ffs_softdep.c lbnadd *= NINDIR(fs);
fs 2511 ufs/ffs/ffs_softdep.c error = bread(ip->i_devvp, dbn, (int)fs->fs_bsize, NOCRED, &bp);
fs 2525 ufs/ffs/ffs_softdep.c nblocks = btodb(fs->fs_bsize);
fs 2526 ufs/ffs/ffs_softdep.c for (i = NINDIR(fs) - 1; i >= 0; i--) {
fs 2534 ufs/ffs/ffs_softdep.c if ((error = indir_trunc(ip, fsbtodb(fs, nb),
fs 2538 ufs/ffs/ffs_softdep.c ffs_blkfree(ip, nb, fs->fs_bsize);
fs 2612 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 2621 ufs/ffs/ffs_softdep.c fs = dp->i_fs;
fs 2622 ufs/ffs/ffs_softdep.c lbn = lblkno(fs, diroffset);
fs 2623 ufs/ffs/ffs_softdep.c offset = blkoff(fs, diroffset);
fs 2630 ufs/ffs/ffs_softdep.c if (isnewblk && lbn < NDADDR && fragoff(fs, diroffset) == 0) {
fs 2661 ufs/ffs/ffs_softdep.c if (inodedep_lookup(fs, dp->i_number, 0, &inodedep) == 0
fs 2683 ufs/ffs/ffs_softdep.c (void) inodedep_lookup(fs, newinum, DEPALLOC, &inodedep);
fs 2703 ufs/ffs/ffs_softdep.c if (blkoff(fs, diroffset) == 0)
fs 2713 ufs/ffs/ffs_softdep.c if (fragoff(fs, diroffset) != 0) {
fs 2726 ufs/ffs/ffs_softdep.c if (inodedep_lookup(fs, dp->i_number, 0, &inodedep) == 0)
fs 3242 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 3250 ufs/ffs/ffs_softdep.c fs = VFSTOUFS(freefile->fx_mnt)->um_fs;
fs 3253 ufs/ffs/ffs_softdep.c error = inodedep_lookup(fs, freefile->fx_oldinum, 0, &idp);
fs 3260 ufs/ffs/ffs_softdep.c tip.i_fs = fs;
fs 3442 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 3454 ufs/ffs/ffs_softdep.c fs = inodedep->id_fs;
fs 3456 ufs/ffs/ffs_softdep.c ino_to_fsbo(fs, inodedep->id_ino);
fs 3527 ufs/ffs/ffs_softdep.c if (adp->ad_oldsize == 0 || adp->ad_oldsize == fs->fs_bsize)
fs 3529 ufs/ffs/ffs_softdep.c dp->di_size = fs->fs_bsize * adp->ad_lbn + adp->ad_oldsize;
fs 3558 ufs/ffs/ffs_softdep.c dp->di_size <= (lastadp->ad_lbn + 1) * fs->fs_bsize) {
fs 3562 ufs/ffs/ffs_softdep.c dp->di_size = (i + 1) * fs->fs_bsize;
fs 3590 ufs/ffs/ffs_softdep.c struct fs *fs = inodedep->id_fs;
fs 3599 ufs/ffs/ffs_softdep.c fs = inodedep->id_fs;
fs 3601 ufs/ffs/ffs_softdep.c ino_to_fsbo(fs, inodedep->id_ino);
fs 3664 ufs/ffs/ffs_softdep.c if (adp->ad_oldsize == 0 || adp->ad_oldsize == fs->fs_bsize)
fs 3666 ufs/ffs/ffs_softdep.c dp->di_extsize = fs->fs_bsize * adp->ad_lbn + adp->ad_oldsize;
fs 3686 ufs/ffs/ffs_softdep.c dp->di_extsize <= (lastadp->ad_lbn + 1) * fs->fs_bsize) {
fs 3690 ufs/ffs/ffs_softdep.c dp->di_extsize = (i + 1) * fs->fs_bsize;
fs 3741 ufs/ffs/ffs_softdep.c if (adp->ad_oldsize == 0 || adp->ad_oldsize == fs->fs_bsize)
fs 3743 ufs/ffs/ffs_softdep.c dp->di_size = fs->fs_bsize * adp->ad_lbn + adp->ad_oldsize;
fs 3772 ufs/ffs/ffs_softdep.c dp->di_size <= (lastadp->ad_lbn + 1) * fs->fs_bsize) {
fs 3776 ufs/ffs/ffs_softdep.c dp->di_size = (i + 1) * fs->fs_bsize;
fs 4558 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 4565 ufs/ffs/ffs_softdep.c fs = ip->i_fs;
fs 4567 ufs/ffs/ffs_softdep.c if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) == 0) {
fs 4656 ufs/ffs/ffs_softdep.c error = bread(pvp, lbn, fs->fs_bsize, p->p_ucred, &bp);
fs 4658 ufs/ffs/ffs_softdep.c bp->b_bcount = blksize(fs, pip, lbn);
fs 4666 ufs/ffs/ffs_softdep.c if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) == 0)
fs 4993 ufs/ffs/ffs_softdep.c flush_inodedep_deps(fs, ino)
fs 4994 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 5020 ufs/ffs/ffs_softdep.c if (inodedep_lookup(fs, ino, 0, &inodedep) == 0)
fs 5074 ufs/ffs/ffs_softdep.c if (inodedep_lookup(fs, ino, 0, &inodedep) != 0)
fs 5431 ufs/ffs/ffs_softdep.c struct fs *fs;
fs 5455 ufs/ffs/ffs_softdep.c fs = inodedep->id_fs;
fs 5457 ufs/ffs/ffs_softdep.c if ((mp->mnt_flag & MNT_SOFTDEP) && fs == VFSTOUFS(mp)->um_fs)
fs 5462 ufs/ffs/ffs_softdep.c firstino = inodedep->id_ino & ~(INOPB(fs) - 1);
fs 5463 ufs/ffs/ffs_softdep.c for (lastino = firstino + INOPB(fs) - 1; lastino > firstino; lastino--)
fs 5464 ufs/ffs/ffs_softdep.c if (inodedep_lookup(fs, lastino, 0, &inodedep) != 0)
fs 5472 ufs/ffs/ffs_softdep.c if (inodedep_lookup(fs, ino, 0, &inodedep) == 0)
fs 56 ufs/ffs/ffs_softdep_stub.c softdep_mount(struct vnode *devvp, struct mount *mp, struct fs *fs,
fs 77 ufs/ffs/ffs_softdep_stub.c softdep_setup_blkmapdep(struct buf *bp, struct fs *fs, daddr_t newblkno)
fs 59 ufs/ffs/ffs_subr.c struct fs *fs;
fs 66 ufs/ffs/ffs_subr.c fs = ip->i_fs;
fs 67 ufs/ffs/ffs_subr.c lbn = lblkno(fs, offset);
fs 68 ufs/ffs/ffs_subr.c bsize = blksize(fs, ip, lbn);
fs 71 ufs/ffs/ffs_subr.c if ((error = bread(vp, lbn, fs->fs_bsize, NOCRED, &bp)) != 0) {
fs 77 ufs/ffs/ffs_subr.c *res = (char *)bp->b_data + blkoff(fs, offset);
fs 83 ufs/ffs/ffs_subr.c void ffs_fragacct(struct fs *, int, int32_t[], int);
fs 84 ufs/ffs/ffs_subr.c int ffs_isfreeblock(struct fs *, unsigned char *, daddr_t);
fs 85 ufs/ffs/ffs_subr.c int ffs_isblock(struct fs *, unsigned char *, daddr_t);
fs 86 ufs/ffs/ffs_subr.c void ffs_clrblock(struct fs *, u_char *, daddr_t);
fs 87 ufs/ffs/ffs_subr.c void ffs_setblock(struct fs *, unsigned char *, daddr_t);
fs 96 ufs/ffs/ffs_subr.c ffs_fragacct(struct fs *fs, int fragmap, int32_t fraglist[], int cnt)
fs 102 ufs/ffs/ffs_subr.c inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1;
fs 104 ufs/ffs/ffs_subr.c for (siz = 1; siz < fs->fs_frag; siz++) {
fs 105 ufs/ffs/ffs_subr.c if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0)
fs 109 ufs/ffs/ffs_subr.c for (pos = siz; pos <= fs->fs_frag; pos++) {
fs 159 ufs/ffs/ffs_subr.c ffs_isblock(struct fs *fs, unsigned char *cp, daddr_t h)
fs 163 ufs/ffs/ffs_subr.c switch (fs->fs_frag) {
fs 183 ufs/ffs/ffs_subr.c ffs_clrblock(struct fs *fs, u_char *cp, daddr_t h)
fs 186 ufs/ffs/ffs_subr.c switch (fs->fs_frag) {
fs 207 ufs/ffs/ffs_subr.c ffs_setblock(struct fs *fs, unsigned char *cp, daddr_t h)
fs 210 ufs/ffs/ffs_subr.c switch (fs->fs_frag) {
fs 231 ufs/ffs/ffs_subr.c ffs_isfreeblock(struct fs *fs, unsigned char *cp, daddr_t h)
fs 234 ufs/ffs/ffs_subr.c switch (fs->fs_frag) {
fs 70 ufs/ffs/ffs_vfsops.c int ffs_validate(struct fs *);
fs 72 ufs/ffs/ffs_vfsops.c void ffs1_compat_read(struct fs *, struct ufsmount *, daddr64_t);
fs 73 ufs/ffs/ffs_vfsops.c void ffs1_compat_write(struct fs *, struct ufsmount *);
fs 114 ufs/ffs/ffs_vfsops.c struct fs *fs;
fs 149 ufs/ffs/ffs_vfsops.c fs = ump->um_fs;
fs 150 ufs/ffs/ffs_vfsops.c (void) copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
fs 153 ufs/ffs/ffs_vfsops.c inittodr(fs->fs_time);
fs 170 ufs/ffs/ffs_vfsops.c struct fs *fs;
fs 202 ufs/ffs/ffs_vfsops.c fs = ump->um_fs;
fs 205 ufs/ffs/ffs_vfsops.c ronly = fs->fs_ronly;
fs 219 ufs/ffs/ffs_vfsops.c if (fs->fs_flags & FS_DOSOFTDEP) {
fs 232 ufs/ffs/ffs_vfsops.c if ((fs->fs_flags & FS_DOSOFTDEP) &&
fs 234 ufs/ffs/ffs_vfsops.c !(mp->mnt_flag & MNT_RDONLY) && fs->fs_ronly == 0) {
fs 248 ufs/ffs/ffs_vfsops.c if (!(fs->fs_flags & FS_DOSOFTDEP) &&
fs 249 ufs/ffs/ffs_vfsops.c (mp->mnt_flag & MNT_SOFTDEP) && fs->fs_ronly == 0) {
fs 279 ufs/ffs/ffs_vfsops.c if (fs->fs_clean == 0) {
fs 287 ufs/ffs/ffs_vfsops.c if (fs->fs_flags & FS_DOSOFTDEP)
fs 290 ufs/ffs/ffs_vfsops.c fs->fs_fsmnt);
fs 296 ufs/ffs/ffs_vfsops.c fs->fs_fsmnt);
fs 300 ufs/ffs/ffs_vfsops.c fs->fs_fsmnt);
fs 306 ufs/ffs/ffs_vfsops.c if ((fs->fs_flags & FS_DOSOFTDEP)) {
fs 307 ufs/ffs/ffs_vfsops.c error = softdep_mount(devvp, mp, fs,
fs 312 ufs/ffs/ffs_vfsops.c fs->fs_contigdirs=(u_int8_t*)malloc((u_long)fs->fs_ncg,
fs 314 ufs/ffs/ffs_vfsops.c bzero(fs->fs_contigdirs, fs->fs_ncg);
fs 433 ufs/ffs/ffs_vfsops.c fs = ump->um_fs;
fs 434 ufs/ffs/ffs_vfsops.c if (ronly != fs->fs_ronly) {
fs 435 ufs/ffs/ffs_vfsops.c fs->fs_ronly = ronly;
fs 436 ufs/ffs/ffs_vfsops.c fs->fs_clean = ronly &&
fs 437 ufs/ffs/ffs_vfsops.c (fs->fs_flags & FS_UNCLEAN) == 0 ? 1 : 0;
fs 439 ufs/ffs/ffs_vfsops.c free(fs->fs_contigdirs, M_UFSMNT);
fs 443 ufs/ffs/ffs_vfsops.c fs->fs_flags |= FS_DOSOFTDEP;
fs 445 ufs/ffs/ffs_vfsops.c fs->fs_flags &= ~FS_DOSOFTDEP;
fs 458 ufs/ffs/ffs_vfsops.c struct fs *fs;
fs 495 ufs/ffs/ffs_vfsops.c fsbtodb(fra->fs, ino_to_fsba(fra->fs, ip->i_number)),
fs 496 ufs/ffs/ffs_vfsops.c (int)fra->fs->fs_bsize, NOCRED, &bp);
fs 504 ufs/ffs/ffs_vfsops.c ino_to_fsbo(fra->fs, ip->i_number));
fs 529 ufs/ffs/ffs_vfsops.c struct fs *fs, *newfs;
fs 556 ufs/ffs/ffs_vfsops.c fs = VFSTOUFS(mountp)->um_fs;
fs 558 ufs/ffs/ffs_vfsops.c error = bread(devvp, (daddr_t)(fs->fs_sblockloc / size), SBSIZE,
fs 565 ufs/ffs/ffs_vfsops.c newfs = (struct fs *)bp->b_data;
fs 576 ufs/ffs/ffs_vfsops.c newfs->fs_csp = fs->fs_csp;
fs 577 ufs/ffs/ffs_vfsops.c newfs->fs_maxcluster = fs->fs_maxcluster;
fs 578 ufs/ffs/ffs_vfsops.c newfs->fs_ronly = fs->fs_ronly;
fs 579 ufs/ffs/ffs_vfsops.c bcopy(newfs, fs, (u_int)fs->fs_sbsize);
fs 580 ufs/ffs/ffs_vfsops.c if (fs->fs_sbsize < SBSIZE)
fs 583 ufs/ffs/ffs_vfsops.c mountp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
fs 584 ufs/ffs/ffs_vfsops.c ffs1_compat_read(fs, VFSTOUFS(mountp), fs->fs_sblockloc);
fs 585 ufs/ffs/ffs_vfsops.c ffs_oldfscompat(fs);
fs 590 ufs/ffs/ffs_vfsops.c blks = howmany(fs->fs_cssize, fs->fs_fsize);
fs 591 ufs/ffs/ffs_vfsops.c space = (caddr_t)fs->fs_csp;
fs 592 ufs/ffs/ffs_vfsops.c for (i = 0; i < blks; i += fs->fs_frag) {
fs 593 ufs/ffs/ffs_vfsops.c size = fs->fs_bsize;
fs 594 ufs/ffs/ffs_vfsops.c if (i + fs->fs_frag > blks)
fs 595 ufs/ffs/ffs_vfsops.c size = (blks - i) * fs->fs_fsize;
fs 596 ufs/ffs/ffs_vfsops.c error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
fs 606 ufs/ffs/ffs_vfsops.c if ((fs->fs_flags & FS_DOSOFTDEP))
fs 607 ufs/ffs/ffs_vfsops.c (void) softdep_mount(devvp, mountp, fs, cred);
fs 611 ufs/ffs/ffs_vfsops.c if (fs->fs_contigsumsize > 0) {
fs 612 ufs/ffs/ffs_vfsops.c lp = fs->fs_maxcluster;
fs 613 ufs/ffs/ffs_vfsops.c for (i = 0; i < fs->fs_ncg; i++)
fs 614 ufs/ffs/ffs_vfsops.c *lp++ = fs->fs_contigsumsize;
fs 619 ufs/ffs/ffs_vfsops.c fra.fs = fs;
fs 631 ufs/ffs/ffs_vfsops.c ffs_validate(struct fs *fsp)
fs 644 ufs/ffs/ffs_vfsops.c if ((u_int)fsp->fs_bsize < sizeof(struct fs))
fs 669 ufs/ffs/ffs_vfsops.c struct fs *fs;
fs 724 ufs/ffs/ffs_vfsops.c fs = (struct fs *) bp->b_data;
fs 728 ufs/ffs/ffs_vfsops.c if (fs->fs_magic == FS_UFS2_MAGIC) {
fs 740 ufs/ffs/ffs_vfsops.c if (fs->fs_magic == FS_UFS1_MAGIC && sbloc == SBLOCK_UFS2)
fs 743 ufs/ffs/ffs_vfsops.c if (ffs_validate(fs))
fs 752 ufs/ffs/ffs_vfsops.c fs->fs_fmod = 0;
fs 753 ufs/ffs/ffs_vfsops.c fs->fs_flags &= ~FS_UNCLEAN;
fs 754 ufs/ffs/ffs_vfsops.c if (fs->fs_clean == 0) {
fs 762 ufs/ffs/ffs_vfsops.c if (fs->fs_flags & FS_DOSOFTDEP)
fs 765 ufs/ffs/ffs_vfsops.c fs->fs_fsmnt);
fs 771 ufs/ffs/ffs_vfsops.c fs->fs_fsmnt);
fs 775 ufs/ffs/ffs_vfsops.c fs->fs_fsmnt);
fs 781 ufs/ffs/ffs_vfsops.c if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) {
fs 792 ufs/ffs/ffs_vfsops.c ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT,
fs 795 ufs/ffs/ffs_vfsops.c if (fs->fs_magic == FS_UFS1_MAGIC)
fs 802 ufs/ffs/ffs_vfsops.c bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
fs 803 ufs/ffs/ffs_vfsops.c if (fs->fs_sbsize < SBSIZE)
fs 807 ufs/ffs/ffs_vfsops.c fs = ump->um_fs;
fs 809 ufs/ffs/ffs_vfsops.c ffs1_compat_read(fs, ump, sbloc);
fs 811 ufs/ffs/ffs_vfsops.c if (fs->fs_clean == 0)
fs 812 ufs/ffs/ffs_vfsops.c fs->fs_flags |= FS_UNCLEAN;
fs 813 ufs/ffs/ffs_vfsops.c fs->fs_ronly = ronly;
fs 814 ufs/ffs/ffs_vfsops.c size = fs->fs_cssize;
fs 815 ufs/ffs/ffs_vfsops.c blks = howmany(size, fs->fs_fsize);
fs 816 ufs/ffs/ffs_vfsops.c if (fs->fs_contigsumsize > 0)
fs 817 ufs/ffs/ffs_vfsops.c size += fs->fs_ncg * sizeof(int32_t);
fs 819 ufs/ffs/ffs_vfsops.c fs->fs_csp = (struct csum *)space;
fs 820 ufs/ffs/ffs_vfsops.c for (i = 0; i < blks; i += fs->fs_frag) {
fs 821 ufs/ffs/ffs_vfsops.c size = fs->fs_bsize;
fs 822 ufs/ffs/ffs_vfsops.c if (i + fs->fs_frag > blks)
fs 823 ufs/ffs/ffs_vfsops.c size = (blks - i) * fs->fs_fsize;
fs 824 ufs/ffs/ffs_vfsops.c error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
fs 827 ufs/ffs/ffs_vfsops.c free(fs->fs_csp, M_UFSMNT);
fs 835 ufs/ffs/ffs_vfsops.c if (fs->fs_contigsumsize > 0) {
fs 836 ufs/ffs/ffs_vfsops.c fs->fs_maxcluster = lp = (int32_t *)space;
fs 837 ufs/ffs/ffs_vfsops.c for (i = 0; i < fs->fs_ncg; i++)
fs 838 ufs/ffs/ffs_vfsops.c *lp++ = fs->fs_contigsumsize;
fs 843 ufs/ffs/ffs_vfsops.c if (fs->fs_id[0] != 0 && fs->fs_id[1] != 0)
fs 844 ufs/ffs/ffs_vfsops.c mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];
fs 847 ufs/ffs/ffs_vfsops.c mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
fs 852 ufs/ffs/ffs_vfsops.c ump->um_nindir = fs->fs_nindir;
fs 853 ufs/ffs/ffs_vfsops.c ump->um_bptrtodb = fs->fs_fsbtodb;
fs 854 ufs/ffs/ffs_vfsops.c ump->um_seqinc = fs->fs_frag;
fs 859 ufs/ffs/ffs_vfsops.c ffs_oldfscompat(fs);
fs 862 ufs/ffs/ffs_vfsops.c fs->fs_contigdirs = NULL;
fs 864 ufs/ffs/ffs_vfsops.c fs->fs_contigdirs = (u_int8_t*)malloc((u_long)fs->fs_ncg,
fs 866 ufs/ffs/ffs_vfsops.c bzero(fs->fs_contigdirs, fs->fs_ncg);
fs 873 ufs/ffs/ffs_vfsops.c fs->fs_fsmnt, /* copy area*/
fs 874 ufs/ffs/ffs_vfsops.c sizeof(fs->fs_fsmnt) - 1, /* max size*/
fs 876 ufs/ffs/ffs_vfsops.c bzero(fs->fs_fsmnt + strsize, sizeof(fs->fs_fsmnt) - strsize);
fs 885 ufs/ffs/ffs_vfsops.c mp->mnt_time = fs->fs_time;
fs 896 ufs/ffs/ffs_vfsops.c ump->um_savedmaxfilesize = fs->fs_maxfilesize; /* XXX */
fs 897 ufs/ffs/ffs_vfsops.c maxfilesize = (u_int64_t)0x80000000 * MIN(PAGE_SIZE, fs->fs_bsize) - 1;
fs 898 ufs/ffs/ffs_vfsops.c if (fs->fs_maxfilesize > maxfilesize) /* XXX */
fs 899 ufs/ffs/ffs_vfsops.c fs->fs_maxfilesize = maxfilesize; /* XXX */
fs 901 ufs/ffs/ffs_vfsops.c if ((fs->fs_flags & FS_DOSOFTDEP) &&
fs 902 ufs/ffs/ffs_vfsops.c (error = softdep_mount(devvp, mp, fs, cred)) != 0) {
fs 903 ufs/ffs/ffs_vfsops.c free(fs->fs_csp, M_UFSMNT);
fs 904 ufs/ffs/ffs_vfsops.c free(fs->fs_contigdirs, M_UFSMNT);
fs 907 ufs/ffs/ffs_vfsops.c fs->fs_fmod = 1;
fs 908 ufs/ffs/ffs_vfsops.c fs->fs_clean = 0;
fs 910 ufs/ffs/ffs_vfsops.c fs->fs_flags |= FS_DOSOFTDEP;
fs 912 ufs/ffs/ffs_vfsops.c fs->fs_flags &= ~FS_DOSOFTDEP;
fs 933 ufs/ffs/ffs_vfsops.c ffs_oldfscompat(struct fs *fs)
fs 937 ufs/ffs/ffs_vfsops.c fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect); /* XXX */
fs 938 ufs/ffs/ffs_vfsops.c fs->fs_interleave = max(fs->fs_interleave, 1); /* XXX */
fs 939 ufs/ffs/ffs_vfsops.c if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
fs 940 ufs/ffs/ffs_vfsops.c fs->fs_nrpos = 8; /* XXX */
fs 941 ufs/ffs/ffs_vfsops.c if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
fs 942 ufs/ffs/ffs_vfsops.c u_int64_t sizepb = fs->fs_bsize; /* XXX */
fs 944 ufs/ffs/ffs_vfsops.c fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */
fs 946 ufs/ffs/ffs_vfsops.c sizepb *= NINDIR(fs); /* XXX */
fs 947 ufs/ffs/ffs_vfsops.c fs->fs_maxfilesize += sizepb; /* XXX */
fs 949 ufs/ffs/ffs_vfsops.c fs->fs_qbmask = ~fs->fs_bmask; /* XXX */
fs 950 ufs/ffs/ffs_vfsops.c fs->fs_qfmask = ~fs->fs_fmask; /* XXX */
fs 952 ufs/ffs/ffs_vfsops.c if (fs->fs_avgfilesize <= 0) /* XXX */
fs 953 ufs/ffs/ffs_vfsops.c fs->fs_avgfilesize = AVFILESIZ; /* XXX */
fs 954 ufs/ffs/ffs_vfsops.c if (fs->fs_avgfpdir <= 0) /* XXX */
fs 955 ufs/ffs/ffs_vfsops.c fs->fs_avgfpdir = AFPDIR; /* XXX */
fs 963 ufs/ffs/ffs_vfsops.c ffs1_compat_read(struct fs *fs, struct ufsmount *ump, daddr64_t sbloc)
fs 965 ufs/ffs/ffs_vfsops.c if (fs->fs_magic == FS_UFS2_MAGIC)
fs 968 ufs/ffs/ffs_vfsops.c if (fs->fs_ffs1_flags & FS_FLAGS_UPDATED)
fs 971 ufs/ffs/ffs_vfsops.c fs->fs_flags = fs->fs_ffs1_flags;
fs 972 ufs/ffs/ffs_vfsops.c fs->fs_sblockloc = sbloc;
fs 973 ufs/ffs/ffs_vfsops.c fs->fs_maxbsize = fs->fs_bsize;
fs 974 ufs/ffs/ffs_vfsops.c fs->fs_time = fs->fs_ffs1_time;
fs 975 ufs/ffs/ffs_vfsops.c fs->fs_size = fs->fs_ffs1_size;
fs 976 ufs/ffs/ffs_vfsops.c fs->fs_dsize = fs->fs_ffs1_dsize;
fs 977 ufs/ffs/ffs_vfsops.c fs->fs_csaddr = fs->fs_ffs1_csaddr;
fs 978 ufs/ffs/ffs_vfsops.c fs->fs_cstotal.cs_ndir = fs->fs_ffs1_cstotal.cs_ndir;
fs 979 ufs/ffs/ffs_vfsops.c fs->fs_cstotal.cs_nbfree = fs->fs_ffs1_cstotal.cs_nbfree;
fs 980 ufs/ffs/ffs_vfsops.c fs->fs_cstotal.cs_nifree = fs->fs_ffs1_cstotal.cs_nifree;
fs 981 ufs/ffs/ffs_vfsops.c fs->fs_cstotal.cs_nffree = fs->fs_ffs1_cstotal.cs_nffree;
fs 982 ufs/ffs/ffs_vfsops.c fs->fs_ffs1_flags |= FS_FLAGS_UPDATED;
fs 989 ufs/ffs/ffs_vfsops.c ffs1_compat_write(struct fs *fs, struct ufsmount *ump)
fs 991 ufs/ffs/ffs_vfsops.c if (fs->fs_magic != FS_UFS1_MAGIC)
fs 994 ufs/ffs/ffs_vfsops.c fs->fs_ffs1_time = fs->fs_time;
fs 995 ufs/ffs/ffs_vfsops.c fs->fs_ffs1_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;
fs 996 ufs/ffs/ffs_vfsops.c fs->fs_ffs1_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;
fs 997 ufs/ffs/ffs_vfsops.c fs->fs_ffs1_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;
fs 998 ufs/ffs/ffs_vfsops.c fs->fs_ffs1_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;
fs 1008 ufs/ffs/ffs_vfsops.c struct fs *fs;
fs 1016 ufs/ffs/ffs_vfsops.c fs = ump->um_fs;
fs 1024 ufs/ffs/ffs_vfsops.c if (fs->fs_ronly == 0) {
fs 1025 ufs/ffs/ffs_vfsops.c fs->fs_clean = (fs->fs_flags & FS_UNCLEAN) ? 0 : 1;
fs 1029 ufs/ffs/ffs_vfsops.c fs->fs_clean = 0;
fs 1032 ufs/ffs/ffs_vfsops.c free(fs->fs_contigdirs, M_UFSMNT);
fs 1037 ufs/ffs/ffs_vfsops.c error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE,
fs 1040 ufs/ffs/ffs_vfsops.c free(fs->fs_csp, M_UFSMNT);
fs 1041 ufs/ffs/ffs_vfsops.c free(fs, M_UFSMNT);
fs 1094 ufs/ffs/ffs_vfsops.c struct fs *fs;
fs 1097 ufs/ffs/ffs_vfsops.c fs = ump->um_fs;
fs 1100 ufs/ffs/ffs_vfsops.c if (fs->fs_magic != FS_MAGIC && fs->fs_magic != FS_UFS2_MAGIC)
fs 1103 ufs/ffs/ffs_vfsops.c if (fs->fs_magic != FS_MAGIC)
fs 1107 ufs/ffs/ffs_vfsops.c sbp->f_bsize = fs->fs_fsize;
fs 1108 ufs/ffs/ffs_vfsops.c sbp->f_iosize = fs->fs_bsize;
fs 1109 ufs/ffs/ffs_vfsops.c sbp->f_blocks = fs->fs_dsize;
fs 1110 ufs/ffs/ffs_vfsops.c sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
fs 1111 ufs/ffs/ffs_vfsops.c fs->fs_cstotal.cs_nffree;
fs 1112 ufs/ffs/ffs_vfsops.c sbp->f_bavail = sbp->f_bfree - ((int64_t)fs->fs_dsize * fs->fs_minfree / 100);
fs 1113 ufs/ffs/ffs_vfsops.c sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
fs 1114 ufs/ffs/ffs_vfsops.c sbp->f_ffree = fs->fs_cstotal.cs_nifree;
fs 1169 ufs/ffs/ffs_vfsops.c struct fs *fs;
fs 1173 ufs/ffs/ffs_vfsops.c fs = ump->um_fs;
fs 1179 ufs/ffs/ffs_vfsops.c if (fs->fs_fmod != 0 && fs->fs_ronly != 0) {
fs 1180 ufs/ffs/ffs_vfsops.c printf("fs = %s\n", fs->fs_fsmnt);
fs 1221 ufs/ffs/ffs_vfsops.c if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0)
fs 1236 ufs/ffs/ffs_vfsops.c struct fs *fs;
fs 1270 ufs/ffs/ffs_vfsops.c ip->i_fs = fs = ump->um_fs;
fs 1298 ufs/ffs/ffs_vfsops.c error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
fs 1299 ufs/ffs/ffs_vfsops.c (int)fs->fs_bsize, NOCRED, &bp);
fs 1316 ufs/ffs/ffs_vfsops.c dp2 = (struct ufs2_dinode *) bp->b_data + ino_to_fsbo(fs, ino);
fs 1322 ufs/ffs/ffs_vfsops.c dp1 = (struct ufs1_dinode *) bp->b_data + ino_to_fsbo(fs, ino);
fs 1360 ufs/ffs/ffs_vfsops.c if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_inodefmt < FS_44INODEFMT) {
fs 1382 ufs/ffs/ffs_vfsops.c struct fs *fs;
fs 1385 ufs/ffs/ffs_vfsops.c fs = VFSTOUFS(mp)->um_fs;
fs 1387 ufs/ffs/ffs_vfsops.c ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
fs 1417 ufs/ffs/ffs_vfsops.c struct fs *dfs, *fs = mp->um_fs;
fs 1426 ufs/ffs/ffs_vfsops.c blks = howmany(fs->fs_cssize, fs->fs_fsize);
fs 1427 ufs/ffs/ffs_vfsops.c space = (caddr_t)fs->fs_csp;
fs 1428 ufs/ffs/ffs_vfsops.c for (i = 0; i < blks; i += fs->fs_frag) {
fs 1429 ufs/ffs/ffs_vfsops.c size = fs->fs_bsize;
fs 1430 ufs/ffs/ffs_vfsops.c if (i + fs->fs_frag > blks)
fs 1431 ufs/ffs/ffs_vfsops.c size = (blks - i) * fs->fs_fsize;
fs 1432 ufs/ffs/ffs_vfsops.c bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
fs 1452 ufs/ffs/ffs_vfsops.c fs->fs_sblockloc >> (fs->fs_fshift - fs->fs_fsbtodb),
fs 1453 ufs/ffs/ffs_vfsops.c (int)fs->fs_sbsize, 0, 0);
fs 1454 ufs/ffs/ffs_vfsops.c fs->fs_fmod = 0;
fs 1455 ufs/ffs/ffs_vfsops.c fs->fs_time = time_second;
fs 1456 ufs/ffs/ffs_vfsops.c bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
fs 1458 ufs/ffs/ffs_vfsops.c dfs = (struct fs *)bp->b_data; /* XXX */
fs 1459 ufs/ffs/ffs_vfsops.c if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
fs 1461 ufs/ffs/ffs_vfsops.c if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
fs 175 ufs/ffs/ffs_vnops.c struct fs *fs;
fs 200 ufs/ffs/ffs_vnops.c fs = ip->i_fs;
fs 201 ufs/ffs/ffs_vnops.c if ((u_int64_t)uio->uio_offset > fs->fs_maxfilesize)
fs 210 ufs/ffs/ffs_vnops.c lbn = lblkno(fs, uio->uio_offset);
fs 212 ufs/ffs/ffs_vnops.c size = fs->fs_bsize; /* WAS blksize(fs, ip, lbn); */
fs 213 ufs/ffs/ffs_vnops.c blkoffset = blkoff(fs, uio->uio_offset);
fs 214 ufs/ffs/ffs_vnops.c xfersize = fs->fs_bsize - blkoffset;
fs 220 ufs/ffs/ffs_vnops.c if (lblktosize(fs, nextlbn) >= DIP(ip, size))
fs 266 ufs/ffs/ffs_vnops.c struct fs *fs;
fs 308 ufs/ffs/ffs_vnops.c fs = ip->i_fs;
fs 310 ufs/ffs/ffs_vnops.c (u_int64_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize)
fs 329 ufs/ffs/ffs_vnops.c lbn = lblkno(fs, uio->uio_offset);
fs 330 ufs/ffs/ffs_vnops.c blkoffset = blkoff(fs, uio->uio_offset);
fs 331 ufs/ffs/ffs_vnops.c xfersize = fs->fs_bsize - blkoffset;
fs 334 ufs/ffs/ffs_vnops.c if (fs->fs_bsize > xfersize)
fs 349 ufs/ffs/ffs_vnops.c size = blksize(fs, ip, lbn) - bp->b_resid;
fs 361 ufs/ffs/ffs_vnops.c else if (xfersize + blkoffset == fs->fs_bsize) {
fs 191 ufs/ffs/fs.h struct fs {
fs 344 ufs/ffs/fs.h #define fs_rotbl(fs) \
fs 345 ufs/ffs/fs.h (((fs)->fs_postblformat == FS_42POSTBLFMT) \
fs 346 ufs/ffs/fs.h ? ((fs)->fs_space) \
fs 347 ufs/ffs/fs.h : ((u_int8_t *)((u_int8_t *)(fs) + (fs)->fs_rotbloff)))
fs 355 ufs/ffs/fs.h #define CGSIZE(fs) \
fs 357 ufs/ffs/fs.h /* blktot size */ (fs)->fs_cpg * sizeof(int32_t) + \
fs 358 ufs/ffs/fs.h /* blks size */ (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(int16_t) + \
fs 359 ufs/ffs/fs.h /* inode map */ howmany((fs)->fs_ipg, NBBY) + \
fs 360 ufs/ffs/fs.h /* block map */ howmany((fs)->fs_fpg, NBBY) + \
fs 361 ufs/ffs/fs.h /* if present */ ((fs)->fs_contigsumsize <= 0 ? 0 : \
fs 362 ufs/ffs/fs.h /* cluster sum */ (fs)->fs_contigsumsize * sizeof(int32_t) + \
fs 363 ufs/ffs/fs.h /* cluster map */ howmany(fragstoblks(fs, (fs)->fs_fpg), NBBY)))
fs 368 ufs/ffs/fs.h #define fs_cs(fs, indx) fs_csp[indx]
fs 410 ufs/ffs/fs.h #define cg_blks(fs, cgp, cylno) \
fs 414 ufs/ffs/fs.h (cgp)->cg_boff) + (cylno) * (fs)->fs_nrpos))
fs 459 ufs/ffs/fs.h #define fsbtodb(fs, b) ((b) << (fs)->fs_fsbtodb)
fs 460 ufs/ffs/fs.h #define dbtofsb(fs, b) ((b) >> (fs)->fs_fsbtodb)
fs 466 ufs/ffs/fs.h #define cgbase(fs, c) ((daddr_t)((fs)->fs_fpg * (c)))
fs 467 ufs/ffs/fs.h #define cgdmin(fs, c) (cgstart(fs, c) + (fs)->fs_dblkno) /* 1st data */
fs 468 ufs/ffs/fs.h #define cgimin(fs, c) (cgstart(fs, c) + (fs)->fs_iblkno) /* inode blk */
fs 469 ufs/ffs/fs.h #define cgsblock(fs, c) (cgstart(fs, c) + (fs)->fs_sblkno) /* super blk */
fs 470 ufs/ffs/fs.h #define cgtod(fs, c) (cgstart(fs, c) + (fs)->fs_cblkno) /* cg block */
fs 471 ufs/ffs/fs.h #define cgstart(fs, c) \
fs 472 ufs/ffs/fs.h (cgbase(fs, c) + (fs)->fs_cgoffset * ((c) & ~((fs)->fs_cgmask)))
fs 480 ufs/ffs/fs.h #define ino_to_cg(fs, x) ((x) / (fs)->fs_ipg)
fs 481 ufs/ffs/fs.h #define ino_to_fsba(fs, x) \
fs 482 ufs/ffs/fs.h ((daddr_t)(cgimin(fs, ino_to_cg(fs, x)) + \
fs 483 ufs/ffs/fs.h (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))
fs 484 ufs/ffs/fs.h #define ino_to_fsbo(fs, x) ((x) % INOPB(fs))
fs 490 ufs/ffs/fs.h #define dtog(fs, d) ((d) / (fs)->fs_fpg)
fs 491 ufs/ffs/fs.h #define dtogd(fs, d) ((d) % (fs)->fs_fpg)
fs 497 ufs/ffs/fs.h #define blkmap(fs, map, loc) \
fs 498 ufs/ffs/fs.h (((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))
fs 499 ufs/ffs/fs.h #define cbtocylno(fs, bno) \
fs 500 ufs/ffs/fs.h (fsbtodb(fs, bno) / (fs)->fs_spc)
fs 501 ufs/ffs/fs.h #define cbtorpos(fs, bno) \
fs 502 ufs/ffs/fs.h ((fs)->fs_nrpos <= 1 ? 0 : \
fs 503 ufs/ffs/fs.h (fsbtodb(fs, bno) % (fs)->fs_spc / (fs)->fs_nsect * (fs)->fs_trackskew + \
fs 504 ufs/ffs/fs.h fsbtodb(fs, bno) % (fs)->fs_spc % (fs)->fs_nsect * (fs)->fs_interleave) % \
fs 505 ufs/ffs/fs.h (fs)->fs_nsect * (fs)->fs_nrpos / (fs)->fs_npsect)
fs 512 ufs/ffs/fs.h #define blkoff(fs, loc) /* calculates (loc % fs->fs_bsize) */ \
fs 513 ufs/ffs/fs.h ((loc) & (fs)->fs_qbmask)
fs 514 ufs/ffs/fs.h #define fragoff(fs, loc) /* calculates (loc % fs->fs_fsize) */ \
fs 515 ufs/ffs/fs.h ((loc) & (fs)->fs_qfmask)
fs 516 ufs/ffs/fs.h #define lblktosize(fs, blk) /* calculates ((off_t)blk * fs->fs_bsize) */ \
fs 517 ufs/ffs/fs.h ((off_t)(blk) << (fs)->fs_bshift)
fs 518 ufs/ffs/fs.h #define lblkno(fs, loc) /* calculates (loc / fs->fs_bsize) */ \
fs 519 ufs/ffs/fs.h ((loc) >> (fs)->fs_bshift)
fs 520 ufs/ffs/fs.h #define numfrags(fs, loc) /* calculates (loc / fs->fs_fsize) */ \
fs 521 ufs/ffs/fs.h ((loc) >> (fs)->fs_fshift)
fs 522 ufs/ffs/fs.h #define blkroundup(fs, size) /* calculates roundup(size, fs->fs_bsize) */ \
fs 523 ufs/ffs/fs.h (((size) + (fs)->fs_qbmask) & (fs)->fs_bmask)
fs 524 ufs/ffs/fs.h #define fragroundup(fs, size) /* calculates roundup(size, fs->fs_fsize) */ \
fs 525 ufs/ffs/fs.h (((size) + (fs)->fs_qfmask) & (fs)->fs_fmask)
fs 526 ufs/ffs/fs.h #define fragstoblks(fs, frags) /* calculates (frags / fs->fs_frag) */ \
fs 527 ufs/ffs/fs.h ((frags) >> (fs)->fs_fragshift)
fs 528 ufs/ffs/fs.h #define blkstofrags(fs, blks) /* calculates (blks * fs->fs_frag) */ \
fs 529 ufs/ffs/fs.h ((blks) << (fs)->fs_fragshift)
fs 530 ufs/ffs/fs.h #define fragnum(fs, fsb) /* calculates (fsb % fs->fs_frag) */ \
fs 531 ufs/ffs/fs.h ((fsb) & ((fs)->fs_frag - 1))
fs 532 ufs/ffs/fs.h #define blknum(fs, fsb) /* calculates rounddown(fsb, fs->fs_frag) */ \
fs 533 ufs/ffs/fs.h ((fsb) &~ ((fs)->fs_frag - 1))
fs 539 ufs/ffs/fs.h #define freespace(fs, percentreserved) \
fs 540 ufs/ffs/fs.h (blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \
fs 541 ufs/ffs/fs.h (fs)->fs_cstotal.cs_nffree - ((fs)->fs_dsize * (percentreserved) / 100))
fs 546 ufs/ffs/fs.h #define blksize(fs, ip, lbn) \
fs 547 ufs/ffs/fs.h (((lbn) >= NDADDR || DIP((ip), size) >= ((lbn) + 1) << (fs)->fs_bshift) \
fs 548 ufs/ffs/fs.h ? (fs)->fs_bsize \
fs 549 ufs/ffs/fs.h : (fragroundup(fs, blkoff(fs, DIP((ip), size)))))
fs 550 ufs/ffs/fs.h #define dblksize(fs, dip, lbn) \
fs 551 ufs/ffs/fs.h (((lbn) >= NDADDR || (dip)->di_size >= ((lbn) + 1) << (fs)->fs_bshift) \
fs 552 ufs/ffs/fs.h ? (fs)->fs_bsize \
fs 553 ufs/ffs/fs.h : (fragroundup(fs, blkoff(fs, (dip)->di_size))))
fs 555 ufs/ffs/fs.h #define sblksize(fs, size, lbn) \
fs 556 ufs/ffs/fs.h (((lbn) >= NDADDR || (size) >= ((lbn) + 1) << (fs)->fs_bshift) \
fs 557 ufs/ffs/fs.h ? (fs)->fs_bsize \
fs 558 ufs/ffs/fs.h : (fragroundup(fs, blkoff(fs, (size)))))
fs 565 ufs/ffs/fs.h #define NSPB(fs) ((fs)->fs_nspf << (fs)->fs_fragshift)
fs 566 ufs/ffs/fs.h #define NSPF(fs) ((fs)->fs_nspf)
fs 569 ufs/ffs/fs.h #define INOPB(fs) ((fs)->fs_inopb)
fs 571 ufs/ffs/fs.h #define INOPF(fs) ((fs)->fs_inopb >> (fs)->fs_fragshift)
fs 576 ufs/ffs/fs.h #define NINDIR(fs) ((fs)->fs_nindir)
fs 252 ufs/ffs/softdep.h struct fs *id_fs; /* associated filesystem */
fs 282 ufs/ffs/softdep.h struct fs *nb_fs; /* associated filesystem */
fs 91 ufs/mfs/mfs_vfsops.c struct fs *fs;
fs 124 ufs/mfs/mfs_vfsops.c fs = ump->um_fs;
fs 125 ufs/mfs/mfs_vfsops.c (void) copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
fs 140 ufs/mfs/mfs_vfsops.c struct fs *fs = (struct fs *)(base + SBOFF);
fs 144 ufs/mfs/mfs_vfsops.c if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
fs 145 ufs/mfs/mfs_vfsops.c fs->fs_bsize < sizeof(struct fs))
fs 149 ufs/mfs/mfs_vfsops.c mfs_rootsize = fs->fs_fsize * fs->fs_size;
fs 168 ufs/mfs/mfs_vfsops.c struct fs *fs;
fs 183 ufs/mfs/mfs_vfsops.c fs = ump->um_fs;
fs 184 ufs/mfs/mfs_vfsops.c if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
fs 192 ufs/mfs/mfs_vfsops.c if (fs->fs_ronly && (mp->mnt_flag & MNT_WANTRDWR))
fs 193 ufs/mfs/mfs_vfsops.c fs->fs_ronly = 0;
fs 221 ufs/mfs/mfs_vfsops.c fs = ump->um_fs;
fs 222 ufs/mfs/mfs_vfsops.c (void) copyinstr(path, fs->fs_fsmnt, sizeof(fs->fs_fsmnt) - 1, &size);
fs 223 ufs/mfs/mfs_vfsops.c bzero(fs->fs_fsmnt + size, sizeof(fs->fs_fsmnt) - size);
fs 224 ufs/mfs/mfs_vfsops.c bcopy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname, MNAMELEN);
fs 75 ufs/ufs/inode.h struct fs *fs; /* FFS */
fs 79 ufs/ufs/inode.h #define i_fs inode_u.fs
fs 52 ufs/ufs/ufsmount.h struct fs *fs; /* FFS */
fs 55 ufs/ufs/ufsmount.h #define um_fs ufsmount_u.fs