2 * Copyright (c) 2010-2012 Semihalf.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
33 #include <sys/systm.h>
35 #include <sys/kernel.h>
37 #include <sys/malloc.h>
38 #include <sys/mount.h>
39 #include <sys/mutex.h>
40 #include <sys/namei.h>
41 #include <sys/rwlock.h>
42 #include <sys/sysctl.h>
43 #include <sys/vnode.h>
46 #include <sys/libkern.h>
51 #include <vm/vm_param.h>
52 #include <vm/vm_kern.h>
53 #include <vm/vm_page.h>
55 #include <geom/geom.h>
56 #include <geom/geom_vfs.h>
58 #include <fs/nandfs/nandfs_mount.h>
59 #include <fs/nandfs/nandfs.h>
60 #include <fs/nandfs/nandfs_subr.h>
63 nandfs_new_segment(struct nandfs_device *fsdev)
68 error = nandfs_alloc_segment(fsdev, &new);
70 fsdev->nd_seg_num = fsdev->nd_next_seg_num;
71 fsdev->nd_next_seg_num = new;
73 DPRINTF(SYNC, ("%s: new segment %jx next %jx error %d\n",
74 __func__, (uintmax_t)fsdev->nd_seg_num, (uintmax_t)new, error));
76 nandfs_error("%s: cannot create segment error %d\n",
83 create_segment(struct nandfs_seginfo *seginfo)
85 struct nandfs_segment *seg;
86 struct nandfs_device *fsdev;
87 struct nandfs_segment *prev;
89 uint64_t start_block, curr;
90 uint32_t blks_per_seg, nblocks;
93 fsdev = seginfo->fsdev;
94 prev = seginfo->curseg;
95 blks_per_seg = fsdev->nd_fsdata.f_blocks_per_segment;
96 nblocks = fsdev->nd_last_segsum.ss_nblocks;
99 vfs_timestamp(&fsdev->nd_ts);
100 /* Touch current segment */
101 error = nandfs_touch_segment(fsdev, fsdev->nd_seg_num);
103 nandfs_error("%s: cannot preallocate segment %jx\n",
104 __func__, fsdev->nd_seg_num);
107 error = nandfs_touch_segment(fsdev, 0);
109 nandfs_error("%s: cannot dirty block with segment 0\n",
113 start_block = fsdev->nd_last_pseg + (uint64_t)nblocks;
117 if (blks_per_seg - (start_block % blks_per_seg) - 1 == 0)
119 curr = nandfs_get_segnum_of_block(fsdev, start_block);
120 /* Allocate new segment if last one is full */
121 if (fsdev->nd_seg_num != curr) {
122 error = nandfs_new_segment(fsdev);
124 nandfs_error("%s: cannot create new segment\n",
131 nandfs_get_segment_range(fsdev, fsdev->nd_seg_num, &start_block, NULL);
134 nandfs_get_segment_range(fsdev, fsdev->nd_next_seg_num,
137 /* Touch current segment and allocate and touch new one */
138 error = nandfs_new_segment(fsdev);
140 nandfs_error("%s: cannot create next segment\n",
145 /* Reiterate in case new buf is dirty */
146 seginfo->reiterate = 1;
149 /* Allocate and initialize nandfs_segment structure */
150 seg = malloc(sizeof(*seg), M_DEVBUF, M_WAITOK|M_ZERO);
151 TAILQ_INIT(&seg->segsum);
152 TAILQ_INIT(&seg->data);
154 seg->start_block = start_block;
155 seg->num_blocks = blks_per_seg - (start_block % blks_per_seg) - 1;
156 seg->seg_num = fsdev->nd_seg_num;
157 seg->seg_next = fsdev->nd_next_seg_num;
158 seg->segsum_blocks = 1;
159 seg->bytes_left = fsdev->nd_blocksize -
160 sizeof(struct nandfs_segment_summary);
161 seg->segsum_bytes = sizeof(struct nandfs_segment_summary);
163 /* Allocate buffer for segment summary */
164 bp = getblk(fsdev->nd_devvp, nandfs_block_to_dblock(fsdev,
165 seg->start_block), fsdev->nd_blocksize, 0, 0, 0);
166 bzero(bp->b_data, seginfo->fsdev->nd_blocksize);
167 bp->b_bufobj = &seginfo->fsdev->nd_devvp->v_bufobj;
168 bp->b_flags |= B_MANAGED;
170 /* Add buffer to segment */
171 TAILQ_INSERT_TAIL(&seg->segsum, bp, b_cluster.cluster_entry);
172 seg->current_off = bp->b_data + sizeof(struct nandfs_segment_summary);
174 DPRINTF(SYNC, ("%s: seg %p : initial settings: start %#jx size :%#x\n",
175 __func__, seg, (uintmax_t)seg->start_block, seg->num_blocks));
176 DPRINTF(SYNC, ("%s: seg->seg_num %#jx cno %#jx next %#jx\n", __func__,
177 (uintmax_t)seg->seg_num, (uintmax_t)(fsdev->nd_last_cno + 1),
178 (uintmax_t)seg->seg_next));
181 LIST_INSERT_HEAD(&seginfo->seg_list, seg, seg_link);
183 LIST_INSERT_AFTER(prev, seg, seg_link);
185 seginfo->curseg = seg;
191 delete_segment(struct nandfs_seginfo *seginfo)
193 struct nandfs_segment *seg, *tseg;
194 struct buf *bp, *tbp;
196 LIST_FOREACH_SAFE(seg, &seginfo->seg_list, seg_link, tseg) {
197 TAILQ_FOREACH_SAFE(bp, &seg->segsum, b_cluster.cluster_entry,
199 TAILQ_REMOVE(&seg->segsum, bp, b_cluster.cluster_entry);
200 bp->b_flags &= ~B_MANAGED;
204 LIST_REMOVE(seg, seg_link);
212 create_seginfo(struct nandfs_device *fsdev, struct nandfs_seginfo **seginfo)
214 struct nandfs_seginfo *info;
216 info = malloc(sizeof(*info), M_DEVBUF, M_WAITOK);
218 LIST_INIT(&info->seg_list);
223 fsdev->nd_seginfo = info;
228 delete_seginfo(struct nandfs_seginfo *seginfo)
230 struct nandfs_device *nffsdev;
232 nffsdev = seginfo->fsdev;
233 delete_segment(seginfo);
234 nffsdev->nd_seginfo = NULL;
235 free(seginfo, M_DEVBUF);
241 nandfs_create_superroot_block(struct nandfs_seginfo *seginfo,
247 bp = nandfs_geteblk(seginfo->fsdev->nd_blocksize, GB_NOWAIT_BD);
249 bzero(bp->b_data, seginfo->fsdev->nd_blocksize);
250 bp->b_bufobj = &seginfo->fsdev->nd_devvp->v_bufobj;
251 bp->b_flags |= B_MANAGED;
253 if (!(seginfo->curseg) || !seginfo->curseg->num_blocks) {
254 error = create_segment(seginfo);
257 nandfs_error("%s: no segment for superroot\n",
263 TAILQ_INSERT_TAIL(&seginfo->curseg->data, bp, b_cluster.cluster_entry);
265 seginfo->curseg->nblocks++;
266 seginfo->curseg->num_blocks--;
274 nandfs_add_superroot(struct nandfs_seginfo *seginfo)
276 struct nandfs_device *fsdev;
277 struct nandfs_super_root *sr;
278 struct buf *bp = NULL;
283 fsdev = seginfo->fsdev;
285 error = nandfs_create_superroot_block(seginfo, &bp);
287 nandfs_error("%s: cannot add superroot\n", __func__);
291 sr = (struct nandfs_super_root *)bp->b_data;
292 /* Save superroot CRC */
293 sr->sr_bytes = NANDFS_SR_BYTES;
295 sr->sr_nongc_ctime = 0;
297 memcpy(&sr->sr_dat, &fsdev->nd_dat_node->nn_inode,
298 sizeof(struct nandfs_inode));
299 memcpy(&sr->sr_cpfile, &fsdev->nd_cp_node->nn_inode,
300 sizeof(struct nandfs_inode));
301 memcpy(&sr->sr_sufile, &fsdev->nd_su_node->nn_inode,
302 sizeof(struct nandfs_inode));
304 crc_skip = sizeof(sr->sr_sum);
305 crc_calc = crc32((uint8_t *)sr + crc_skip, NANDFS_SR_BYTES - crc_skip);
307 sr->sr_sum = crc_calc;
309 bp->b_flags |= B_MANAGED;
310 bp->b_bufobj = &seginfo->fsdev->nd_devvp->v_bufobj;
312 bp->b_flags &= ~B_INVAL;
313 nandfs_dirty_bufs_increment(fsdev);
314 DPRINTF(SYNC, ("%s: bp:%p\n", __func__, bp));
320 nandfs_add_segsum_block(struct nandfs_seginfo *seginfo, struct buf **newbp)
322 struct nandfs_device *fsdev;
327 if (!(seginfo->curseg) || seginfo->curseg->num_blocks <= 1) {
328 error = create_segment(seginfo);
330 nandfs_error("%s: error:%d when creating segment\n",
334 *newbp = TAILQ_FIRST(&seginfo->curseg->segsum);
338 fsdev = seginfo->fsdev;
339 blk = nandfs_block_to_dblock(fsdev, seginfo->curseg->start_block +
340 seginfo->curseg->segsum_blocks);
342 bp = getblk(fsdev->nd_devvp, blk, fsdev->nd_blocksize, 0, 0, 0);
344 bzero(bp->b_data, seginfo->fsdev->nd_blocksize);
345 bp->b_bufobj = &seginfo->fsdev->nd_devvp->v_bufobj;
346 bp->b_flags |= B_MANAGED;
348 TAILQ_INSERT_TAIL(&seginfo->curseg->segsum, bp,
349 b_cluster.cluster_entry);
350 seginfo->curseg->num_blocks--;
352 seginfo->curseg->segsum_blocks++;
353 seginfo->curseg->bytes_left = seginfo->fsdev->nd_blocksize;
354 seginfo->curseg->current_off = bp->b_data;
359 DPRINTF(SYNC, ("%s: bp %p\n", __func__, bp));
365 nandfs_add_blocks(struct nandfs_seginfo *seginfo, struct nandfs_node *node,
368 union nandfs_binfo *binfo;
372 if (!(seginfo->curseg) || !seginfo->curseg->num_blocks) {
373 error = create_segment(seginfo);
375 nandfs_error("%s: error:%d when creating segment\n",
381 if (seginfo->curseg->bytes_left < sizeof(union nandfs_binfo)) {
382 error = nandfs_add_segsum_block(seginfo, &seg_bp);
384 nandfs_error("%s: error:%d when adding segsum\n",
389 binfo = (union nandfs_binfo *)seginfo->curseg->current_off;
391 if (node->nn_ino != NANDFS_DAT_INO) {
392 binfo->bi_v.bi_blkoff = bp->b_lblkno;
393 binfo->bi_v.bi_ino = node->nn_ino;
395 binfo->bi_dat.bi_blkoff = bp->b_lblkno;
396 binfo->bi_dat.bi_ino = node->nn_ino;
397 if (NANDFS_IS_INDIRECT(bp))
398 binfo->bi_dat.bi_level = 1;
400 binfo->bi_dat.bi_level = 0;
404 seginfo->curseg->bytes_left -= sizeof(union nandfs_binfo);
405 seginfo->curseg->segsum_bytes += sizeof(union nandfs_binfo);
406 seginfo->curseg->current_off = (char *)binfo;
408 TAILQ_INSERT_TAIL(&seginfo->curseg->data, bp, b_cluster.cluster_entry);
410 seginfo->curseg->nbinfos++;
411 seginfo->curseg->nblocks++;
412 seginfo->curseg->num_blocks--;
415 DPRINTF(SYNC, ("%s: bp (%p) number %x (left %x)\n",
416 __func__, bp, seginfo->curseg->nblocks,
417 seginfo->curseg->num_blocks));
422 nandfs_iterate_dirty_buf(struct vnode *vp, struct nandfs_seginfo *seginfo,
425 struct buf *bp, *tbd;
427 struct nandfs_node *node;
433 ASSERT_VOP_ELOCKED(vp, __func__);
435 /* Iterate dirty data bufs */
436 TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, tbd) {
437 DPRINTF(SYNC, ("%s: vp (%p): bp (%p) with lblkno %jx ino %jx "
438 "add buf\n", __func__, vp, bp, bp->b_lblkno, node->nn_ino));
440 if (!(NANDFS_ISGATHERED(bp))) {
441 error = nandfs_bmap_update_dat(node,
442 nandfs_vblk_get(bp), bp);
446 nandfs_add_blocks(seginfo, node, bp);
454 nandfs_iterate_system_vnode(struct nandfs_node *node,
455 struct nandfs_seginfo *seginfo)
461 if (node->nn_ino != NANDFS_IFILE_INO)
466 nblocks = vp->v_bufobj.bo_dirty.bv_cnt;
467 DPRINTF(SYNC, ("%s: vp (%p): nblocks %x ino %jx\n",
468 __func__, vp, nblocks, node->nn_ino));
471 nandfs_iterate_dirty_buf(vp, seginfo, hold);
477 nandfs_iterate_dirty_vnodes(struct mount *mp, struct nandfs_seginfo *seginfo)
479 struct nandfs_node *nandfs_node;
480 struct vnode *vp, *mvp;
487 MNT_VNODE_FOREACH_ACTIVE(vp, mp, mvp) {
490 if (mp->mnt_syncer == vp || VOP_ISLOCKED(vp)) {
494 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK | LK_NOWAIT, td) != 0)
497 nandfs_node = VTON(vp);
498 if (nandfs_node->nn_flags & IN_MODIFIED) {
499 nandfs_node->nn_flags &= ~(IN_MODIFIED);
505 if (vp->v_bufobj.bo_dirty.bv_cnt) {
506 error = nandfs_iterate_dirty_buf(vp, seginfo, 0);
508 nandfs_error("%s: cannot iterate vnode:%p "
509 "err:%d\n", __func__, vp, error);
520 nandfs_node_update(nandfs_node);
527 nandfs_update_phys_block(struct nandfs_device *fsdev, struct buf *bp,
528 uint64_t phys_blknr, union nandfs_binfo *binfo)
530 struct nandfs_node *node, *dat;
537 new_blknr = nandfs_vblk_get(bp);
538 dat = fsdev->nd_dat_node;
540 DPRINTF(BMAP, ("%s: ino %#jx lblk %#jx: vblk %#jx -> %#jx\n",
541 __func__, (uintmax_t)node->nn_ino, (uintmax_t)bp->b_lblkno,
542 (uintmax_t)new_blknr, (uintmax_t)phys_blknr));
544 if (node->nn_ino != NANDFS_DAT_INO) {
545 KASSERT((new_blknr != 0), ("vblk for bp %p is 0", bp));
547 nandfs_vblock_assign(fsdev, new_blknr, phys_blknr);
548 binfo->bi_v.bi_vblocknr = new_blknr;
549 binfo->bi_v.bi_blkoff = bp->b_lblkno;
550 binfo->bi_v.bi_ino = node->nn_ino;
552 VOP_LOCK(NTOV(dat), LK_EXCLUSIVE);
553 error = nandfs_bmap_update_block(node, bp, phys_blknr);
555 nandfs_error("%s: error updating block:%jx for bp:%p\n",
556 __func__, (uintmax_t)phys_blknr, bp);
557 VOP_UNLOCK(NTOV(dat), 0);
560 VOP_UNLOCK(NTOV(dat), 0);
561 binfo->bi_dat.bi_blkoff = bp->b_lblkno;
562 binfo->bi_dat.bi_ino = node->nn_ino;
563 if (NANDFS_IS_INDIRECT(bp))
564 binfo->bi_dat.bi_level = 1;
566 binfo->bi_dat.bi_level = 0;
572 #define NBINFO(off) ((off) + sizeof(union nandfs_binfo))
574 nandfs_segment_assign_pblk(struct nandfs_segment *nfsseg)
576 struct nandfs_device *fsdev;
577 union nandfs_binfo *binfo;
578 struct buf *bp, *seg_bp;
580 uint32_t curr_off, blocksize;
583 fsdev = nfsseg->fsdev;
584 blocksize = fsdev->nd_blocksize;
586 blocknr = nfsseg->start_block + nfsseg->segsum_blocks;
587 seg_bp = TAILQ_FIRST(&nfsseg->segsum);
588 DPRINTF(SYNC, ("%s: seg:%p segsum bp:%p data:%p\n",
589 __func__, nfsseg, seg_bp, seg_bp->b_data));
591 binfo = (union nandfs_binfo *)(seg_bp->b_data +
592 sizeof(struct nandfs_segment_summary));
593 curr_off = sizeof(struct nandfs_segment_summary);
595 TAILQ_FOREACH(bp, &nfsseg->data, b_cluster.cluster_entry) {
596 KASSERT((bp->b_vp), ("bp %p has not vp", bp));
598 DPRINTF(BMAP, ("\n\n%s: assign buf %p for ino %#jx next %p\n",
599 __func__, bp, (uintmax_t)VTON(bp->b_vp)->nn_ino,
600 TAILQ_NEXT(bp, b_cluster.cluster_entry)));
602 if (NBINFO(curr_off) > blocksize) {
603 seg_bp = TAILQ_NEXT(seg_bp, b_cluster.cluster_entry);
604 binfo = (union nandfs_binfo *)seg_bp->b_data;
606 DPRINTF(SYNC, ("%s: next segsum %p data %p\n",
607 __func__, seg_bp, seg_bp->b_data));
610 error = nandfs_update_phys_block(fsdev, bp, blocknr, binfo);
612 nandfs_error("%s: err:%d when updatinng phys block:%jx"
613 " for bp:%p and binfo:%p\n", __func__, error,
614 (uintmax_t)blocknr, bp, binfo);
618 curr_off = NBINFO(curr_off);
627 nandfs_seginfo_assign_pblk(struct nandfs_seginfo *seginfo)
629 struct nandfs_segment *nfsseg;
632 LIST_FOREACH(nfsseg, &seginfo->seg_list, seg_link) {
633 error = nandfs_segment_assign_pblk(nfsseg);
641 static struct nandfs_segment_summary *
642 nandfs_fill_segsum(struct nandfs_segment *seg, int has_sr)
644 struct nandfs_segment_summary *ss;
645 struct nandfs_device *fsdev;
647 uint32_t rest, segsum_size, blocksize, crc_calc;
649 uint8_t *crc_area, crc_skip;
651 DPRINTF(SYNC, ("%s: seg %#jx nblocks %#x sumbytes %#x\n",
652 __func__, (uintmax_t) seg->seg_num,
653 seg->nblocks + seg->segsum_blocks,
658 flags = NANDFS_SS_LOGBGN | NANDFS_SS_LOGEND;
660 flags |= NANDFS_SS_SR;
662 bp = TAILQ_FIRST(&seg->segsum);
663 ss = (struct nandfs_segment_summary *) bp->b_data;
664 ss->ss_magic = NANDFS_SEGSUM_MAGIC;
665 ss->ss_bytes = sizeof(struct nandfs_segment_summary);
666 ss->ss_flags = flags;
667 ss->ss_seq = ++(fsdev->nd_seg_sequence);
668 ss->ss_create = fsdev->nd_ts.tv_sec;
669 nandfs_get_segment_range(fsdev, seg->seg_next, &ss->ss_next, NULL);
670 ss->ss_nblocks = seg->nblocks + seg->segsum_blocks;
671 ss->ss_nbinfos = seg->nbinfos;
672 ss->ss_sumbytes = seg->segsum_bytes;
674 crc_skip = sizeof(ss->ss_datasum) + sizeof(ss->ss_sumsum);
675 blocksize = seg->fsdev->nd_blocksize;
677 segsum_size = seg->segsum_bytes - crc_skip;
678 rest = min(seg->segsum_bytes, blocksize) - crc_skip;
679 crc_area = (uint8_t *)ss + crc_skip;
681 while (segsum_size > 0) {
682 crc_calc = crc32_raw(crc_area, rest, crc_calc);
686 bp = TAILQ_NEXT(bp, b_cluster.cluster_entry);
687 crc_area = (uint8_t *)bp->b_data;
688 rest = segsum_size <= blocksize ? segsum_size : blocksize;
690 ss->ss_sumsum = crc_calc ^ ~0U;
697 nandfs_save_buf(struct buf *bp, uint64_t blocknr, struct nandfs_device *fsdev)
702 bo = &fsdev->nd_devvp->v_bufobj;
704 bp->b_blkno = nandfs_block_to_dblock(fsdev, blocknr);
705 bp->b_iooffset = dbtob(bp->b_blkno);
707 KASSERT(bp->b_bufobj != NULL, ("no bufobj for %p", bp));
708 if (bp->b_bufobj != bo) {
709 BO_LOCK(bp->b_bufobj);
710 BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK,
711 BO_LOCKPTR(bp->b_bufobj));
712 KASSERT(BUF_ISLOCKED(bp), ("Problem with locking buffer"));
715 DPRINTF(SYNC, ("%s: buf: %p offset %#jx blk %#jx size %#x\n",
716 __func__, bp, (uintmax_t)bp->b_offset, (uintmax_t)blocknr,
717 fsdev->nd_blocksize));
720 nandfs_buf_clear(bp, 0xffffffff);
721 bp->b_flags &= ~(B_ASYNC|B_INVAL|B_MANAGED);
724 nandfs_error("%s: error:%d when writing buffer:%p\n",
725 __func__, error, bp);
732 nandfs_clean_buf(struct nandfs_device *fsdev, struct buf *bp)
735 DPRINTF(SYNC, ("%s: buf: %p\n", __func__, bp));
738 nandfs_buf_clear(bp, 0xffffffff);
739 bp->b_flags &= ~(B_ASYNC|B_INVAL|B_MANAGED);
740 nandfs_undirty_buf_fsdev(fsdev, bp);
744 nandfs_clean_segblocks(struct nandfs_segment *seg, uint8_t unlock)
746 struct nandfs_device *fsdev = seg->fsdev;
747 struct nandfs_segment *next_seg;
748 struct buf *bp, *tbp, *next_bp;
749 struct vnode *vp, *next_vp;
751 VOP_LOCK(fsdev->nd_devvp, LK_EXCLUSIVE);
752 TAILQ_FOREACH_SAFE(bp, &seg->segsum, b_cluster.cluster_entry, tbp) {
753 TAILQ_REMOVE(&seg->segsum, bp, b_cluster.cluster_entry);
754 nandfs_clean_buf(fsdev, bp);
757 TAILQ_FOREACH_SAFE(bp, &seg->data, b_cluster.cluster_entry, tbp) {
758 TAILQ_REMOVE(&seg->data, bp, b_cluster.cluster_entry);
761 * If bp is not super-root and vnode is not currently
766 next_bp = TAILQ_NEXT(bp, b_cluster.cluster_entry);
768 next_seg = LIST_NEXT(seg, seg_link);
770 next_bp = TAILQ_FIRST(&next_seg->data);
774 next_vp = next_bp->b_vp;
776 nandfs_clean_buf(fsdev, bp);
778 if (unlock && vp != NULL && next_vp != vp &&
779 !NANDFS_SYS_NODE(VTON(vp)->nn_ino))
782 nandfs_dirty_bufs_decrement(fsdev);
785 VOP_UNLOCK(fsdev->nd_devvp, 0);
789 nandfs_save_segblocks(struct nandfs_segment *seg, uint8_t unlock)
791 struct nandfs_device *fsdev = seg->fsdev;
792 struct nandfs_segment *next_seg;
793 struct buf *bp, *tbp, *next_bp;
794 struct vnode *vp, *next_vp;
799 VOP_LOCK(fsdev->nd_devvp, LK_EXCLUSIVE);
800 TAILQ_FOREACH_SAFE(bp, &seg->segsum, b_cluster.cluster_entry, tbp) {
801 TAILQ_REMOVE(&seg->segsum, bp, b_cluster.cluster_entry);
802 blocknr = seg->start_block + i;
803 error = nandfs_save_buf(bp, blocknr, fsdev);
805 nandfs_error("%s: error saving buf: %p blocknr:%jx\n",
806 __func__, bp, (uintmax_t)blocknr);
813 TAILQ_FOREACH_SAFE(bp, &seg->data, b_cluster.cluster_entry, tbp) {
814 TAILQ_REMOVE(&seg->data, bp, b_cluster.cluster_entry);
816 blocknr = seg->start_block + seg->segsum_blocks + i;
818 * If bp is not super-root and vnode is not currently
823 next_bp = TAILQ_NEXT(bp, b_cluster.cluster_entry);
825 next_seg = LIST_NEXT(seg, seg_link);
827 next_bp = TAILQ_FIRST(&next_seg->data);
831 next_vp = next_bp->b_vp;
833 error = nandfs_save_buf(bp, blocknr, fsdev);
835 nandfs_error("%s: error saving buf: %p blknr: %jx\n",
836 __func__, bp, (uintmax_t)blocknr);
837 if (unlock && vp != NULL && next_vp != vp &&
838 !NANDFS_SYS_NODE(VTON(vp)->nn_ino))
843 if (unlock && vp != NULL && next_vp != vp &&
844 !NANDFS_SYS_NODE(VTON(vp)->nn_ino))
848 nandfs_dirty_bufs_decrement(fsdev);
852 nandfs_clean_segblocks(seg, unlock);
853 VOP_UNLOCK(fsdev->nd_devvp, 0);
857 VOP_UNLOCK(fsdev->nd_devvp, 0);
863 clean_seginfo(struct nandfs_seginfo *seginfo, uint8_t unlock)
865 struct nandfs_segment *seg;
867 DPRINTF(SYNC, ("%s: seginfo %p\n", __func__, seginfo));
869 LIST_FOREACH(seg, &seginfo->seg_list, seg_link) {
870 nandfs_clean_segblocks(seg, unlock);
875 save_seginfo(struct nandfs_seginfo *seginfo, uint8_t unlock)
877 struct nandfs_segment *seg;
878 struct nandfs_device *fsdev;
879 struct nandfs_segment_summary *ss;
882 fsdev = seginfo->fsdev;
884 DPRINTF(SYNC, ("%s: seginfo %p\n", __func__, seginfo));
886 LIST_FOREACH(seg, &seginfo->seg_list, seg_link) {
887 if (LIST_NEXT(seg, seg_link)) {
888 nandfs_fill_segsum(seg, 0);
889 error = nandfs_save_segblocks(seg, unlock);
891 nandfs_error("%s: error:%d saving seg:%p\n",
892 __func__, error, seg);
896 ss = nandfs_fill_segsum(seg, 1);
897 fsdev->nd_last_segsum = *ss;
898 error = nandfs_save_segblocks(seg, unlock);
900 nandfs_error("%s: error:%d saving seg:%p\n",
901 __func__, error, seg);
904 fsdev->nd_last_cno++;
905 fsdev->nd_last_pseg = seg->start_block;
910 clean_seginfo(seginfo, unlock);
915 nandfs_invalidate_bufs(struct nandfs_device *fsdev, uint64_t segno)
918 struct buf *bp, *tbd;
921 nandfs_get_segment_range(fsdev, segno, &start, &end);
923 bo = &NTOV(fsdev->nd_gc_node)->v_bufobj;
927 TAILQ_FOREACH_SAFE(bp, &bo->bo_clean.bv_hd, b_bobufs, tbd) {
928 if (!(bp->b_lblkno >= start && bp->b_lblkno <= end))
931 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL))
932 goto restart_locked_gc;
935 bp->b_flags |= (B_INVAL | B_RELBUF);
936 bp->b_flags &= ~(B_ASYNC | B_MANAGED);
944 /* Process segments marks to free by cleaner */
946 nandfs_process_segments(struct nandfs_device *fsdev)
948 uint64_t saved_segment;
951 if (fsdev->nd_free_base) {
952 saved_segment = nandfs_get_segnum_of_block(fsdev,
953 fsdev->nd_super.s_last_pseg);
954 for (i = 0; i < fsdev->nd_free_count; i++) {
955 if (fsdev->nd_free_base[i] == NANDFS_NOSEGMENT)
957 /* Update superblock if clearing segment point by it */
958 if (fsdev->nd_free_base[i] == saved_segment) {
959 nandfs_write_superblock(fsdev);
960 saved_segment = nandfs_get_segnum_of_block(
961 fsdev, fsdev->nd_super.s_last_pseg);
963 nandfs_invalidate_bufs(fsdev, fsdev->nd_free_base[i]);
964 nandfs_clear_segment(fsdev, fsdev->nd_free_base[i]);
967 free(fsdev->nd_free_base, M_NANDFSTEMP);
968 fsdev->nd_free_base = NULL;
969 fsdev->nd_free_count = 0;
973 /* Collect and write dirty buffers */
975 nandfs_sync_file(struct vnode *vp)
977 struct nandfs_device *fsdev;
978 struct nandfs_node *nandfs_node;
979 struct nandfsmount *nmp;
980 struct nandfs_node *dat, *su, *ifile, *cp;
981 struct nandfs_seginfo *seginfo = NULL;
982 struct nandfs_segment *seg;
986 ASSERT_VOP_LOCKED(vp, __func__);
987 DPRINTF(SYNC, ("%s: START\n", __func__));
990 nmp = VFSTONANDFS(vp->v_mount);
991 fsdev = nmp->nm_nandfsdev;
993 dat = fsdev->nd_dat_node;
994 su = fsdev->nd_su_node;
995 cp = fsdev->nd_cp_node;
996 ifile = nmp->nm_ifile_node;
998 NANDFS_WRITEASSERT(fsdev);
999 if (lockmgr(&fsdev->nd_seg_const, LK_UPGRADE, NULL) != 0) {
1000 DPRINTF(SYNC, ("%s: lost shared lock\n", __func__));
1001 if (lockmgr(&fsdev->nd_seg_const, LK_EXCLUSIVE, NULL) != 0)
1002 panic("couldn't lock exclusive");
1004 DPRINTF(SYNC, ("%s: got lock\n", __func__));
1006 VOP_LOCK(NTOV(su), LK_EXCLUSIVE);
1007 create_seginfo(fsdev, &seginfo);
1011 nandfs_node = VTON(vp);
1012 if (nandfs_node->nn_flags & IN_MODIFIED) {
1013 nandfs_node->nn_flags &= ~(IN_MODIFIED);
1017 if (vp->v_bufobj.bo_dirty.bv_cnt) {
1018 error = nandfs_iterate_dirty_buf(vp, seginfo, 0);
1020 clean_seginfo(seginfo, 0);
1021 delete_seginfo(seginfo);
1022 VOP_UNLOCK(NTOV(su), 0);
1023 lockmgr(&fsdev->nd_seg_const, LK_DOWNGRADE, NULL);
1024 nandfs_error("%s: err:%d iterating dirty bufs vp:%p",
1025 __func__, error, vp);
1032 VOP_LOCK(NTOV(ifile), LK_EXCLUSIVE);
1033 error = nandfs_node_update(nandfs_node);
1035 clean_seginfo(seginfo, 0);
1036 delete_seginfo(seginfo);
1037 VOP_UNLOCK(NTOV(ifile), 0);
1038 VOP_UNLOCK(NTOV(su), 0);
1039 lockmgr(&fsdev->nd_seg_const, LK_DOWNGRADE, NULL);
1040 nandfs_error("%s: err:%d updating vp:%p",
1041 __func__, error, vp);
1044 VOP_UNLOCK(NTOV(ifile), 0);
1048 if (seginfo->blocks) {
1049 VOP_LOCK(NTOV(cp), LK_EXCLUSIVE);
1051 /* Create new checkpoint */
1052 error = nandfs_get_checkpoint(fsdev, cp, fsdev->nd_last_cno + 1);
1054 clean_seginfo(seginfo, 0);
1055 delete_seginfo(seginfo);
1056 VOP_UNLOCK(NTOV(cp), 0);
1057 VOP_UNLOCK(NTOV(su), 0);
1058 lockmgr(&fsdev->nd_seg_const, LK_DOWNGRADE, NULL);
1059 nandfs_error("%s: err:%d getting cp:%jx",
1060 __func__, error, fsdev->nd_last_cno + 1);
1064 /* Reiterate all blocks and assign physical block number */
1065 nandfs_seginfo_assign_pblk(seginfo);
1067 /* Fill checkpoint data */
1068 error = nandfs_set_checkpoint(fsdev, cp, fsdev->nd_last_cno + 1,
1069 &ifile->nn_inode, seginfo->blocks);
1071 clean_seginfo(seginfo, 0);
1072 delete_seginfo(seginfo);
1073 VOP_UNLOCK(NTOV(cp), 0);
1074 VOP_UNLOCK(NTOV(su), 0);
1075 lockmgr(&fsdev->nd_seg_const, LK_DOWNGRADE, NULL);
1076 nandfs_error("%s: err:%d setting cp:%jx",
1077 __func__, error, fsdev->nd_last_cno + 1);
1081 VOP_UNLOCK(NTOV(cp), 0);
1082 LIST_FOREACH(seg, &seginfo->seg_list, seg_link)
1083 nandfs_update_segment(fsdev, seg->seg_num,
1084 seg->nblocks + seg->segsum_blocks);
1086 VOP_LOCK(NTOV(dat), LK_EXCLUSIVE);
1087 error = save_seginfo(seginfo, 0);
1089 clean_seginfo(seginfo, 0);
1090 delete_seginfo(seginfo);
1091 VOP_UNLOCK(NTOV(dat), 0);
1092 VOP_UNLOCK(NTOV(su), 0);
1093 lockmgr(&fsdev->nd_seg_const, LK_DOWNGRADE, NULL);
1094 nandfs_error("%s: err:%d updating seg",
1098 VOP_UNLOCK(NTOV(dat), 0);
1101 VOP_UNLOCK(NTOV(su), 0);
1103 delete_seginfo(seginfo);
1104 lockmgr(&fsdev->nd_seg_const, LK_DOWNGRADE, NULL);
1106 if (cno_changed && !error) {
1107 if (nandfs_cps_between_sblocks != 0 &&
1108 fsdev->nd_last_cno % nandfs_cps_between_sblocks == 0)
1109 nandfs_write_superblock(fsdev);
1112 ASSERT_VOP_LOCKED(vp, __func__);
1113 DPRINTF(SYNC, ("%s: END error %d\n", __func__, error));
1118 nandfs_segment_constructor(struct nandfsmount *nmp, int flags)
1120 struct nandfs_device *fsdev;
1121 struct nandfs_seginfo *seginfo = NULL;
1122 struct nandfs_segment *seg;
1123 struct nandfs_node *dat, *su, *ifile, *cp, *gc;
1124 int cno_changed, error;
1126 DPRINTF(SYNC, ("%s: START\n", __func__));
1127 fsdev = nmp->nm_nandfsdev;
1129 lockmgr(&fsdev->nd_seg_const, LK_EXCLUSIVE, NULL);
1130 DPRINTF(SYNC, ("%s: git lock\n", __func__));
1132 create_seginfo(fsdev, &seginfo);
1134 dat = fsdev->nd_dat_node;
1135 su = fsdev->nd_su_node;
1136 cp = fsdev->nd_cp_node;
1137 gc = fsdev->nd_gc_node;
1138 ifile = nmp->nm_ifile_node;
1140 VOP_LOCK(NTOV(su), LK_EXCLUSIVE);
1141 VOP_LOCK(NTOV(ifile), LK_EXCLUSIVE);
1142 VOP_LOCK(NTOV(gc), LK_EXCLUSIVE);
1143 VOP_LOCK(NTOV(cp), LK_EXCLUSIVE);
1145 nandfs_iterate_system_vnode(gc, seginfo);
1146 nandfs_iterate_dirty_vnodes(nmp->nm_vfs_mountp, seginfo);
1147 nandfs_iterate_system_vnode(ifile, seginfo);
1148 nandfs_iterate_system_vnode(su, seginfo);
1151 if (seginfo->blocks || flags) {
1153 /* Create new checkpoint */
1154 error = nandfs_get_checkpoint(fsdev, cp, fsdev->nd_last_cno + 1);
1156 clean_seginfo(seginfo, 0);
1157 delete_seginfo(seginfo);
1161 /* Collect blocks from system files */
1162 nandfs_iterate_system_vnode(cp, seginfo);
1163 nandfs_iterate_system_vnode(su, seginfo);
1164 VOP_LOCK(NTOV(dat), LK_EXCLUSIVE);
1165 nandfs_iterate_system_vnode(dat, seginfo);
1166 VOP_UNLOCK(NTOV(dat), 0);
1168 seginfo->reiterate = 0;
1169 nandfs_iterate_system_vnode(su, seginfo);
1170 VOP_LOCK(NTOV(dat), LK_EXCLUSIVE);
1171 nandfs_iterate_system_vnode(dat, seginfo);
1172 VOP_UNLOCK(NTOV(dat), 0);
1173 if (seginfo->reiterate)
1175 if (!(seginfo->curseg) || !seginfo->curseg->num_blocks) {
1176 error = create_segment(seginfo);
1178 clean_seginfo(seginfo, 0);
1179 delete_seginfo(seginfo);
1185 /* Reiterate all blocks and assign physical block number */
1186 nandfs_seginfo_assign_pblk(seginfo);
1188 /* Fill superroot */
1189 error = nandfs_add_superroot(seginfo);
1191 clean_seginfo(seginfo, 0);
1192 delete_seginfo(seginfo);
1195 KASSERT(!(seginfo->reiterate), ("reiteration after superroot"));
1197 /* Fill checkpoint data */
1198 nandfs_set_checkpoint(fsdev, cp, fsdev->nd_last_cno + 1,
1199 &ifile->nn_inode, seginfo->blocks);
1201 LIST_FOREACH(seg, &seginfo->seg_list, seg_link)
1202 nandfs_update_segment(fsdev, seg->seg_num,
1203 seg->nblocks + seg->segsum_blocks);
1205 VOP_LOCK(NTOV(dat), LK_EXCLUSIVE);
1206 error = save_seginfo(seginfo, 1);
1208 clean_seginfo(seginfo, 1);
1209 delete_seginfo(seginfo);
1212 VOP_UNLOCK(NTOV(dat), 0);
1215 VOP_UNLOCK(NTOV(cp), 0);
1216 VOP_UNLOCK(NTOV(gc), 0);
1217 VOP_UNLOCK(NTOV(ifile), 0);
1219 nandfs_process_segments(fsdev);
1221 VOP_UNLOCK(NTOV(su), 0);
1223 delete_seginfo(seginfo);
1226 * XXX: a hack, will go away soon
1228 if ((NTOV(dat)->v_bufobj.bo_dirty.bv_cnt != 0 ||
1229 NTOV(cp)->v_bufobj.bo_dirty.bv_cnt != 0 ||
1230 NTOV(gc)->v_bufobj.bo_dirty.bv_cnt != 0 ||
1231 NTOV(ifile)->v_bufobj.bo_dirty.bv_cnt != 0 ||
1232 NTOV(su)->v_bufobj.bo_dirty.bv_cnt != 0) &&
1233 (flags & NANDFS_UMOUNT)) {
1234 DPRINTF(SYNC, ("%s: RERUN\n", __func__));
1238 MPASS(fsdev->nd_free_base == NULL);
1240 lockmgr(&fsdev->nd_seg_const, LK_RELEASE, NULL);
1243 if ((nandfs_cps_between_sblocks != 0 &&
1244 fsdev->nd_last_cno % nandfs_cps_between_sblocks == 0) ||
1245 flags & NANDFS_UMOUNT)
1246 nandfs_write_superblock(fsdev);
1249 DPRINTF(SYNC, ("%s: END\n", __func__));
1252 VOP_UNLOCK(NTOV(dat), 0);
1254 VOP_UNLOCK(NTOV(cp), 0);
1255 VOP_UNLOCK(NTOV(gc), 0);
1256 VOP_UNLOCK(NTOV(ifile), 0);
1257 VOP_UNLOCK(NTOV(su), 0);
1258 lockmgr(&fsdev->nd_seg_const, LK_RELEASE, NULL);
1265 * Show details about the given NANDFS mount point.
1267 DB_SHOW_COMMAND(nandfs, db_show_nandfs)
1270 struct nandfs_device *nffsdev;
1271 struct nandfs_segment *seg;
1272 struct nandfsmount *nmp;
1277 db_printf("\nUsage: show nandfs <mount_addr>\n");
1281 mp = (struct mount *)addr;
1282 db_printf("%p %s on %s (%s)\n", mp, mp->mnt_stat.f_mntfromname,
1283 mp->mnt_stat.f_mntonname, mp->mnt_stat.f_fstypename);
1286 nmp = (struct nandfsmount *)(mp->mnt_data);
1287 nffsdev = nmp->nm_nandfsdev;
1288 db_printf("dev vnode:%p\n", nffsdev->nd_devvp);
1289 db_printf("blocksize:%jx last cno:%jx last pseg:%jx seg num:%jx\n",
1290 (uintmax_t)nffsdev->nd_blocksize, (uintmax_t)nffsdev->nd_last_cno,
1291 (uintmax_t)nffsdev->nd_last_pseg, (uintmax_t)nffsdev->nd_seg_num);
1292 db_printf("system nodes: dat:%p cp:%p su:%p ifile:%p gc:%p\n",
1293 nffsdev->nd_dat_node, nffsdev->nd_cp_node, nffsdev->nd_su_node,
1294 nmp->nm_ifile_node, nffsdev->nd_gc_node);
1296 if (nffsdev->nd_seginfo != NULL) {
1297 LIST_FOREACH(seg, &nffsdev->nd_seginfo->seg_list, seg_link) {
1298 db_printf("seg: %p\n", seg);
1299 TAILQ_FOREACH(bp, &seg->segsum,
1300 b_cluster.cluster_entry)
1301 db_printf("segbp %p\n", bp);
1302 TAILQ_FOREACH(bp, &seg->data,
1303 b_cluster.cluster_entry) {
1305 db_printf("bp:%p bp->b_vp:%p ino:%jx\n", bp, vp,
1306 (uintmax_t)(vp ? VTON(vp)->nn_ino : 0));