Lines Matching refs:fs
81 struct lfs *fs;
92 fs = lifa->fs;
94 devvp = VTOI(fs->lfs_ivnode)->i_devvp;
97 error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),
108 num = LFS_INOPB(fs);
110 dip = DINO_IN_BLOCK(fs, lifa->buf, i);
111 ino = lfs_dino_getinumber(fs, dip);
114 true_addr = lfs_sb_getidaddr(fs);
117 LFS_IENTRY(ifp, fs, ino, ibp);
118 true_addr = lfs_if_getdaddr(fs, ifp);
124 LFS_ASSERT_MAXINO(fs, ino);
133 vp = fs->lfs_ivnode;
135 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,
140 KASSERT(VTOI(vp)->i_gen == lfs_dino_getgen(fs, dip));
141 lfs_setclean(fs, vp);
142 if (vp != fs->lfs_ivnode) {
154 struct lfs *fs;
165 fs = lifa->fs;
167 devvp = VTOI(fs->lfs_ivnode)->i_devvp;
170 error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),
181 num = LFS_INOPB(fs);
183 dip = DINO_IN_BLOCK(fs, lifa->buf, i);
184 ino = lfs_dino_getinumber(fs, dip);
187 true_addr = lfs_sb_getidaddr(fs);
190 LFS_IENTRY(ifp, fs, ino, ibp);
191 true_addr = lfs_if_getdaddr(fs, ifp);
200 LFS_ASSERT_MAXINO(fs, ino);
208 error = check_clean_list(fs, ino);
211 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,
216 KASSERT(VTOI(vp)->i_gen == lfs_dino_getgen(fs, dip));
219 lfs_setclean(fs, vp);
220 lfs_writeinode(fs, fs->lfs_sp, VTOI(vp));
232 rewrite_block(struct lfs *fs, struct vnode *vp, daddr_t lbn, daddr_t offset, size_t size, int *have_finfop)
247 if (offset != 0 && LFS_DBTOFSB(fs, daddr) != offset)
253 //size = lfs_blksize(fs, VTOI(vp), lbn);
258 if (vp == fs->lfs_ivnode) {
264 lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);
265 fs->lfs_sp->vp = vp;
276 while (lfs_gatherblock(fs->lfs_sp, bp, &bufcache_lock)) {
282 KASSERT(fs->lfs_sp->cbpp[-1] == bp);
288 check_clean_list(struct lfs *fs, ino_t ino)
296 TAILQ_FOREACH(ip, &fs->lfs_cleanhd, i_lfs_clean) {
307 struct lfs *fs;
318 fs = lffa->fs;
324 ino = lfs_fi_getino(fs, fip);
325 gen = lfs_fi_getversion(fs, fip);
328 vp = fs->lfs_ivnode;
330 LFS_ASSERT_MAXINO(fs, ino);
331 error = check_clean_list(fs, ino);
335 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,
350 if (vp != NULL && vp != fs->lfs_ivnode) {
355 bytes = ((lfs_fi_getnblocks(fs, fip) - 1) << lfs_sb_getbshift(fs))
356 + lfs_fi_getlastlength(fs, fip);
357 *offsetp += lfs_btofsb(fs, bytes);
367 lfs_setclean(fs, vp);
368 size = lfs_sb_getbsize(fs);
370 for (j = 0; j < lfs_fi_getnblocks(fs, fip); ++j) {
371 if (j == lfs_fi_getnblocks(fs, fip) - 1)
372 size = lfs_fi_getlastlength(fs, fip);
379 lbn = lfs_fi_getblock(fs, fip, j);
380 error = rewrite_block(fs, vp, lbn, *offsetp,
385 *fragsp += lfs_btofsb(fs, size);
387 *offsetp += lfs_btofsb(fs, size);
394 lfs_updatemeta(fs->lfs_sp);
395 fs->lfs_sp->vp = NULL;
396 lfs_release_finfo(fs);
397 lfs_writeinode(fs, fs->lfs_sp, VTOI(vp));
401 if (vp != fs->lfs_ivnode) {
412 struct lfs *fs;
421 fs = lffa->fs;
426 ino = lfs_fi_getino(fs, fip);
427 gen = lfs_fi_getversion(fs, fip);
430 vp = fs->lfs_ivnode;
432 LFS_ASSERT_MAXINO(fs, ino);
433 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino,
439 lfs_setclean(fs, vp);
441 if (vp == fs->lfs_ivnode)
450 bytes = ((lfs_fi_getnblocks(fs, fip) - 1) << lfs_sb_getbshift(fs))
451 + lfs_fi_getlastlength(fs, fip);
452 *offsetp += lfs_btofsb(fs, bytes);
461 lfs_rewrite_segment(struct lfs *fs, int sn, int *fragsp, kauth_cred_t cred, struct lwp *l)
465 ASSERT_SEGLOCK(fs);
467 offset = lfs_sntod(fs, sn);
468 lfs_skip_superblock(fs, &offset);
469 endpseg = lfs_sntod(fs, sn + 1);
474 lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,
486 lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,
496 lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,
508 lfs_rewrite_segments(struct lfs *fs, int *snn, int len, int *directp, int *offsetp, struct lwp *l)
516 ASSERT_NO_SEGLOCK(fs);
521 lfs_writer_enter(fs, "rewritesegs");
522 if ((error = lfs_cleanerlock(fs)) != 0) {
523 lfs_writer_leave(fs);
535 LFS_SEGENTRY(sup, fs, snn[i], bp);
544 offset = lfs_sntod(fs, snn[i]);
545 lfs_skip_superblock(fs, &offset);
546 endpseg = lfs_sntod(fs, snn[i] + 1);
549 lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,
558 lfs_seglock(fs, SEGM_CLEAN);
563 LFS_SEGENTRY(sup, fs, snn[i], bp);
572 error = lfs_rewrite_segment(fs, snn[i], directp, cred, l);
576 while (lfs_writeseg(fs, fs->lfs_sp))
579 *offsetp = lfs_btofsb(fs, fs->lfs_sp->bytes_written);
580 lfs_segunlock(fs);
581 lfs_cleanerunlock(fs);
582 lfs_writer_leave(fs);
590 struct lfs *fs;
601 fs = lifa->fs;
603 devvp = VTOI(fs->lfs_ivnode)->i_devvp;
606 error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),
615 num = LFS_INOPB(fs);
617 dip = DINO_IN_BLOCK(fs, dbp->b_data, i);
618 ino = lfs_dino_getinumber(fs, dip);
621 true_addr = lfs_sb_getidaddr(fs);
624 LFS_IENTRY(ifp, fs, ino, ibp);
625 true_addr = lfs_if_getdaddr(fs, ifp);
641 struct lfs *fs;
651 fs = lffa->fs;
656 ino = lfs_fi_getino(fs, fip);
657 gen = lfs_fi_getversion(fs, fip);
658 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino, LK_EXCLUSIVE|LK_NOWAIT, &vp);
673 bytes = ((lfs_fi_getnblocks(fs, fip) - 1)
674 << lfs_sb_getbshift(fs))
675 fs, fip);
676 *offsetp += lfs_btofsb(fs, bytes);
685 size = lfs_sb_getbsize(fs);
686 for (j = 0; j < lfs_fi_getnblocks(fs, fip); ++j) {
687 if (j == lfs_fi_getnblocks(fs, fip) - 1)
688 size = lfs_fi_getlastlength(fs, fip);
690 lbn = lfs_fi_getblock(fs, fip, j);
698 if (LFS_DBTOFSB(fs, daddr) == *offsetp) {
703 *offsetp += lfs_btofsb(fs, size);
714 lfs_checkempty(struct lfs *fs, int sn, kauth_cred_t cred, struct lwp *l)
719 ASSERT_SEGLOCK(fs);
721 offset = lfs_sntod(fs, sn);
722 lfs_skip_superblock(fs, &offset);
723 endpseg = lfs_sntod(fs, sn + 1);
726 error = lfs_parse_pseg(fs, &offset, 0, cred, NULL, l,
737 segselect_greedy(struct lfs *fs, int sn, SEGUSE *sup)
739 return lfs_sb_getssize(fs) - sup->su_nbytes;
743 segselect_cb_rosenblum(struct lfs *fs, int sn, SEGUSE *sup, long age)
747 benefit = (int64_t)lfs_sb_getssize(fs) - sup->su_nbytes -
748 (sup->su_nsums + 1) * lfs_sb_getfsize(fs);
751 if (lfs_sb_getbsize(fs) > lfs_sb_getfsize(fs)) /* fragmentation */
752 benefit -= (lfs_sb_getbsize(fs) / 2);
757 cost = lfs_sb_getssize(fs) + sup->su_nbytes;
762 segselect_cb_time(struct lfs *fs, int sn, SEGUSE *sup)
769 return segselect_cb_rosenblum(fs, sn, sup, age);
783 segselect_cb_serial(struct lfs *fs, int sn, SEGUSE *sup)
790 addr = lfs_segtod(fs, sn);
791 lfs_skip_superblock(fs, &addr);
792 bread(fs->lfs_devvp, LFS_FSBTODB(fs, addr),
793 lfs_sb_getsumsize(fs), 0, &bp);
794 magic = lfs_ss_getmagic(fs, ((SEGSUM *)bp->b_data));
795 serial = lfs_ss_getserial(fs, ((SEGSUM *)bp->b_data));
801 age = lfs_sb_getserial(fs) - serial;
802 return segselect_cb_rosenblum(fs, sn, sup, age);
811 struct lfs *fs;
840 fs = VFSTOULFS(mp)->um_lfs;
843 if (fs->lfs_clean_selector == NULL) {
845 if (fs->lfs_autoclean_status) {
846 fs->lfs_autoclean_status =
848 cv_broadcast(&fs->lfs_cleanquitcv);
853 cleaned_something += clean(fs);
884 clean(struct lfs *fs)
896 func = fs->lfs_clean_selector;
901 thresh = fs->lfs_autoclean.thresh;
902 if (fs->lfs_flags & LFS_MUSTCLEAN)
911 bfree = lfs_sb_getbfree(fs)
912 + lfs_segtod(fs, 1) * lfs_sb_getminfree(fs);
913 avail = lfs_sb_getavail(fs) - fs->lfs_ravail - fs->lfs_favail;
916 thresh = lfs_sb_getssize(fs) * (bfree - avail)
917 / (lfs_sb_getsize(fs) - avail);
918 if (thresh > lfs_sb_getsumsize(fs) + 5 * lfs_sb_getbsize(fs))
919 thresh = lfs_sb_getsumsize(fs) + 5 * lfs_sb_getbsize(fs);
920 if (thresh > lfs_sb_getssize(fs) - lfs_sb_getbsize(fs))
924 target = fs->lfs_autoclean.target;
927 target = lfs_segtod(fs, 1) / 2;
930 oldsn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
935 for (sn = 0; sn < lfs_sb_getnseg(fs); sn++) {
938 LFS_SEGENTRY(sup, fs, sn, bp);
950 prio = (*func)(fs, sn, sup);
968 nclean, (int)lfs_sb_getnseg(fs), nzero, nempty, nready,
977 if (maxprio > 0 && fs->lfs_lastcleaned == maxsn) {
978 LFS_SEGENTRY(sup, fs, maxsn, bp);
980 LFS_WRITESEGENTRY(sup, fs, sn, bp);
991 lfs_seguse_clrflag_all(fs, SEGUSE_ERROR);
997 (void)lfs_rewrite_segments(fs, &maxsn, 1,
1001 fs->lfs_clean_accum += offset;
1004 fs->lfs_lastcleaned = maxsn;
1011 if (fs->lfs_flags & LFS_MUSTCLEAN) {
1015 lfs_segwrite(fs->lfs_ivnode->v_mount,
1017 lfs_segwrite(fs->lfs_ivnode->v_mount,
1021 } else if (fs->lfs_clean_accum > target) {
1023 lfs_segwrite(fs->lfs_ivnode->v_mount, SEGM_CKP);
1024 fs->lfs_clean_accum = 0;
1025 } else if (lfs_dtosn(fs, lfs_sb_getoffset(fs)) != oldsn
1028 lfs_segwrite(fs->lfs_ivnode->v_mount, SEGM_CKP);
1029 fs->lfs_clean_accum = 0;
1047 lfs_rewrite_file(struct lfs *fs, ino_t *inoa, int len, bool scramble,
1060 if ((error = lfs_cleanerlock(fs)) != 0)
1062 lfs_seglock(fs, 0);
1064 error = VFS_VGET(fs->lfs_ivnode->v_mount, inoa[i],
1078 hiblk = lfs_lblkno(fs, ip->i_size + lfs_sb_getbsize(fs) - 1) - 1;
1084 if (lfs_needsflush(fs)) {
1085 lfs_segwrite(fs->lfs_ivnode->v_mount, 0);
1088 error = bread(vp, lbn, lfs_blksize(fs, ip, lbn), 0, &bp);
1094 *directp += lfs_btofsb(fs, bp->b_bcount);
1104 lfs_segwrite(fs->lfs_ivnode->v_mount, 0);
1105 *offsetp += lfs_btofsb(fs, fs->lfs_sp->bytes_written);
1106 lfs_segunlock(fs);
1107 lfs_cleanerunlock(fs);
1113 lfs_cleanctl(struct lfs *fs, struct lfs_autoclean_params *params)
1117 fs->lfs_autoclean = *params;
1120 switch (fs->lfs_autoclean.mode) {
1139 fs->lfs_autoclean_status != LFS_AUTOCLEAN_STATUS_OFF) {
1140 cv_wait(&fs->lfs_cleanquitcv, &lfs_lock);
1142 if (fs->lfs_clean_selector == NULL && cleanfunc != NULL)
1151 if (fs->lfs_clean_selector != NULL && cleanfunc == NULL) {
1159 fs->lfs_clean_selector = cleanfunc;
Indexes created Sun Feb 15 12:34:49 CET 2026