Lines Matching refs:fs
116 lfs_extend_ifile(struct lfs *fs, kauth_cred_t cred)
129 ASSERT_SEGLOCK(fs);
138 vp = fs->lfs_ivnode;
140 blkno = lfs_lblkno(fs, ip->i_size);
141 if ((error = lfs_balloc(vp, ip->i_size, lfs_sb_getbsize(fs), cred, 0,
145 ip->i_size += lfs_sb_getbsize(fs);
146 lfs_dino_setsize(fs, ip->i_din, ip->i_size);
154 maxino = ((ip->i_size >> lfs_sb_getbshift(fs)) - lfs_sb_getcleansz(fs) -
155 lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);
156 fs->lfs_ino_bitmap = (lfs_bm_t *)
157 realloc(fs->lfs_ino_bitmap, ((maxino + BMMASK) >> BMSHIFT) *
159 KASSERT(fs->lfs_ino_bitmap != NULL);
162 i = (blkno - lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs)) *
163 lfs_sb_getifpb(fs);
166 xmax = i + lfs_sb_getifpb(fs);
174 LFS_GET_HEADFREE(fs, cip, cbp, &oldhead);
175 LFS_PUT_HEADFREE(fs, cip, cbp, i);
176 LFS_GET_TAILFREE(fs, cip, cbp, &tail);
182 LFS_PUT_TAILFREE(fs, cip, cbp, tail);
184 KASSERTMSG((lfs_sb_getfreehd(fs) != LFS_UNUSED_INUM),
195 if (fs->lfs_is64) {
197 SET_BITMAP_FREE(fs, i);
204 } else if (lfs_sb_getversion(fs) > 1) {
206 SET_BITMAP_FREE(fs, i);
215 SET_BITMAP_FREE(fs, i);
224 (intmax_t)xmax - lfs_sb_getifpb(fs), (intmax_t)tail));
239 * to frob fs->lfs_fmod.
249 struct lfs *fs;
255 fs = VTOI(pvp)->i_lfs;
256 if (fs->lfs_ronly)
259 if (!(fs->lfs_flags & LFS_NOTYET))
260 ASSERT_NO_SEGLOCK(fs);
262 DEBUG_CHECK_FREELIST(fs);
264 lfs_seglock(fs, SEGM_PROT);
267 LFS_GET_HEADFREE(fs, cip, cbp, ino);
275 CLR_BITMAP_FREE(fs, *ino);
281 LFS_IENTRY(ifp, fs, *ino, bp);
282 if (lfs_if_getdaddr(fs, ifp) != LFS_UNUSED_DADDR)
287 LFS_PUT_HEADFREE(fs, cip, cbp, lfs_if_getnextfree(fs, ifp));
289 *ino, (uintmax_t)lfs_if_getnextfree(fs, ifp)));
295 *gen = lfs_if_getversion(fs, ifp);
306 lfs_if_setdaddr(fs, ifp, LFS_ILLEGAL_DADDR);
307 lfs_if_setnextfree(fs, ifp, LFS_UNUSED_INUM);
310 if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {
315 if ((error = lfs_extend_ifile(fs, cred)) != 0) {
317 LFS_PUT_HEADFREE(fs, cip, cbp, *ino);
320 lfs_segunlock(fs);
324 KASSERTMSG((lfs_sb_getfreehd(fs) != LFS_UNUSED_INUM),
329 fs->lfs_fmod = 1;
333 lfs_sb_addnfiles(fs, 1);
336 lfs_segunlock(fs);
338 DEBUG_CHECK_FREELIST(fs);
350 lfs_valloc_fixed(struct lfs *fs, ino_t ino, int vers)
358 if (fs->lfs_ronly)
361 if (!(fs->lfs_flags & LFS_NOTYET))
362 ASSERT_NO_SEGLOCK(fs);
364 DEBUG_CHECK_FREELIST(fs);
366 lfs_seglock(fs, SEGM_PROT);
374 while (VTOI(fs->lfs_ivnode)->i_size <= (ino /
375 lfs_sb_getifpb(fs) + lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs))
376 << lfs_sb_getbshift(fs)) {
379 lfs_extend_ifile(fs, NOCRED);
386 LFS_IENTRY(ifp, fs, ino, bp);
387 oldnext = lfs_if_getnextfree(fs, ifp);
391 LFS_GET_TAILFREE(fs, cip, cbp, &tailino);
394 LFS_GET_HEADFREE(fs, cip, cbp, &headino);
397 LFS_PUT_HEADFREE(fs, cip, cbp, oldnext);
402 maxino = ((VTOI(fs->lfs_ivnode)->i_size >> lfs_sb_getbshift(fs))
403 - lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs))
404 * lfs_sb_getifpb(fs);
410 LFS_IENTRY(ifp, fs, thisino, bp);
411 nextfree = lfs_if_getnextfree(fs, ifp);
424 lfs_segunlock(fs);
430 lfs_segunlock(fs);
436 lfs_if_setnextfree(fs, ifp, oldnext);
442 LFS_PUT_TAILFREE(fs, cip, cbp, thisino);
446 LFS_IENTRY(ifp, fs, ino, bp);
447 lfs_if_setversion(fs, ifp, vers);
448 lfs_if_setnextfree(fs, ifp, LFS_UNUSED_INUM);
450 lfs_if_setdaddr(fs, ifp, LFS_ILLEGAL_DADDR);
453 if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {
459 if ((error = lfs_extend_ifile(fs, NOCRED)) != 0) {
461 LFS_PUT_HEADFREE(fs, cip, cbp, ino);
464 lfs_segunlock(fs);
468 KASSERTMSG((lfs_sb_getfreehd(fs) != LFS_UNUSED_INUM),
472 lfs_segunlock(fs);
474 DEBUG_CHECK_FREELIST(fs);
485 lfs_last_alloc_ino(struct lfs *fs)
489 maxino = ((fs->lfs_ivnode->v_size >> lfs_sb_getbshift(fs)) -
490 lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) *
491 lfs_sb_getifpb(fs);
493 if (ISSET_BITMAP_FREE(fs, ino) == 0)
506 lfs_freelist_prev(struct lfs *fs, ino_t ino)
510 if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {
518 if (ISSET_BITMAP_FREE(fs, tino))
528 freehdbb = (lfs_sb_getfreehd(fs) >> BMSHIFT);
530 if (fs->lfs_ino_bitmap[bb])
532 if (fs->lfs_ino_bitmap[bb] == 0)
538 if (ISSET_BITMAP_FREE(fs, tino))
564 struct lfs *fs;
569 fs = ip->i_lfs;
574 ASSERT_NO_SEGLOCK(fs);
579 while (lfs_sb_getversion(fs) > 1 && WRITEINPROG(vp)) {
584 lfs_seglock(fs, SEGM_PROT);
586 DEBUG_CHECK_FREELIST(fs);
601 --fs->lfs_dirvcount;
602 TAILQ_REMOVE(&fs->lfs_dchainhd, ip, i_lfs_dchain);
603 wakeup(&fs->lfs_dirvcount);
612 * them to the fs-wide list for that purpose.
619 LIST_INSERT_HEAD(&fs->lfs_segdhd, sd, list);
627 lfs_finalize_ino_seguse(fs, ip);
643 SET_BITMAP_FREE(fs, ino);
651 LFS_IENTRY(ifp, fs, ino, bp);
654 old_iaddr = lfs_if_getdaddr(fs, ifp);
655 lfs_if_setdaddr(fs, ifp, LFS_UNUSED_DADDR);
658 lfs_if_setversion(fs, ifp, lfs_if_getversion(fs, ifp) + 1);
661 if (lfs_sb_getversion(fs) == 1) {
666 LFS_GET_HEADFREE(fs, cip, cbp, &nextfree);
667 lfs_if_setnextfree(fs, ifp, nextfree);
668 LFS_PUT_HEADFREE(fs, cip, cbp, ino);
681 lfs_if_setnextfree(fs, ifp, LFS_UNUSED_INUM);
689 tino = lfs_freelist_prev(fs, ino);
699 LFS_IENTRY(ifp, fs, ino, bp);
701 LFS_GET_HEADFREE(fs, cip, cbp, &nextfree);
702 lfs_if_setnextfree(fs, ifp, nextfree);
703 LFS_PUT_HEADFREE(fs, cip, cbp, ino);
710 LFS_GET_TAILFREE(fs, cip, cbp, &otail);
712 LFS_PUT_TAILFREE(fs, cip, cbp, ino);
728 LFS_IENTRY(ifp, fs, tino, bp);
730 onf = lfs_if_getnextfree(fs, ifp);
731 lfs_if_setnextfree(fs, ifp, ino);
736 LFS_IENTRY(ifp, fs, ino, bp);
738 lfs_if_setnextfree(fs, ifp, onf);
744 LFS_GET_TAILFREE(fs, cip, cbp, &otail);
745 LFS_PUT_TAILFREE(fs, cip, cbp, ino);
753 /* XXX: shouldn't this check be further up *before* we trash the fs? */
762 LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, old_iaddr), bp);
764 KASSERTMSG((sup->su_nbytes >= DINOSIZE(fs)),
767 lfs_dtosn(fs, old_iaddr),
768 (int)DINOSIZE(fs) - sup->su_nbytes);
770 sup->su_nbytes -= DINOSIZE(fs);
772 LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, old_iaddr), bp); /* Ifile */
777 fs->lfs_fmod = 1;
781 lfs_sb_subnfiles(fs, 1);
783 lfs_segunlock(fs);
785 DEBUG_CHECK_FREELIST(fs);
797 lfs_order_freelist(struct lfs *fs, ino_t **orphanp, size_t *norphanp)
807 ASSERT_NO_SEGLOCK(fs);
808 lfs_seglock(fs, SEGM_PROT);
810 DEBUG_CHECK_FREELIST(fs);
812 /* largest inode on fs */
813 maxino = ((fs->lfs_ivnode->v_size >> lfs_sb_getbshift(fs)) -
814 lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);
817 /* XXX: assert that fs->lfs_ino_bitmap is null here */
818 fs->lfs_ino_bitmap =
821 KASSERT(fs->lfs_ino_bitmap != NULL);
830 if (ino % lfs_sb_getifpb(fs) == 0)
831 LFS_IENTRY(ifp, fs, ino, bp);
833 LFS_IENTRY_NEXT(ifp, fs);
850 if (lfs_if_getnextfree(fs, ifp) == LFS_ORPHAN_NEXTFREE(fs)) {
871 if (DADDR_IS_BAD(lfs_if_getdaddr(fs, ifp))) {
888 LFS_IENTRY(ifp, fs, lastino, bp);
890 lfs_if_setnextfree(fs, ifp, ino);
895 LFS_IENTRY(ifp, fs, ino, bp);
901 SET_BITMAP_FREE(fs, ino);
905 if ((ino + 1) % lfs_sb_getifpb(fs) == 0)
911 LFS_PUT_HEADFREE(fs, cip, bp, firstino);
912 LFS_PUT_TAILFREE(fs, cip, bp, lastino);
915 lfs_segunlock(fs);
933 DEBUG_CHECK_FREELIST(fs);
950 lfs_orphan(struct lfs *fs, struct vnode *vp)
987 LFS_IENTRY(ifp, fs, ip->i_number, bp);
988 nextfree = lfs_if_getnextfree(fs, ifp);
989 if (nextfree == LFS_ORPHAN_NEXTFREE(fs)) {
994 lfs_if_setnextfree(fs, ifp, LFS_ORPHAN_NEXTFREE(fs));
1003 lfs_free_orphans(struct lfs *fs, ino_t *orphan, size_t norphan)
1007 DEBUG_CHECK_FREELIST(fs);
1020 LFS_IENTRY(ifp, fs, ino, bp);
1021 KASSERT(!DADDR_IS_BAD(lfs_if_getdaddr(fs, ifp)));
1022 segno = lfs_dtosn(fs, lfs_if_getdaddr(fs, ifp));
1029 error = VFS_VGET(fs->lfs_ivnode->v_mount, ino, LK_EXCLUSIVE,
1061 LFS_SEGENTRY(sup, fs, segno, bp);
1062 KASSERT(sup->su_nbytes >= DINOSIZE(fs));
1063 sup->su_nbytes -= DINOSIZE(fs);
1064 LFS_WRITESEGENTRY(sup, fs, segno, bp);
1067 LFS_IENTRY(ifp, fs, ino, bp);
1068 lfs_if_setdaddr(fs, ifp, LFS_UNUSED_DADDR);
1075 DEBUG_CHECK_FREELIST(fs);
1082 lfs_check_freelist(struct lfs *fs, const char *func, int line)
1094 lfs_seglock(fs, SEGM_PROT);
1096 ip = VTOI(fs->lfs_ivnode);
1097 maxino = ((ip->i_size >> lfs_sb_getbshift(fs)) - lfs_sb_getcleansz(fs) -
1098 lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);
1105 LFS_GET_TAILFREE(fs, cip, bp, &tailino);
1108 LFS_IENTRY(ifp, fs, i, bp);
1109 if (lfs_if_getdaddr(fs, ifp) == LFS_UNUSED_DADDR) {
1111 if (lfs_if_getnextfree(fs, ifp) == LFS_UNUSED_INUM
1114 dump_freelist(fs);
1123 || (!INUM_IS_BAD(fs, lfs_if_getnextfree(fs, ifp)))) {
1124 if (lfs_if_getdaddr(fs, ifp) != LFS_UNUSED_DADDR) {
1126 dump_freelist(fs);
1132 (intmax_t)lfs_if_getdaddr(fs, ifp),
1133 (intmax_t)lfs_if_getnextfree(fs, ifp));
1146 LFS_GET_HEADFREE(fs, cip, bp, &headino);
1153 LFS_IENTRY(ifp, fs, thisino, bp);
1154 nextfree = lfs_if_getnextfree(fs, ifp);
1161 dump_freelist(fs);
1168 dump_freelist(fs);
1175 dump_freelist(fs);
1181 lfs_segunlock(fs);
1185 dump_freelist(struct lfs *fs)
1194 ip = VTOI(fs->lfs_ivnode);
1195 maxino = ((ip->i_size >> lfs_sb_getbshift(fs)) - lfs_sb_getcleansz(fs) -
1196 lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);
1198 LFS_GET_HEADFREE(fs, cip, bp, &headino);
1200 LFS_GET_TAILFREE(fs, cip, bp, &tailino);
1204 LFS_IENTRY(ifp, fs, i, bp);
1205 ni = lfs_if_getnextfree(fs, ifp);