Lines Matching refs:fs
76 struct lfs *fs;
87 fs = lifa->fs;
89 devvp = VTOI(fs->lfs_ivnode)->i_devvp;
92 error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),
103 num = LFS_INOPB(fs);
105 dip = DINO_IN_BLOCK(fs, lifa->buf, i);
106 ino = lfs_dino_getinumber(fs, dip);
109 true_addr = lfs_sb_getidaddr(fs);
112 LFS_IENTRY(ifp, fs, ino, ibp);
113 true_addr = lfs_if_getdaddr(fs, ifp);
119 LFS_ASSERT_MAXINO(fs, ino);
128 vp = fs->lfs_ivnode;
130 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,
135 KASSERT(VTOI(vp)->i_gen == lfs_dino_getgen(fs, dip));
136 lfs_setclean(fs, vp);
137 if (vp != fs->lfs_ivnode) {
149 struct lfs *fs;
160 fs = lifa->fs;
162 devvp = VTOI(fs->lfs_ivnode)->i_devvp;
165 error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),
176 num = LFS_INOPB(fs);
178 dip = DINO_IN_BLOCK(fs, lifa->buf, i);
179 ino = lfs_dino_getinumber(fs, dip);
182 true_addr = lfs_sb_getidaddr(fs);
185 LFS_IENTRY(ifp, fs, ino, ibp);
186 true_addr = lfs_if_getdaddr(fs, ifp);
195 LFS_ASSERT_MAXINO(fs, ino);
203 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,
208 KASSERT(VTOI(vp)->i_gen == lfs_dino_getgen(fs, dip));
211 lfs_setclean(fs, vp);
212 lfs_writeinode(fs, fs->lfs_sp, VTOI(vp));
224 rewrite_block(struct lfs *fs, struct vnode *vp, daddr_t lbn, daddr_t offset, size_t size, int *have_finfop)
239 if (offset != 0 && LFS_DBTOFSB(fs, daddr) != offset)
245 //size = lfs_blksize(fs, VTOI(vp), lbn);
250 if (vp == fs->lfs_ivnode) {
256 lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);
257 fs->lfs_sp->vp = vp;
266 while (lfs_gatherblock(fs->lfs_sp, bp, &bufcache_lock)) {
272 KASSERT(fs->lfs_sp->cbpp[-1] == bp);
280 struct lfs *fs;
291 fs = lffa->fs;
297 ino = lfs_fi_getino(fs, fip);
298 gen = lfs_fi_getversion(fs, fip);
301 vp = fs->lfs_ivnode;
303 LFS_ASSERT_MAXINO(fs, ino);
304 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,
319 if (vp != NULL && vp != fs->lfs_ivnode) {
324 bytes = ((lfs_fi_getnblocks(fs, fip) - 1) << lfs_sb_getbshift(fs))
325 + lfs_fi_getlastlength(fs, fip);
326 *offsetp += lfs_btofsb(fs, bytes);
336 lfs_setclean(fs, vp);
337 size = lfs_sb_getbsize(fs);
339 for (j = 0; j < lfs_fi_getnblocks(fs, fip); ++j) {
340 if (j == lfs_fi_getnblocks(fs, fip) - 1)
341 size = lfs_fi_getlastlength(fs, fip);
348 lbn = lfs_fi_getblock(fs, fip, j);
349 error = rewrite_block(fs, vp, lbn, *offsetp,
354 *fragsp += lfs_btofsb(fs, size);
356 *offsetp += lfs_btofsb(fs, size);
363 lfs_updatemeta(fs->lfs_sp);
364 fs->lfs_sp->vp = NULL;
365 lfs_release_finfo(fs);
366 lfs_writeinode(fs, fs->lfs_sp, VTOI(vp));
370 if (vp != fs->lfs_ivnode) {
381 struct lfs *fs;
390 fs = lffa->fs;
395 ino = lfs_fi_getino(fs, fip);
396 gen = lfs_fi_getversion(fs, fip);
399 vp = fs->lfs_ivnode;
401 LFS_ASSERT_MAXINO(fs, ino);
402 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,
408 lfs_setclean(fs, vp);
410 if (vp == fs->lfs_ivnode)
419 bytes = ((lfs_fi_getnblocks(fs, fip) - 1) << lfs_sb_getbshift(fs))
420 + lfs_fi_getlastlength(fs, fip);
421 *offsetp += lfs_btofsb(fs, bytes);
430 lfs_rewrite_segment(struct lfs *fs, int sn, int *fragsp, kauth_cred_t cred, struct lwp *l)
434 ASSERT_SEGLOCK(fs);
436 offset = lfs_sntod(fs, sn);
437 lfs_skip_superblock(fs, &offset);
438 endpseg = lfs_sntod(fs, sn + 1);
443 lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,
455 lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,
465 lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,
477 lfs_rewrite_segments(struct lfs *fs, int *snn, int len, int *directp, int *offsetp, struct lwp *l)
485 ASSERT_NO_SEGLOCK(fs);
490 lfs_writer_enter(fs, "rewritesegs");
491 if ((error = lfs_cleanerlock(fs)) != 0) {
492 lfs_writer_leave(fs);
504 LFS_SEGENTRY(sup, fs, snn[i], bp);
513 offset = lfs_sntod(fs, snn[i]);
514 lfs_skip_superblock(fs, &offset);
515 endpseg = lfs_sntod(fs, snn[i] + 1);
518 lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,
527 lfs_seglock(fs, SEGM_CLEAN);
532 LFS_SEGENTRY(sup, fs, snn[i], bp);
541 error = lfs_rewrite_segment(fs, snn[i], directp, cred, l);
547 while (lfs_writeseg(fs, fs->lfs_sp))
550 *offsetp = lfs_btofsb(fs, fs->lfs_sp->bytes_written);
551 lfs_segunlock(fs);
552 lfs_cleanerunlock(fs);
553 lfs_writer_leave(fs);
560 lfs_isseq(const struct lfs *fs, long int lbn1, long int lbn2)
562 return lbn2 == lbn1 + lfs_sb_getfrag(__UNCONST(fs));
571 lfs_rewrite_file(struct lfs *fs, ino_t ino, struct lwp *l)
579 ASSERT_SEGLOCK(fs);
581 LFS_ASSERT_MAXINO(fs, ino);
583 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino, LK_EXCLUSIVE, &vp);
587 lfs_acquire_finfo(fs, ino, VTOI(vp)->i_gen);
594 size = lfs_blksize(fs, VTOI(vp), lbn);
595 error = rewrite_block(fs, vp, lbn++, 0x0, size, NULL);
600 lfs_release_finfo(fs);
601 while (lfs_writeseg(fs, fs->lfs_sp))
603 lfs_segunlock(fs);
613 struct lfs *fs;
624 fs = lifa->fs;
626 devvp = VTOI(fs->lfs_ivnode)->i_devvp;
629 error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),
638 num = LFS_INOPB(fs);
640 dip = DINO_IN_BLOCK(fs, dbp->b_data, i);
641 ino = lfs_dino_getinumber(fs, dip);
644 true_addr = lfs_sb_getidaddr(fs);
647 LFS_IENTRY(ifp, fs, ino, ibp);
648 true_addr = lfs_if_getdaddr(fs, ifp);
664 struct lfs *fs;
674 fs = lffa->fs;
679 ino = lfs_fi_getino(fs, fip);
680 gen = lfs_fi_getversion(fs, fip);
681 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino, LK_EXCLUSIVE, &vp);
696 bytes = ((lfs_fi_getnblocks(fs, fip) - 1)
697 << lfs_sb_getbshift(fs))
698 + lfs_fi_getlastlength(fs, fip);
699 *offsetp += lfs_btofsb(fs, bytes);
708 size = lfs_sb_getbsize(fs);
709 for (j = 0; j < lfs_fi_getnblocks(fs, fip); ++j) {
710 if (j == lfs_fi_getnblocks(fs, fip) - 1)
711 size = lfs_fi_getlastlength(fs, fip);
713 lbn = lfs_fi_getblock(fs, fip, j);
721 if (LFS_DBTOFSB(fs, daddr) == *offsetp) {
726 *offsetp += lfs_btofsb(fs, size);
737 lfs_checkempty(struct lfs *fs, int sn, kauth_cred_t cred, struct lwp *l)
742 ASSERT_SEGLOCK(fs);
744 offset = lfs_sntod(fs, sn);
745 lfs_skip_superblock(fs, &offset);
746 endpseg = lfs_sntod(fs, sn + 1);
749 error = lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,
760 segselect_greedy(struct lfs *fs, int sn, SEGUSE *sup)
762 return lfs_sb_getssize(fs) - sup->su_nbytes;
766 segselect_cb_rosenblum(struct lfs *fs, int sn, SEGUSE *sup, long age)
770 benefit = (int64_t)lfs_sb_getssize(fs) - sup->su_nbytes -
771 (sup->su_nsums + 1) * lfs_sb_getfsize(fs);
774 if (lfs_sb_getbsize(fs) > lfs_sb_getfsize(fs)) /* fragmentation */
775 benefit -= (lfs_sb_getbsize(fs) / 2);
780 cost = lfs_sb_getssize(fs) + sup->su_nbytes;
785 segselect_cb_time(struct lfs *fs, int sn, SEGUSE *sup)
792 return segselect_cb_rosenblum(fs, sn, sup, age);
806 segselect_cb_serial(struct lfs *fs, int sn, SEGUSE *sup)
813 addr = lfs_segtod(fs, sn);
814 lfs_skip_superblock(fs, &addr);
815 bread(fs->lfs_devvp, LFS_FSBTODB(fs, addr),
816 lfs_sb_getsumsize(fs), 0, &bp);
817 magic = lfs_ss_getmagic(fs, ((SEGSUM *)bp->b_data));
818 serial = lfs_ss_getserial(fs, ((SEGSUM *)bp->b_data));
824 age = lfs_sb_getserial(fs) - serial;
825 return segselect_cb_rosenblum(fs, sn, sup, age);
834 struct lfs *fs;
869 fs = VFSTOULFS(mp)->um_lfs;
872 if (fs->lfs_clean_selector != NULL)
875 cleaned_something += clean(fs);
906 clean(struct lfs *fs)
917 func = fs->lfs_clean_selector;
921 thresh = fs->lfs_autoclean.thresh;
922 if (fs->lfs_flags & LFS_MUSTCLEAN)
931 bfree = lfs_sb_getbfree(fs)
932 + lfs_segtod(fs, 1) * lfs_sb_getminfree(fs);
933 avail = lfs_sb_getavail(fs) - fs->lfs_ravail - fs->lfs_favail;
936 thresh = lfs_sb_getssize(fs) * (bfree - avail)
937 / (lfs_sb_getsize(fs) - avail);
938 if (thresh > lfs_sb_getsumsize(fs) + 5 * lfs_sb_getbsize(fs))
939 thresh = lfs_sb_getsumsize(fs) + 5 * lfs_sb_getbsize(fs);
940 if (thresh > lfs_sb_getssize(fs) - lfs_sb_getbsize(fs))
944 target = fs->lfs_autoclean.target;
947 target = lfs_segtod(fs, 1) / 2;
950 oldsn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
955 for (sn = 0; sn < lfs_sb_getnseg(fs); sn++) {
958 LFS_SEGENTRY(sup, fs, sn, bp);
970 prio = (*func)(fs, sn, sup);
988 nclean, (int)lfs_sb_getnseg(fs), nzero, nempty, nready,
997 if (maxprio > 0 && fs->lfs_lastcleaned == maxsn) {
998 LFS_SEGENTRY(sup, fs, maxsn, bp);
1000 LFS_WRITESEGENTRY(sup, fs, sn, bp);
1011 lfs_seguse_clrflag_all(fs, SEGUSE_ERROR);
1017 (void)lfs_rewrite_segments(fs, &maxsn, 1,
1021 fs->lfs_clean_accum += offset;
1024 fs->lfs_lastcleaned = maxsn;
1031 if (fs->lfs_flags & LFS_MUSTCLEAN) {
1035 lfs_segwrite(fs->lfs_ivnode->v_mount,
1037 lfs_segwrite(fs->lfs_ivnode->v_mount,
1041 } else if (fs->lfs_clean_accum > target) {
1043 lfs_segwrite(fs->lfs_ivnode->v_mount, SEGM_CKP);
1044 fs->lfs_clean_accum = 0;
1045 } else if (lfs_dtosn(fs, lfs_sb_getoffset(fs)) != oldsn
1048 lfs_segwrite(fs->lfs_ivnode->v_mount, SEGM_CKP);
1049 fs->lfs_clean_accum = 0;
1067 lfs_rewrite_file(struct lfs *fs, ino_t *inoa, int len, bool scramble,
1077 if ((error = lfs_cleanerlock(fs)) != 0)
1080 lfs_seglock(fs, flags);
1082 error = VFS_VGET(fs->lfs_ivnode->v_mount, inoa[i], LK_EXCLUSIVE, &vp);
1095 hiblk = lfs_lblkno(fs, ip->i_size + lfs_sb_getbsize(fs) - 1) - 1;
1101 if (lfs_needsflush(fs)) {
1102 lfs_segwrite(fs->lfs_ivnode->v_mount, flags);
1105 error = bread(vp, lbn, lfs_blksize(fs, ip, lbn), 0, &bp);
1111 *directp += lfs_btofsb(fs, bp->b_bcount);
1121 lfs_segwrite(fs->lfs_ivnode->v_mount, flags);
1122 *offsetp += lfs_btofsb(fs, fs->lfs_sp->bytes_written);
1123 lfs_segunlock(fs);
1124 lfs_cleanerunlock(fs);
1130 lfs_cleanctl(struct lfs *fs, struct lfs_autoclean_params *params)
1134 fs->lfs_autoclean = *params;
1137 switch (fs->lfs_autoclean.mode) {
1155 if (fs->lfs_clean_selector == NULL && cleanfunc != NULL)
1164 if (fs->lfs_clean_selector != NULL && cleanfunc == NULL)
1169 fs->lfs_clean_selector = cleanfunc;