Lines Matching refs:fs
111 lfs_match_data(struct lfs * fs, struct ubuf * bp)
117 lfs_match_indir(struct lfs * fs, struct ubuf * bp)
122 return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 0);
126 lfs_match_dindir(struct lfs * fs, struct ubuf * bp)
131 return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 1);
135 lfs_match_tindir(struct lfs * fs, struct ubuf * bp)
140 return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 2);
147 lfs_segwrite(struct lfs * fs, int flags)
155 lfs_seglock(fs, flags | SEGM_CKP);
156 sp = fs->lfs_sp;
158 lfs_writevnodes(fs, sp, VN_REG);
159 lfs_writevnodes(fs, sp, VN_DIROP);
161 lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) & ~(SS_CONT));
164 vp = fs->lfs_ivnode;
165 fs->lfs_flags &= ~LFS_IFDIRTY;
167 if (LIST_FIRST(&vp->v_dirtyblkhd) != NULL || lfs_sb_getidaddr(fs) <= 0)
168 lfs_writefile(fs, sp, vp);
170 redo = lfs_writeinode(fs, sp, ip);
171 redo += lfs_writeseg(fs, sp);
172 redo += (fs->lfs_flags & LFS_IFDIRTY);
175 lfs_segunlock(fs);
178 written_bytes, (ulfs_daddr_t)lfs_btofsb(fs, written_bytes));
180 written_data, (ulfs_daddr_t)lfs_btofsb(fs, written_data));
182 written_indir, (ulfs_daddr_t)lfs_btofsb(fs, written_indir));
184 written_dev, (ulfs_daddr_t)lfs_btofsb(fs, written_dev));
186 written_inodes, lfs_btofsb(fs, written_inodes * fs->lfs_ibsize));
195 lfs_writefile(struct lfs * fs, struct segment * sp, struct uvnode * vp)
205 if (sp->seg_bytes_left < lfs_sb_getbsize(fs) ||
206 sp->sum_bytes_left < FINFOSIZE(fs) + LFS_BLKPTRSIZE(fs))
207 (void) lfs_writeseg(fs, sp);
209 sp->sum_bytes_left -= FINFOSIZE(fs);
211 lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) + 1);
214 lfs_ss_setflags(fs, ssp,
215 lfs_ss_getflags(fs, ssp) | (SS_DIROP | SS_CONT));
219 lfs_fi_setnblocks(fs, fip, 0);
220 lfs_fi_setino(fs, fip, ip->i_number);
221 LFS_IENTRY(ifp, fs, lfs_fi_getino(fs, fip), bp);
222 lfs_fi_setversion(fs, fip, lfs_if_getversion(fs, ifp));
225 lfs_gather(fs, sp, vp, lfs_match_data);
226 lfs_gather(fs, sp, vp, lfs_match_indir);
227 lfs_gather(fs, sp, vp, lfs_match_dindir);
228 lfs_gather(fs, sp, vp, lfs_match_tindir);
231 if (lfs_fi_getnblocks(fs, fip) != 0) {
232 sp->fip = NEXT_FINFO(fs, fip);
233 lfs_blocks_fromfinfo(fs, &sp->start_lbp, sp->fip);
236 sp->sum_bytes_left += FINFOSIZE(fs);
237 lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) - 1);
242 lfs_writeinode(struct lfs * fs, struct segment * sp, struct inode * ip)
261 if (sp->seg_bytes_left < lfs_sb_getibsize(fs) ||
262 sp->sum_bytes_left < LFS_BLKPTRSIZE(fs))
263 (void) lfs_writeseg(fs, sp);
266 daddr = lfs_sb_getoffset(fs);
267 lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
269 getblk(fs->lfs_devvp, LFS_FSBTODB(fs, daddr),
270 lfs_sb_getibsize(fs));
275 for (i = 0; i < LFS_INOPB(fs); ++i) {
278 tmpdip = DINO_IN_BLOCK(fs, sp->ibp->b_data, i);
279 lfs_dino_setinumber(fs, tmpdip, 0);
283 lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
285 sp->seg_bytes_left -= lfs_sb_getibsize(fs);
286 sp->sum_bytes_left -= LFS_BLKPTRSIZE(fs);
289 iip = NTH_IINFO(fs, sp->segsum, sp->ninodes / LFS_INOPB(fs));
290 lfs_ii_setblock(fs, iip, daddr);
308 lfs_copy_dinode(fs, sp->idp, ip->i_din);
309 ip->i_lfs_osize = lfs_dino_getsize(fs, ip->i_din);
313 cdp = DINO_IN_BLOCK(fs, bp->b_data, sp->ninodes % LFS_INOPB(fs));
314 lfs_copy_dinode(fs, cdp, ip->i_din);
317 ip->i_lfs_osize = lfs_dino_getsize(fs, ip->i_din);
320 sp->idp = DINO_IN_BLOCK(fs, bp->b_data, sp->ninodes % LFS_INOPB(fs));
328 lfs_ss_setninos(fs, ssp, lfs_ss_getninos(fs, ssp) + 1);
331 if (++sp->ninodes % LFS_INOPB(fs) == 0)
340 daddr = lfs_sb_getidaddr(fs);
341 lfs_sb_setidaddr(fs, LFS_DBTOFSB(fs, bp->b_blkno));
344 LFS_IENTRY(ifp, fs, ino, ibp);
345 daddr = lfs_if_getdaddr(fs, ifp);
346 lfs_if_setdaddr(fs, ifp, LFS_DBTOFSB(fs, bp->b_blkno) + fsb);
356 u_int32_t oldsn = lfs_dtosn(fs, daddr);
357 LFS_SEGENTRY(sup, fs, oldsn, bp);
358 sup->su_nbytes -= DINOSIZE(fs);
362 fs->lfs_flags |= LFS_IFDIRTY;
363 LFS_WRITESEGENTRY(sup, fs, oldsn, bp); /* Ifile */
371 struct lfs *fs;
380 fs = sp->fs;
381 blksinblk = howmany(bp->b_bcount, lfs_sb_getbsize(fs));
382 if (sp->sum_bytes_left < LFS_BLKPTRSIZE(fs) * blksinblk ||
386 version = lfs_fi_getversion(fs, sp->fip);
387 (void) lfs_writeseg(fs, sp);
389 lfs_fi_setversion(fs, sp->fip, version);
390 lfs_fi_setino(fs, sp->fip, VTOI(sp->vp)->i_number);
393 lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) + 1);
394 sp->sum_bytes_left -= FINFOSIZE(fs);
406 bn = lfs_fi_getnblocks(fs, sp->fip);
407 lfs_fi_setnblocks(fs, sp->fip, bn + 1);
408 lfs_fi_setblock(fs, sp->fip, bn, bp->b_lblkno + j);
411 sp->sum_bytes_left -= LFS_BLKPTRSIZE(fs) * blksinblk;
417 lfs_gather(struct lfs * fs, struct segment * sp, struct uvnode * vp, int (*match) (struct lfs *, struct ubuf *))
428 if ((bp->b_flags & (B_BUSY | B_GATHERED)) || !match(fs, bp)) {
450 lfs_update_single(struct lfs * fs, struct segment * sp, daddr_t lbn,
466 error = ulfs_bmaparray(fs, vp, lbn, &daddr, a, &num);
471 daddr = LFS_DBTOFSB(fs, daddr);
473 frags = lfs_numfrags(fs, size);
476 ooff = lfs_dino_getdb(fs, ip->i_din, lbn);
478 lfs_dino_setblocks(fs, ip->i_din,
479 lfs_dino_getblocks(fs, ip->i_din) + frags);
482 ofrags = lfs_btofsb(fs, ip->i_lfs_fragsize[lbn]);
483 lfs_dino_setblocks(fs, ip->i_din,
484 lfs_dino_getblocks(fs, ip->i_din) + (frags - ofrags));
486 lfs_dino_setdb(fs, ip->i_din, lbn, ndaddr);
489 ooff = lfs_dino_getib(fs, ip->i_din, a[0].in_off);
491 lfs_dino_setblocks(fs, ip->i_din,
492 lfs_dino_getblocks(fs, ip->i_din) + frags);
493 lfs_dino_setib(fs, ip->i_din, a[0].in_off, ndaddr);
497 if (bread(vp, ap->in_lbn, lfs_sb_getbsize(fs), 0, &bp))
501 ooff = lfs_iblock_get(fs, bp->b_data, ap->in_off);
503 lfs_dino_setblocks(fs, ip->i_din,
504 lfs_dino_getblocks(fs, ip->i_din) + frags);
505 lfs_iblock_set(fs, bp->b_data, ap->in_off, ndaddr);
514 u_int32_t oldsn = lfs_dtosn(fs, daddr);
518 osize = lfs_sb_getbsize(fs);
519 LFS_SEGENTRY(sup, fs, oldsn, bp);
522 fs->lfs_flags |= LFS_IFDIRTY;
523 LFS_WRITESEGENTRY(sup, fs, oldsn, bp);
542 struct lfs *fs;
550 fs = sp->fs;
560 lfs_blocks_fromvoid(fs, &tmpptr, (void *)NEXT_FINFO(fs, sp->fip));
561 nblocks = lfs_blocks_sub(fs, &tmpptr, &sp->start_lbp);
578 num = howmany(sp->start_bpp[i]->b_bcount, lfs_sb_getbsize(fs));
585 lfs_shellsort(fs, sp->start_bpp, &sp->start_lbp, nblocks, lfs_sb_getbsize(fs));
593 lfs_fi_setlastlength(fs, sp->fip, ((sp->start_bpp[nblocks - 1]->b_bcount - 1) &
594 lfs_sb_getbmask(fs)) + 1);
602 lbn = lfs_blocks_get(fs, &sp->start_lbp, 0);
604 sbp->b_blkno = LFS_FSBTODB(fs, lfs_sb_getoffset(fs));
613 if ((sbp->b_bcount & lfs_sb_getbmask(fs)) && i != 0)
621 bytesleft -= lfs_sb_getbsize(fs)) {
622 size = MIN(bytesleft, lfs_sb_getbsize(fs));
623 frags = lfs_numfrags(fs, size);
624 lbn = lfs_blocks_get(fs, &sp->start_lbp, 0);
625 lfs_blocks_inc(fs, &sp->start_lbp);
626 lfs_update_single(fs, sp, lbn, lfs_sb_getoffset(fs), size);
627 lfs_sb_addoffset(fs, frags);
637 lfs_initseg(struct lfs * fs)
645 sp = fs->lfs_sp;
650 if (!LFS_PARTIAL_FITS(fs)) {
652 lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) -
653 lfs_sb_getcurseg(fs)));
654 lfs_newseg(fs);
656 lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
658 sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
659 sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs));
665 LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
667 lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_SBPAD));
672 if (lfs_sb_getversion(fs) > 1 && sp->seg_number == 0 &&
673 lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD)) {
674 lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_LABELPAD) - lfs_sb_gets0addr(fs));
675 sp->seg_bytes_left -= LFS_LABELPAD - lfs_fsbtob(fs, lfs_sb_gets0addr(fs));
678 sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
679 sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs) -
680 (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
682 lfs_sb_setlastpseg(fs, lfs_sb_getoffset(fs));
684 sp->fs = fs;
692 sbp = *sp->cbpp = getblk(fs->lfs_devvp,
693 LFS_FSBTODB(fs, lfs_sb_getoffset(fs)), lfs_sb_getsumsize(fs));
695 memset(sp->segsum, 0, lfs_sb_getsumsize(fs));
697 lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
701 lfs_ss_setnext(fs, ssp, lfs_sb_getnextseg(fs));
702 lfs_ss_setnfinfo(fs, ssp, 0);
703 lfs_ss_setninos(fs, ssp, 0);
704 lfs_ss_setmagic(fs, ssp, SS_MAGIC);
707 sp->fip = SEGSUM_FINFOBASE(fs, ssp);
708 lfs_fi_setnblocks(fs, sp->fip, 0);
709 lfs_blocks_fromfinfo(fs, &sp->start_lbp, sp->fip);
710 lfs_fi_setlastlength(fs, sp->fip, 0);
712 sp->seg_bytes_left -= lfs_sb_getsumsize(fs);
713 sp->sum_bytes_left = lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs);
724 lfs_newseg(struct lfs * fs)
731 LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
736 LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
738 LFS_CLEANERINFO(cip, fs, bp);
739 lfs_ci_shiftcleantodirty(fs, cip, 1);
740 lfs_sb_setnclean(fs, lfs_ci_getclean(fs, cip));
741 LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
743 lfs_sb_setlastseg(fs, lfs_sb_getcurseg(fs));
744 lfs_sb_setcurseg(fs, lfs_sb_getnextseg(fs));
745 for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + lfs_sb_getinterleave(fs);;) {
746 sn = (sn + 1) % lfs_sb_getnseg(fs);
749 LFS_SEGENTRY(sup, fs, sn, bp);
757 ++fs->lfs_nactive;
758 lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
763 lfs_writeseg(struct lfs * fs, struct segment * sp)
784 nblocks, (int)LFS_DBTOFSB(fs, (*sp->bpp)->b_blkno));
789 devvp = fs->lfs_devvp;
792 LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
800 assert(lfs_dtosn(fs, LFS_DBTOFSB(fs, (*bpp)->b_blkno)) == sp->seg_number);
804 lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_RFW);
806 ninos = (lfs_ss_getninos(fs, ssp) + LFS_INOPB(fs) - 1) / LFS_INOPB(fs);
807 sup->su_nbytes += lfs_ss_getninos(fs, ssp) * DINOSIZE(fs);
809 if (lfs_sb_getversion(fs) == 1)
815 lfs_sb_adddmeta(fs, (lfs_btofsb(fs, lfs_sb_getsumsize(fs)) + lfs_btofsb(fs, ninos *
816 lfs_sb_getibsize(fs))));
817 lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
820 LFS_WRITESEGENTRY(sup, fs, sp->seg_number, bp); /* Ifile */
827 if (lfs_sb_getversion(fs) == 1)
836 byteoffset += lfs_sb_getbsize(fs)) {
843 if (lfs_sb_getversion(fs) == 1)
844 lfs_ss_setocreate(fs, ssp, write_time);
846 lfs_ss_setcreate(fs, ssp, write_time);
847 lfs_sb_addserial(fs, 1);
848 lfs_ss_setserial(fs, ssp, lfs_sb_getserial(fs));
849 lfs_ss_setident(fs, ssp, lfs_sb_getident(fs));
855 lfs_ss_setdatasum(fs, ssp, cksum(datap, (nblocks - 1) * el_size));
856 sumstart = lfs_ss_getsumstart(fs);
857 lfs_ss_setsumsum(fs, ssp,
858 cksum((char *)ssp + sumstart, lfs_sb_getsumsize(fs) - sumstart));
861 lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
862 lfs_btofsb(fs, lfs_sb_getsumsize(fs))));
872 if (bp->b_vp != fs->lfs_devvp)
876 if (bp->b_vp == fs->lfs_devvp)
891 return (lfs_initseg(fs) || do_again);
898 lfs_shellsort(struct lfs *fs,
921 lfs_blocks_set(fs, lb_array, incr++,
933 lfs_seglock(struct lfs * fs, unsigned long flags)
938 if (fs->lfs_seglock) {
939 ++fs->lfs_seglock;
940 fs->lfs_sp->seg_flags |= flags;
943 fs->lfs_seglock = 1;
945 sp = fs->lfs_sp = emalloc(sizeof(*sp));
946 allocsize = lfs_sb_getssize(fs) * sizeof(struct ubuf *);
953 (void) lfs_initseg(fs);
963 lfs_segunlock(struct lfs * fs)
968 sp = fs->lfs_sp;
970 if (fs->lfs_seglock == 1) {
973 lfs_sb_suboffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
987 fs->lfs_sp = NULL;
989 fs->lfs_nactive = 0;
992 lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));
993 lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));
995 --fs->lfs_seglock;
996 fs->lfs_lockpid = 0;
997 } else if (fs->lfs_seglock == 0) {
1000 --fs->lfs_seglock;
1005 lfs_writevnodes(struct lfs *fs, struct segment *sp, int op)
1026 lfs_writefile(fs, sp, vp);
1027 (void) lfs_writeinode(fs, sp, ip);
1035 lfs_writesuper(struct lfs *fs, daddr_t daddr)
1040 if (lfs_sb_getversion(fs) == 1)
1041 lfs_sb_setotstamp(fs, write_time);
1042 lfs_sb_settstamp(fs, write_time);
1047 lfs_sb_setcksum(fs, lfs_sb_cksum(fs));
1049 bp = getblk(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), LFS_SBPAD);
1050 memcpy(bp->b_data, &fs->lfs_dlfs_u, sizeof(struct dlfs));
Indexes created Wed Oct 15 16:09:53 GMT 2025