Lines Matching defs:freeblks
656 SOFTDEP_TYPE(FREEBLKS, freeblks, "Blocks freed from an inode");
808 struct freeblks *);
823 struct freeblks *, int);
824 static int setup_trunc_indir(struct freeblks *, struct inode *,
827 static void trunc_indirdep(struct indirdep *, struct freeblks *, struct buf *,
847 static inline void setup_freedirect(struct freeblks *, struct inode *,
849 static inline void setup_freeext(struct freeblks *, struct inode *, int, int);
850 static inline void setup_freeindir(struct freeblks *, struct inode *, int,
852 static inline struct freeblks *newfreeblks(struct mount *, struct inode *);
853 static void freeblks_free(struct ufsmount *, struct freeblks *, int);
857 static void trunc_dependencies(struct inode *, struct freeblks *, ufs_lbn_t,
860 static int cancel_pagedep(struct pagedep *, struct freeblks *, int);
861 static int deallocate_dependencies(struct buf *, struct freeblks *, int);
865 struct allocdirect *, struct freeblks *);
870 static int handle_workitem_freeblocks(struct freeblks *, int);
871 static int handle_complete_freeblocks(struct freeblks *, int);
939 static struct jfreeblk *newjfreeblk(struct freeblks *, ufs_lbn_t,
941 static void adjust_newfreework(struct freeblks *, int);
942 static struct jtrunc *newjtrunc(struct freeblks *, off_t, int);
944 static void cancel_jfreeblk(struct freeblks *, ufs2_daddr_t);
947 static struct freework *newfreework(struct ufsmount *, struct freeblks *,
1259 static int req_clear_remove; /* syncer process flush some freeblks */
1282 static int stat_jwait_freeblks; /* Times blocked in jwait() for freeblks. */
1685 struct freeblks *freeblks;
1699 TAILQ_FOREACH(freeblks, &inodedep->id_freeblklst, fb_next) {
1701 if (!LIST_EMPTY(&freeblks->fb_jblkdephd)) {
1703 &freeblks->fb_jblkdephd)->jb_list,
1708 if (freeblks->fb_state & INPROGRESS) {
1709 wait_worklist(&freeblks->fb_list, "ptrwait");
1713 if ((freeblks->fb_state & COMPLETE) == 0) {
1719 if ((freeblks->fb_state & (ALLCOMPLETE | ONWORKLIST)) ==
1721 remove_from_worklist(&freeblks->fb_list);
1722 freeblks->fb_state |= INPROGRESS;
1728 handle_workitem_freeblocks(freeblks, 0);
1733 if (freeblks->fb_cgwait)
1743 if (freeblks == NULL)
3949 * is removed from the freeblks list of pending journal writes and the
3950 * jsegdep is moved to the freeblks jwork to be completed when all blocks
3957 struct freeblks *freeblks;
3963 freeblks = jblkdep->jb_freeblks;
3965 jwork_insert(&freeblks->fb_jwork, jsegdep);
3967 * If the freeblks is all journaled, we can add it to the worklist.
3969 if (LIST_EMPTY(&freeblks->fb_jblkdephd) &&
3970 (freeblks->fb_state & ALLCOMPLETE) == ALLCOMPLETE)
3971 add_to_worklist(&freeblks->fb_list, WK_NODELAY);
4108 * and before the freeblks is visible outside of softdep_setup_freeblocks().
4111 newfreework(ump, freeblks, parent, lbn, nb, frags, off, journal)
4113 struct freeblks *freeblks;
4124 workitem_alloc(&freework->fw_list, D_FREEWORK, freeblks->fb_list.wk_mp);
4127 freework->fw_freeblks = freeblks;
4137 newjfreeblk(freeblks, lbn, nb, frags);
4140 WORKLIST_INSERT(&freeblks->fb_freeworkhd, &freework->fw_list);
4141 freeblks->fb_ref++;
4152 cancel_jfreeblk(freeblks, blkno)
4153 struct freeblks *freeblks;
4159 LIST_FOREACH(jblkdep, &freeblks->fb_jblkdephd, jb_deps) {
4180 newjfreeblk(freeblks, lbn, blkno, frags)
4181 struct freeblks *freeblks;
4190 freeblks->fb_list.wk_mp);
4192 jfreeblk->jf_dep.jb_freeblks = freeblks;
4193 jfreeblk->jf_ino = freeblks->fb_inum;
4197 LIST_INSERT_HEAD(&freeblks->fb_jblkdephd, &jfreeblk->jf_dep, jb_deps);
4214 adjust_newfreework(freeblks, frag_offset)
4215 struct freeblks *freeblks;
4220 KASSERT((LIST_FIRST(&freeblks->fb_jblkdephd) != NULL &&
4221 LIST_FIRST(&freeblks->fb_jblkdephd)->jb_list.wk_type == D_JFREEBLK),
4222 ("adjust_newfreework: Missing freeblks dependency"));
4224 jfreeblk = WK_JFREEBLK(LIST_FIRST(&freeblks->fb_jblkdephd));
4233 newjtrunc(freeblks, size, extsize)
4234 struct freeblks *freeblks;
4242 freeblks->fb_list.wk_mp);
4244 jtrunc->jt_dep.jb_freeblks = freeblks;
4245 jtrunc->jt_ino = freeblks->fb_inum;
4248 LIST_INSERT_HEAD(&freeblks->fb_jblkdephd, &jtrunc->jt_dep, jb_deps);
6091 setup_freedirect(freeblks, ip, i, needj)
6092 struct freeblks *freeblks;
6108 newfreework(ump, freeblks, NULL, i, blkno, frags, 0, needj);
6112 setup_freeext(freeblks, ip, i, needj)
6113 struct freeblks *freeblks;
6129 newfreework(ump, freeblks, NULL, -1 - i, blkno, frags, 0, needj);
6133 setup_freeindir(freeblks, ip, i, lbn, needj)
6134 struct freeblks *freeblks;
6148 newfreework(ump, freeblks, NULL, lbn, blkno, ump->um_fs->fs_frag,
6152 static inline struct freeblks *
6157 struct freeblks *freeblks;
6159 freeblks = malloc(sizeof(struct freeblks),
6161 workitem_alloc(&freeblks->fb_list, D_FREEBLKS, mp);
6162 LIST_INIT(&freeblks->fb_jblkdephd);
6163 LIST_INIT(&freeblks->fb_jwork);
6164 freeblks->fb_ref = 0;
6165 freeblks->fb_cgwait = 0;
6166 freeblks->fb_state = ATTACHED;
6167 freeblks->fb_uid = ip->i_uid;
6168 freeblks->fb_inum = ip->i_number;
6169 freeblks->fb_vtype = ITOV(ip)->v_type;
6170 freeblks->fb_modrev = DIP(ip, i_modrev);
6171 freeblks->fb_devvp = ITODEVVP(ip);
6172 freeblks->fb_chkcnt = 0;
6173 freeblks->fb_len = 0;
6175 return (freeblks);
6179 trunc_indirdep(indirdep, freeblks, bp, off)
6181 struct freeblks *freeblks;
6192 cancel_allocindir(aip, bp, freeblks, 1);
6195 cancel_allocindir(aip, bp, freeblks, 1);
6201 cancel_allocindir(aip, NULL, freeblks, 0);
6204 cancel_allocindir(aip, NULL, freeblks, 0);
6214 setup_trunc_indir(freeblks, ip, lbn, lastlbn, blkno)
6215 struct freeblks *freeblks;
6239 mp = freeblks->fb_list.wk_mp;
6273 freework = newfreework(ump, freeblks, NULL, lbn, blkno, 0, off + 1, 0);
6293 trunc_indirdep(indirn, freeblks, bp, off);
6295 trunc_indirdep(indirdep, freeblks, bp, off);
6325 return setup_trunc_indir(freeblks, ip, lbn, lastlbn, blkno);
6331 * copy and writes them to disk before the freeblks is allowed to complete.
6503 struct freeblks *freeblks, *fbn;
6529 freeblks = newfreeblks(mp, ip);
6571 setup_freedirect(freeblks, ip, i, needj);
6576 setup_freeindir(freeblks, ip, i, -lbn -i,
6585 setup_trunc_indir(freeblks, ip, -lbn - i,
6601 newfreework(ump, freeblks, NULL, lastlbn,
6604 adjust_newfreework(freeblks,
6616 newjtrunc(freeblks, length, 0);
6624 freeblks->fb_len = length;
6628 setup_freeext(freeblks, ip, i, needj);
6635 quotaref(vp, freeblks->fb_quota);
6638 freeblks->fb_chkcnt = -datablocks;
6672 * Add the freeblks structure to the list of operations that
6676 * freeblks below once we have deleted the dependencies.
6679 WORKLIST_INSERT(&bp->b_dep, &freeblks->fb_list);
6681 freeblks->fb_state |= COMPLETE;
6686 freeblks);
6698 freeblks);
6709 cancel_jfreeblk(freeblks, adp->ad_newblkno);
6710 cancel_newblk(WK_NEWBLK(wk), NULL, &freeblks->fb_jwork);
6711 WORKLIST_INSERT(&freeblks->fb_freeworkhd, wk);
6717 LIST_FOREACH(jblkdep, &freeblks->fb_jblkdephd, jb_deps)
6724 trunc_dependencies(ip, freeblks, lastlbn, frags, flags);
6762 TAILQ_INSERT_TAIL(&inodedep->id_freeblklst, freeblks, fb_next);
6763 freeblks->fb_state |= DEPCOMPLETE | ONDEPLIST;
6768 if (freeblks->fb_len == 0 && (flags & IO_NORMAL) != 0)
6771 if ((freeblks->fb_state & ALLCOMPLETE) == ALLCOMPLETE &&
6772 LIST_EMPTY(&freeblks->fb_jblkdephd))
6773 freeblks->fb_state |= INPROGRESS;
6775 freeblks = NULL;
6777 if (freeblks)
6778 handle_workitem_freeblocks(freeblks, 0);
6828 * soft updates implementation. The freeblks->fb_chkcnt field is
6846 struct freeblks *freeblks;
6873 freeblks = newfreeblks(mp, ip);
6880 setup_freedirect(freeblks, ip, i, 0);
6883 setup_freeindir(freeblks, ip, i, -lbn -i, 0);
6891 setup_freeext(freeblks, ip, i, 0);
6898 quotaref(ITOV(ip), freeblks->fb_quota);
6901 freeblks->fb_chkcnt = -datablocks;
6930 * Add the freeblks structure to the list of operations that
6934 * freeblks below once we have deleted the dependencies.
6938 WORKLIST_INSERT(&bp->b_dep, &freeblks->fb_list);
6940 freeblks->fb_state |= COMPLETE;
6955 freeblks);
6962 freeblks);
6966 trunc_dependencies(ip, freeblks, -1, 0, flags);
6970 freeblks->fb_state |= DEPCOMPLETE;
6975 if ((freeblks->fb_state & ALLCOMPLETE) == ALLCOMPLETE)
6976 freeblks->fb_state |= INPROGRESS;
6978 freeblks = NULL;
6980 if (freeblks)
6981 handle_workitem_freeblocks(freeblks, 0);
7082 trunc_dependencies(ip, freeblks, lastlbn, lastoff, flags)
7084 struct freeblks *freeblks;
7118 if (deallocate_dependencies(bp, freeblks, blkoff))
7161 cancel_pagedep(pagedep, freeblks, blkoff)
7163 struct freeblks *freeblks;
7173 * to be processed after the freeblks proceeds. If
7192 WORKLIST_INSERT(&freeblks->fb_freeworkhd, &dirrem->dm_list);
7243 deallocate_dependencies(bp, freeblks, off)
7245 struct freeblks *freeblks;
7264 cancel_indirdep(indirdep, bp, freeblks);
7269 if (cancel_pagedep(pagedep, freeblks, off)) {
7287 * to be written. It can be freed when the freeblks
7292 WORKLIST_INSERT(&freeblks->fb_freeworkhd, wk);
7328 cancel_allocdirect(adphead, adp, freeblks)
7331 struct freeblks *freeblks;
7343 LIST_FOREACH(wk, &freeblks->fb_freeworkhd, wk_list) {
7356 cancel_jfreeblk(freeblks, freework->fw_blkno);
7363 * freeblks work is complete.
7366 &freeblks->fb_jwork);
7367 WORKLIST_INSERT(&freeblks->fb_freeworkhd, &newblk->nb_list);
7536 struct freeblks *freeblks;
7571 * Clear out freeblks that no longer need to reference
7574 while ((freeblks =
7576 TAILQ_REMOVE(&inodedep->id_freeblklst, freeblks,
7578 freeblks->fb_state &= ~ONDEPLIST;
7715 * Free the block referenced by a freework structure. The parent freeblks
7725 struct freeblks *freeblks;
7742 freeblks = freework->fw_freeblks;
7744 needj = MOUNTEDSUJ(freeblks->fb_list.wk_mp) != 0;
7762 * release the freeblks. If we're not journaling, we can just
7763 * free the freeblks immediately.
7771 freeblks->fb_cgwait++;
7775 freeblks_free(ump, freeblks, btodb(bsize));
7778 freeblks->fb_inum, freework->fw_blkno, freework->fw_lbn, bsize);
7779 ffs_blkfree(ump, fs, freeblks->fb_devvp, freework->fw_blkno, bsize,
7780 freeblks->fb_inum, freeblks->fb_vtype, &wkhd);
7791 * We enqueue freework items that need processing back on the freeblks and
7792 * add the freeblks to the worklist. This makes it easier to find all work
7799 struct freeblks *freeblks;
7801 freeblks = freework->fw_freeblks;
7803 WORKLIST_INSERT(&freeblks->fb_freeworkhd, &freework->fw_list);
7804 if ((freeblks->fb_state &
7806 LIST_EMPTY(&freeblks->fb_jblkdephd))
7807 add_to_worklist(&freeblks->fb_list, WK_NODELAY);
7821 struct freeblks *freeblks;
7825 freeblks = freework->fw_freeblks;
7826 ump = VFSTOUFS(freeblks->fb_list.wk_mp);
7845 * ref on either the parent or the freeblks structure is released and
7846 * the freeblks is added back to the worklist if there is more work to do.
7852 struct freeblks *freeblks;
7855 freeblks = freework->fw_freeblks;
7858 freeblks->fb_cgwait--;
7867 if (--freeblks->fb_ref != 0)
7869 if ((freeblks->fb_state & (ALLCOMPLETE | ONWORKLIST | INPROGRESS)) ==
7870 ALLCOMPLETE && LIST_EMPTY(&freeblks->fb_jblkdephd))
7871 add_to_worklist(&freeblks->fb_list, WK_NODELAY);
7883 handle_workitem_freeblocks(freeblks, flags)
7884 struct freeblks *freeblks;
7893 KASSERT(LIST_EMPTY(&freeblks->fb_jblkdephd),
7895 ump = VFSTOUFS(freeblks->fb_list.wk_mp);
7897 while ((wk = LIST_FIRST(&freeblks->fb_freeworkhd)) != NULL) {
7914 freework = newfreework(ump, freeblks, NULL,
7940 if (freeblks->fb_ref != 0) {
7941 freeblks->fb_state &= ~INPROGRESS;
7942 wake_worklist(&freeblks->fb_list);
7943 freeblks = NULL;
7946 if (freeblks)
7947 return handle_complete_freeblocks(freeblks, flags);
7958 freeblks_free(ump, freeblks, blocks)
7960 struct freeblks *freeblks;
7967 remain = -freeblks->fb_chkcnt;
7968 freeblks->fb_chkcnt += blocks;
7984 handle_complete_freeblocks(freeblks, flags)
7985 struct freeblks *freeblks;
7995 ump = VFSTOUFS(freeblks->fb_list.wk_mp);
7998 spare = freeblks->fb_chkcnt;
8005 if (spare && freeblks->fb_len != 0) {
8006 if (ffs_vgetf(freeblks->fb_list.wk_mp, freeblks->fb_inum,
8010 if (DIP(ip, i_modrev) == freeblks->fb_modrev) {
8029 quotaadj(freeblks->fb_quota, ump, -spare);
8030 quotarele(freeblks->fb_quota);
8033 if (freeblks->fb_state & ONDEPLIST) {
8034 inodedep_lookup(freeblks->fb_list.wk_mp, freeblks->fb_inum,
8036 TAILQ_REMOVE(&inodedep->id_freeblklst, freeblks, fb_next);
8037 freeblks->fb_state &= ~ONDEPLIST;
8045 handle_jwork(&freeblks->fb_jwork);
8046 WORKITEM_FREE(freeblks, D_FREEBLKS);
8052 * Release blocks associated with the freeblks and stored in the indirect
8070 struct freeblks *freeblks;
8086 freeblks = freework->fw_freeblks;
8087 ump = VFSTOUFS(freeblks->fb_list.wk_mp);
8112 } else if ((bp = incore(&freeblks->fb_devvp->v_bufobj, dbn)) != NULL) {
8121 } else if (bread(freeblks->fb_devvp, dbn, (int)fs->fs_bsize,
8192 nfreework = newfreework(ump, freeblks, freework,
8214 freeblks->fb_inum, nb, fs->fs_bsize);
8215 ffs_blkfree(ump, fs, freeblks->fb_devvp, nb,
8216 fs->fs_bsize, freeblks->fb_inum,
8217 freeblks->fb_vtype, &wkhd);
8229 freeblks_free(ump, freeblks, freedblocks);
8240 freeblks->fb_cgwait += freedeps;
8252 freeblks->fb_inum, dbn, fs->fs_bsize);
8253 ffs_blkfree(ump, fs, freeblks->fb_devvp, dbn, fs->fs_bsize,
8254 freeblks->fb_inum, freeblks->fb_vtype, NULL);
8271 cancel_allocindir(aip, bp, freeblks, trunc)
8274 struct freeblks *freeblks;
8308 jwork_move(&freeblks->fb_jwork, &freefrag->ff_jwork);
8317 cancel_newblk(newblk, NULL, &freeblks->fb_jwork);
8318 WORKLIST_INSERT(&freeblks->fb_freeworkhd, &newblk->nb_list);
9153 * the number of freefile and freeblks structures.
9970 struct freeblks *freeblks;
10026 freeblks = WK_FREEBLKS(wk);
10027 jblkdep = LIST_FIRST(&freeblks->fb_jblkdephd);
10029 * We have to wait for the freeblks to be journaled
10032 * we revisit the freeblks if it's not removed by
10553 cancel_indirdep(indirdep, bp, freeblks)
10556 struct freeblks *freeblks;
10586 cancel_allocindir(aip, bp, freeblks, 0);
10588 cancel_allocindir(aip, NULL, freeblks, 0);
10590 cancel_allocindir(aip, NULL, freeblks, 0);
10592 cancel_allocindir(aip, NULL, freeblks, 0);
10606 indirdep->ir_freeblks = freeblks;
10990 struct freeblks *freeblks;
11089 freeblks = WK_FREEBLKS(wk);
11091 LIST_EMPTY(&freeblks->fb_jblkdephd))
13690 * reduce the number of dirrem, freefile, and freeblks dependency structures.
13962 struct freeblks *freeblks;
14063 freeblks = WK_FREEBLKS(wk);
14064 if (LIST_FIRST(&freeblks->fb_jblkdephd)) {