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 <fs/nandfs/nandfs_mount.h>
52 #include <fs/nandfs/nandfs.h>
53 #include <fs/nandfs/nandfs_subr.h>
56 nandfs_vblock_alloc(struct nandfs_device *nandfsdev, nandfs_daddr_t *vblock)
58 struct nandfs_node *dat;
59 struct nandfs_mdt *mdt;
60 struct nandfs_alloc_request req;
61 struct nandfs_dat_entry *dat_entry;
66 dat = nandfsdev->nd_dat_node;
67 mdt = &nandfsdev->nd_dat_mdt;
68 start = nandfsdev->nd_last_cno + 1;
70 locked = NANDFS_VOP_ISLOCKED(NTOV(dat));
72 VOP_LOCK(NTOV(dat), LK_EXCLUSIVE);
75 /* Alloc vblock number */
76 error = nandfs_find_free_entry(mdt, dat, &req);
78 nandfs_error("%s: cannot find free vblk entry\n",
81 VOP_UNLOCK(NTOV(dat), 0);
85 /* Read/create buffer */
86 error = nandfs_get_entry_block(mdt, dat, &req, &entry, 1);
88 nandfs_error("%s: cannot get free vblk entry\n",
90 nandfs_abort_entry(&req);
92 VOP_UNLOCK(NTOV(dat), 0);
96 /* Fill out vblock data */
97 dat_entry = (struct nandfs_dat_entry *) req.bp_entry->b_data;
98 dat_entry[entry].de_start = start;
99 dat_entry[entry].de_end = UINTMAX_MAX;
100 dat_entry[entry].de_blocknr = 0;
102 /* Commit allocation */
103 error = nandfs_alloc_entry(mdt, &req);
105 nandfs_error("%s: cannot get free vblk entry\n",
108 VOP_UNLOCK(NTOV(dat), 0);
112 /* Return allocated vblock */
113 *vblock = req.entrynum;
114 DPRINTF(DAT, ("%s: allocated vblock %#jx\n",
115 __func__, (uintmax_t)*vblock));
118 VOP_UNLOCK(NTOV(dat), 0);
123 nandfs_vblock_assign(struct nandfs_device *nandfsdev, nandfs_daddr_t vblock,
126 struct nandfs_node *dat;
127 struct nandfs_mdt *mdt;
128 struct nandfs_alloc_request req;
129 struct nandfs_dat_entry *dat_entry;
133 dat = nandfsdev->nd_dat_node;
134 mdt = &nandfsdev->nd_dat_mdt;
136 locked = NANDFS_VOP_ISLOCKED(NTOV(dat));
138 VOP_LOCK(NTOV(dat), LK_EXCLUSIVE);
139 req.entrynum = vblock;
141 error = nandfs_get_entry_block(mdt, dat, &req, &entry, 0);
143 dat_entry = (struct nandfs_dat_entry *) req.bp_entry->b_data;
144 dat_entry[entry].de_blocknr = block;
146 DPRINTF(DAT, ("%s: assing vblock %jx->%jx\n",
147 __func__, (uintmax_t)vblock, (uintmax_t)block));
150 * It is mostly called from syncer() so
151 * we want to force making buf dirty
153 error = nandfs_dirty_buf(req.bp_entry, 1);
157 VOP_UNLOCK(NTOV(dat), 0);
163 nandfs_vblock_end(struct nandfs_device *nandfsdev, nandfs_daddr_t vblock)
165 struct nandfs_node *dat;
166 struct nandfs_mdt *mdt;
167 struct nandfs_alloc_request req;
168 struct nandfs_dat_entry *dat_entry;
173 dat = nandfsdev->nd_dat_node;
174 mdt = &nandfsdev->nd_dat_mdt;
175 end = nandfsdev->nd_last_cno;
177 locked = NANDFS_VOP_ISLOCKED(NTOV(dat));
179 VOP_LOCK(NTOV(dat), LK_EXCLUSIVE);
180 req.entrynum = vblock;
182 error = nandfs_get_entry_block(mdt, dat, &req, &entry, 0);
184 dat_entry = (struct nandfs_dat_entry *) req.bp_entry->b_data;
185 dat_entry[entry].de_end = end;
186 DPRINTF(DAT, ("%s: end vblock %#jx at checkpoint %#jx\n",
187 __func__, (uintmax_t)vblock, (uintmax_t)end));
190 * It is mostly called from syncer() so
191 * we want to force making buf dirty
193 error = nandfs_dirty_buf(req.bp_entry, 1);
197 VOP_UNLOCK(NTOV(dat), 0);
203 nandfs_vblock_free(struct nandfs_device *nandfsdev, nandfs_daddr_t vblock)
205 struct nandfs_node *dat;
206 struct nandfs_mdt *mdt;
207 struct nandfs_alloc_request req;
210 dat = nandfsdev->nd_dat_node;
211 mdt = &nandfsdev->nd_dat_mdt;
213 VOP_LOCK(NTOV(dat), LK_EXCLUSIVE);
214 req.entrynum = vblock;
216 error = nandfs_find_entry(mdt, dat, &req);
218 DPRINTF(DAT, ("%s: vblk %#jx\n", __func__, (uintmax_t)vblock));
219 nandfs_free_entry(mdt, &req);
222 VOP_UNLOCK(NTOV(dat), 0);
227 nandfs_get_dat_vinfo_ioctl(struct nandfs_device *nandfsdev, struct nandfs_argv *nargv)
229 struct nandfs_vinfo *vinfo;
233 if (nargv->nv_nmembs > NANDFS_VINFO_MAX)
236 size = sizeof(struct nandfs_vinfo) * nargv->nv_nmembs;
237 vinfo = malloc(size, M_NANDFSTEMP, M_WAITOK|M_ZERO);
239 error = copyin((void *)(uintptr_t)nargv->nv_base, vinfo, size);
241 free(vinfo, M_NANDFSTEMP);
245 error = nandfs_get_dat_vinfo(nandfsdev, vinfo, nargv->nv_nmembs);
247 error = copyout(vinfo, (void *)(uintptr_t)nargv->nv_base, size);
248 free(vinfo, M_NANDFSTEMP);
253 nandfs_get_dat_vinfo(struct nandfs_device *nandfsdev, struct nandfs_vinfo *vinfo,
256 struct nandfs_node *dat;
257 struct nandfs_mdt *mdt;
258 struct nandfs_alloc_request req;
259 struct nandfs_dat_entry *dat_entry;
263 dat = nandfsdev->nd_dat_node;
264 mdt = &nandfsdev->nd_dat_mdt;
266 DPRINTF(DAT, ("%s: nmembs %#x\n", __func__, nmembs));
268 VOP_LOCK(NTOV(dat), LK_EXCLUSIVE);
270 for (i = 0; i < nmembs; i++) {
271 req.entrynum = vinfo[i].nvi_vblocknr;
273 error = nandfs_get_entry_block(mdt, dat,&req, &idx, 0);
277 dat_entry = ((struct nandfs_dat_entry *) req.bp_entry->b_data);
278 vinfo[i].nvi_start = dat_entry[idx].de_start;
279 vinfo[i].nvi_end = dat_entry[idx].de_end;
280 vinfo[i].nvi_blocknr = dat_entry[idx].de_blocknr;
282 DPRINTF(DAT, ("%s: vinfo: %jx[%jx-%jx]->%jx\n",
283 __func__, vinfo[i].nvi_vblocknr, vinfo[i].nvi_start,
284 vinfo[i].nvi_end, vinfo[i].nvi_blocknr));
286 brelse(req.bp_entry);
289 VOP_UNLOCK(NTOV(dat), 0);
294 nandfs_get_dat_bdescs_ioctl(struct nandfs_device *nffsdev,
295 struct nandfs_argv *nargv)
297 struct nandfs_bdesc *bd;
301 size = nargv->nv_nmembs * sizeof(struct nandfs_bdesc);
302 bd = malloc(size, M_NANDFSTEMP, M_WAITOK);
303 error = copyin((void *)(uintptr_t)nargv->nv_base, bd, size);
305 free(bd, M_NANDFSTEMP);
309 error = nandfs_get_dat_bdescs(nffsdev, bd, nargv->nv_nmembs);
312 error = copyout(bd, (void *)(uintptr_t)nargv->nv_base, size);
314 free(bd, M_NANDFSTEMP);
319 nandfs_get_dat_bdescs(struct nandfs_device *nffsdev, struct nandfs_bdesc *bd,
322 struct nandfs_node *dat_node;
327 dat_node = nffsdev->nd_dat_node;
329 VOP_LOCK(NTOV(dat_node), LK_EXCLUSIVE);
331 for (i = 0; i < nmembs; i++) {
333 ("%s: bd ino:%#jx oblk:%#jx blocknr:%#jx off:%#jx\n",
334 __func__, (uintmax_t)bd[i].bd_ino,
335 (uintmax_t)bd[i].bd_oblocknr, (uintmax_t)bd[i].bd_blocknr,
336 (uintmax_t)bd[i].bd_offset));
338 error = nandfs_bmap_lookup(dat_node, bd[i].bd_offset, &map);
341 bd[i].bd_blocknr = map;
344 VOP_UNLOCK(NTOV(dat_node), 0);