Lines Matching defs:ump
142 softdep_setup_sbupdate(ump, fs, bp)
143 struct ufsmount *ump;
796 static void jseg_write(struct ufsmount *ump, struct jseg *, uint8_t *);
948 static int journal_unsuspend(struct ufsmount *ump);
1005 #define LOCK_PTR(ump) (&(ump)->um_softdep->sd_fslock)
1006 #define TRY_ACQUIRE_LOCK(ump) rw_try_wlock(&(ump)->um_softdep->sd_fslock)
1007 #define ACQUIRE_LOCK(ump) rw_wlock(&(ump)->um_softdep->sd_fslock)
1008 #define FREE_LOCK(ump) rw_wunlock(&(ump)->um_softdep->sd_fslock)
1009 #define LOCK_OWNED(ump) rw_assert(&(ump)->um_softdep->sd_fslock, \
1206 struct ufsmount *ump;
1220 ump = VFSTOUFS(item->wk_mp);
1221 LOCK_OWNED(ump);
1222 KASSERT(ump->softdep_deps > 0,
1224 ump->um_fs->fs_fsmnt));
1225 if (--ump->softdep_deps == 0 && ump->softdep_req)
1226 wakeup(&ump->softdep_deps);
1229 ump->um_fs->fs_fsmnt, TYPENAME(item->wk_type)));
1230 KASSERT(ump->softdep_curdeps[item->wk_type] > 0,
1232 ump->um_fs->fs_fsmnt, TYPENAME(item->wk_type)));
1234 ump->softdep_curdeps[item->wk_type] -= 1;
1247 struct ufsmount *ump;
1253 ump = VFSTOUFS(mp);
1260 ACQUIRE_LOCK(ump);
1261 ump->softdep_curdeps[type] += 1;
1262 ump->softdep_deps++;
1263 ump->softdep_accdeps++;
1265 LIST_INSERT_HEAD(&ump->softdep_alldeps[type], item, wk_all);
1267 FREE_LOCK(ump);
1275 struct ufsmount *ump;
1277 ump = VFSTOUFS(item->wk_mp);
1278 LOCK_OWNED(ump);
1279 KASSERT(ump->softdep_curdeps[item->wk_type] > 0,
1282 ump->softdep_curdeps[item->wk_type] -= 1;
1283 ump->softdep_curdeps[newtype] += 1;
1571 struct ufsmount *ump;
1576 ump = VFSTOUFS(mp);
1578 ACQUIRE_LOCK(ump);
1579 ump->softdep_flags &= ~FLUSH_STARTING;
1580 wakeup(&ump->softdep_flushtd);
1581 FREE_LOCK(ump);
1593 ACQUIRE_LOCK(ump);
1594 if ((ump->softdep_flags & (FLUSH_CLEANUP | FLUSH_EXIT)) == 0)
1595 msleep(&ump->softdep_flushtd, LOCK_PTR(ump), PVM,
1597 ump->softdep_flags &= ~FLUSH_CLEANUP;
1601 if ((ump->softdep_flags & FLUSH_EXIT) == 0) {
1602 FREE_LOCK(ump);
1605 ump->softdep_flags &= ~FLUSH_EXIT;
1606 FREE_LOCK(ump);
1607 wakeup(&ump->softdep_flags);
1609 printf("Stop thread %s: searchfailed %d, did cleanups %d\n", td->td_name, searchfailed, ump->um_softdep->sd_cleanups);
1620 struct ufsmount *ump;
1622 ump = VFSTOUFS(mp);
1623 LOCK_OWNED(ump);
1624 if ((ump->softdep_flags & (FLUSH_CLEANUP | FLUSH_EXIT)) == 0)
1625 ump->softdep_flags |= FLUSH_CLEANUP;
1626 wakeup(&ump->softdep_flushtd);
1630 softdep_send_speedup(struct ufsmount *ump, off_t shortage, u_int flags)
1634 if ((ump->um_flags & UM_CANSPEEDUP) == 0)
1641 g_vfs_strategy(ump->um_bo, bp);
1647 softdep_speedup(ump)
1648 struct ufsmount *ump;
1653 LOCK_OWNED(ump);
1654 worklist_speedup(ump->um_mountp);
1665 if ((altump = sdp->sd_ump) == ump)
1714 struct ufsmount *ump;
1716 ump = VFSTOUFS(wk->wk_mp);
1717 LOCK_OWNED(ump);
1722 if (ump->softdep_on_worklist == 0) {
1723 LIST_INSERT_HEAD(&ump->softdep_workitem_pending, wk, wk_list);
1724 ump->softdep_worklist_tail = wk;
1726 LIST_INSERT_HEAD(&ump->softdep_workitem_pending, wk, wk_list);
1728 LIST_INSERT_AFTER(ump->softdep_worklist_tail, wk, wk_list);
1729 ump->softdep_worklist_tail = wk;
1731 ump->softdep_on_worklist += 1;
1744 struct ufsmount *ump;
1746 ump = VFSTOUFS(wk->wk_mp);
1747 if (ump->softdep_worklist_tail == wk)
1748 ump->softdep_worklist_tail =
1751 ump->softdep_on_worklist -= 1;
1769 struct ufsmount *ump;
1771 ump = VFSTOUFS(wk->wk_mp);
1773 msleep(wk, LOCK_PTR(ump), PVM, wmesg, 0);
1791 struct ufsmount *ump;
1798 ump = VFSTOUFS(mp);
1799 ACQUIRE_LOCK(ump);
1803 while (ump->softdep_on_worklist > 0) {
1814 FREE_LOCK(ump);
1817 ACQUIRE_LOCK(ump);
1828 journal_unsuspend(ump);
1829 FREE_LOCK(ump);
1844 struct ufsmount *ump;
1849 ump = VFSTOUFS(mp);
1850 LOCK_OWNED(ump);
1873 FREE_LOCK(ump);
1878 ACQUIRE_LOCK(ump);
1894 struct ufsmount *ump;
1900 ump = VFSTOUFS(mp);
1901 LOCK_OWNED(ump);
1922 FREE_LOCK(ump);
1924 ACQUIRE_LOCK(ump);
1931 FREE_LOCK(ump);
1938 ACQUIRE_LOCK(ump);
1945 FREE_LOCK(ump);
1948 ACQUIRE_LOCK(ump);
1968 struct ufsmount *ump;
1981 ump = VFSTOUFS(mp);
1982 LOCK_OWNED(ump);
1986 LIST_INSERT_HEAD(&ump->softdep_workitem_pending, &sentinel, wk_list);
1999 FREE_LOCK(ump);
2032 ACQUIRE_LOCK(ump);
2049 if (ump->softdep_worklist_tail == &sentinel)
2050 ump->softdep_worklist_tail =
2066 struct ufsmount *ump;
2075 ump = VFSTOUFS(wk->wk_mp);
2076 ACQUIRE_LOCK(ump);
2088 FREE_LOCK(ump);
2103 struct ufsmount *ump;
2114 ump = VFSTOUFS(oldmnt);
2115 devvp = ump->um_devvp;
2131 struct ufsmount *ump;
2136 ump = VFSTOUFS(mp);
2137 devvp = ump->um_devvp;
2140 ACQUIRE_LOCK(ump);
2141 for (i = 0; i < SU_WAITIDLE_RETRIES && ump->softdep_deps != 0; i++) {
2142 ump->softdep_req = 1;
2144 ump->softdep_on_worklist == 0,
2146 msleep(&ump->softdep_deps, LOCK_PTR(ump), PVM | PDROP,
2151 ACQUIRE_LOCK(ump);
2155 ump->softdep_req = 0;
2156 if (i == SU_WAITIDLE_RETRIES && error == 0 && ump->softdep_deps != 0) {
2161 FREE_LOCK(ump);
2175 struct ufsmount *ump;
2225 ump = VFSTOUFS(oldmnt);
2226 UFS_LOCK(ump);
2228 if (ump->um_quotas[i] != NULLVP)
2231 UFS_UNLOCK(ump);
2278 #define PAGEDEP_HASH(ump, inum, lbn) \
2279 (&(ump)->pagedep_hashtbl[((inum) + (lbn)) & (ump)->pagedep_hash_size])
2316 struct ufsmount *ump;
2320 ump = VFSTOUFS(mp);
2321 LOCK_OWNED(ump);
2330 pagedephd = PAGEDEP_HASH(ump, ino, lbn);
2339 FREE_LOCK(ump);
2343 ACQUIRE_LOCK(ump);
2368 #define INODEDEP_HASH(ump, inum) \
2369 (&(ump)->inodedep_hashtbl[(inum) & (ump)->inodedep_hash_size])
2404 struct ufsmount *ump;
2407 ump = VFSTOUFS(mp);
2408 LOCK_OWNED(ump);
2409 fs = ump->um_fs;
2410 inodedephd = INODEDEP_HASH(ump, inum);
2421 if (softdep_excess_items(ump, D_INODEDEP))
2424 FREE_LOCK(ump);
2428 ACQUIRE_LOCK(ump);
2462 #define NEWBLK_HASH(ump, inum) \
2463 (&(ump)->newblk_hashtbl[(inum) & (ump)->newblk_hash_size])
2508 struct ufsmount *ump;
2510 ump = VFSTOUFS(mp);
2511 LOCK_OWNED(ump);
2512 newblkhd = NEWBLK_HASH(ump, newblkno);
2517 if (softdep_excess_items(ump, D_NEWBLK) ||
2518 softdep_excess_items(ump, D_ALLOCDIRECT) ||
2519 softdep_excess_items(ump, D_ALLOCINDIR))
2522 FREE_LOCK(ump);
2526 ACQUIRE_LOCK(ump);
2545 #define INDIR_HASH(ump, blkno) \
2546 (&(ump)->indir_hashtbl[(blkno) & (ump)->indir_hash_size])
2560 struct ufsmount *ump;
2562 ump = VFSTOUFS(mp);
2563 wkhd = INDIR_HASH(ump, blkno);
2584 struct ufsmount *ump;
2586 ump = VFSTOUFS(freework->fw_list.wk_mp);
2587 jblocks = ump->softdep_jblocks;
2593 TAILQ_INSERT_HEAD(INDIR_HASH(ump, freework->fw_blkno), freework,
2602 struct ufsmount *ump;
2604 ump = VFSTOUFS(freework->fw_list.wk_mp);
2606 TAILQ_REMOVE(INDIR_HASH(ump, freework->fw_blkno), freework, fw_next);
2669 struct ufsmount *ump;
2683 ump = VFSTOUFS(mp);
2684 ump->um_softdep = sdp;
2686 rw_init(LOCK_PTR(ump), "per-fs softdep");
2687 sdp->sd_ump = ump;
2688 LIST_INIT(&ump->softdep_workitem_pending);
2689 LIST_INIT(&ump->softdep_journal_pending);
2690 TAILQ_INIT(&ump->softdep_unlinked);
2691 LIST_INIT(&ump->softdep_dirtycg);
2692 ump->softdep_worklist_tail = NULL;
2693 ump->softdep_on_worklist = 0;
2694 ump->softdep_deps = 0;
2695 LIST_INIT(&ump->softdep_mkdirlisthd);
2696 ump->pagedep_hashtbl = hashinit(desiredvnodes / 5, M_PAGEDEP,
2697 &ump->pagedep_hash_size);
2698 ump->pagedep_nextclean = 0;
2699 ump->inodedep_hashtbl = hashinit(desiredvnodes, M_INODEDEP,
2700 &ump->inodedep_hash_size);
2701 ump->inodedep_nextclean = 0;
2702 ump->newblk_hashtbl = hashinit(max_softdeps / 2, M_NEWBLK,
2703 &ump->newblk_hash_size);
2704 ump->bmsafemap_hashtbl = hashinit(1024, M_BMSAFEMAP,
2705 &ump->bmsafemap_hash_size);
2707 ump->indir_hashtbl = malloc(i * sizeof(struct indir_hashhead),
2709 ump->indir_hash_size = i - 1;
2710 for (i = 0; i <= ump->indir_hash_size; i++)
2711 TAILQ_INIT(&ump->indir_hashtbl[i]);
2714 LIST_INIT(&ump->softdep_alldeps[i]);
2728 ACQUIRE_LOCK(ump);
2729 ump->softdep_flags |= FLUSH_STARTING;
2730 FREE_LOCK(ump);
2732 &ump->softdep_flushtd, 0, 0, "softdepflush", "%s worker",
2734 ACQUIRE_LOCK(ump);
2735 while ((ump->softdep_flags & FLUSH_STARTING) != 0) {
2736 msleep(&ump->softdep_flushtd, LOCK_PTR(ump), PVM, "sdstart",
2739 FREE_LOCK(ump);
2778 struct ufsmount *ump;
2785 ump = VFSTOUFS(mp);
2793 journal_unmount(ump);
2799 if (ump->softdep_flushtd != NULL) {
2800 ACQUIRE_LOCK(ump);
2801 ump->softdep_flags |= FLUSH_EXIT;
2802 wakeup(&ump->softdep_flushtd);
2803 msleep(&ump->softdep_flags, LOCK_PTR(ump), PVM | PDROP,
2805 KASSERT((ump->softdep_flags & FLUSH_EXIT) == 0,
2812 TAILQ_REMOVE(&softdepmounts, ump->um_softdep, sd_next);
2814 rw_destroy(LOCK_PTR(ump));
2815 hashdestroy(ump->pagedep_hashtbl, M_PAGEDEP, ump->pagedep_hash_size);
2816 hashdestroy(ump->inodedep_hashtbl, M_INODEDEP, ump->inodedep_hash_size);
2817 hashdestroy(ump->newblk_hashtbl, M_NEWBLK, ump->newblk_hash_size);
2818 hashdestroy(ump->bmsafemap_hashtbl, M_BMSAFEMAP,
2819 ump->bmsafemap_hash_size);
2820 free(ump->indir_hashtbl, M_FREEWORK);
2823 KASSERT(ump->softdep_curdeps[i] == 0,
2824 ("Unmount %s: Dep type %s != 0 (%ld)", ump->um_fs->fs_fsmnt,
2825 TYPENAME(i), ump->softdep_curdeps[i]));
2826 KASSERT(LIST_EMPTY(&ump->softdep_alldeps[i]),
2827 ("Unmount %s: Dep type %s not empty (%p)", ump->um_fs->fs_fsmnt,
2828 TYPENAME(i), LIST_FIRST(&ump->softdep_alldeps[i])));
2831 free(ump->um_softdep, M_MOUNTDATA);
2980 struct ufsmount *ump;
2988 ump = VFSTOUFS(mp);
2989 ump->softdep_journal_tail = NULL;
2990 ump->softdep_on_journal = 0;
2991 ump->softdep_accdeps = 0;
2992 ump->softdep_req = 0;
2993 ump->softdep_jblocks = NULL;
3018 ump->softdep_jblocks = jblocks;
3044 journal_unmount(ump)
3045 struct ufsmount *ump;
3048 if (ump->softdep_jblocks)
3049 jblocks_destroy(ump->softdep_jblocks);
3050 ump->softdep_jblocks = NULL;
3062 struct ufsmount *ump;
3064 ump = VFSTOUFS(wk->wk_mp);
3065 LOCK_OWNED(ump);
3070 if (LIST_EMPTY(&ump->softdep_journal_pending)) {
3071 ump->softdep_jblocks->jb_age = ticks;
3072 LIST_INSERT_HEAD(&ump->softdep_journal_pending, wk, wk_list);
3074 LIST_INSERT_AFTER(ump->softdep_journal_tail, wk, wk_list);
3075 ump->softdep_journal_tail = wk;
3076 ump->softdep_on_journal += 1;
3088 struct ufsmount *ump;
3090 ump = VFSTOUFS(wk->wk_mp);
3091 LOCK_OWNED(ump);
3096 LIST_FOREACH(wkn, &ump->softdep_journal_pending, wk_list)
3109 if (ump->softdep_journal_tail == wk)
3110 ump->softdep_journal_tail =
3113 ump->softdep_on_journal -= 1;
3122 journal_space(ump, thresh)
3123 struct ufsmount *ump;
3129 jblocks = ump->softdep_jblocks;
3140 ump->softdep_curdeps[D_INODEDEP] > limit / stat_flush_threads)
3146 avail = (ump->softdep_on_journal * JREC_SIZE) / DEV_BSIZE;
3153 journal_suspend(ump)
3154 struct ufsmount *ump;
3160 mp = UFSTOVFS(ump);
3164 jblocks = ump->softdep_jblocks;
3171 mp->mnt_susp_owner = ump->softdep_flushtd;
3181 journal_unsuspend(struct ufsmount *ump)
3186 mp = UFSTOVFS(ump);
3187 jblocks = ump->softdep_jblocks;
3190 journal_space(ump, jblocks->jb_min)) {
3192 FREE_LOCK(ump);
3195 ACQUIRE_LOCK(ump);
3218 struct ufsmount *ump;
3232 ump = VFSTOUFS(vp->v_mount);
3233 ACQUIRE_LOCK(ump);
3234 if (journal_space(ump, 0)) {
3235 FREE_LOCK(ump);
3239 FREE_LOCK(ump);
3248 ACQUIRE_LOCK(ump);
3251 if (journal_space(ump, 0) == 0) {
3252 softdep_speedup(ump);
3253 if (journal_space(ump, 1) == 0)
3254 journal_suspend(ump);
3256 FREE_LOCK(ump);
3267 softdep_prerename_vnode(ump, vp)
3268 struct ufsmount *ump;
3279 ACQUIRE_LOCK(ump);
3282 FREE_LOCK(ump);
3299 struct ufsmount *ump;
3302 ump = VFSTOUFS(fdvp->v_mount);
3304 if (journal_space(ump, 0))
3312 error = softdep_prerename_vnode(ump, fdvp);
3318 error = softdep_prerename_vnode(ump, fvp);
3325 error = softdep_prerename_vnode(ump, tdvp);
3333 error = softdep_prerename_vnode(ump, tvp);
3339 ACQUIRE_LOCK(ump);
3340 softdep_speedup(ump);
3341 process_worklist_item(UFSTOVFS(ump), 2, LK_NOWAIT);
3342 if (journal_space(ump, 0) == 0) {
3343 softdep_speedup(ump);
3344 if (journal_space(ump, 1) == 0)
3345 journal_suspend(ump);
3347 FREE_LOCK(ump);
3368 struct ufsmount *ump;
3373 ump = VFSTOUFS(dvp->v_mount);
3381 if (journal_space(ump, 0) || (vp != NULL && IS_SNAPSHOT(VTOI(vp))))
3404 ACQUIRE_LOCK(ump);
3407 FREE_LOCK(ump);
3417 ACQUIRE_LOCK(ump);
3421 softdep_speedup(ump);
3423 process_worklist_item(UFSTOVFS(ump), 2, LK_NOWAIT);
3424 if (journal_space(ump, 0) == 0) {
3425 softdep_speedup(ump);
3426 if (journal_space(ump, 1) == 0)
3427 journal_suspend(ump);
3429 FREE_LOCK(ump);
3436 jseg_write(ump, jseg, data)
3437 struct ufsmount *ump;
3447 rec->jsr_blocks = jseg->js_size / ump->um_devvp->v_bufobj.bo_bsize;
3449 rec->jsr_time = ump->um_fs->fs_mtime;
3599 struct ufsmount *ump;
3603 ump = VFSTOUFS(mp);
3604 jblocks = ump->softdep_jblocks;
3605 ACQUIRE_LOCK(ump);
3606 while (ump->softdep_on_journal) {
3610 FREE_LOCK(ump);
3622 struct ufsmount *ump;
3633 ump = VFSTOUFS(jseg->js_list.wk_mp);
3634 ACQUIRE_LOCK(ump);
3652 FREE_LOCK(ump);
3663 softdep_synchronize(bp, ump, caller1)
3665 struct ufsmount *ump;
3672 bp->bio_offset = ump->um_cp->provider->mediasize;
3676 g_io_request(bp, ump->um_cp);
3689 struct ufsmount *ump;
3710 ump = VFSTOUFS(mp);
3711 LOCK_OWNED(ump);
3712 fs = ump->um_fs;
3713 jblocks = ump->softdep_jblocks;
3714 devbsize = ump->um_devvp->v_bufobj.bo_bsize;
3724 cnt = ump->softdep_on_journal;
3750 softdep_speedup(ump);
3751 msleep(jblocks, LOCK_PTR(ump), PRIBIO, "jblocks", hz);
3753 FREE_LOCK(ump);
3765 ACQUIRE_LOCK(ump);
3773 cnt = ump->softdep_on_journal;
3777 FREE_LOCK(ump);
3779 ACQUIRE_LOCK(ump);
3830 jseg_write(ump, jseg, data);
3839 if (LIST_EMPTY(&ump->softdep_journal_pending))
3842 while ((wk = LIST_FIRST(&ump->softdep_journal_pending))
3848 jseg_write(ump, jseg, data);
3902 FREE_LOCK(ump);
3904 pbgetvp(ump->um_devvp, bp);
3913 ACQUIRE_LOCK(ump);
3922 softdep_synchronize(bio, ump,
3932 if (journal_unsuspend(ump))
3934 FREE_LOCK(ump);
3936 ffs_sbupdate(ump, MNT_WAIT, 0);
3937 ACQUIRE_LOCK(ump);
4464 newfreework(ump, freeblks, parent, lbn, nb, frags, off, journal)
4465 struct ufsmount *ump;
4486 freework->fw_ref = (MOUNTEDSUJ(UFSTOVFS(ump)) == 0 ||
4487 lbn >= -UFS_NXADDR) ? 0 : NINDIR(ump->um_fs) + 1;
4492 ACQUIRE_LOCK(ump);
4495 FREE_LOCK(ump);
5426 struct ufsmount *ump;
5431 ump = VFSTOUFS(mp);
5432 fs = ump->um_fs;
5475 ACQUIRE_LOCK(ump);
5489 FREE_LOCK(ump);
5492 #define BMSAFEMAP_HASH(ump, cg) \
5493 (&(ump)->bmsafemap_hashtbl[(cg) & (ump)->bmsafemap_hash_size])
5533 struct ufsmount *ump;
5535 ump = VFSTOUFS(mp);
5536 LOCK_OWNED(ump);
5545 bmsafemaphd = BMSAFEMAP_HASH(ump, cg);
5554 FREE_LOCK(ump);
5558 ACQUIRE_LOCK(ump);
5575 LIST_INSERT_HEAD(&ump->softdep_dirtycg, bmsafemap, sm_next);
5933 struct ufsmount *ump;
5938 ump = ITOUMP(ip);
5939 fs = ump->um_fs;
5944 workitem_alloc(&freefrag->ff_list, D_FREEFRAG, UFSTOVFS(ump));
5953 if (MOUNTEDSUJ(UFSTOVFS(ump))) {
5972 struct ufsmount *ump = VFSTOUFS(freefrag->ff_list.wk_mp);
5984 ACQUIRE_LOCK(ump);
5995 FREE_LOCK(ump);
5996 ffs_blkfree(ump, ump->um_fs, ump->um_devvp, freefrag->ff_blkno,
5999 ACQUIRE_LOCK(ump);
6001 FREE_LOCK(ump);
6026 struct ufsmount *ump;
6030 ump = VFSTOUFS(mp);
6057 ACQUIRE_LOCK(ump);
6108 FREE_LOCK(ump);
6121 FREE_LOCK(ump);
6211 struct ufsmount *ump;
6214 ump = VFSTOUFS(mp);
6235 FREE_LOCK(ump);
6254 struct ufsmount *ump;
6257 ump = ITOUMP(ip);
6258 KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(ump)) != 0,
6266 inodedep_lookup(UFSTOVFS(ump), ip->i_number, DEPALLOC, &inodedep);
6270 FREE_LOCK(ump);
6303 struct ufsmount *ump;
6308 ump = VFSTOUFS(mp);
6309 LOCK_OWNED(ump);
6312 fs = ump->um_fs;
6329 FREE_LOCK(ump);
6349 getblk(ump->um_devvp, bp->b_blkno, bp->b_bcount, 0, 0, 0);
6353 ACQUIRE_LOCK(ump);
6387 struct ufsmount *ump;
6390 ump = VFSTOUFS(mp);
6391 LOCK_OWNED(ump);
6392 fs = ump->um_fs;
6477 struct ufsmount *ump;
6485 ump = ITOUMP(ip);
6486 frags = sblksize(ump->um_fs, ip->i_size, i);
6487 frags = numfrags(ump->um_fs, frags);
6488 newfreework(ump, freeblks, NULL, i, blkno, frags, 0, needj);
6498 struct ufsmount *ump;
6506 ump = ITOUMP(ip);
6507 frags = sblksize(ump->um_fs, ip->i_din2->di_extsize, i);
6508 frags = numfrags(ump->um_fs, frags);
6509 newfreework(ump, freeblks, NULL, -1 - i, blkno, frags, 0, needj);
6520 struct ufsmount *ump;
6527 ump = ITOUMP(ip);
6528 newfreework(ump, freeblks, NULL, lbn, blkno, ump->um_fs->fs_frag,
6606 struct ufsmount *ump;
6619 ump = VFSTOUFS(mp);
6625 error = ffs_breadz(ump, ITOV(ip), lbn, blkptrtodb(ump, blkno),
6630 lbnadd = lbn_offset(ump->um_fs, level);
6636 if (off + 1 == NINDIR(ump->um_fs))
6638 freework = newfreework(ump, freeblks, NULL, lbn, blkno, 0, off + 1, 0);
6644 ACQUIRE_LOCK(ump);
6656 if (newblk_lookup(mp, dbtofsb(ump->um_fs, bp->b_blkno), 0,
6663 FREE_LOCK(ump);
6706 struct ufsmount *ump;
6711 ump = VFSTOUFS(freework->fw_list.wk_mp);
6712 LOCK_OWNED(ump);
6723 LOCK_PTR(ump)) == 0)
6725 ACQUIRE_LOCK(ump);
6781 FREE_LOCK(ump);
6783 ACQUIRE_LOCK(ump);
6884 struct ufsmount *ump;
6894 ump = ITOUMP(ip);
6895 mp = UFSTOVFS(ump);
6896 fs = ump->um_fs;
6907 ACQUIRE_LOCK(ump);
6919 FREE_LOCK(ump);
6979 newfreework(ump, freeblks, NULL, lastlbn,
7017 UFS_LOCK(ump);
7019 UFS_UNLOCK(ump);
7030 error = ffs_breadz(ump, ump->um_devvp, dbn, dbn, (int)fs->fs_bsize,
7039 if (ump->um_fstype == UFS1) {
7047 ACQUIRE_LOCK(ump);
7099 FREE_LOCK(ump);
7135 } else if (!ffs_fsfail_cleanup(ump, error)) {
7140 ACQUIRE_LOCK(ump);
7156 FREE_LOCK(ump);
7171 struct ufsmount *ump;
7173 ump = ITOUMP(ip);
7174 KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(ump)) != 0,
7180 workitem_alloc(&jfsync->jfs_list, D_JFSYNC, UFSTOVFS(ump));
7183 ACQUIRE_LOCK(ump);
7186 FREE_LOCK(ump);
7229 struct ufsmount *ump;
7238 ump = ITOUMP(ip);
7239 mp = UFSTOVFS(ump);
7245 fs = ump->um_fs;
7246 if ((error = bread(ump->um_devvp,
7249 if (!ffs_fsfail_cleanup(ump, error))
7283 UFS_LOCK(ump);
7285 UFS_UNLOCK(ump);
7292 if (ump->um_fstype == UFS1) {
7307 ACQUIRE_LOCK(ump);
7346 FREE_LOCK(ump);
7349 ACQUIRE_LOCK(ump);
7361 FREE_LOCK(ump);
7635 struct ufsmount *ump;
7637 ump = softdep_bp_to_mp(bp);
7638 if (ump == NULL)
7640 ACQUIRE_LOCK(ump);
7654 FREE_LOCK(ump);
7689 FREE_LOCK(ump);
7919 struct ufsmount *ump;
7921 ump = ITOUMP(ip);
7922 KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(ump)) != 0,
7932 freefile->fx_devvp = ump->um_devvp;
7934 UFS_LOCK(ump);
7935 ump->um_fs->fs_pendinginodes += 1;
7936 UFS_UNLOCK(ump);
7949 ACQUIRE_LOCK(ump);
7981 FREE_LOCK(ump);
7988 FREE_LOCK(ump);
8109 struct ufsmount *ump;
8115 ump = VFSTOUFS(freework->fw_list.wk_mp);
8116 LOCK_OWNED(ump);
8125 fs = ump->um_fs;
8156 FREE_LOCK(ump);
8157 freeblks_free(ump, freeblks, btodb(bsize));
8161 ffs_blkfree(ump, fs, freeblks->fb_devvp, freework->fw_blkno, bsize,
8163 ACQUIRE_LOCK(ump);
8204 struct ufsmount *ump;
8208 ump = VFSTOUFS(freeblks->fb_list.wk_mp);
8209 fs = ump->um_fs;
8219 FREE_LOCK(ump);
8222 ACQUIRE_LOCK(ump);
8272 struct ufsmount *ump;
8278 ump = VFSTOUFS(freeblks->fb_list.wk_mp);
8279 key = ffs_blkrelease_start(ump, freeblks->fb_devvp, freeblks->fb_inum);
8280 ACQUIRE_LOCK(ump);
8297 FREE_LOCK(ump);
8298 freework = newfreework(ump, freeblks, NULL,
8300 ump->um_fs->fs_frag, 0, 0);
8301 ACQUIRE_LOCK(ump);
8329 FREE_LOCK(ump);
8330 ffs_blkrelease_finish(ump, key);
8343 freeblks_free(ump, freeblks, blocks)
8344 struct ufsmount *ump;
8351 UFS_LOCK(ump);
8357 fs = ump->um_fs;
8360 UFS_UNLOCK(ump);
8377 struct ufsmount *ump;
8380 ump = VFSTOUFS(freeblks->fb_list.wk_mp);
8381 fs = ump->um_fs;
8409 UFS_LOCK(ump);
8411 UFS_UNLOCK(ump);
8416 quotaadj(freeblks->fb_quota, ump, -spare);
8419 ACQUIRE_LOCK(ump);
8434 FREE_LOCK(ump);
8462 struct ufsmount *ump;
8472 ump = VFSTOUFS(mp);
8473 fs = ump->um_fs;
8507 error = ffs_breadz(ump, freeblks->fb_devvp, dbn, dbn,
8512 ACQUIRE_LOCK(ump);
8529 FREE_LOCK(ump);
8544 FREE_LOCK(ump);
8546 if (ump->um_fstype == UFS1) {
8558 needj = MOUNTEDSUJ(UFSTOVFS(ump)) != 0;
8569 key = ffs_blkrelease_start(ump, freeblks->fb_devvp, freeblks->fb_inum);
8587 nfreework = newfreework(ump, freeblks, freework,
8610 ffs_blkfree(ump, fs, freeblks->fb_devvp, nb,
8615 ffs_blkrelease_finish(ump, key);
8625 freeblks_free(ump, freeblks, freedblocks);
8631 ACQUIRE_LOCK(ump);
8639 FREE_LOCK(ump);
8649 ffs_blkfree(ump, fs, freeblks->fb_devvp, dbn, fs->fs_bsize,
8654 ACQUIRE_LOCK(ump);
8656 FREE_LOCK(ump);
8739 struct ufsmount *ump;
8743 ump = VFSTOUFS(mp);
8767 LIST_INSERT_HEAD(&ump->softdep_mkdirlisthd, mkdir1, md_mkdirs);
8806 LIST_INSERT_HEAD(&ump->softdep_mkdirlisthd, mkdir2, md_mkdirs);
8815 LIST_INSERT_HEAD(&ump->softdep_mkdirlisthd, mkdir2, md_mkdirs);
8865 struct ufsmount *ump;
8870 ump = VFSTOUFS(mp);
8883 fs = ump->um_fs;
8909 ACQUIRE_LOCK(ump);
8992 FREE_LOCK(ump);
9002 FREE_LOCK(ump);
9010 FREE_LOCK(ump);
9036 struct ufsmount *ump;
9041 ump = VFSTOUFS(mp);
9059 lbn = lblkno(ump->um_fs, I_OFFSET(dp));
9060 offset = blkoff(ump->um_fs, I_OFFSET(dp));
9063 ACQUIRE_LOCK(ump);
9085 FREE_LOCK(ump);
9101 struct ufsmount *ump;
9108 ump = VFSTOUFS(inodedep->id_list.wk_mp);
9109 for (mkdir = LIST_FIRST(&ump->softdep_mkdirlisthd); mkdir;
9169 struct ufsmount *ump;
9206 ump = VFSTOUFS(dap->da_list.wk_mp);
9207 LIST_FOREACH(mkdir, &ump->softdep_mkdirlisthd, md_mkdirs) {
9251 struct ufsmount *ump;
9253 ump = VFSTOUFS(dap->da_list.wk_mp);
9254 LOCK_OWNED(ump);
9273 for (mkdir = LIST_FIRST(&ump->softdep_mkdirlisthd); mkdir;
9327 struct ufsmount *ump;
9330 ump = ITOUMP(ip);
9331 KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(ump)) != 0,
9343 if (inodedep_lookup(UFSTOVFS(ump), ip->i_number, 0, &inodedep) == 0)
9363 FREE_LOCK(ump);
9370 FREE_LOCK(ump);
9441 struct ufsmount *ump;
9452 ump = VFSTOUFS(inodedep->id_list.wk_mp);
9453 for (mkdir = LIST_FIRST(&ump->softdep_mkdirlisthd); mkdir;
9532 struct ufsmount *ump;
9540 ump = ITOUMP(dp);
9549 ACQUIRE_LOCK(ump);
9550 if (!IS_SNAPSHOT(ip) && softdep_excess_items(ump, D_DIRREM))
9551 schedule_cleanup(UFSTOVFS(ump));
9553 FREE_LOCK(ump);
9583 ACQUIRE_LOCK(ump);
9584 lbn = lblkno(ump->um_fs, I_OFFSET(dp));
9585 offset = blkoff(ump->um_fs, I_OFFSET(dp));
9586 pagedep_lookup(UFSTOVFS(ump), bp, dp->i_number, lbn, DEPALLOC,
9693 struct ufsmount *ump;
9696 ump = VFSTOUFS(mp);
9697 offset = blkoff(ump->um_fs, I_OFFSET(dp));
9747 FREE_LOCK(ump);
9821 FREE_LOCK(ump);
9835 struct ufsmount *ump;
9837 ump = ITOUMP(ip);
9838 KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(ump)) != 0,
9840 ACQUIRE_LOCK(ump);
9841 inodedep_lookup(UFSTOVFS(ump), ip->i_number, DEPALLOC, &inodedep);
9845 FREE_LOCK(ump);
9853 softdep_setup_sbupdate(ump, fs, bp)
9854 struct ufsmount *ump;
9861 KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(ump)) != 0,
9869 workitem_alloc(&sbdep->sb_list, D_SBDEP, UFSTOVFS(ump));
9871 sbdep->sb_ump = ump;
9872 ACQUIRE_LOCK(ump);
9874 FREE_LOCK(ump);
9882 first_unlinked_inodedep(ump)
9883 struct ufsmount *ump;
9888 LOCK_OWNED(ump);
9889 for (inodedep = TAILQ_LAST(&ump->softdep_unlinked, inodedeplst);
9980 struct ufsmount *ump;
9982 ump = VFSTOUFS(mp);
9983 LOCK_OWNED(ump);
9986 ump->um_fs->fs_fmod = 1;
9990 TAILQ_INSERT_HEAD(&ump->softdep_unlinked, inodedep, id_unlinked);
10002 struct ufsmount *ump;
10013 ump = VFSTOUFS(inodedep->id_list.wk_mp);
10014 fs = ump->um_fs;
10018 LOCK_OWNED(ump);
10056 FREE_LOCK(ump);
10058 bp = getblk(ump->um_devvp, btodb(fs->fs_sblockloc),
10062 error = ffs_breadz(ump, ump->um_devvp, dbn, dbn,
10066 ACQUIRE_LOCK(ump);
10076 FREE_LOCK(ump);
10078 ACQUIRE_LOCK(ump);
10093 TAILQ_REMOVE(&ump->softdep_unlinked, inodedep, id_unlinked);
10094 FREE_LOCK(ump);
10103 ffs_oldfscompat_write(bpfs, ump);
10104 softdep_setup_sbupdate(ump, bpfs, bp);
10124 ACQUIRE_LOCK(ump);
10130 FREE_LOCK(ump);
10131 bp = getblk(ump->um_devvp, btodb(fs->fs_sblockloc),
10135 ffs_oldfscompat_write(bpfs, ump);
10136 softdep_setup_sbupdate(ump, bpfs, bp);
10143 ACQUIRE_LOCK(ump);
10153 TAILQ_REMOVE(&ump->softdep_unlinked, inodedep, id_unlinked);
10169 struct ufsmount *ump;
10180 ump = VFSTOUFS(mp);
10186 ACQUIRE_LOCK(ump);
10237 FREE_LOCK(ump);
10265 FREE_LOCK(ump);
10286 FREE_LOCK(ump);
10291 FREE_LOCK(ump);
10319 struct ufsmount *ump;
10325 ump = VFSTOUFS(freefile->fx_list.wk_mp);
10326 fs = ump->um_fs;
10328 ACQUIRE_LOCK(ump);
10329 error = inodedep_lookup(UFSTOVFS(ump), freefile->fx_oldinum, 0, &idp);
10330 FREE_LOCK(ump);
10334 UFS_LOCK(ump);
10336 UFS_UNLOCK(ump);
10339 if ((error = ffs_freefile(ump, fs, freefile->fx_devvp,
10342 ACQUIRE_LOCK(ump);
10344 FREE_LOCK(ump);
10393 struct ufsmount *ump;
10406 ump = softdep_bp_to_mp(bp);
10407 if (ump == NULL)
10412 ACQUIRE_LOCK(ump);
10495 FREE_LOCK(ump);
10577 struct ufsmount *ump;
10589 ump = VFSTOUFS(inodedep->id_list.wk_mp);
10590 LOCK_OWNED(ump);
10611 FREE_LOCK(ump);
10614 ACQUIRE_LOCK(ump);
10749 struct ufsmount *ump;
10761 ump = VFSTOUFS(inodedep->id_list.wk_mp);
10762 LOCK_OWNED(ump);
10784 FREE_LOCK(ump);
10787 ACQUIRE_LOCK(ump);
10883 if (!ffs_fsfail_cleanup(ump, 0) &&
10891 if (!ffs_fsfail_cleanup(ump, 0) &&
11072 struct ufsmount *ump;
11088 ump = VFSTOUFS(indirdep->ir_list.wk_mp);
11089 LOCK_OWNED(ump);
11090 FREE_LOCK(ump);
11093 ACQUIRE_LOCK(ump);
11115 struct ufsmount *ump;
11122 ump = VFSTOUFS(mp);
11123 ACQUIRE_LOCK(ump);
11124 if (!ffs_fsfail_cleanup(ump, 0)) {
11125 fs = ump->um_fs;
11150 FREE_LOCK(ump);
11169 struct ufsmount *ump;
11186 ump = VFSTOUFS(mp);
11187 KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(ump)) != 0,
11189 ACQUIRE_LOCK(ump);
11191 fs = ump->um_fs;
11265 FREE_LOCK(ump);
11403 struct ufsmount *ump;
11405 ump = softdep_bp_to_mp(bp);
11406 if (ump == NULL)
11409 if (ffs_fsfail_cleanup(ump, bp->b_error)) {
11435 struct ufsmount *ump;
11440 ump = softdep_bp_to_mp(bp);
11441 KASSERT(LIST_EMPTY(&bp->b_dep) || ump != NULL,
11444 if (ump == NULL)
11455 ACQUIRE_LOCK(ump);
11482 FREE_LOCK(ump);
11580 FREE_LOCK(ump);
12318 struct ufsmount *ump;
12329 ump = VFSTOUFS(bmsafemap->sm_list.wk_mp);
12436 LIST_INSERT_HEAD(&ump->softdep_dirtycg, bmsafemap, sm_next);
12620 struct ufsmount *ump;
12622 ump = ITOUMP(ip);
12623 KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(ump)) != 0,
12629 ACQUIRE_LOCK(ump);
12630 if (inodedep_lookup(UFSTOVFS(ump), ip->i_number, 0, &inodedep) == 0) {
12631 FREE_LOCK(ump);
12637 (ump->um_flags & UM_FSFAIL_CLEANUP) != 0,
12644 FREE_LOCK(ump);
12665 struct ufsmount *ump;
12672 ump = ITOUMP(ip);
12673 mp = UFSTOVFS(ump);
12676 fs = ump->um_fs;
12695 ACQUIRE_LOCK(ump);
12698 FREE_LOCK(ump);
12762 FREE_LOCK(ump);
12767 FREE_LOCK(ump);
12771 ibp = getdirtybuf(ibp, LOCK_PTR(ump), MNT_WAIT);
12780 FREE_LOCK(ump);
12783 FREE_LOCK(ump);
12833 struct ufsmount *ump;
12848 ump = VFSTOUFS(mp);
12849 fs = ump->um_fs;
12852 ACQUIRE_LOCK(ump);
12855 FREE_LOCK(ump);
12913 FREE_LOCK(ump);
12935 ACQUIRE_LOCK(ump);
12948 FREE_LOCK(ump);
12958 FREE_LOCK(ump);
12970 if (!ffs_fsfail_cleanup(ump, error))
12972 ACQUIRE_LOCK(ump);
12976 FREE_LOCK(ump);
13041 struct ufsmount *ump;
13047 ump = VFSTOUFS(mp);
13049 ACQUIRE_LOCK(ump);
13050 LIST_INSERT_HEAD(&ump->softdep_dirtycg, sentinel, sm_next);
13065 bp = getdirtybuf(bmsafemap->sm_buf, LOCK_PTR(ump), waitfor);
13072 FREE_LOCK(ump);
13077 ACQUIRE_LOCK(ump);
13082 FREE_LOCK(ump);
13136 struct ufsmount *ump;
13152 ump = VFSTOUFS(vp->v_mount);
13153 ACQUIRE_LOCK(ump);
13177 nbp = getdirtybuf(nbp, LOCK_PTR(ump), waitfor);
13180 FREE_LOCK(ump);
13183 ACQUIRE_LOCK(ump);
13208 nbp = getdirtybuf(nbp, LOCK_PTR(ump), waitfor);
13211 FREE_LOCK(ump);
13214 ACQUIRE_LOCK(ump);
13267 FREE_LOCK(ump);
13283 struct ufsmount *ump;
13299 ump = VFSTOUFS(mp);
13300 LOCK_OWNED(ump);
13304 FREE_LOCK(ump);
13305 ACQUIRE_LOCK(ump);
13347 struct ufsmount *ump;
13352 ump = VFSTOUFS(adp->ad_list.wk_mp);
13353 LOCK_OWNED(ump);
13363 bp = getdirtybuf(bp, LOCK_PTR(ump), waitfor);
13369 FREE_LOCK(ump);
13374 ACQUIRE_LOCK(ump);
13390 struct ufsmount *ump;
13403 ump = VFSTOUFS(mp);
13404 ACQUIRE_LOCK(ump);
13412 FREE_LOCK(ump);
13429 bp = getdirtybuf(bp, LOCK_PTR(ump), MNT_WAIT);
13432 FREE_LOCK(ump);
13436 ACQUIRE_LOCK(ump);
13442 FREE_LOCK(ump);
13449 ACQUIRE_LOCK(ump);
13472 ACQUIRE_LOCK(ump);
13489 struct ufsmount *ump;
13498 ump = VFSTOUFS(mp);
13499 LOCK_OWNED(ump);
13507 FREE_LOCK(ump);
13510 ACQUIRE_LOCK(ump);
13537 if (inodedep_lookup(UFSTOVFS(ump), inum, 0, &inodedep) == 0)
13551 FREE_LOCK(ump);
13567 ACQUIRE_LOCK(ump);
13574 inodedep_lookup(UFSTOVFS(ump), inum, 0,
13592 if (inodedep_lookup(UFSTOVFS(ump), inum, 0, &inodedep) == 0)
13600 bp = getdirtybuf(bp, LOCK_PTR(ump), MNT_WAIT);
13603 FREE_LOCK(ump);
13606 ACQUIRE_LOCK(ump);
13616 FREE_LOCK(ump);
13625 ACQUIRE_LOCK(ump);
13632 inodedep_lookup(UFSTOVFS(ump), inum, 0, &inodedep);
13639 ACQUIRE_LOCK(ump);
13658 struct ufsmount *ump;
13664 ump = VFSTOUFS(vp->v_mount);
13665 ACQUIRE_LOCK(ump);
13671 if (journal_space(ump, 0) == 0)
13684 ump->softdep_curdeps[D_DIRREM] <
13686 ump->softdep_curdeps[D_INODEDEP] <
13688 ump->softdep_curdeps[D_INDIRDEP] <
13690 ump->softdep_curdeps[D_FREEBLKS] <
13692 FREE_LOCK(ump);
13699 if (ump->softdep_curdeps[D_INDIRDEP] <
13701 softdep_speedup(ump);
13703 FREE_LOCK(ump);
13765 struct ufsmount *ump;
13788 ump = VFSTOUFS(mp);
13789 mtx_assert(UFS_MTX(ump), MA_OWNED);
13790 UFS_UNLOCK(ump);
13793 UFS_LOCK(ump);
13800 ACQUIRE_LOCK(ump);
13803 FREE_LOCK(ump);
13838 UFS_LOCK(ump);
13845 softdep_send_speedup(ump, needed * fs->fs_bsize,
13847 if ((resource == FLUSH_BLOCKS_WAIT && ump->softdep_on_worklist > 0 &&
13851 ACQUIRE_LOCK(ump);
13852 if (ump->softdep_on_worklist > 0 &&
13853 process_worklist_item(UFSTOVFS(ump),
13854 ump->softdep_on_worklist, LK_NOWAIT) != 0)
13856 FREE_LOCK(ump);
13864 ACQUIRE_LOCK(ump);
13868 if ((ump->um_softdep->sd_flags & FLUSH_DI_ACTIVE) == 0) {
13869 ump->um_softdep->sd_flags |= FLUSH_DI_ACTIVE;
13870 FREE_LOCK(ump);
13872 ACQUIRE_LOCK(ump);
13873 ump->um_softdep->sd_flags &= ~FLUSH_DI_ACTIVE;
13874 wakeup(&ump->um_softdep->sd_flags);
13876 while ((ump->um_softdep->sd_flags &
13878 msleep(&ump->um_softdep->sd_flags,
13879 LOCK_PTR(ump), PVM, "ffsvina", hz);
13883 FREE_LOCK(ump);
13906 ACQUIRE_LOCK(ump);
13907 if ((ump->um_softdep->sd_flags & FLUSH_RC_ACTIVE) == 0) {
13908 ump->um_softdep->sd_flags |= FLUSH_RC_ACTIVE;
13909 FREE_LOCK(ump);
13910 failed_vnode = softdep_request_cleanup_flush(mp, ump);
13911 ACQUIRE_LOCK(ump);
13912 ump->um_softdep->sd_flags &= ~FLUSH_RC_ACTIVE;
13913 wakeup(&ump->um_softdep->sd_flags);
13914 FREE_LOCK(ump);
13915 if (ump->softdep_on_worklist > 0) {
13921 while ((ump->um_softdep->sd_flags &
13923 msleep(&ump->um_softdep->sd_flags,
13924 LOCK_PTR(ump), PVM, "ffsrca", hz);
13926 FREE_LOCK(ump);
13933 UFS_LOCK(ump);
13947 softdep_request_cleanup_flush(mp, ump)
13949 struct ufsmount *ump;
13973 lvp = ump->um_devvp;
13982 softdep_excess_items(struct ufsmount *ump, int item)
13987 ump->softdep_curdeps[item] > max_softdeps /
13994 struct ufsmount *ump;
13997 ump = VFSTOUFS(mp);
13998 LOCK_OWNED(ump);
13999 FREE_LOCK(ump);
14024 struct ufsmount *ump;
14035 ump = VFSTOUFS(mp);
14038 ACQUIRE_LOCK(ump);
14039 if (softdep_excess_items(ump, D_INODEDEP)) {
14043 if (softdep_excess_items(ump, D_DIRREM)) {
14047 FREE_LOCK(ump);
14048 if (softdep_excess_items(ump, D_NEWBLK) ||
14049 softdep_excess_items(ump, D_ALLOCDIRECT) ||
14050 softdep_excess_items(ump, D_ALLOCINDIR)) {
14081 struct ufsmount *ump;
14083 ump = VFSTOUFS(mp);
14084 LOCK_OWNED(ump);
14098 if (ump->softdep_on_worklist > max_softdeps / 10) {
14109 if (softdep_speedup(ump) &&
14150 FREE_LOCK(ump);
14160 ACQUIRE_LOCK(ump);
14190 struct ufsmount *ump;
14200 ump = VFSTOUFS(mp);
14201 suj_susp = MOUNTEDSUJ(mp) && ump->softdep_jblocks->jb_suspended;
14203 FREE_LOCK(ump);
14204 softdep_send_speedup(ump, 0, BIO_SPEEDUP_TRIM | BIO_SPEEDUP_WRITE);
14205 ACQUIRE_LOCK(ump);
14246 struct ufsmount *ump;
14252 ump = VFSTOUFS(mp);
14253 LOCK_OWNED(ump);
14255 for (cnt = 0; cnt <= ump->pagedep_hash_size; cnt++) {
14256 pagedephd = &ump->pagedep_hashtbl[ump->pagedep_nextclean++];
14257 if (ump->pagedep_nextclean > ump->pagedep_hash_size)
14258 ump->pagedep_nextclean = 0;
14265 FREE_LOCK(ump);
14290 ACQUIRE_LOCK(ump);
14306 struct ufsmount *ump;
14312 ump = VFSTOUFS(mp);
14313 fs = ump->um_fs;
14314 LOCK_OWNED(ump);
14320 for (cnt = 0; cnt <= ump->inodedep_hash_size; cnt++) {
14321 inodedephd = &ump->inodedep_hashtbl[ump->inodedep_nextclean++];
14322 if (ump->inodedep_nextclean > ump->inodedep_hash_size)
14323 ump->inodedep_nextclean = 0;
14346 FREE_LOCK(ump);
14350 ACQUIRE_LOCK(ump);
14358 ACQUIRE_LOCK(ump);
14379 ACQUIRE_LOCK(ump);
14389 struct ufsmount *ump;
14395 ump = VFSTOUFS(wk->wk_mp);
14396 ACQUIRE_LOCK(ump);
14401 FREE_LOCK(ump);
14413 struct ufsmount *ump;
14416 ump = ITOUMP(ip);
14417 KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(ump)) != 0,
14419 fs = ump->um_fs;
14420 error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
14436 struct ufsmount *ump;
14442 ump = VFSTOUFS(wk->wk_mp);
14443 ACQUIRE_LOCK(ump);
14445 FREE_LOCK(ump);
14462 * The ump mount point is stable after we get a correct
14465 * head wk_mp, because we do not yet own SU ump lock and
14511 struct ufsmount *ump;
14525 ump = softdep_bp_to_mp(bp);
14526 if (ump == NULL)
14529 ACQUIRE_LOCK(ump);
14660 FREE_LOCK(ump);
14741 struct ufsmount *ump;
14782 ump = VFSTOUFS(mp);
14784 if (!TRY_ACQUIRE_LOCK(ump)) {
14786 ACQUIRE_LOCK(ump);
14787 FREE_LOCK(ump);
14793 FREE_LOCK(ump);
14806 for (inodedep = TAILQ_FIRST(&ump->softdep_unlinked);
14828 ump->softdep_deps != unlinked ||
14829 softdep_accdepcnt != ump->softdep_accdeps ||
14834 FREE_LOCK(ump);
14849 struct ufsmount *ump;
14856 ump = VFSTOUFS(mp);
14857 ACQUIRE_LOCK(ump);
14858 *softdep_depsp = ump->softdep_deps;
14859 *softdep_accdepsp = ump->softdep_accdeps;
14860 FREE_LOCK(ump);
14912 extern void db_print_ffs(struct ufsmount *ump);
14914 db_print_ffs(struct ufsmount *ump)
14916 db_printf("mp %p (%s) devvp %p\n", ump->um_mountp,
14917 ump->um_mountp->mnt_stat.f_mntonname, ump->um_devvp);
14919 ump->um_fs, ump->softdep_on_worklist,
14920 ump->softdep_deps, ump->softdep_req);
15037 struct ufsmount *ump;
15044 ump = (struct ufsmount *)addr;
15045 for (cnt = 0; cnt < ump->inodedep_hash_size; cnt++) {
15046 inodedephd = &ump->inodedep_hashtbl[cnt];