1 /* $NetBSD: v7fs_datablock.c,v 1.4 2011/07/18 21:51:49 apb Exp $ */ 2 3 /*- 4 * Copyright (c) 2011 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by UCHIYAMA Yasushi. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #if HAVE_NBTOOL_CONFIG_H 33 #include "nbtool_config.h" 34 #endif 35 36 #include <sys/cdefs.h> 37 __KERNEL_RCSID(0, "$NetBSD: v7fs_datablock.c,v 1.4 2011/07/18 21:51:49 apb Exp $"); 38 #if defined _KERNEL_OPT 39 #include "opt_v7fs.h" 40 #endif 41 42 #include <sys/types.h> 43 #ifdef _KERNEL 44 #include <sys/systm.h> 45 #include <sys/param.h> 46 #else 47 #include <stdio.h> 48 #include <string.h> 49 #include <errno.h> 50 #endif 51 52 #include "v7fs.h" 53 #include "v7fs_impl.h" 54 #include "v7fs_endian.h" 55 #include "v7fs_inode.h" 56 #include "v7fs_datablock.h" 57 #include "v7fs_superblock.h" 58 59 #ifdef V7FS_DATABLOCK_DEBUG 60 #define DPRINTF(fmt, args...) printf("%s: " fmt, __func__, ##args) 61 #else 62 #define DPRINTF(fmt, args...) ((void)0) 63 #endif 64 65 static int v7fs_datablock_deallocate(struct v7fs_self *, v7fs_daddr_t); 66 static int loop1(struct v7fs_self *, v7fs_daddr_t, size_t *, 67 int (*)(struct v7fs_self *, void *, v7fs_daddr_t, size_t), void *); 68 static int loop2(struct v7fs_self *, v7fs_daddr_t, size_t *, 69 int (*)(struct v7fs_self *, void *, v7fs_daddr_t, size_t), void *); 70 static v7fs_daddr_t link(struct v7fs_self *, v7fs_daddr_t, int); 71 static v7fs_daddr_t add_leaf(struct v7fs_self *, v7fs_daddr_t, int); 72 static v7fs_daddr_t unlink(struct v7fs_self *, v7fs_daddr_t, int); 73 static v7fs_daddr_t remove_leaf(struct v7fs_self *, v7fs_daddr_t, int); 74 static v7fs_daddr_t remove_self(struct v7fs_self *, v7fs_daddr_t); 75 76 #ifdef V7FS_DATABLOCK_DEBUG 77 void daddr_map_dump(const struct v7fs_daddr_map *); 78 #else 79 #define daddr_map_dump(x) ((void)0) 80 #endif 81 82 bool 83 datablock_number_sanity(const struct v7fs_self *fs, v7fs_daddr_t blk) 84 { 85 const struct v7fs_superblock *sb = &fs->superblock; 86 bool ok = (blk >= sb->datablock_start_sector) && 87 (blk < sb->volume_size); 88 89 #ifdef V7FS_DATABLOCK_DEBUG 90 if (!ok) { 91 DPRINTF("Bad data block #%d\n", blk); 92 } 93 #endif 94 95 return ok; 96 } 97 98 int 99 v7fs_datablock_allocate(struct v7fs_self *fs, v7fs_daddr_t *block_number) 100 { 101 struct v7fs_superblock *sb = &fs->superblock; 102 v7fs_daddr_t blk; 103 int error = 0; 104 105 *block_number = 0; 106 SUPERB_LOCK(fs); 107 do { 108 if (!sb->total_freeblock) { 109 DPRINTF("free block exhausted!!!\n"); 110 SUPERB_UNLOCK(fs); 111 return ENOSPC; 112 } 113 114 /* Get free block from superblock cache. */ 115 blk = sb->freeblock[--sb->nfreeblock]; 116 sb->total_freeblock--; 117 sb->modified = 1; 118 119 /* If nfreeblock is zero, it block is next freeblock link. */ 120 if (sb->nfreeblock == 0) { 121 if ((error = v7fs_freeblock_update(fs, blk))) { 122 DPRINTF("no freeblock!!!\n"); 123 SUPERB_UNLOCK(fs); 124 return error; 125 } 126 /* This freeblock link is no longer required. */ 127 /* use as data block. */ 128 } 129 } while (!datablock_number_sanity(fs, blk)); /* skip bogus block. */ 130 SUPERB_UNLOCK(fs); 131 132 DPRINTF("Get freeblock %d\n", blk); 133 /* Zero clear datablock. */ 134 void *buf; 135 if (!(buf = scratch_read(fs, blk))) 136 return EIO; 137 memset(buf, 0, V7FS_BSIZE); 138 if (!fs->io.write(fs->io.cookie, buf, blk)) 139 error = EIO; 140 scratch_free(fs, buf); 141 142 if (error == 0) 143 *block_number = blk; 144 145 return error; 146 } 147 148 static int 149 v7fs_datablock_deallocate(struct v7fs_self *fs, v7fs_daddr_t blk) 150 { 151 struct v7fs_superblock *sb = &fs->superblock; 152 void *buf; 153 int error = 0; 154 155 if (!datablock_number_sanity(fs, blk)) 156 return EIO; 157 158 /* Add to in-core freelist. */ 159 SUPERB_LOCK(fs); 160 if (sb->nfreeblock < V7FS_MAX_FREEBLOCK) { 161 sb->freeblock[sb->nfreeblock++] = blk; 162 sb->total_freeblock++; 163 sb->modified = 1; 164 DPRINTF("n_freeblock=%d\n", sb->total_freeblock); 165 SUPERB_UNLOCK(fs); 166 return 0; 167 } 168 169 /* No space to push. */ 170 /* Make this block to freeblock list.and current cache moved to this. */ 171 if (!(buf = scratch_read(fs, blk))) { 172 SUPERB_UNLOCK(fs); 173 return EIO; /* Fatal */ 174 } 175 176 struct v7fs_freeblock *fb = (struct v7fs_freeblock *)buf; 177 fb->nfreeblock = V7FS_MAX_FREEBLOCK; 178 int i; 179 for (i = 0; i < V7FS_MAX_FREEBLOCK; i++) 180 fb->freeblock[i] = V7FS_VAL32(fs, sb->freeblock[i]); 181 182 if (!fs->io.write(fs->io.cookie, (uint8_t *)fb, blk)) { 183 error = EIO; /* Fatal */ 184 } else { 185 /* Link. on next allocate, this block is used as datablock, */ 186 /* and swap outed freeblock list is restored. */ 187 sb->freeblock[0] = blk; 188 sb->nfreeblock = 1; 189 sb->total_freeblock++; 190 sb->modified = 1; 191 DPRINTF("n_freeblock=%d\n", sb->total_freeblock); 192 } 193 SUPERB_UNLOCK(fs); 194 scratch_free(fs, buf); 195 196 return error; 197 } 198 199 int 200 v7fs_datablock_addr(size_t sz, struct v7fs_daddr_map *map) 201 { 202 #define NIDX V7FS_DADDR_PER_BLOCK 203 #define DIRECT_SZ (V7FS_NADDR_DIRECT * V7FS_BSIZE) 204 #define IDX1_SZ (NIDX * V7FS_BSIZE) 205 #define IDX2_SZ (NIDX * NIDX * V7FS_BSIZE) 206 #define ROUND(x, a) ((((x) + ((a) - 1)) & ~((a) - 1))) 207 if (!sz) { 208 map->level = 0; 209 map->index[0] = 0; 210 return 0; 211 } 212 213 sz = V7FS_ROUND_BSIZE(sz); 214 215 /* Direct */ 216 if (sz <= DIRECT_SZ) { 217 map->level = 0; 218 map->index[0] = (sz >> V7FS_BSHIFT) - 1; 219 return 0; 220 } 221 /* Index 1 */ 222 sz -= DIRECT_SZ; 223 224 if (sz <= IDX1_SZ) { 225 map->level = 1; 226 map->index[0] = (sz >> V7FS_BSHIFT) - 1; 227 return 0; 228 } 229 sz -= IDX1_SZ; 230 231 /* Index 2 */ 232 if (sz <= IDX2_SZ) { 233 map->level = 2; 234 map->index[0] = ROUND(sz, IDX1_SZ) / IDX1_SZ - 1; 235 map->index[1] = ((sz - (map->index[0] * IDX1_SZ)) >> 236 V7FS_BSHIFT) - 1; 237 return 0; 238 } 239 sz -= IDX2_SZ; 240 241 /* Index 3 */ 242 map->level = 3; 243 map->index[0] = ROUND(sz, IDX2_SZ) / IDX2_SZ - 1; 244 sz -= map->index[0] * IDX2_SZ; 245 map->index[1] = ROUND(sz, IDX1_SZ) / IDX1_SZ - 1; 246 sz -= map->index[1] * IDX1_SZ; 247 map->index[2] = (sz >> V7FS_BSHIFT) - 1; 248 249 return map->index[2] >= NIDX ? ENOSPC : 0; 250 } 251 252 int 253 v7fs_datablock_foreach(struct v7fs_self *fs, struct v7fs_inode *p, 254 int (*func)(struct v7fs_self *, void *, v7fs_daddr_t, size_t), void *ctx) 255 { 256 size_t i; 257 v7fs_daddr_t blk, blk2; 258 size_t filesize; 259 bool last; 260 int ret; 261 262 if (!(filesize = v7fs_inode_filesize(p))) 263 return V7FS_ITERATOR_END; 264 #ifdef V7FS_DATABLOCK_DEBUG 265 size_t sz = filesize; 266 #endif 267 268 /* Direct */ 269 for (i = 0; i < V7FS_NADDR_DIRECT; i++, filesize -= V7FS_BSIZE) { 270 blk = p->addr[i]; 271 if (!datablock_number_sanity(fs, blk)) { 272 DPRINTF("inode#%d direct=%zu filesize=%zu\n", 273 p->inode_number, i, sz); 274 return EIO; 275 } 276 277 last = filesize <= V7FS_BSIZE; 278 if ((ret = func(fs, ctx, blk, last ? filesize : V7FS_BSIZE))) 279 return ret; 280 if (last) 281 return V7FS_ITERATOR_END; 282 } 283 284 /* Index 1 */ 285 blk = p->addr[V7FS_NADDR_INDEX1]; 286 if (!datablock_number_sanity(fs, blk)) 287 return EIO; 288 289 if ((ret = loop1(fs, blk, &filesize, func, ctx))) 290 return ret; 291 292 /* Index 2 */ 293 blk = p->addr[V7FS_NADDR_INDEX2]; 294 if (!datablock_number_sanity(fs, blk)) 295 return EIO; 296 297 if ((ret = loop2(fs, blk, &filesize, func, ctx))) 298 return ret; 299 300 /* Index 3 */ 301 blk = p->addr[V7FS_NADDR_INDEX3]; 302 if (!datablock_number_sanity(fs, blk)) 303 return EIO; 304 305 for (i = 0; i < V7FS_DADDR_PER_BLOCK; i++) { 306 blk2 = link(fs, blk, i); 307 if (!datablock_number_sanity(fs, blk)) 308 return EIO; 309 310 if ((ret = loop2(fs, blk2, &filesize, func, ctx))) 311 return ret; 312 } 313 314 return EFBIG; 315 } 316 317 static int 318 loop2(struct v7fs_self *fs, v7fs_daddr_t listblk, size_t *filesize, 319 int (*func)(struct v7fs_self *, void *, v7fs_daddr_t, size_t), void *ctx) 320 { 321 v7fs_daddr_t blk; 322 int ret; 323 size_t j; 324 325 for (j = 0; j < V7FS_DADDR_PER_BLOCK; j++) { 326 blk = link(fs, listblk, j); 327 if (!datablock_number_sanity(fs, blk)) 328 return EIO; 329 if ((ret = loop1(fs, blk, filesize, func, ctx))) 330 return ret; 331 } 332 333 return 0; 334 } 335 336 static int 337 loop1(struct v7fs_self *fs, v7fs_daddr_t listblk, size_t *filesize, 338 int (*func)(struct v7fs_self *, void *, v7fs_daddr_t, size_t), void *ctx) 339 { 340 v7fs_daddr_t blk; 341 bool last; 342 int ret; 343 size_t k; 344 345 for (k = 0; k < V7FS_DADDR_PER_BLOCK; k++, *filesize -= V7FS_BSIZE) { 346 blk = link(fs, listblk, k); 347 if (!datablock_number_sanity(fs, blk)) 348 return EIO; 349 last = *filesize <= V7FS_BSIZE; 350 if ((ret = func(fs, ctx, blk, last ? *filesize : V7FS_BSIZE))) 351 return ret; 352 if (last) 353 return V7FS_ITERATOR_END; 354 } 355 356 return 0; 357 } 358 359 v7fs_daddr_t 360 v7fs_datablock_last(struct v7fs_self *fs, struct v7fs_inode *inode, 361 v7fs_off_t ofs) 362 { 363 struct v7fs_daddr_map map; 364 v7fs_daddr_t blk = 0; 365 v7fs_daddr_t *addr = inode->addr; 366 367 /* Inquire last data block location. */ 368 if (v7fs_datablock_addr(ofs, &map) != 0) 369 return 0; 370 371 switch (map.level) 372 { 373 case 0: /*Direct */ 374 blk = inode->addr[map.index[0]]; 375 break; 376 case 1: /*Index1 */ 377 blk = link(fs, addr[V7FS_NADDR_INDEX1], map.index[0]); 378 break; 379 case 2: /*Index2 */ 380 blk = link(fs, link(fs, addr[V7FS_NADDR_INDEX2], map.index[0]), 381 map.index[1]); 382 break; 383 case 3: /*Index3 */ 384 blk = link(fs, link(fs, link(fs, addr[V7FS_NADDR_INDEX3], 385 map.index[0]), map.index[1]), map.index[2]); 386 break; 387 } 388 389 return blk; 390 } 391 392 int 393 v7fs_datablock_expand(struct v7fs_self *fs, struct v7fs_inode *inode, size_t sz) 394 { 395 size_t old_filesize = inode->filesize; 396 size_t new_filesize = old_filesize + sz; 397 struct v7fs_daddr_map oldmap, newmap; 398 v7fs_daddr_t blk, idxblk; 399 int error; 400 v7fs_daddr_t old_nblk = V7FS_ROUND_BSIZE(old_filesize) >> V7FS_BSHIFT; 401 v7fs_daddr_t new_nblk = V7FS_ROUND_BSIZE(new_filesize) >> V7FS_BSHIFT; 402 403 if (old_nblk == new_nblk) { 404 inode->filesize += sz; 405 v7fs_inode_writeback(fs, inode); 406 return 0; /* no need to expand. */ 407 } 408 struct v7fs_inode backup = *inode; 409 v7fs_daddr_t required_blk = new_nblk - old_nblk; 410 411 DPRINTF("%zu->%zu, required block=%d\n", old_filesize, new_filesize, 412 required_blk); 413 414 v7fs_datablock_addr(old_filesize, &oldmap); 415 v7fs_daddr_t i; 416 for (i = 0; i < required_blk; i++) { 417 v7fs_datablock_addr(old_filesize + (i+1) * V7FS_BSIZE, &newmap); 418 daddr_map_dump(&oldmap); 419 daddr_map_dump(&newmap); 420 421 if (oldmap.level != newmap.level) { 422 /* Allocate index area */ 423 if ((error = v7fs_datablock_allocate(fs, &idxblk))) 424 return error; 425 426 switch (newmap.level) { 427 case 1: 428 DPRINTF("0->1\n"); 429 inode->addr[V7FS_NADDR_INDEX1] = idxblk; 430 blk = add_leaf(fs, idxblk, 0); 431 break; 432 case 2: 433 DPRINTF("1->2\n"); 434 inode->addr[V7FS_NADDR_INDEX2] = idxblk; 435 blk = add_leaf(fs, add_leaf(fs, idxblk, 0), 0); 436 break; 437 case 3: 438 DPRINTF("2->3\n"); 439 inode->addr[V7FS_NADDR_INDEX3] = idxblk; 440 blk = add_leaf(fs, add_leaf(fs, add_leaf(fs, 441 idxblk, 0), 0), 0); 442 break; 443 } 444 } else { 445 switch (newmap.level) { 446 case 0: 447 if ((error = v7fs_datablock_allocate(fs, &blk))) 448 return error; 449 inode->addr[newmap.index[0]] = blk; 450 DPRINTF("direct index %d = blk%d\n", 451 newmap.index[0], blk); 452 break; 453 case 1: 454 idxblk = inode->addr[V7FS_NADDR_INDEX1]; 455 blk = add_leaf(fs, idxblk, newmap.index[0]); 456 break; 457 case 2: 458 idxblk = inode->addr[V7FS_NADDR_INDEX2]; 459 if (oldmap.index[0] != newmap.index[0]) 460 add_leaf(fs, idxblk, newmap.index[0]); 461 blk = add_leaf(fs, link(fs,idxblk, 462 newmap.index[0]), newmap.index[1]); 463 break; 464 case 3: 465 idxblk = inode->addr[V7FS_NADDR_INDEX3]; 466 467 if (oldmap.index[0] != newmap.index[0]) 468 add_leaf(fs, idxblk, newmap.index[0]); 469 470 if (oldmap.index[1] != newmap.index[1]) 471 add_leaf(fs, link(fs, idxblk, 472 newmap.index[0]), newmap.index[1]); 473 blk = add_leaf(fs, link(fs, link(fs, idxblk, 474 newmap.index[0]), newmap.index[1]), 475 newmap.index[2]); 476 break; 477 } 478 } 479 if (!blk) { 480 *inode = backup; /* structure copy; */ 481 return ENOSPC; 482 } 483 oldmap = newmap; 484 } 485 inode->filesize += sz; 486 v7fs_inode_writeback(fs, inode); 487 488 return 0; 489 } 490 491 static v7fs_daddr_t 492 link(struct v7fs_self *fs, v7fs_daddr_t listblk, int n) 493 { 494 v7fs_daddr_t *list; 495 v7fs_daddr_t blk; 496 void *buf; 497 498 if (!datablock_number_sanity(fs, listblk)) 499 return 0; 500 if (!(buf = scratch_read(fs, listblk))) 501 return 0; 502 list = (v7fs_daddr_t *)buf; 503 blk = V7FS_VAL32(fs, list[n]); 504 scratch_free(fs, buf); 505 506 if (!datablock_number_sanity(fs, blk)) 507 return 0; 508 509 return blk; 510 } 511 512 static v7fs_daddr_t 513 add_leaf(struct v7fs_self *fs, v7fs_daddr_t up, int idx) 514 { 515 v7fs_daddr_t newblk; 516 v7fs_daddr_t *daddr_list; 517 int error = 0; 518 void *buf; 519 520 if (!up) 521 return 0; 522 if (!datablock_number_sanity(fs, up)) 523 return 0; 524 525 if ((error = v7fs_datablock_allocate(fs, &newblk))) 526 return 0; 527 if (!(buf = scratch_read(fs, up))) 528 return 0; 529 daddr_list = (v7fs_daddr_t *)buf; 530 daddr_list[idx] = V7FS_VAL32(fs, newblk); 531 if (!fs->io.write(fs->io.cookie, buf, up)) 532 newblk = 0; 533 scratch_free(fs, buf); 534 535 return newblk; 536 } 537 538 int 539 v7fs_datablock_contract(struct v7fs_self *fs, struct v7fs_inode *inode, 540 size_t sz) 541 { 542 size_t old_filesize = inode->filesize; 543 size_t new_filesize = old_filesize - sz; 544 struct v7fs_daddr_map oldmap, newmap; 545 v7fs_daddr_t blk, idxblk; 546 int error = 0; 547 v7fs_daddr_t old_nblk = V7FS_ROUND_BSIZE(old_filesize) >> V7FS_BSHIFT; 548 v7fs_daddr_t new_nblk = V7FS_ROUND_BSIZE(new_filesize) >> V7FS_BSHIFT; 549 550 if (old_nblk == new_nblk) { 551 inode->filesize -= sz; 552 v7fs_inode_writeback(fs, inode); 553 return 0; /* no need to contract; */ 554 } 555 v7fs_daddr_t erase_blk = old_nblk - new_nblk; 556 557 DPRINTF("%zu->%zu # of erased block=%d\n", old_filesize, new_filesize, 558 erase_blk); 559 560 v7fs_datablock_addr(old_filesize, &oldmap); 561 v7fs_daddr_t i; 562 for (i = 0; i < erase_blk; i++) { 563 v7fs_datablock_addr(old_filesize - (i+1) * V7FS_BSIZE, &newmap); 564 565 if (oldmap.level != newmap.level) { 566 switch (newmap.level) { 567 case 0: /*1->0 */ 568 DPRINTF("1->0\n"); 569 idxblk = inode->addr[V7FS_NADDR_INDEX1]; 570 inode->addr[V7FS_NADDR_INDEX1] = 0; 571 error = v7fs_datablock_deallocate(fs, 572 remove_self(fs, idxblk)); 573 break; 574 case 1: /*2->1 */ 575 DPRINTF("2->1\n"); 576 idxblk = inode->addr[V7FS_NADDR_INDEX2]; 577 inode->addr[V7FS_NADDR_INDEX2] = 0; 578 error = v7fs_datablock_deallocate(fs, 579 remove_self(fs, remove_self(fs, idxblk))); 580 break; 581 case 2:/*3->2 */ 582 DPRINTF("3->2\n"); 583 idxblk = inode->addr[V7FS_NADDR_INDEX3]; 584 inode->addr[V7FS_NADDR_INDEX3] = 0; 585 error = v7fs_datablock_deallocate(fs, 586 remove_self(fs, remove_self(fs, 587 remove_self(fs, idxblk)))); 588 break; 589 } 590 } else { 591 switch (newmap.level) { 592 case 0: 593 DPRINTF("[0] %d\n", oldmap.index[0]); 594 blk = inode->addr[oldmap.index[0]]; 595 error = v7fs_datablock_deallocate(fs, blk); 596 break; 597 case 1: 598 DPRINTF("[1] %d\n", oldmap.index[0]); 599 idxblk = inode->addr[V7FS_NADDR_INDEX1]; 600 remove_leaf(fs, idxblk, oldmap.index[0]); 601 602 break; 603 case 2: 604 DPRINTF("[2] %d %d\n", oldmap.index[0], 605 oldmap.index[1]); 606 idxblk = inode->addr[V7FS_NADDR_INDEX2]; 607 remove_leaf(fs, link(fs, idxblk, 608 oldmap.index[0]), oldmap.index[1]); 609 if (oldmap.index[0] != newmap.index[0]) { 610 remove_leaf(fs, idxblk, 611 oldmap.index[0]); 612 } 613 break; 614 case 3: 615 DPRINTF("[2] %d %d %d\n", oldmap.index[0], 616 oldmap.index[1], oldmap.index[2]); 617 idxblk = inode->addr[V7FS_NADDR_INDEX3]; 618 remove_leaf(fs, link(fs, link(fs, idxblk, 619 oldmap.index[0]), oldmap.index[1]), 620 oldmap.index[2]); 621 622 if (oldmap.index[1] != newmap.index[1]) { 623 remove_leaf(fs, link(fs, idxblk, 624 oldmap.index[0]), oldmap.index[1]); 625 } 626 if (oldmap.index[0] != newmap.index[0]) { 627 remove_leaf(fs, idxblk, 628 oldmap.index[0]); 629 } 630 break; 631 } 632 } 633 oldmap = newmap; 634 } 635 inode->filesize -= sz; 636 v7fs_inode_writeback(fs, inode); 637 638 return error; 639 } 640 641 static v7fs_daddr_t 642 unlink(struct v7fs_self *fs, v7fs_daddr_t idxblk, int n) 643 { 644 v7fs_daddr_t *daddr_list; 645 v7fs_daddr_t blk; 646 void *buf; 647 648 if (!(buf = scratch_read(fs, idxblk))) 649 return 0; 650 daddr_list = (v7fs_daddr_t *)buf; 651 blk = V7FS_VAL32(fs, daddr_list[n]); 652 daddr_list[n] = 0; 653 fs->io.write(fs->io.cookie, buf, idxblk); 654 scratch_free(fs, buf); 655 656 return blk; /* unlinked block. */ 657 } 658 659 static v7fs_daddr_t 660 remove_self(struct v7fs_self *fs, v7fs_daddr_t up) 661 { 662 v7fs_daddr_t down; 663 664 if (!datablock_number_sanity(fs, up)) 665 return 0; 666 667 /* At 1st, remove from datablock list. */ 668 down = unlink(fs, up, 0); 669 670 /* link self to freelist. */ 671 v7fs_datablock_deallocate(fs, up); 672 673 return down; 674 } 675 676 static v7fs_daddr_t 677 remove_leaf(struct v7fs_self *fs, v7fs_daddr_t up, int n) 678 { 679 v7fs_daddr_t down; 680 681 if (!datablock_number_sanity(fs, up)) 682 return 0; 683 684 /* At 1st, remove from datablock list. */ 685 down = unlink(fs, up, n); 686 687 /* link leaf to freelist. */ 688 v7fs_datablock_deallocate(fs, down); 689 690 return down; 691 } 692 693 int 694 v7fs_datablock_size_change(struct v7fs_self *fs, size_t newsz, 695 struct v7fs_inode *inode) 696 { 697 ssize_t diff = newsz - v7fs_inode_filesize(inode); 698 int error = 0; 699 700 if (diff > 0) 701 error = v7fs_datablock_expand(fs, inode, diff); 702 else if (diff < 0) 703 error = v7fs_datablock_contract(fs, inode, -diff); 704 705 return error; 706 } 707 708 #ifdef V7FS_DATABLOCK_DEBUG 709 void 710 daddr_map_dump(const struct v7fs_daddr_map *map) 711 { 712 713 DPRINTF("level %d ", map->level); 714 int m, n = !map->level ? 1 : map->level; 715 for (m = 0; m < n; m++) 716 printf("[%d]", map->index[m]); 717 printf("\n"); 718 } 719 #endif 720