1 /* 2 * linux/fs/affs/file.c 3 * 4 * (c) 1996 Hans-Joachim Widmaier - Rewritten 5 * 6 * (C) 1993 Ray Burr - Modified for Amiga FFS filesystem. 7 * 8 * (C) 1992 Eric Youngdale Modified for ISO 9660 filesystem. 9 * 10 * (C) 1991 Linus Torvalds - minix filesystem 11 * 12 * affs regular file handling primitives 13 */ 14 15 #include "affs.h" 16 17 #if PAGE_SIZE < 4096 18 #error PAGE_SIZE must be at least 4096 19 #endif 20 21 static int affs_grow_extcache(struct inode *inode, u32 lc_idx); 22 static struct buffer_head *affs_alloc_extblock(struct inode *inode, struct buffer_head *bh, u32 ext); 23 static inline struct buffer_head *affs_get_extblock(struct inode *inode, u32 ext); 24 static struct buffer_head *affs_get_extblock_slow(struct inode *inode, u32 ext); 25 static int affs_file_open(struct inode *inode, struct file *filp); 26 static int affs_file_release(struct inode *inode, struct file *filp); 27 28 const struct file_operations affs_file_operations = { 29 .llseek = generic_file_llseek, 30 .read = do_sync_read, 31 .aio_read = generic_file_aio_read, 32 .write = do_sync_write, 33 .aio_write = generic_file_aio_write, 34 .mmap = generic_file_mmap, 35 .open = affs_file_open, 36 .release = affs_file_release, 37 .fsync = file_fsync, 38 .sendfile = generic_file_sendfile, 39 }; 40 41 const struct inode_operations affs_file_inode_operations = { 42 .truncate = affs_truncate, 43 .setattr = affs_notify_change, 44 }; 45 46 static int 47 affs_file_open(struct inode *inode, struct file *filp) 48 { 49 if (atomic_read(&filp->f_count) != 1) 50 return 0; 51 pr_debug("AFFS: open(%d)\n", AFFS_I(inode)->i_opencnt); 52 AFFS_I(inode)->i_opencnt++; 53 return 0; 54 } 55 56 static int 57 affs_file_release(struct inode *inode, struct file *filp) 58 { 59 if (atomic_read(&filp->f_count) != 0) 60 return 0; 61 pr_debug("AFFS: release(%d)\n", AFFS_I(inode)->i_opencnt); 62 AFFS_I(inode)->i_opencnt--; 63 if (!AFFS_I(inode)->i_opencnt) 64 affs_free_prealloc(inode); 65 66 return 0; 67 } 68 69 static int 70 affs_grow_extcache(struct inode *inode, u32 lc_idx) 71 { 72 struct super_block *sb = inode->i_sb; 73 struct buffer_head *bh; 74 u32 lc_max; 75 int i, j, key; 76 77 if (!AFFS_I(inode)->i_lc) { 78 char *ptr = (char *)get_zeroed_page(GFP_NOFS); 79 if (!ptr) 80 return -ENOMEM; 81 AFFS_I(inode)->i_lc = (u32 *)ptr; 82 AFFS_I(inode)->i_ac = (struct affs_ext_key *)(ptr + AFFS_CACHE_SIZE / 2); 83 } 84 85 lc_max = AFFS_LC_SIZE << AFFS_I(inode)->i_lc_shift; 86 87 if (AFFS_I(inode)->i_extcnt > lc_max) { 88 u32 lc_shift, lc_mask, tmp, off; 89 90 /* need to recalculate linear cache, start from old size */ 91 lc_shift = AFFS_I(inode)->i_lc_shift; 92 tmp = (AFFS_I(inode)->i_extcnt / AFFS_LC_SIZE) >> lc_shift; 93 for (; tmp; tmp >>= 1) 94 lc_shift++; 95 lc_mask = (1 << lc_shift) - 1; 96 97 /* fix idx and old size to new shift */ 98 lc_idx >>= (lc_shift - AFFS_I(inode)->i_lc_shift); 99 AFFS_I(inode)->i_lc_size >>= (lc_shift - AFFS_I(inode)->i_lc_shift); 100 101 /* first shrink old cache to make more space */ 102 off = 1 << (lc_shift - AFFS_I(inode)->i_lc_shift); 103 for (i = 1, j = off; j < AFFS_LC_SIZE; i++, j += off) 104 AFFS_I(inode)->i_ac[i] = AFFS_I(inode)->i_ac[j]; 105 106 AFFS_I(inode)->i_lc_shift = lc_shift; 107 AFFS_I(inode)->i_lc_mask = lc_mask; 108 } 109 110 /* fill cache to the needed index */ 111 i = AFFS_I(inode)->i_lc_size; 112 AFFS_I(inode)->i_lc_size = lc_idx + 1; 113 for (; i <= lc_idx; i++) { 114 if (!i) { 115 AFFS_I(inode)->i_lc[0] = inode->i_ino; 116 continue; 117 } 118 key = AFFS_I(inode)->i_lc[i - 1]; 119 j = AFFS_I(inode)->i_lc_mask + 1; 120 // unlock cache 121 for (; j > 0; j--) { 122 bh = affs_bread(sb, key); 123 if (!bh) 124 goto err; 125 key = be32_to_cpu(AFFS_TAIL(sb, bh)->extension); 126 affs_brelse(bh); 127 } 128 // lock cache 129 AFFS_I(inode)->i_lc[i] = key; 130 } 131 132 return 0; 133 134 err: 135 // lock cache 136 return -EIO; 137 } 138 139 static struct buffer_head * 140 affs_alloc_extblock(struct inode *inode, struct buffer_head *bh, u32 ext) 141 { 142 struct super_block *sb = inode->i_sb; 143 struct buffer_head *new_bh; 144 u32 blocknr, tmp; 145 146 blocknr = affs_alloc_block(inode, bh->b_blocknr); 147 if (!blocknr) 148 return ERR_PTR(-ENOSPC); 149 150 new_bh = affs_getzeroblk(sb, blocknr); 151 if (!new_bh) { 152 affs_free_block(sb, blocknr); 153 return ERR_PTR(-EIO); 154 } 155 156 AFFS_HEAD(new_bh)->ptype = cpu_to_be32(T_LIST); 157 AFFS_HEAD(new_bh)->key = cpu_to_be32(blocknr); 158 AFFS_TAIL(sb, new_bh)->stype = cpu_to_be32(ST_FILE); 159 AFFS_TAIL(sb, new_bh)->parent = cpu_to_be32(inode->i_ino); 160 affs_fix_checksum(sb, new_bh); 161 162 mark_buffer_dirty_inode(new_bh, inode); 163 164 tmp = be32_to_cpu(AFFS_TAIL(sb, bh)->extension); 165 if (tmp) 166 affs_warning(sb, "alloc_ext", "previous extension set (%x)", tmp); 167 AFFS_TAIL(sb, bh)->extension = cpu_to_be32(blocknr); 168 affs_adjust_checksum(bh, blocknr - tmp); 169 mark_buffer_dirty_inode(bh, inode); 170 171 AFFS_I(inode)->i_extcnt++; 172 mark_inode_dirty(inode); 173 174 return new_bh; 175 } 176 177 static inline struct buffer_head * 178 affs_get_extblock(struct inode *inode, u32 ext) 179 { 180 /* inline the simplest case: same extended block as last time */ 181 struct buffer_head *bh = AFFS_I(inode)->i_ext_bh; 182 if (ext == AFFS_I(inode)->i_ext_last) 183 atomic_inc(&bh->b_count); 184 else 185 /* we have to do more (not inlined) */ 186 bh = affs_get_extblock_slow(inode, ext); 187 188 return bh; 189 } 190 191 static struct buffer_head * 192 affs_get_extblock_slow(struct inode *inode, u32 ext) 193 { 194 struct super_block *sb = inode->i_sb; 195 struct buffer_head *bh; 196 u32 ext_key; 197 u32 lc_idx, lc_off, ac_idx; 198 u32 tmp, idx; 199 200 if (ext == AFFS_I(inode)->i_ext_last + 1) { 201 /* read the next extended block from the current one */ 202 bh = AFFS_I(inode)->i_ext_bh; 203 ext_key = be32_to_cpu(AFFS_TAIL(sb, bh)->extension); 204 if (ext < AFFS_I(inode)->i_extcnt) 205 goto read_ext; 206 if (ext > AFFS_I(inode)->i_extcnt) 207 BUG(); 208 bh = affs_alloc_extblock(inode, bh, ext); 209 if (IS_ERR(bh)) 210 return bh; 211 goto store_ext; 212 } 213 214 if (ext == 0) { 215 /* we seek back to the file header block */ 216 ext_key = inode->i_ino; 217 goto read_ext; 218 } 219 220 if (ext >= AFFS_I(inode)->i_extcnt) { 221 struct buffer_head *prev_bh; 222 223 /* allocate a new extended block */ 224 if (ext > AFFS_I(inode)->i_extcnt) 225 BUG(); 226 227 /* get previous extended block */ 228 prev_bh = affs_get_extblock(inode, ext - 1); 229 if (IS_ERR(prev_bh)) 230 return prev_bh; 231 bh = affs_alloc_extblock(inode, prev_bh, ext); 232 affs_brelse(prev_bh); 233 if (IS_ERR(bh)) 234 return bh; 235 goto store_ext; 236 } 237 238 again: 239 /* check if there is an extended cache and whether it's large enough */ 240 lc_idx = ext >> AFFS_I(inode)->i_lc_shift; 241 lc_off = ext & AFFS_I(inode)->i_lc_mask; 242 243 if (lc_idx >= AFFS_I(inode)->i_lc_size) { 244 int err; 245 246 err = affs_grow_extcache(inode, lc_idx); 247 if (err) 248 return ERR_PTR(err); 249 goto again; 250 } 251 252 /* every n'th key we find in the linear cache */ 253 if (!lc_off) { 254 ext_key = AFFS_I(inode)->i_lc[lc_idx]; 255 goto read_ext; 256 } 257 258 /* maybe it's still in the associative cache */ 259 ac_idx = (ext - lc_idx - 1) & AFFS_AC_MASK; 260 if (AFFS_I(inode)->i_ac[ac_idx].ext == ext) { 261 ext_key = AFFS_I(inode)->i_ac[ac_idx].key; 262 goto read_ext; 263 } 264 265 /* try to find one of the previous extended blocks */ 266 tmp = ext; 267 idx = ac_idx; 268 while (--tmp, --lc_off > 0) { 269 idx = (idx - 1) & AFFS_AC_MASK; 270 if (AFFS_I(inode)->i_ac[idx].ext == tmp) { 271 ext_key = AFFS_I(inode)->i_ac[idx].key; 272 goto find_ext; 273 } 274 } 275 276 /* fall back to the linear cache */ 277 ext_key = AFFS_I(inode)->i_lc[lc_idx]; 278 find_ext: 279 /* read all extended blocks until we find the one we need */ 280 //unlock cache 281 do { 282 bh = affs_bread(sb, ext_key); 283 if (!bh) 284 goto err_bread; 285 ext_key = be32_to_cpu(AFFS_TAIL(sb, bh)->extension); 286 affs_brelse(bh); 287 tmp++; 288 } while (tmp < ext); 289 //lock cache 290 291 /* store it in the associative cache */ 292 // recalculate ac_idx? 293 AFFS_I(inode)->i_ac[ac_idx].ext = ext; 294 AFFS_I(inode)->i_ac[ac_idx].key = ext_key; 295 296 read_ext: 297 /* finally read the right extended block */ 298 //unlock cache 299 bh = affs_bread(sb, ext_key); 300 if (!bh) 301 goto err_bread; 302 //lock cache 303 304 store_ext: 305 /* release old cached extended block and store the new one */ 306 affs_brelse(AFFS_I(inode)->i_ext_bh); 307 AFFS_I(inode)->i_ext_last = ext; 308 AFFS_I(inode)->i_ext_bh = bh; 309 atomic_inc(&bh->b_count); 310 311 return bh; 312 313 err_bread: 314 affs_brelse(bh); 315 return ERR_PTR(-EIO); 316 } 317 318 static int 319 affs_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_result, int create) 320 { 321 struct super_block *sb = inode->i_sb; 322 struct buffer_head *ext_bh; 323 u32 ext; 324 325 pr_debug("AFFS: get_block(%u, %lu)\n", (u32)inode->i_ino, (unsigned long)block); 326 327 328 if (block > (sector_t)0x7fffffffUL) 329 BUG(); 330 331 if (block >= AFFS_I(inode)->i_blkcnt) { 332 if (block > AFFS_I(inode)->i_blkcnt || !create) 333 goto err_big; 334 } else 335 create = 0; 336 337 //lock cache 338 affs_lock_ext(inode); 339 340 ext = (u32)block / AFFS_SB(sb)->s_hashsize; 341 block -= ext * AFFS_SB(sb)->s_hashsize; 342 ext_bh = affs_get_extblock(inode, ext); 343 if (IS_ERR(ext_bh)) 344 goto err_ext; 345 map_bh(bh_result, sb, (sector_t)be32_to_cpu(AFFS_BLOCK(sb, ext_bh, block))); 346 347 if (create) { 348 u32 blocknr = affs_alloc_block(inode, ext_bh->b_blocknr); 349 if (!blocknr) 350 goto err_alloc; 351 set_buffer_new(bh_result); 352 AFFS_I(inode)->mmu_private += AFFS_SB(sb)->s_data_blksize; 353 AFFS_I(inode)->i_blkcnt++; 354 355 /* store new block */ 356 if (bh_result->b_blocknr) 357 affs_warning(sb, "get_block", "block already set (%x)", bh_result->b_blocknr); 358 AFFS_BLOCK(sb, ext_bh, block) = cpu_to_be32(blocknr); 359 AFFS_HEAD(ext_bh)->block_count = cpu_to_be32(block + 1); 360 affs_adjust_checksum(ext_bh, blocknr - bh_result->b_blocknr + 1); 361 bh_result->b_blocknr = blocknr; 362 363 if (!block) { 364 /* insert first block into header block */ 365 u32 tmp = be32_to_cpu(AFFS_HEAD(ext_bh)->first_data); 366 if (tmp) 367 affs_warning(sb, "get_block", "first block already set (%d)", tmp); 368 AFFS_HEAD(ext_bh)->first_data = cpu_to_be32(blocknr); 369 affs_adjust_checksum(ext_bh, blocknr - tmp); 370 } 371 } 372 373 affs_brelse(ext_bh); 374 //unlock cache 375 affs_unlock_ext(inode); 376 return 0; 377 378 err_big: 379 affs_error(inode->i_sb,"get_block","strange block request %d", block); 380 return -EIO; 381 err_ext: 382 // unlock cache 383 affs_unlock_ext(inode); 384 return PTR_ERR(ext_bh); 385 err_alloc: 386 brelse(ext_bh); 387 clear_buffer_mapped(bh_result); 388 bh_result->b_bdev = NULL; 389 // unlock cache 390 affs_unlock_ext(inode); 391 return -ENOSPC; 392 } 393 394 static int affs_writepage(struct page *page, struct writeback_control *wbc) 395 { 396 return block_write_full_page(page, affs_get_block, wbc); 397 } 398 static int affs_readpage(struct file *file, struct page *page) 399 { 400 return block_read_full_page(page, affs_get_block); 401 } 402 static int affs_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to) 403 { 404 return cont_prepare_write(page, from, to, affs_get_block, 405 &AFFS_I(page->mapping->host)->mmu_private); 406 } 407 static sector_t _affs_bmap(struct address_space *mapping, sector_t block) 408 { 409 return generic_block_bmap(mapping,block,affs_get_block); 410 } 411 const struct address_space_operations affs_aops = { 412 .readpage = affs_readpage, 413 .writepage = affs_writepage, 414 .sync_page = block_sync_page, 415 .prepare_write = affs_prepare_write, 416 .commit_write = generic_commit_write, 417 .bmap = _affs_bmap 418 }; 419 420 static inline struct buffer_head * 421 affs_bread_ino(struct inode *inode, int block, int create) 422 { 423 struct buffer_head *bh, tmp_bh; 424 int err; 425 426 tmp_bh.b_state = 0; 427 err = affs_get_block(inode, block, &tmp_bh, create); 428 if (!err) { 429 bh = affs_bread(inode->i_sb, tmp_bh.b_blocknr); 430 if (bh) { 431 bh->b_state |= tmp_bh.b_state; 432 return bh; 433 } 434 err = -EIO; 435 } 436 return ERR_PTR(err); 437 } 438 439 static inline struct buffer_head * 440 affs_getzeroblk_ino(struct inode *inode, int block) 441 { 442 struct buffer_head *bh, tmp_bh; 443 int err; 444 445 tmp_bh.b_state = 0; 446 err = affs_get_block(inode, block, &tmp_bh, 1); 447 if (!err) { 448 bh = affs_getzeroblk(inode->i_sb, tmp_bh.b_blocknr); 449 if (bh) { 450 bh->b_state |= tmp_bh.b_state; 451 return bh; 452 } 453 err = -EIO; 454 } 455 return ERR_PTR(err); 456 } 457 458 static inline struct buffer_head * 459 affs_getemptyblk_ino(struct inode *inode, int block) 460 { 461 struct buffer_head *bh, tmp_bh; 462 int err; 463 464 tmp_bh.b_state = 0; 465 err = affs_get_block(inode, block, &tmp_bh, 1); 466 if (!err) { 467 bh = affs_getemptyblk(inode->i_sb, tmp_bh.b_blocknr); 468 if (bh) { 469 bh->b_state |= tmp_bh.b_state; 470 return bh; 471 } 472 err = -EIO; 473 } 474 return ERR_PTR(err); 475 } 476 477 static int 478 affs_do_readpage_ofs(struct file *file, struct page *page, unsigned from, unsigned to) 479 { 480 struct inode *inode = page->mapping->host; 481 struct super_block *sb = inode->i_sb; 482 struct buffer_head *bh; 483 char *data; 484 u32 bidx, boff, bsize; 485 u32 tmp; 486 487 pr_debug("AFFS: read_page(%u, %ld, %d, %d)\n", (u32)inode->i_ino, page->index, from, to); 488 if (from > to || to > PAGE_CACHE_SIZE) 489 BUG(); 490 kmap(page); 491 data = page_address(page); 492 bsize = AFFS_SB(sb)->s_data_blksize; 493 tmp = (page->index << PAGE_CACHE_SHIFT) + from; 494 bidx = tmp / bsize; 495 boff = tmp % bsize; 496 497 while (from < to) { 498 bh = affs_bread_ino(inode, bidx, 0); 499 if (IS_ERR(bh)) 500 return PTR_ERR(bh); 501 tmp = min(bsize - boff, to - from); 502 if (from + tmp > to || tmp > bsize) 503 BUG(); 504 memcpy(data + from, AFFS_DATA(bh) + boff, tmp); 505 affs_brelse(bh); 506 bidx++; 507 from += tmp; 508 boff = 0; 509 } 510 flush_dcache_page(page); 511 kunmap(page); 512 return 0; 513 } 514 515 static int 516 affs_extent_file_ofs(struct inode *inode, u32 newsize) 517 { 518 struct super_block *sb = inode->i_sb; 519 struct buffer_head *bh, *prev_bh; 520 u32 bidx, boff; 521 u32 size, bsize; 522 u32 tmp; 523 524 pr_debug("AFFS: extent_file(%u, %d)\n", (u32)inode->i_ino, newsize); 525 bsize = AFFS_SB(sb)->s_data_blksize; 526 bh = NULL; 527 size = AFFS_I(inode)->mmu_private; 528 bidx = size / bsize; 529 boff = size % bsize; 530 if (boff) { 531 bh = affs_bread_ino(inode, bidx, 0); 532 if (IS_ERR(bh)) 533 return PTR_ERR(bh); 534 tmp = min(bsize - boff, newsize - size); 535 if (boff + tmp > bsize || tmp > bsize) 536 BUG(); 537 memset(AFFS_DATA(bh) + boff, 0, tmp); 538 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(be32_to_cpu(AFFS_DATA_HEAD(bh)->size) + tmp); 539 affs_fix_checksum(sb, bh); 540 mark_buffer_dirty_inode(bh, inode); 541 size += tmp; 542 bidx++; 543 } else if (bidx) { 544 bh = affs_bread_ino(inode, bidx - 1, 0); 545 if (IS_ERR(bh)) 546 return PTR_ERR(bh); 547 } 548 549 while (size < newsize) { 550 prev_bh = bh; 551 bh = affs_getzeroblk_ino(inode, bidx); 552 if (IS_ERR(bh)) 553 goto out; 554 tmp = min(bsize, newsize - size); 555 if (tmp > bsize) 556 BUG(); 557 AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA); 558 AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino); 559 AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx); 560 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp); 561 affs_fix_checksum(sb, bh); 562 bh->b_state &= ~(1UL << BH_New); 563 mark_buffer_dirty_inode(bh, inode); 564 if (prev_bh) { 565 u32 tmp = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next); 566 if (tmp) 567 affs_warning(sb, "extent_file_ofs", "next block already set for %d (%d)", bidx, tmp); 568 AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr); 569 affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp); 570 mark_buffer_dirty_inode(prev_bh, inode); 571 affs_brelse(prev_bh); 572 } 573 size += bsize; 574 bidx++; 575 } 576 affs_brelse(bh); 577 inode->i_size = AFFS_I(inode)->mmu_private = newsize; 578 return 0; 579 580 out: 581 inode->i_size = AFFS_I(inode)->mmu_private = newsize; 582 return PTR_ERR(bh); 583 } 584 585 static int 586 affs_readpage_ofs(struct file *file, struct page *page) 587 { 588 struct inode *inode = page->mapping->host; 589 u32 to; 590 int err; 591 592 pr_debug("AFFS: read_page(%u, %ld)\n", (u32)inode->i_ino, page->index); 593 to = PAGE_CACHE_SIZE; 594 if (((page->index + 1) << PAGE_CACHE_SHIFT) > inode->i_size) { 595 to = inode->i_size & ~PAGE_CACHE_MASK; 596 memset(page_address(page) + to, 0, PAGE_CACHE_SIZE - to); 597 } 598 599 err = affs_do_readpage_ofs(file, page, 0, to); 600 if (!err) 601 SetPageUptodate(page); 602 unlock_page(page); 603 return err; 604 } 605 606 static int affs_prepare_write_ofs(struct file *file, struct page *page, unsigned from, unsigned to) 607 { 608 struct inode *inode = page->mapping->host; 609 u32 size, offset; 610 u32 tmp; 611 int err = 0; 612 613 pr_debug("AFFS: prepare_write(%u, %ld, %d, %d)\n", (u32)inode->i_ino, page->index, from, to); 614 offset = page->index << PAGE_CACHE_SHIFT; 615 if (offset + from > AFFS_I(inode)->mmu_private) { 616 err = affs_extent_file_ofs(inode, offset + from); 617 if (err) 618 return err; 619 } 620 size = inode->i_size; 621 622 if (PageUptodate(page)) 623 return 0; 624 625 if (from) { 626 err = affs_do_readpage_ofs(file, page, 0, from); 627 if (err) 628 return err; 629 } 630 if (to < PAGE_CACHE_SIZE) { 631 zero_user_page(page, to, PAGE_CACHE_SIZE - to, KM_USER0); 632 if (size > offset + to) { 633 if (size < offset + PAGE_CACHE_SIZE) 634 tmp = size & ~PAGE_CACHE_MASK; 635 else 636 tmp = PAGE_CACHE_SIZE; 637 err = affs_do_readpage_ofs(file, page, to, tmp); 638 } 639 } 640 return err; 641 } 642 643 static int affs_commit_write_ofs(struct file *file, struct page *page, unsigned from, unsigned to) 644 { 645 struct inode *inode = page->mapping->host; 646 struct super_block *sb = inode->i_sb; 647 struct buffer_head *bh, *prev_bh; 648 char *data; 649 u32 bidx, boff, bsize; 650 u32 tmp; 651 int written; 652 653 pr_debug("AFFS: commit_write(%u, %ld, %d, %d)\n", (u32)inode->i_ino, page->index, from, to); 654 bsize = AFFS_SB(sb)->s_data_blksize; 655 data = page_address(page); 656 657 bh = NULL; 658 written = 0; 659 tmp = (page->index << PAGE_CACHE_SHIFT) + from; 660 bidx = tmp / bsize; 661 boff = tmp % bsize; 662 if (boff) { 663 bh = affs_bread_ino(inode, bidx, 0); 664 if (IS_ERR(bh)) 665 return PTR_ERR(bh); 666 tmp = min(bsize - boff, to - from); 667 if (boff + tmp > bsize || tmp > bsize) 668 BUG(); 669 memcpy(AFFS_DATA(bh) + boff, data + from, tmp); 670 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(be32_to_cpu(AFFS_DATA_HEAD(bh)->size) + tmp); 671 affs_fix_checksum(sb, bh); 672 mark_buffer_dirty_inode(bh, inode); 673 written += tmp; 674 from += tmp; 675 bidx++; 676 } else if (bidx) { 677 bh = affs_bread_ino(inode, bidx - 1, 0); 678 if (IS_ERR(bh)) 679 return PTR_ERR(bh); 680 } 681 while (from + bsize <= to) { 682 prev_bh = bh; 683 bh = affs_getemptyblk_ino(inode, bidx); 684 if (IS_ERR(bh)) 685 goto out; 686 memcpy(AFFS_DATA(bh), data + from, bsize); 687 if (buffer_new(bh)) { 688 AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA); 689 AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino); 690 AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx); 691 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(bsize); 692 AFFS_DATA_HEAD(bh)->next = 0; 693 bh->b_state &= ~(1UL << BH_New); 694 if (prev_bh) { 695 u32 tmp = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next); 696 if (tmp) 697 affs_warning(sb, "commit_write_ofs", "next block already set for %d (%d)", bidx, tmp); 698 AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr); 699 affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp); 700 mark_buffer_dirty_inode(prev_bh, inode); 701 } 702 } 703 affs_brelse(prev_bh); 704 affs_fix_checksum(sb, bh); 705 mark_buffer_dirty_inode(bh, inode); 706 written += bsize; 707 from += bsize; 708 bidx++; 709 } 710 if (from < to) { 711 prev_bh = bh; 712 bh = affs_bread_ino(inode, bidx, 1); 713 if (IS_ERR(bh)) 714 goto out; 715 tmp = min(bsize, to - from); 716 if (tmp > bsize) 717 BUG(); 718 memcpy(AFFS_DATA(bh), data + from, tmp); 719 if (buffer_new(bh)) { 720 AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA); 721 AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino); 722 AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx); 723 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp); 724 AFFS_DATA_HEAD(bh)->next = 0; 725 bh->b_state &= ~(1UL << BH_New); 726 if (prev_bh) { 727 u32 tmp = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next); 728 if (tmp) 729 affs_warning(sb, "commit_write_ofs", "next block already set for %d (%d)", bidx, tmp); 730 AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr); 731 affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp); 732 mark_buffer_dirty_inode(prev_bh, inode); 733 } 734 } else if (be32_to_cpu(AFFS_DATA_HEAD(bh)->size) < tmp) 735 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp); 736 affs_brelse(prev_bh); 737 affs_fix_checksum(sb, bh); 738 mark_buffer_dirty_inode(bh, inode); 739 written += tmp; 740 from += tmp; 741 bidx++; 742 } 743 SetPageUptodate(page); 744 745 done: 746 affs_brelse(bh); 747 tmp = (page->index << PAGE_CACHE_SHIFT) + from; 748 if (tmp > inode->i_size) 749 inode->i_size = AFFS_I(inode)->mmu_private = tmp; 750 751 return written; 752 753 out: 754 bh = prev_bh; 755 if (!written) 756 written = PTR_ERR(bh); 757 goto done; 758 } 759 760 const struct address_space_operations affs_aops_ofs = { 761 .readpage = affs_readpage_ofs, 762 //.writepage = affs_writepage_ofs, 763 //.sync_page = affs_sync_page_ofs, 764 .prepare_write = affs_prepare_write_ofs, 765 .commit_write = affs_commit_write_ofs 766 }; 767 768 /* Free any preallocated blocks. */ 769 770 void 771 affs_free_prealloc(struct inode *inode) 772 { 773 struct super_block *sb = inode->i_sb; 774 775 pr_debug("AFFS: free_prealloc(ino=%lu)\n", inode->i_ino); 776 777 while (AFFS_I(inode)->i_pa_cnt) { 778 AFFS_I(inode)->i_pa_cnt--; 779 affs_free_block(sb, ++AFFS_I(inode)->i_lastalloc); 780 } 781 } 782 783 /* Truncate (or enlarge) a file to the requested size. */ 784 785 void 786 affs_truncate(struct inode *inode) 787 { 788 struct super_block *sb = inode->i_sb; 789 u32 ext, ext_key; 790 u32 last_blk, blkcnt, blk; 791 u32 size; 792 struct buffer_head *ext_bh; 793 int i; 794 795 pr_debug("AFFS: truncate(inode=%d, oldsize=%u, newsize=%u)\n", 796 (u32)inode->i_ino, (u32)AFFS_I(inode)->mmu_private, (u32)inode->i_size); 797 798 last_blk = 0; 799 ext = 0; 800 if (inode->i_size) { 801 last_blk = ((u32)inode->i_size - 1) / AFFS_SB(sb)->s_data_blksize; 802 ext = last_blk / AFFS_SB(sb)->s_hashsize; 803 } 804 805 if (inode->i_size > AFFS_I(inode)->mmu_private) { 806 struct address_space *mapping = inode->i_mapping; 807 struct page *page; 808 u32 size = inode->i_size - 1; 809 int res; 810 811 page = grab_cache_page(mapping, size >> PAGE_CACHE_SHIFT); 812 if (!page) 813 return; 814 size = (size & (PAGE_CACHE_SIZE - 1)) + 1; 815 res = mapping->a_ops->prepare_write(NULL, page, size, size); 816 if (!res) 817 res = mapping->a_ops->commit_write(NULL, page, size, size); 818 unlock_page(page); 819 page_cache_release(page); 820 mark_inode_dirty(inode); 821 return; 822 } else if (inode->i_size == AFFS_I(inode)->mmu_private) 823 return; 824 825 // lock cache 826 ext_bh = affs_get_extblock(inode, ext); 827 if (IS_ERR(ext_bh)) { 828 affs_warning(sb, "truncate", "unexpected read error for ext block %u (%d)", 829 ext, PTR_ERR(ext_bh)); 830 return; 831 } 832 if (AFFS_I(inode)->i_lc) { 833 /* clear linear cache */ 834 i = (ext + 1) >> AFFS_I(inode)->i_lc_shift; 835 if (AFFS_I(inode)->i_lc_size > i) { 836 AFFS_I(inode)->i_lc_size = i; 837 for (; i < AFFS_LC_SIZE; i++) 838 AFFS_I(inode)->i_lc[i] = 0; 839 } 840 /* clear associative cache */ 841 for (i = 0; i < AFFS_AC_SIZE; i++) 842 if (AFFS_I(inode)->i_ac[i].ext >= ext) 843 AFFS_I(inode)->i_ac[i].ext = 0; 844 } 845 ext_key = be32_to_cpu(AFFS_TAIL(sb, ext_bh)->extension); 846 847 blkcnt = AFFS_I(inode)->i_blkcnt; 848 i = 0; 849 blk = last_blk; 850 if (inode->i_size) { 851 i = last_blk % AFFS_SB(sb)->s_hashsize + 1; 852 blk++; 853 } else 854 AFFS_HEAD(ext_bh)->first_data = 0; 855 size = AFFS_SB(sb)->s_hashsize; 856 if (size > blkcnt - blk + i) 857 size = blkcnt - blk + i; 858 for (; i < size; i++, blk++) { 859 affs_free_block(sb, be32_to_cpu(AFFS_BLOCK(sb, ext_bh, i))); 860 AFFS_BLOCK(sb, ext_bh, i) = 0; 861 } 862 AFFS_TAIL(sb, ext_bh)->extension = 0; 863 affs_fix_checksum(sb, ext_bh); 864 mark_buffer_dirty_inode(ext_bh, inode); 865 affs_brelse(ext_bh); 866 867 if (inode->i_size) { 868 AFFS_I(inode)->i_blkcnt = last_blk + 1; 869 AFFS_I(inode)->i_extcnt = ext + 1; 870 if (AFFS_SB(sb)->s_flags & SF_OFS) { 871 struct buffer_head *bh = affs_bread_ino(inode, last_blk, 0); 872 u32 tmp; 873 if (IS_ERR(ext_bh)) { 874 affs_warning(sb, "truncate", "unexpected read error for last block %u (%d)", 875 ext, PTR_ERR(ext_bh)); 876 return; 877 } 878 tmp = be32_to_cpu(AFFS_DATA_HEAD(bh)->next); 879 AFFS_DATA_HEAD(bh)->next = 0; 880 affs_adjust_checksum(bh, -tmp); 881 affs_brelse(bh); 882 } 883 } else { 884 AFFS_I(inode)->i_blkcnt = 0; 885 AFFS_I(inode)->i_extcnt = 1; 886 } 887 AFFS_I(inode)->mmu_private = inode->i_size; 888 // unlock cache 889 890 while (ext_key) { 891 ext_bh = affs_bread(sb, ext_key); 892 size = AFFS_SB(sb)->s_hashsize; 893 if (size > blkcnt - blk) 894 size = blkcnt - blk; 895 for (i = 0; i < size; i++, blk++) 896 affs_free_block(sb, be32_to_cpu(AFFS_BLOCK(sb, ext_bh, i))); 897 affs_free_block(sb, ext_key); 898 ext_key = be32_to_cpu(AFFS_TAIL(sb, ext_bh)->extension); 899 affs_brelse(ext_bh); 900 } 901 affs_free_prealloc(inode); 902 } 903