Lines Matching defs:fs
70 #include <ufs/ffs/fs.h>
85 ffs_snapblkfree(struct fs *fs,
135 static int expunge_ufs1(struct vnode *, struct inode *, struct fs *,
136 int (*)(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *, struct fs *,
139 ufs1_daddr_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, struct fs *,
140 int (*)(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *, struct fs *,
143 struct fs *, ufs_lbn_t, int);
145 struct fs *, ufs_lbn_t, int);
147 struct fs *, ufs_lbn_t, int);
148 static int expunge_ufs2(struct vnode *, struct inode *, struct fs *,
149 int (*)(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *, struct fs *,
152 ufs2_daddr_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, struct fs *,
153 int (*)(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *, struct fs *,
156 struct fs *, ufs_lbn_t, int);
158 struct fs *, ufs_lbn_t, int);
160 struct fs *, ufs_lbn_t, int);
206 struct fs *copy_fs = NULL, *fs, *bpfs;
223 fs = ump->um_fs;
231 "using gjournal", fs->fs_fsmnt);
245 if (fs->fs_snapinum[snaploc] == 0)
305 vnode_create_vobject(nd.ni_vp, fs->fs_size, td);
315 numblks = howmany(fs->fs_size, fs->fs_frag);
316 error = UFS_BALLOC(vp, lblktosize(fs, (off_t)numblks),
317 fs->fs_bsize, KERNCRED, BA_CLRBUF, &bp);
321 ip->i_size = lblktosize(fs, (off_t)(numblks + 1));
336 for (blkno = UFS_NDADDR; blkno < numblks; blkno += NINDIR(fs)) {
337 error = UFS_BALLOC(vp, lblktosize(fs, (off_t)blkno),
338 fs->fs_bsize, td->td_ucred, BA_METAONLY, &ibp);
346 error = UFS_BALLOC(vp, fs->fs_sblockloc, fs->fs_sbsize, KERNCRED,
351 blkno = fragstoblks(fs, fs->fs_csaddr);
352 len = howmany(fs->fs_cssize, fs->fs_bsize);
354 error = UFS_BALLOC(vp, lblktosize(fs, (off_t)(blkno + loc)),
355 fs->fs_bsize, KERNCRED, 0, &nbp);
363 for (cg = 0; cg < fs->fs_ncg; cg++) {
364 error = UFS_BALLOC(vp, lfragtosize(fs, cgtod(fs, cg)),
365 fs->fs_bsize, KERNCRED, 0, &nbp);
393 len = roundup2(howmany(fs->fs_ncg, NBBY), sizeof(uint64_t));
396 fs->fs_active = space;
398 for (cg = 0; cg < fs->fs_ncg; cg++) {
399 error = UFS_BALLOC(vp, lfragtosize(fs, cgtod(fs, cg)),
400 fs->fs_bsize, KERNCRED, 0, &nbp);
459 for (cg = 0; cg < fs->fs_ncg; cg++) {
460 if ((ACTIVECGNUM(fs, cg) & ACTIVECGOFF(cg)) != 0)
465 error = UFS_BALLOC(vp, lfragtosize(fs, cgtod(fs, cg)),
466 fs->fs_bsize, KERNCRED, 0, &nbp);
478 copy_fs = malloc((uint64_t)fs->fs_bsize, M_UFSMNT, M_WAITOK);
479 bcopy(fs, copy_fs, fs->fs_sbsize);
482 if ((fs->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) == 0)
484 size = fs->fs_bsize < SBLOCKSIZE ? fs->fs_bsize : SBLOCKSIZE;
485 if (fs->fs_sbsize < size)
486 bzero(&((char *)copy_fs)[fs->fs_sbsize],
487 size - fs->fs_sbsize);
488 size = blkroundup(fs, fs->fs_cssize);
489 if (fs->fs_contigsumsize > 0)
490 size += fs->fs_ncg * sizeof(int32_t);
493 bcopy(fs->fs_csp, copy_fs->fs_csp, fs->fs_cssize);
494 space = (char *)space + fs->fs_cssize;
495 loc = howmany(fs->fs_cssize, fs->fs_fsize);
496 i = fs->fs_frag - loc % fs->fs_frag;
497 len = (i == fs->fs_frag) ? 0 : i * fs->fs_fsize;
499 if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + loc),
509 if (fs->fs_contigsumsize > 0) {
511 for (i = 0; i < fs->fs_ncg; i++)
512 *lp++ = fs->fs_contigsumsize;
543 snaplistsize = fs->fs_ncg + howmany(fs->fs_cssize, fs->fs_bsize) +
600 loc = howmany(xp->i_size, fs->fs_bsize) - 1;
602 len = fragroundup(fs, blkoff(fs, xp->i_size));
603 if (len != 0 && len < fs->fs_bsize) {
633 if (fs->fs_flags & FS_SUJ) {
658 error = UFS_BALLOC(vp, lblktosize(fs, blockno),
659 fs->fs_bsize, KERNCRED, BA_CLRBUF, &bp);
688 *blkp++ = lblkno(fs, fs->fs_sblockloc);
689 blkno = fragstoblks(fs, fs->fs_csaddr);
690 for (cg = 0; cg < fs->fs_ncg; cg++) {
691 if (fragstoblks(fs, cgtod(fs, cg)) > blkno)
693 *blkp++ = fragstoblks(fs, cgtod(fs, cg));
695 len = howmany(fs->fs_cssize, fs->fs_bsize);
698 for (; cg < fs->fs_ncg; cg++)
699 *blkp++ = fragstoblks(fs, cgtod(fs, cg));
713 fs->fs_snapinum[snaploc] = ip->i_number;
740 endtime.tv_nsec / 1000000, redo, fs->fs_ncg);
753 error = expunge_ufs1(vp, xp, fs, snapacct_ufs1,
756 error = expunge_ufs2(vp, xp, fs, snapacct_ufs2,
766 fs->fs_snapinum[snaploc] = 0;
788 fs->fs_snapinum[snaploc] = 0;
805 auio.uio_offset = lblktosize(fs, (off_t)numblks);
810 fs->fs_snapinum[snaploc] = 0;
818 blkno = fragstoblks(fs, fs->fs_csaddr);
819 len = howmany(fs->fs_cssize, fs->fs_bsize);
822 error = bread(vp, blkno + loc, fs->fs_bsize, KERNCRED, &nbp);
824 fs->fs_snapinum[snaploc] = 0;
828 bcopy(space, nbp->b_data, fs->fs_bsize);
829 space = (char *)space + fs->fs_bsize;
832 error = bread(vp, lblkno(fs, fs->fs_sblockloc), fs->fs_bsize,
837 loc = blkoff(fs, fs->fs_sblockloc);
839 bpfs = (struct fs *)&nbp->b_data[loc];
840 bcopy((caddr_t)copy_fs, (caddr_t)bpfs, (uint64_t)fs->fs_sbsize);
871 if (fs->fs_active != 0) {
872 free(fs->fs_active, M_DEVBUF);
873 fs->fs_active = 0;
925 struct fs *fs;
930 fs = ITOFS(ip);
931 if ((error = ffs_getcg(fs, ITODEVVP(ip), cg, 0, &bp, &cgp)) != 0)
934 ACTIVESET(fs, cg);
941 fs->fs_cs(fs, cg) = cgp->cg_cs;
943 bcopy(bp->b_data, nbp->b_data, fs->fs_cgsize);
944 if (fs->fs_cgsize < fs->fs_bsize)
945 bzero(&nbp->b_data[fs->fs_cgsize],
946 fs->fs_bsize - fs->fs_cgsize);
951 numblks = howmany(fs->fs_size, fs->fs_frag);
952 len = howmany(fs->fs_fpg, fs->fs_frag);
953 base = cgbase(fs, cg) / fs->fs_frag;
959 if (ffs_isblock(fs, cg_blksfree(cgp), loc))
967 error = UFS_BALLOC(vp, lblktosize(fs, (off_t)(base + loc)),
968 fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
972 indiroff = (base + loc - UFS_NDADDR) % NINDIR(fs);
974 if (indiroff >= NINDIR(fs)) {
979 lblktosize(fs, (off_t)(base + loc)),
980 fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
987 if (ffs_isblock(fs, cg_blksfree(cgp), loc))
998 if (ffs_isblock(fs, cg_blksfree(cgp), loc))
1019 if ((fs->fs_metackhash & CK_CYLGRP) != 0) {
1022 calculate_crc32c(~0L, nbp->b_data, fs->fs_cgsize);
1038 struct fs *fs,
1040 struct fs *, ufs_lbn_t, int),
1055 lbn = fragstoblks(fs, ino_to_fsba(fs, cancelip->i_number));
1063 error = ffs_balloc_ufs1(snapvp, lblktosize(fs, (off_t)lbn),
1064 fs->fs_bsize, KERNCRED, BA_METAONLY, &bp);
1068 indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
1073 if ((error = bread(snapvp, lbn, fs->fs_bsize, KERNCRED, &bp)))
1076 error = ffs_balloc_ufs1(snapvp, lblktosize(fs, (off_t)lbn),
1077 fs->fs_bsize, KERNCRED, 0, &bp);
1088 ino_to_fsbo(fs, cancelip->i_number);
1101 numblks = howmany(cancelip->i_size, fs->fs_bsize);
1103 &cancelip->i_din1->di_db[UFS_NDADDR], fs, 0, expungetype)))
1106 &cancelip->i_din1->di_ib[UFS_NIADDR], fs, -1, expungetype)))
1115 blksperindir, fs, acctfunc, expungetype);
1118 blksperindir *= NINDIR(fs);
1139 struct fs *fs,
1141 struct fs *, ufs_lbn_t, int),
1163 bp = getblk(cancelvp, lbn, fs->fs_bsize, 0, 0, 0);
1164 bp->b_blkno = fsbtodb(fs, blkno);
1166 (error = readblock(cancelvp, bp, fragstoblks(fs, blkno)))) {
1174 if (last > NINDIR(fs))
1175 last = NINDIR(fs);
1176 bap = malloc(fs->fs_bsize, M_DEVBUF, M_WAITOK);
1177 bcopy(bp->b_data, (caddr_t)bap, fs->fs_bsize);
1179 error = (*acctfunc)(snapvp, &bap[0], &bap[last], fs,
1187 subblksperindir = blksperindir / NINDIR(fs);
1190 rlbn, remblks, subblksperindir, fs, acctfunc, expungetype);
1209 struct fs *fs,
1215 if ((error = snapacct_ufs1(vp, oldblkp, lastblkp, fs, lblkno, exptype)))
1217 return (mapacct_ufs1(vp, oldblkp, lastblkp, fs, lblkno, exptype));
1227 struct fs *fs,
1241 lbn = fragstoblks(fs, blkno);
1246 error = ffs_balloc_ufs1(vp, lblktosize(fs, (off_t)lbn),
1247 fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
1251 [(lbn - UFS_NDADDR) % NINDIR(fs)];
1280 struct fs *fs,
1302 blkno = blkstofrags(fs, lblkno);
1303 ffs_blkfree(ITOUMP(ip), fs, vp, blkno, fs->fs_bsize, inum,
1320 struct fs *fs,
1322 struct fs *, ufs_lbn_t, int),
1337 lbn = fragstoblks(fs, ino_to_fsba(fs, cancelip->i_number));
1345 error = ffs_balloc_ufs2(snapvp, lblktosize(fs, (off_t)lbn),
1346 fs->fs_bsize, KERNCRED, BA_METAONLY, &bp);
1350 indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
1355 if ((error = bread(snapvp, lbn, fs->fs_bsize, KERNCRED, &bp)))
1358 error = ffs_balloc_ufs2(snapvp, lblktosize(fs, (off_t)lbn),
1359 fs->fs_bsize, KERNCRED, 0, &bp);
1370 ino_to_fsbo(fs, cancelip->i_number);
1379 ffs_update_dinode_ckhash(fs, dip);
1385 numblks = howmany(cancelip->i_size, fs->fs_bsize);
1387 &cancelip->i_din2->di_db[UFS_NDADDR], fs, 0, expungetype)))
1390 &cancelip->i_din2->di_ib[UFS_NIADDR], fs, -1, expungetype)))
1399 blksperindir, fs, acctfunc, expungetype);
1402 blksperindir *= NINDIR(fs);
1423 struct fs *fs,
1425 struct fs *, ufs_lbn_t, int),
1447 bp = getblk(cancelvp, lbn, fs->fs_bsize, 0, 0, 0);
1448 bp->b_blkno = fsbtodb(fs, blkno);
1450 (error = readblock(cancelvp, bp, fragstoblks(fs, blkno)))) {
1458 if (last > NINDIR(fs))
1459 last = NINDIR(fs);
1460 bap = malloc(fs->fs_bsize, M_DEVBUF, M_WAITOK);
1461 bcopy(bp->b_data, (caddr_t)bap, fs->fs_bsize);
1463 error = (*acctfunc)(snapvp, &bap[0], &bap[last], fs,
1471 subblksperindir = blksperindir / NINDIR(fs);
1474 rlbn, remblks, subblksperindir, fs, acctfunc, expungetype);
1493 struct fs *fs,
1499 if ((error = snapacct_ufs2(vp, oldblkp, lastblkp, fs, lblkno, exptype)))
1501 return (mapacct_ufs2(vp, oldblkp, lastblkp, fs, lblkno, exptype));
1511 struct fs *fs,
1525 lbn = fragstoblks(fs, blkno);
1530 error = ffs_balloc_ufs2(vp, lblktosize(fs, (off_t)lbn),
1531 fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
1535 [(lbn - UFS_NDADDR) % NINDIR(fs)];
1564 struct fs *fs,
1587 blkno = blkstofrags(fs, lblkno);
1588 ffs_blkfree(ITOUMP(ip), fs, vp, blkno, fs->fs_bsize, inum,
1602 struct fs *fs;
1627 fs = ump->um_fs;
1630 if (fs->fs_snapinum[snaploc] == ip->i_number)
1634 if (fs->fs_snapinum[snaploc] == 0)
1636 fs->fs_snapinum[snaploc - 1] = fs->fs_snapinum[snaploc];
1638 fs->fs_snapinum[snaploc - 1] = 0;
1652 struct fs *fs;
1658 fs = ITOFS(ip);
1686 else if ((dblk == blkstofrags(fs, blkno) &&
1687 ffs_snapblkfree(fs, ITODEVVP(ip), dblk, fs->fs_bsize,
1690 btodb(fs->fs_bsize));
1694 numblks = howmany(ip->i_size, fs->fs_bsize);
1695 for (blkno = UFS_NDADDR; blkno < numblks; blkno += NINDIR(fs)) {
1696 error = UFS_BALLOC(vp, lblktosize(fs, (off_t)blkno),
1697 fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
1700 if (fs->fs_size - blkno > NINDIR(fs))
1701 last = NINDIR(fs);
1703 last = fs->fs_size - blkno;
1711 else if ((dblk == blkstofrags(fs, blkno) &&
1712 ffs_snapblkfree(fs, ITODEVVP(ip), dblk,
1713 fs->fs_bsize, ip->i_number, vp->v_type,
1716 btodb(fs->fs_bsize);
1726 else if ((dblk == blkstofrags(fs, blkno) &&
1727 ffs_snapblkfree(fs, ITODEVVP(ip), dblk,
1728 fs->fs_bsize, ip->i_number, vp->v_type, NULL))) {
1729 ip->i_din2->di_blocks -= btodb(fs->fs_bsize);
1776 ffs_snapblkfree(struct fs *fs,
1793 lbn = fragstoblks(fs, bno);
1821 error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),
1822 fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
1826 indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
1879 if (size == fs->fs_bsize) {
1920 error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),
1921 fs->fs_bsize, KERNCRED, 0, &cbp);
1943 bcopy(savedcbp->b_data, cbp->b_data, fs->fs_bsize);
1954 bzero(cbp->b_data, fs->fs_bsize);
1998 struct fs *fs = ump->um_fs;
2015 mp->mnt_stat.f_iosize = fs->fs_bsize;
2023 if (fs->fs_snapinum[snaploc] == 0)
2025 if ((error = ffs_vget(mp, fs->fs_snapinum[snaploc],
2036 lblktosize(fs, howmany(fs->fs_size, fs->fs_frag))) {
2045 reason, fs->fs_snapinum[snaploc]);
2049 if (fs->fs_snapinum[loc] == 0)
2051 fs->fs_snapinum[loc - 1] = fs->fs_snapinum[loc];
2053 fs->fs_snapinum[loc - 1] = 0;
2098 lblktosize(fs, howmany(fs->fs_size, fs->fs_frag));
2171 struct fs *fs;
2180 fs = ITOFS(TAILQ_FIRST(&sn->sn_head));
2181 lbn = fragstoblks(fs, dbtofsb(fs, bp->b_blkno));
2279 struct fs *fs;
2303 fs = ITOFS(ip);
2304 lbn = fragstoblks(fs, dbtofsb(fs, bp->b_blkno));
2374 error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),
2375 fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
2379 indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
2403 error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),
2404 fs->fs_bsize, KERNCRED, 0, &cbp);
2413 printf("fs metadata");
2432 bcopy(savedcbp->b_data, cbp->b_data, fs->fs_bsize);
2445 bzero(cbp->b_data, fs->fs_bsize);
2530 struct fs *fs;
2533 fs = ITOFS(ip);
2536 bp->b_iooffset = dbtob(fsbtodb(fs, blkstofrags(fs, lbn)));