2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2010-2012 Semihalf.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <sys/cdefs.h>
30 __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/sysctl.h>
42 #include <sys/vnode.h>
47 #include <vm/vm_param.h>
48 #include <vm/vm_kern.h>
49 #include <vm/vm_page.h>
51 #include <geom/geom.h>
52 #include <geom/geom_vfs.h>
54 #include <fs/nandfs/nandfs_mount.h>
55 #include <fs/nandfs/nandfs.h>
56 #include <fs/nandfs/nandfs_subr.h>
58 #define SU_USAGE_OFF(bp, offset) \
59 ((struct nandfs_segment_usage *)((bp)->b_data + offset))
62 nandfs_seg_usage_blk_offset(struct nandfs_device *fsdev, uint64_t seg,
63 uint64_t *blk, uint64_t *offset)
68 seg_size = fsdev->nd_fsdata.f_segment_usage_size;
70 off = roundup(sizeof(struct nandfs_sufile_header), seg_size);
71 off += (seg * seg_size);
73 *blk = off / fsdev->nd_blocksize;
74 *offset = off % fsdev->nd_blocksize;
78 /* Alloc new segment */
80 nandfs_alloc_segment(struct nandfs_device *fsdev, uint64_t *seg)
82 struct nandfs_node *su_node;
83 struct nandfs_sufile_header *su_header;
84 struct nandfs_segment_usage *su_usage;
85 struct buf *bp_header, *bp;
86 uint64_t blk, vblk, offset, i, rest, nsegments;
90 seg_size = fsdev->nd_fsdata.f_segment_usage_size;
91 nsegments = fsdev->nd_fsdata.f_nsegments;
93 su_node = fsdev->nd_su_node;
94 ASSERT_VOP_LOCKED(NTOV(su_node), __func__);
96 /* Read header buffer */
97 error = nandfs_bread(su_node, 0, NOCRED, 0, &bp_header);
103 su_header = (struct nandfs_sufile_header *)bp_header->b_data;
105 /* Get last allocated segment */
106 i = su_header->sh_last_alloc + 1;
111 nandfs_seg_usage_blk_offset(fsdev, i, &blk, &offset);
113 error = nandfs_bmap_lookup(su_node, blk, &vblk);
115 nandfs_error("%s: cannot find vblk for blk "
116 "blk:%jx\n", __func__, blk);
120 error = nandfs_bread(su_node, blk, NOCRED, 0,
123 error = nandfs_bcreate(su_node, blk, NOCRED, 0,
126 nandfs_error("%s: cannot create/read "
127 "vblk:%jx\n", __func__, vblk);
133 su_usage = SU_USAGE_OFF(bp, offset);
135 su_usage = SU_USAGE_OFF(bp_header, offset);
139 rest = (fsdev->nd_blocksize - offset) / seg_size;
140 /* Go through all su usage in block */
142 /* When last check start from beginning */
146 if (!su_usage->su_flags) {
147 su_usage->su_flags = 1;
154 /* If all checked return error */
155 if (i == su_header->sh_last_alloc) {
156 DPRINTF(SEG, ("%s: cannot allocate segment \n",
166 /* Otherwise read another block */
169 if (i == nsegments) {
180 su_header->sh_last_alloc = i;
181 su_header->sh_ncleansegs--;
182 su_header->sh_ndirtysegs++;
184 fsdev->nd_super.s_free_blocks_count = su_header->sh_ncleansegs *
185 fsdev->nd_fsdata.f_blocks_per_segment;
186 fsdev->nd_clean_segs--;
189 * It is mostly called from syncer() so we want to force
192 error = nandfs_dirty_buf(bp_header, 1);
194 if (bp && bp != bp_header)
198 if (bp && bp != bp_header)
199 nandfs_dirty_buf(bp, 1);
201 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)i));
206 DPRINTF(SEG, ("%s: failed\n", __func__));
212 * Make buffer dirty, it will be updated soon but first it need to be
213 * gathered by syncer.
216 nandfs_touch_segment(struct nandfs_device *fsdev, uint64_t seg)
218 struct nandfs_node *su_node;
220 uint64_t blk, offset;
223 su_node = fsdev->nd_su_node;
224 ASSERT_VOP_LOCKED(NTOV(su_node), __func__);
226 nandfs_seg_usage_blk_offset(fsdev, seg, &blk, &offset);
228 error = nandfs_bread(su_node, blk, NOCRED, 0, &bp);
231 nandfs_error("%s: cannot preallocate new segment\n", __func__);
234 nandfs_dirty_buf(bp, 1);
236 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)seg));
240 /* Update block count of segment */
242 nandfs_update_segment(struct nandfs_device *fsdev, uint64_t seg, uint32_t nblks)
244 struct nandfs_node *su_node;
245 struct nandfs_segment_usage *su_usage;
247 uint64_t blk, offset;
250 su_node = fsdev->nd_su_node;
251 ASSERT_VOP_LOCKED(NTOV(su_node), __func__);
253 nandfs_seg_usage_blk_offset(fsdev, seg, &blk, &offset);
255 error = nandfs_bread(su_node, blk, NOCRED, 0, &bp);
257 nandfs_error("%s: read block:%jx to update\n",
263 su_usage = SU_USAGE_OFF(bp, offset);
264 su_usage->su_lastmod = fsdev->nd_ts.tv_sec;
265 su_usage->su_flags = NANDFS_SEGMENT_USAGE_DIRTY;
266 su_usage->su_nblocks += nblks;
268 DPRINTF(SEG, ("%s: seg:%#jx inc:%#x cur:%#x\n", __func__,
269 (uintmax_t)seg, nblks, su_usage->su_nblocks));
271 nandfs_dirty_buf(bp, 1);
276 /* Make segment free */
278 nandfs_free_segment(struct nandfs_device *fsdev, uint64_t seg)
280 struct nandfs_node *su_node;
281 struct nandfs_sufile_header *su_header;
282 struct nandfs_segment_usage *su_usage;
283 struct buf *bp_header, *bp;
284 uint64_t blk, offset;
287 su_node = fsdev->nd_su_node;
288 ASSERT_VOP_LOCKED(NTOV(su_node), __func__);
291 error = nandfs_bread(su_node, 0, NOCRED, 0, &bp_header);
297 su_header = (struct nandfs_sufile_header *)bp_header->b_data;
298 nandfs_seg_usage_blk_offset(fsdev, seg, &blk, &offset);
300 /* Read su usage block if other than su header block */
302 error = nandfs_bread(su_node, blk, NOCRED, 0, &bp);
311 /* Reset su usage data */
312 su_usage = SU_USAGE_OFF(bp, offset);
313 su_usage->su_lastmod = fsdev->nd_ts.tv_sec;
314 su_usage->su_nblocks = 0;
315 su_usage->su_flags = 0;
317 /* Update clean/dirty counter in header */
318 su_header->sh_ncleansegs++;
319 su_header->sh_ndirtysegs--;
322 * Make buffers dirty, called by cleaner
323 * so force dirty even if no much space left
326 nandfs_dirty_buf(bp_header, 1);
328 nandfs_dirty_buf(bp, 1);
330 /* Update free block count */
331 fsdev->nd_super.s_free_blocks_count = su_header->sh_ncleansegs *
332 fsdev->nd_fsdata.f_blocks_per_segment;
333 fsdev->nd_clean_segs++;
335 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)seg));
341 nandfs_bad_segment(struct nandfs_device *fsdev, uint64_t seg)
343 struct nandfs_node *su_node;
344 struct nandfs_segment_usage *su_usage;
346 uint64_t blk, offset;
349 su_node = fsdev->nd_su_node;
350 ASSERT_VOP_LOCKED(NTOV(su_node), __func__);
352 nandfs_seg_usage_blk_offset(fsdev, seg, &blk, &offset);
354 error = nandfs_bread(su_node, blk, NOCRED, 0, &bp);
360 su_usage = SU_USAGE_OFF(bp, offset);
361 su_usage->su_lastmod = fsdev->nd_ts.tv_sec;
362 su_usage->su_flags = NANDFS_SEGMENT_USAGE_ERROR;
364 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)seg));
366 nandfs_dirty_buf(bp, 1);
372 nandfs_markgc_segment(struct nandfs_device *fsdev, uint64_t seg)
374 struct nandfs_node *su_node;
375 struct nandfs_segment_usage *su_usage;
377 uint64_t blk, offset;
380 su_node = fsdev->nd_su_node;
382 VOP_LOCK(NTOV(su_node), LK_EXCLUSIVE);
384 nandfs_seg_usage_blk_offset(fsdev, seg, &blk, &offset);
386 error = nandfs_bread(su_node, blk, NOCRED, 0, &bp);
389 VOP_UNLOCK(NTOV(su_node), 0);
393 su_usage = SU_USAGE_OFF(bp, offset);
394 MPASS((su_usage->su_flags & NANDFS_SEGMENT_USAGE_GC) == 0);
395 su_usage->su_flags |= NANDFS_SEGMENT_USAGE_GC;
398 VOP_UNLOCK(NTOV(su_node), 0);
400 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)seg));
406 nandfs_clear_segment(struct nandfs_device *fsdev, uint64_t seg)
408 uint64_t offset, segsize;
412 bps = fsdev->nd_fsdata.f_blocks_per_segment;
413 bsize = fsdev->nd_blocksize;
414 segsize = bsize * bps;
415 nandfs_get_segment_range(fsdev, seg, &offset, NULL);
418 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)seg));
420 /* Erase it and mark it bad when fail */
421 if (nandfs_erase(fsdev, offset, segsize))
422 error = nandfs_bad_segment(fsdev, seg);
428 error = nandfs_free_segment(fsdev, seg);
434 nandfs_get_seg_stat(struct nandfs_device *nandfsdev,
435 struct nandfs_seg_stat *nss)
437 struct nandfs_sufile_header *suhdr;
438 struct nandfs_node *su_node;
442 su_node = nandfsdev->nd_su_node;
444 NANDFS_WRITELOCK(nandfsdev);
445 VOP_LOCK(NTOV(su_node), LK_SHARED);
446 err = nandfs_bread(nandfsdev->nd_su_node, 0, NOCRED, 0, &bp);
449 VOP_UNLOCK(NTOV(su_node), 0);
450 NANDFS_WRITEUNLOCK(nandfsdev);
454 suhdr = (struct nandfs_sufile_header *)bp->b_data;
455 nss->nss_nsegs = nandfsdev->nd_fsdata.f_nsegments;
456 nss->nss_ncleansegs = suhdr->sh_ncleansegs;
457 nss->nss_ndirtysegs = suhdr->sh_ndirtysegs;
459 nss->nss_nongc_ctime = nandfsdev->nd_ts.tv_sec;
460 nss->nss_prot_seq = nandfsdev->nd_seg_sequence;
463 VOP_UNLOCK(NTOV(su_node), 0);
465 NANDFS_WRITEUNLOCK(nandfsdev);
471 nandfs_get_segment_info_ioctl(struct nandfs_device *fsdev,
472 struct nandfs_argv *nargv)
474 struct nandfs_suinfo *nsi;
477 if (nargv->nv_nmembs > NANDFS_SEGMENTS_MAX)
480 nsi = malloc(sizeof(struct nandfs_suinfo) * nargv->nv_nmembs,
481 M_NANDFSTEMP, M_WAITOK | M_ZERO);
483 error = nandfs_get_segment_info(fsdev, nsi, nargv->nv_nmembs,
487 error = copyout(nsi, (void *)(uintptr_t)nargv->nv_base,
488 sizeof(struct nandfs_suinfo) * nargv->nv_nmembs);
490 free(nsi, M_NANDFSTEMP);
495 nandfs_get_segment_info(struct nandfs_device *fsdev, struct nandfs_suinfo *nsi,
496 uint32_t nmembs, uint64_t segment)
499 return (nandfs_get_segment_info_filter(fsdev, nsi, nmembs, segment,
504 nandfs_get_segment_info_filter(struct nandfs_device *fsdev,
505 struct nandfs_suinfo *nsi, uint32_t nmembs, uint64_t segment,
506 uint64_t *nsegs, uint32_t filter, uint32_t nfilter)
508 struct nandfs_segment_usage *su;
509 struct nandfs_node *su_node;
511 uint64_t curr, blocknr, blockoff, i;
517 lockmgr(&fsdev->nd_seg_const, LK_EXCLUSIVE, NULL);
518 su_node = fsdev->nd_su_node;
520 VOP_LOCK(NTOV(su_node), LK_SHARED);
525 for (i = 0; i < nmembs; segment++) {
526 if (segment == fsdev->nd_fsdata.f_nsegments)
529 nandfs_seg_usage_blk_offset(fsdev, segment, &blocknr,
532 if (i == 0 || curr != blocknr) {
535 err = nandfs_bread(su_node, blocknr, NOCRED,
543 su = SU_USAGE_OFF(bp, blockoff);
544 flags = su->su_flags;
545 if (segment == fsdev->nd_seg_num ||
546 segment == fsdev->nd_next_seg_num)
547 flags |= NANDFS_SEGMENT_USAGE_ACTIVE;
549 if (nfilter != 0 && (flags & nfilter) != 0)
551 if (filter != 0 && (flags & filter) == 0)
554 nsi->nsi_num = segment;
555 nsi->nsi_lastmod = su->su_lastmod;
556 nsi->nsi_blocks = su->su_nblocks;
557 nsi->nsi_flags = flags;
567 VOP_UNLOCK(NTOV(su_node), 0);
568 lockmgr(&fsdev->nd_seg_const, LK_RELEASE, NULL);