Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/fs/nandfs/nandfs_sufile.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2010-2012 Semihalf. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 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. 15 * 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 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/conf.h> 35 #include <sys/kernel.h> 36 #include <sys/lock.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> 43 #include <sys/buf.h> 44 #include <sys/bio.h> 45 46 #include <vm/vm.h> 47 #include <vm/vm_param.h> 48 #include <vm/vm_kern.h> 49 #include <vm/vm_page.h> 50 51 #include <geom/geom.h> 52 #include <geom/geom_vfs.h> 53 54 #include <fs/nandfs/nandfs_mount.h> 55 #include <fs/nandfs/nandfs.h> 56 #include <fs/nandfs/nandfs_subr.h> 57 58 #define SU_USAGE_OFF(bp, offset) \ 59 ((struct nandfs_segment_usage *)((bp)->b_data + offset)) 60 61 static int 62 nandfs_seg_usage_blk_offset(struct nandfs_device *fsdev, uint64_t seg, 63 uint64_t *blk, uint64_t *offset) 64 { 65 uint64_t off; 66 uint16_t seg_size; 67 68 seg_size = fsdev->nd_fsdata.f_segment_usage_size; 69 70 off = roundup(sizeof(struct nandfs_sufile_header), seg_size); 71 off += (seg * seg_size); 72 73 *blk = off / fsdev->nd_blocksize; 74 *offset = off % fsdev->nd_blocksize; 75 return (0); 76 } 77 78 /* Alloc new segment */ 79 int 80 nandfs_alloc_segment(struct nandfs_device *fsdev, uint64_t *seg) 81 { 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; 87 uint16_t seg_size; 88 int error, found; 89 90 seg_size = fsdev->nd_fsdata.f_segment_usage_size; 91 nsegments = fsdev->nd_fsdata.f_nsegments; 92 93 su_node = fsdev->nd_su_node; 94 ASSERT_VOP_LOCKED(NTOV(su_node), __func__); 95 96 /* Read header buffer */ 97 error = nandfs_bread(su_node, 0, NOCRED, 0, &bp_header); 98 if (error) { 99 brelse(bp_header); 100 return (error); 101 } 102 103 su_header = (struct nandfs_sufile_header *)bp_header->b_data; 104 105 /* Get last allocated segment */ 106 i = su_header->sh_last_alloc + 1; 107 108 found = 0; 109 bp = NULL; 110 while (!found) { 111 nandfs_seg_usage_blk_offset(fsdev, i, &blk, &offset); 112 if(blk != 0) { 113 error = nandfs_bmap_lookup(su_node, blk, &vblk); 114 if (error) { 115 nandfs_error("%s: cannot find vblk for blk " 116 "blk:%jx\n", __func__, blk); 117 return (error); 118 } 119 if (vblk) 120 error = nandfs_bread(su_node, blk, NOCRED, 0, 121 &bp); 122 else 123 error = nandfs_bcreate(su_node, blk, NOCRED, 0, 124 &bp); 125 if (error) { 126 nandfs_error("%s: cannot create/read " 127 "vblk:%jx\n", __func__, vblk); 128 if (bp) 129 brelse(bp); 130 return (error); 131 } 132 133 su_usage = SU_USAGE_OFF(bp, offset); 134 } else { 135 su_usage = SU_USAGE_OFF(bp_header, offset); 136 bp = bp_header; 137 } 138 139 rest = (fsdev->nd_blocksize - offset) / seg_size; 140 /* Go through all su usage in block */ 141 while (rest) { 142 /* When last check start from beginning */ 143 if (i == nsegments) 144 break; 145 146 if (!su_usage->su_flags) { 147 su_usage->su_flags = 1; 148 found = 1; 149 break; 150 } 151 su_usage++; 152 i++; 153 154 /* If all checked return error */ 155 if (i == su_header->sh_last_alloc) { 156 DPRINTF(SEG, ("%s: cannot allocate segment \n", 157 __func__)); 158 brelse(bp_header); 159 if (blk != 0) 160 brelse(bp); 161 return (1); 162 } 163 rest--; 164 } 165 if (!found) { 166 /* Otherwise read another block */ 167 if (blk != 0) 168 brelse(bp); 169 if (i == nsegments) { 170 blk = 0; 171 i = 0; 172 } else 173 blk++; 174 offset = 0; 175 } 176 } 177 178 if (found) { 179 *seg = i; 180 su_header->sh_last_alloc = i; 181 su_header->sh_ncleansegs--; 182 su_header->sh_ndirtysegs++; 183 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--; 187 188 /* 189 * It is mostly called from syncer() so we want to force 190 * making buf dirty. 191 */ 192 error = nandfs_dirty_buf(bp_header, 1); 193 if (error) { 194 if (bp && bp != bp_header) 195 brelse(bp); 196 return (error); 197 } 198 if (bp && bp != bp_header) 199 nandfs_dirty_buf(bp, 1); 200 201 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)i)); 202 203 return (0); 204 } 205 206 DPRINTF(SEG, ("%s: failed\n", __func__)); 207 208 return (1); 209 } 210 211 /* 212 * Make buffer dirty, it will be updated soon but first it need to be 213 * gathered by syncer. 214 */ 215 int 216 nandfs_touch_segment(struct nandfs_device *fsdev, uint64_t seg) 217 { 218 struct nandfs_node *su_node; 219 struct buf *bp; 220 uint64_t blk, offset; 221 int error; 222 223 su_node = fsdev->nd_su_node; 224 ASSERT_VOP_LOCKED(NTOV(su_node), __func__); 225 226 nandfs_seg_usage_blk_offset(fsdev, seg, &blk, &offset); 227 228 error = nandfs_bread(su_node, blk, NOCRED, 0, &bp); 229 if (error) { 230 brelse(bp); 231 nandfs_error("%s: cannot preallocate new segment\n", __func__); 232 return (error); 233 } else 234 nandfs_dirty_buf(bp, 1); 235 236 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)seg)); 237 return (error); 238 } 239 240 /* Update block count of segment */ 241 int 242 nandfs_update_segment(struct nandfs_device *fsdev, uint64_t seg, uint32_t nblks) 243 { 244 struct nandfs_node *su_node; 245 struct nandfs_segment_usage *su_usage; 246 struct buf *bp; 247 uint64_t blk, offset; 248 int error; 249 250 su_node = fsdev->nd_su_node; 251 ASSERT_VOP_LOCKED(NTOV(su_node), __func__); 252 253 nandfs_seg_usage_blk_offset(fsdev, seg, &blk, &offset); 254 255 error = nandfs_bread(su_node, blk, NOCRED, 0, &bp); 256 if (error) { 257 nandfs_error("%s: read block:%jx to update\n", 258 __func__, blk); 259 brelse(bp); 260 return (error); 261 } 262 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; 267 268 DPRINTF(SEG, ("%s: seg:%#jx inc:%#x cur:%#x\n", __func__, 269 (uintmax_t)seg, nblks, su_usage->su_nblocks)); 270 271 nandfs_dirty_buf(bp, 1); 272 273 return (0); 274 } 275 276 /* Make segment free */ 277 int 278 nandfs_free_segment(struct nandfs_device *fsdev, uint64_t seg) 279 { 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; 285 int error; 286 287 su_node = fsdev->nd_su_node; 288 ASSERT_VOP_LOCKED(NTOV(su_node), __func__); 289 290 /* Read su header */ 291 error = nandfs_bread(su_node, 0, NOCRED, 0, &bp_header); 292 if (error) { 293 brelse(bp_header); 294 return (error); 295 } 296 297 su_header = (struct nandfs_sufile_header *)bp_header->b_data; 298 nandfs_seg_usage_blk_offset(fsdev, seg, &blk, &offset); 299 300 /* Read su usage block if other than su header block */ 301 if (blk != 0) { 302 error = nandfs_bread(su_node, blk, NOCRED, 0, &bp); 303 if (error) { 304 brelse(bp); 305 brelse(bp_header); 306 return (error); 307 } 308 } else 309 bp = bp_header; 310 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; 316 317 /* Update clean/dirty counter in header */ 318 su_header->sh_ncleansegs++; 319 su_header->sh_ndirtysegs--; 320 321 /* 322 * Make buffers dirty, called by cleaner 323 * so force dirty even if no much space left 324 * on device 325 */ 326 nandfs_dirty_buf(bp_header, 1); 327 if (bp != bp_header) 328 nandfs_dirty_buf(bp, 1); 329 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++; 334 335 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)seg)); 336 337 return (0); 338 } 339 340 static int 341 nandfs_bad_segment(struct nandfs_device *fsdev, uint64_t seg) 342 { 343 struct nandfs_node *su_node; 344 struct nandfs_segment_usage *su_usage; 345 struct buf *bp; 346 uint64_t blk, offset; 347 int error; 348 349 su_node = fsdev->nd_su_node; 350 ASSERT_VOP_LOCKED(NTOV(su_node), __func__); 351 352 nandfs_seg_usage_blk_offset(fsdev, seg, &blk, &offset); 353 354 error = nandfs_bread(su_node, blk, NOCRED, 0, &bp); 355 if (error) { 356 brelse(bp); 357 return (error); 358 } 359 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; 363 364 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)seg)); 365 366 nandfs_dirty_buf(bp, 1); 367 368 return (0); 369 } 370 371 int 372 nandfs_markgc_segment(struct nandfs_device *fsdev, uint64_t seg) 373 { 374 struct nandfs_node *su_node; 375 struct nandfs_segment_usage *su_usage; 376 struct buf *bp; 377 uint64_t blk, offset; 378 int error; 379 380 su_node = fsdev->nd_su_node; 381 382 VOP_LOCK(NTOV(su_node), LK_EXCLUSIVE); 383 384 nandfs_seg_usage_blk_offset(fsdev, seg, &blk, &offset); 385 386 error = nandfs_bread(su_node, blk, NOCRED, 0, &bp); 387 if (error) { 388 brelse(bp); 389 VOP_UNLOCK(NTOV(su_node), 0); 390 return (error); 391 } 392 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; 396 397 brelse(bp); 398 VOP_UNLOCK(NTOV(su_node), 0); 399 400 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)seg)); 401 402 return (0); 403 } 404 405 int 406 nandfs_clear_segment(struct nandfs_device *fsdev, uint64_t seg) 407 { 408 uint64_t offset, segsize; 409 uint32_t bps, bsize; 410 int error = 0; 411 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); 416 offset *= bsize; 417 418 DPRINTF(SEG, ("%s: seg:%#jx\n", __func__, (uintmax_t)seg)); 419 420 /* Erase it and mark it bad when fail */ 421 if (nandfs_erase(fsdev, offset, segsize)) 422 error = nandfs_bad_segment(fsdev, seg); 423 424 if (error) 425 return (error); 426 427 /* Mark it free */ 428 error = nandfs_free_segment(fsdev, seg); 429 430 return (error); 431 } 432 433 int 434 nandfs_get_seg_stat(struct nandfs_device *nandfsdev, 435 struct nandfs_seg_stat *nss) 436 { 437 struct nandfs_sufile_header *suhdr; 438 struct nandfs_node *su_node; 439 struct buf *bp; 440 int err; 441 442 su_node = nandfsdev->nd_su_node; 443 444 NANDFS_WRITELOCK(nandfsdev); 445 VOP_LOCK(NTOV(su_node), LK_SHARED); 446 err = nandfs_bread(nandfsdev->nd_su_node, 0, NOCRED, 0, &bp); 447 if (err) { 448 brelse(bp); 449 VOP_UNLOCK(NTOV(su_node), 0); 450 NANDFS_WRITEUNLOCK(nandfsdev); 451 return (-1); 452 } 453 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; 458 nss->nss_ctime = 0; 459 nss->nss_nongc_ctime = nandfsdev->nd_ts.tv_sec; 460 nss->nss_prot_seq = nandfsdev->nd_seg_sequence; 461 462 brelse(bp); 463 VOP_UNLOCK(NTOV(su_node), 0); 464 465 NANDFS_WRITEUNLOCK(nandfsdev); 466 467 return (0); 468 } 469 470 int 471 nandfs_get_segment_info_ioctl(struct nandfs_device *fsdev, 472 struct nandfs_argv *nargv) 473 { 474 struct nandfs_suinfo *nsi; 475 int error; 476 477 if (nargv->nv_nmembs > NANDFS_SEGMENTS_MAX) 478 return (EINVAL); 479 480 nsi = malloc(sizeof(struct nandfs_suinfo) * nargv->nv_nmembs, 481 M_NANDFSTEMP, M_WAITOK | M_ZERO); 482 483 error = nandfs_get_segment_info(fsdev, nsi, nargv->nv_nmembs, 484 nargv->nv_index); 485 486 if (error == 0) 487 error = copyout(nsi, (void *)(uintptr_t)nargv->nv_base, 488 sizeof(struct nandfs_suinfo) * nargv->nv_nmembs); 489 490 free(nsi, M_NANDFSTEMP); 491 return (error); 492 } 493 494 int 495 nandfs_get_segment_info(struct nandfs_device *fsdev, struct nandfs_suinfo *nsi, 496 uint32_t nmembs, uint64_t segment) 497 { 498 499 return (nandfs_get_segment_info_filter(fsdev, nsi, nmembs, segment, 500 NULL, 0, 0)); 501 } 502 503 int 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) 507 { 508 struct nandfs_segment_usage *su; 509 struct nandfs_node *su_node; 510 struct buf *bp; 511 uint64_t curr, blocknr, blockoff, i; 512 uint32_t flags; 513 int err = 0; 514 515 curr = ~(0); 516 517 lockmgr(&fsdev->nd_seg_const, LK_EXCLUSIVE, NULL); 518 su_node = fsdev->nd_su_node; 519 520 VOP_LOCK(NTOV(su_node), LK_SHARED); 521 522 bp = NULL; 523 if (nsegs != NULL) 524 *nsegs = 0; 525 for (i = 0; i < nmembs; segment++) { 526 if (segment == fsdev->nd_fsdata.f_nsegments) 527 break; 528 529 nandfs_seg_usage_blk_offset(fsdev, segment, &blocknr, 530 &blockoff); 531 532 if (i == 0 || curr != blocknr) { 533 if (bp != NULL) 534 brelse(bp); 535 err = nandfs_bread(su_node, blocknr, NOCRED, 536 0, &bp); 537 if (err) { 538 goto out; 539 } 540 curr = blocknr; 541 } 542 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; 548 549 if (nfilter != 0 && (flags & nfilter) != 0) 550 continue; 551 if (filter != 0 && (flags & filter) == 0) 552 continue; 553 554 nsi->nsi_num = segment; 555 nsi->nsi_lastmod = su->su_lastmod; 556 nsi->nsi_blocks = su->su_nblocks; 557 nsi->nsi_flags = flags; 558 nsi++; 559 i++; 560 if (nsegs != NULL) 561 (*nsegs)++; 562 } 563 564 out: 565 if (bp != NULL) 566 brelse(bp); 567 VOP_UNLOCK(NTOV(su_node), 0); 568 lockmgr(&fsdev->nd_seg_const, LK_RELEASE, NULL); 569 570 return (err); 571 }
Cache object: 7a43cea8b05bf5a7bd6a083ce74eac6a
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]