Lines Matching refs:fs
102 lfs_setup_resblks(struct lfs *fs)
107 ASSERT_NO_SEGLOCK(fs);
108 fs->lfs_resblk = malloc(LFS_N_TOTAL * sizeof(res_t), M_SEGMENT,
111 fs->lfs_resblk[i].inuse = 0;
112 fs->lfs_resblk[i].p = NULL;
115 LIST_INIT(fs->lfs_reshash + i);
122 fs->lfs_resblk[i].size = lfs_sb_getsumsize(fs);
124 fs->lfs_resblk[i].size = LFS_SBPAD;
126 fs->lfs_resblk[i].size = lfs_sb_getbsize(fs);
128 fs->lfs_resblk[i].size = MAXPHYS;
130 fs->lfs_resblk[i].size = MAXPHYS;
132 fs->lfs_resblk[i].size = LFS_MARKV_MAXBLKCNT * sizeof(BLOCK_INFO);
135 fs->lfs_resblk[i].p = malloc(fs->lfs_resblk[i].size,
142 pool_init(&fs->lfs_clpool, sizeof(struct lfs_cluster), 0, 0, 0,
144 pool_init(&fs->lfs_segpool, sizeof(struct segment), 0, 0, 0,
147 maxbpp = ((lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs)) / sizeof(int32_t) + 2);
148 maxbpp = MIN(maxbpp, lfs_segsize(fs) / lfs_sb_getfsize(fs) + 2);
149 pool_init(&fs->lfs_bpppool, maxbpp * sizeof(struct buf *), 0, 0, 0,
154 lfs_free_resblks(struct lfs *fs)
158 pool_destroy(&fs->lfs_bpppool);
159 pool_destroy(&fs->lfs_segpool);
160 pool_destroy(&fs->lfs_clpool);
164 while (fs->lfs_resblk[i].inuse)
165 mtsleep(&fs->lfs_resblk, PRIBIO + 1, "lfs_free", 0,
167 if (fs->lfs_resblk[i].p != NULL)
168 free(fs->lfs_resblk[i].p, M_SEGMENT);
170 free(fs->lfs_resblk, M_SEGMENT);
185 lfs_malloc(struct lfs *fs, size_t size, int type)
192 ASSERT_MAYBE_SEGLOCK(fs);
219 if (fs->lfs_resblk[start + i].inuse == 0) {
220 re = fs->lfs_resblk + start + i;
225 LIST_INSERT_HEAD(&fs->lfs_reshash[h], re, res);
232 mtsleep(&fs->lfs_resblk, PVM, "lfs_malloc", 0,
243 lfs_free(struct lfs *fs, void *p, int type)
248 ASSERT_MAYBE_SEGLOCK(fs);
251 LIST_FOREACH(re, &fs->lfs_reshash[h], res) {
256 wakeup(&fs->lfs_resblk);
264 KDASSERTMSG(fs->lfs_resblk[i].p == p,
282 lfs_seglock(struct lfs *fs, unsigned long flags)
287 if (fs->lfs_seglock) {
288 if (fs->lfs_lockpid == curproc->p_pid &&
289 fs->lfs_locklwp == curlwp->l_lid) {
290 ++fs->lfs_seglock;
291 fs->lfs_sp->seg_flags |= flags;
298 while (fs->lfs_seglock) {
299 (void)mtsleep(&fs->lfs_seglock, PRIBIO + 1,
305 fs->lfs_seglock = 1;
306 fs->lfs_lockpid = curproc->p_pid;
307 fs->lfs_locklwp = curlwp->l_lid;
309 fs->lfs_cleanind = 0;
314 rw_enter(&fs->lfs_fraglock, RW_WRITER);
316 sp = fs->lfs_sp = pool_get(&fs->lfs_segpool, PR_WAITOK);
317 sp->bpp = pool_get(&fs->lfs_bpppool, PR_WAITOK);
323 (void) lfs_initseg(fs, 0);
332 ++fs->lfs_iocount;
333 fs->lfs_startseg = lfs_sb_getcurseg(fs);
365 lfs_unmark_dirop(struct lfs *fs)
371 KASSERT(fs != NULL);
372 ASSERT_NO_SEGLOCK(fs);
374 doit = !(fs->lfs_flags & LFS_UNDIROP);
376 fs->lfs_flags |= LFS_UNDIROP;
385 TAILQ_INSERT_HEAD(&fs->lfs_dchainhd, marker, i_lfs_dchain);
387 TAILQ_REMOVE(&fs->lfs_dchainhd, marker, i_lfs_dchain);
388 TAILQ_INSERT_AFTER(&fs->lfs_dchainhd, ip, marker,
395 --fs->lfs_dirvcount;
397 TAILQ_REMOVE(&fs->lfs_dchainhd, ip, i_lfs_dchain);
399 fs->lfs_unlockvp = vp;
403 fs->lfs_unlockvp = NULL;
407 TAILQ_REMOVE(&fs->lfs_dchainhd, marker, i_lfs_dchain);
408 fs->lfs_flags &= ~LFS_UNDIROP;
409 wakeup(&fs->lfs_flags);
416 lfs_auto_segclean(struct lfs *fs)
422 ASSERT_SEGLOCK(fs);
430 for (i = 0; i < lfs_sb_getnseg(fs); i++) {
432 LFS_SEGENTRY(sup, fs, i, bp);
451 while (waited == 0 && fs->lfs_sbactive)
452 mtsleep(&fs->lfs_sbactive, PRIBIO+1,
457 lfs_markclean(fs, i, sup, NOCRED, curlwp);
466 LFS_WRITESEGENTRY(sup, fs, i, bp);
477 lfs_segunlock(struct lfs *fs)
484 sp = fs->lfs_sp;
488 if (!LFS_SEGLOCK_HELD(fs))
491 if (fs->lfs_seglock == 1) {
502 lfs_sb_suboffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
504 lfs_freebuf(fs, bp);
506 pool_put(&fs->lfs_bpppool, sp->bpp);
512 * fs->lfs_sp so another process can use it (we have to
516 pool_put(&fs->lfs_segpool, sp);
517 fs->lfs_sp = NULL;
525 if (--fs->lfs_iocount <= 1)
526 wakeup(&fs->lfs_iocount);
538 --fs->lfs_seglock;
539 fs->lfs_lockpid = 0;
540 fs->lfs_locklwp = 0;
542 wakeup(&fs->lfs_seglock);
552 while (ckp && sync && fs->lfs_iocount) {
553 (void)mtsleep(&fs->lfs_iocount, PRIBIO + 1,
555 DLOG((DLOG_SEG, "sleeping on iocount %x == %d\n", fs, fs->lfs_iocount));
564 pool_put(&fs->lfs_segpool, sp);
567 fs->lfs_nactive = 0;
571 lfs_writesuper(fs, lfs_sb_getsboff(fs, fs->lfs_activesb));
572 lfs_writesuper(fs, lfs_sb_getsboff(fs, 1 - fs->lfs_activesb));
573 if (!(fs->lfs_ivnode->v_mount->mnt_iflag & IMNT_UNMOUNT)) {
574 lfs_auto_segclean(fs);
577 lfs_auto_segclean(fs);
579 fs->lfs_activesb = 1 - fs->lfs_activesb;
584 --fs->lfs_seglock;
585 fs->lfs_lockpid = 0;
586 fs->lfs_locklwp = 0;
588 wakeup(&fs->lfs_seglock);
591 rw_exit(&fs->lfs_fraglock);
593 lfs_unmark_dirop(fs);
595 --fs->lfs_seglock;
596 KASSERT(fs->lfs_seglock != 0);
605 lfs_cleanerlock(struct lfs *fs)
610 while (fs->lfs_cleanlock) {
611 printf("cleanlock=%p, waiting\n", fs->lfs_cleanlock);
612 error = cv_wait_sig(&fs->lfs_cleanercv, &lfs_lock);
617 fs->lfs_cleanlock = curlwp;
627 lfs_cleanerlock_held(struct lfs *fs)
632 retval = (fs->lfs_cleanlock == curlwp);
642 lfs_cleanerunlock(struct lfs *fs)
647 while ((ip = TAILQ_FIRST(&fs->lfs_cleanhd)) != NULL)
648 lfs_clrclean(fs, ITOV(ip));
651 fs->lfs_cleanlock = NULL;
652 cv_broadcast(&fs->lfs_cleanercv);
662 lfs_writer_enter(struct lfs *fs, const char *wmesg)
666 ASSERT_NO_SEGLOCK(fs);
670 fs->lfs_writer++;
672 while (fs->lfs_dirops > 0) {
673 ++fs->lfs_diropwait;
674 error = mtsleep(&fs->lfs_writer, PRIBIO+1, wmesg, 0,
677 --fs->lfs_diropwait;
684 lfs_writer_tryenter(struct lfs *fs)
688 ASSERT_MAYBE_SEGLOCK(fs);
690 writer_set = (fs->lfs_dirops == 0);
692 fs->lfs_writer++;
699 lfs_writer_leave(struct lfs *fs)
703 ASSERT_MAYBE_SEGLOCK(fs);
705 dowakeup = !(--fs->lfs_writer);
707 cv_broadcast(&fs->lfs_diropscv);
717 lfs_segunlock_relock(struct lfs *fs)
719 int n = fs->lfs_seglock;
728 lfs_writeseg(fs, fs->lfs_sp);
732 fs->lfs_flags |= LFS_MUSTCLEAN;
734 LFS_CLEANERINFO(cip, fs, bp);
735 lfs_ci_setflags(fs, cip,
736 lfs_ci_getflags(fs, cip) | LFS_CLEANER_MUST_CLEAN);
737 LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
740 seg_flags = fs->lfs_sp->seg_flags;
742 fs->lfs_sp->seg_flags |= SEGM_PROT; /* Don't unmark dirop nodes */
743 while(fs->lfs_seglock)
744 lfs_segunlock(fs);
747 lfs_wakeup_cleaner(fs);
749 while (LFS_STARVED_FOR_SEGS(fs))
750 mtsleep(&fs->lfs_availsleep, PRIBIO, "relock", 0,
756 lfs_seglock(fs, seg_flags);
760 fs->lfs_flags &= ~LFS_MUSTCLEAN;
762 LFS_CLEANERINFO(cip, fs, bp);
763 lfs_ci_setflags(fs, cip,
764 lfs_ci_getflags(fs, cip) & ~LFS_CLEANER_MUST_CLEAN);
765 LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
774 lfs_wakeup_cleaner(struct lfs *fs)
776 if (fs->lfs_nowrap > 0)
779 cv_broadcast(&fs->lfs_nextsegsleep);
789 lfs_setclean(struct lfs *fs, struct vnode *vp)
793 KASSERT(lfs_cleanerlock_held(fs));
805 TAILQ_INSERT_HEAD(&fs->lfs_cleanhd, ip, i_lfs_clean);
817 lfs_clrclean(struct lfs *fs, struct vnode *vp)
821 KASSERT(lfs_cleanerlock_held(fs));
831 if (vp->v_type == VREG && vp != fs->lfs_ivnode)
832 lfs_ungather(fs, NULL, vp, lfs_match_data);
835 TAILQ_REMOVE(&fs->lfs_cleanhd, ip, i_lfs_clean);
845 lfs_seguse_clrflag_all(struct lfs *fs, uint32_t flag)
851 for (i = 0; i < lfs_sb_getnseg(fs); i++) {
852 LFS_SEGENTRY(sup, fs, i, bp);
855 LFS_WRITESEGENTRY(sup, fs, i, bp);