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 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 char *kaddr = kmap_atomic(page, KM_USER0); 632 633 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to); 634 flush_dcache_page(page); 635 kunmap_atomic(kaddr, KM_USER0); 636 if (size > offset + to) { 637 if (size < offset + PAGE_CACHE_SIZE) 638 tmp = size & ~PAGE_CACHE_MASK; 639 else 640 tmp = PAGE_CACHE_SIZE; 641 err = affs_do_readpage_ofs(file, page, to, tmp); 642 } 643 } 644 return err; 645 } 646 647 static int affs_commit_write_ofs(struct file *file, struct page *page, unsigned from, unsigned to) 648 { 649 struct inode *inode = page->mapping->host; 650 struct super_block *sb = inode->i_sb; 651 struct buffer_head *bh, *prev_bh; 652 char *data; 653 u32 bidx, boff, bsize; 654 u32 tmp; 655 int written; 656 657 pr_debug("AFFS: commit_write(%u, %ld, %d, %d)\n", (u32)inode->i_ino, page->index, from, to); 658 bsize = AFFS_SB(sb)->s_data_blksize; 659 data = page_address(page); 660 661 bh = NULL; 662 written = 0; 663 tmp = (page->index << PAGE_CACHE_SHIFT) + from; 664 bidx = tmp / bsize; 665 boff = tmp % bsize; 666 if (boff) { 667 bh = affs_bread_ino(inode, bidx, 0); 668 if (IS_ERR(bh)) 669 return PTR_ERR(bh); 670 tmp = min(bsize - boff, to - from); 671 if (boff + tmp > bsize || tmp > bsize) 672 BUG(); 673 memcpy(AFFS_DATA(bh) + boff, data + from, tmp); 674 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(be32_to_cpu(AFFS_DATA_HEAD(bh)->size) + tmp); 675 affs_fix_checksum(sb, bh); 676 mark_buffer_dirty_inode(bh, inode); 677 written += tmp; 678 from += tmp; 679 bidx++; 680 } else if (bidx) { 681 bh = affs_bread_ino(inode, bidx - 1, 0); 682 if (IS_ERR(bh)) 683 return PTR_ERR(bh); 684 } 685 while (from + bsize <= to) { 686 prev_bh = bh; 687 bh = affs_getemptyblk_ino(inode, bidx); 688 if (IS_ERR(bh)) 689 goto out; 690 memcpy(AFFS_DATA(bh), data + from, bsize); 691 if (buffer_new(bh)) { 692 AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA); 693 AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino); 694 AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx); 695 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(bsize); 696 AFFS_DATA_HEAD(bh)->next = 0; 697 bh->b_state &= ~(1UL << BH_New); 698 if (prev_bh) { 699 u32 tmp = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next); 700 if (tmp) 701 affs_warning(sb, "commit_write_ofs", "next block already set for %d (%d)", bidx, tmp); 702 AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr); 703 affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp); 704 mark_buffer_dirty_inode(prev_bh, inode); 705 } 706 } 707 affs_brelse(prev_bh); 708 affs_fix_checksum(sb, bh); 709 mark_buffer_dirty_inode(bh, inode); 710 written += bsize; 711 from += bsize; 712 bidx++; 713 } 714 if (from < to) { 715 prev_bh = bh; 716 bh = affs_bread_ino(inode, bidx, 1); 717 if (IS_ERR(bh)) 718 goto out; 719 tmp = min(bsize, to - from); 720 if (tmp > bsize) 721 BUG(); 722 memcpy(AFFS_DATA(bh), data + from, tmp); 723 if (buffer_new(bh)) { 724 AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA); 725 AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino); 726 AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx); 727 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp); 728 AFFS_DATA_HEAD(bh)->next = 0; 729 bh->b_state &= ~(1UL << BH_New); 730 if (prev_bh) { 731 u32 tmp = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next); 732 if (tmp) 733 affs_warning(sb, "commit_write_ofs", "next block already set for %d (%d)", bidx, tmp); 734 AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr); 735 affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp); 736 mark_buffer_dirty_inode(prev_bh, inode); 737 } 738 } else if (be32_to_cpu(AFFS_DATA_HEAD(bh)->size) < tmp) 739 AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp); 740 affs_brelse(prev_bh); 741 affs_fix_checksum(sb, bh); 742 mark_buffer_dirty_inode(bh, inode); 743 written += tmp; 744 from += tmp; 745 bidx++; 746 } 747 SetPageUptodate(page); 748 749 done: 750 affs_brelse(bh); 751 tmp = (page->index << PAGE_CACHE_SHIFT) + from; 752 if (tmp > inode->i_size) 753 inode->i_size = AFFS_I(inode)->mmu_private = tmp; 754 755 return written; 756 757 out: 758 bh = prev_bh; 759 if (!written) 760 written = PTR_ERR(bh); 761 goto done; 762 } 763 764 const struct address_space_operations affs_aops_ofs = { 765 .readpage = affs_readpage_ofs, 766 //.writepage = affs_writepage_ofs, 767 //.sync_page = affs_sync_page_ofs, 768 .prepare_write = affs_prepare_write_ofs, 769 .commit_write = affs_commit_write_ofs 770 }; 771 772 /* Free any preallocated blocks. */ 773 774 void 775 affs_free_prealloc(struct inode *inode) 776 { 777 struct super_block *sb = inode->i_sb; 778 779 pr_debug("AFFS: free_prealloc(ino=%lu)\n", inode->i_ino); 780 781 while (AFFS_I(inode)->i_pa_cnt) { 782 AFFS_I(inode)->i_pa_cnt--; 783 affs_free_block(sb, ++AFFS_I(inode)->i_lastalloc); 784 } 785 } 786 787 /* Truncate (or enlarge) a file to the requested size. */ 788 789 void 790 affs_truncate(struct inode *inode) 791 { 792 struct super_block *sb = inode->i_sb; 793 u32 ext, ext_key; 794 u32 last_blk, blkcnt, blk; 795 u32 size; 796 struct buffer_head *ext_bh; 797 int i; 798 799 pr_debug("AFFS: truncate(inode=%d, oldsize=%u, newsize=%u)\n", 800 (u32)inode->i_ino, (u32)AFFS_I(inode)->mmu_private, (u32)inode->i_size); 801 802 last_blk = 0; 803 ext = 0; 804 if (inode->i_size) { 805 last_blk = ((u32)inode->i_size - 1) / AFFS_SB(sb)->s_data_blksize; 806 ext = last_blk / AFFS_SB(sb)->s_hashsize; 807 } 808 809 if (inode->i_size > AFFS_I(inode)->mmu_private) { 810 struct address_space *mapping = inode->i_mapping; 811 struct page *page; 812 u32 size = inode->i_size - 1; 813 int res; 814 815 page = grab_cache_page(mapping, size >> PAGE_CACHE_SHIFT); 816 if (!page) 817 return; 818 size = (size & (PAGE_CACHE_SIZE - 1)) + 1; 819 res = mapping->a_ops->prepare_write(NULL, page, size, size); 820 if (!res) 821 res = mapping->a_ops->commit_write(NULL, page, size, size); 822 unlock_page(page); 823 page_cache_release(page); 824 mark_inode_dirty(inode); 825 return; 826 } else if (inode->i_size == AFFS_I(inode)->mmu_private) 827 return; 828 829 // lock cache 830 ext_bh = affs_get_extblock(inode, ext); 831 if (IS_ERR(ext_bh)) { 832 affs_warning(sb, "truncate", "unexpected read error for ext block %u (%d)", 833 ext, PTR_ERR(ext_bh)); 834 return; 835 } 836 if (AFFS_I(inode)->i_lc) { 837 /* clear linear cache */ 838 i = (ext + 1) >> AFFS_I(inode)->i_lc_shift; 839 if (AFFS_I(inode)->i_lc_size > i) { 840 AFFS_I(inode)->i_lc_size = i; 841 for (; i < AFFS_LC_SIZE; i++) 842 AFFS_I(inode)->i_lc[i] = 0; 843 } 844 /* clear associative cache */ 845 for (i = 0; i < AFFS_AC_SIZE; i++) 846 if (AFFS_I(inode)->i_ac[i].ext >= ext) 847 AFFS_I(inode)->i_ac[i].ext = 0; 848 } 849 ext_key = be32_to_cpu(AFFS_TAIL(sb, ext_bh)->extension); 850 851 blkcnt = AFFS_I(inode)->i_blkcnt; 852 i = 0; 853 blk = last_blk; 854 if (inode->i_size) { 855 i = last_blk % AFFS_SB(sb)->s_hashsize + 1; 856 blk++; 857 } else 858 AFFS_HEAD(ext_bh)->first_data = 0; 859 size = AFFS_SB(sb)->s_hashsize; 860 if (size > blkcnt - blk + i) 861 size = blkcnt - blk + i; 862 for (; i < size; i++, blk++) { 863 affs_free_block(sb, be32_to_cpu(AFFS_BLOCK(sb, ext_bh, i))); 864 AFFS_BLOCK(sb, ext_bh, i) = 0; 865 } 866 AFFS_TAIL(sb, ext_bh)->extension = 0; 867 affs_fix_checksum(sb, ext_bh); 868 mark_buffer_dirty_inode(ext_bh, inode); 869 affs_brelse(ext_bh); 870 871 if (inode->i_size) { 872 AFFS_I(inode)->i_blkcnt = last_blk + 1; 873 AFFS_I(inode)->i_extcnt = ext + 1; 874 if (AFFS_SB(sb)->s_flags & SF_OFS) { 875 struct buffer_head *bh = affs_bread_ino(inode, last_blk, 0); 876 u32 tmp; 877 if (IS_ERR(ext_bh)) { 878 affs_warning(sb, "truncate", "unexpected read error for last block %u (%d)", 879 ext, PTR_ERR(ext_bh)); 880 return; 881 } 882 tmp = be32_to_cpu(AFFS_DATA_HEAD(bh)->next); 883 AFFS_DATA_HEAD(bh)->next = 0; 884 affs_adjust_checksum(bh, -tmp); 885 affs_brelse(bh); 886 } 887 } else { 888 AFFS_I(inode)->i_blkcnt = 0; 889 AFFS_I(inode)->i_extcnt = 1; 890 } 891 AFFS_I(inode)->mmu_private = inode->i_size; 892 // unlock cache 893 894 while (ext_key) { 895 ext_bh = affs_bread(sb, ext_key); 896 size = AFFS_SB(sb)->s_hashsize; 897 if (size > blkcnt - blk) 898 size = blkcnt - blk; 899 for (i = 0; i < size; i++, blk++) 900 affs_free_block(sb, be32_to_cpu(AFFS_BLOCK(sb, ext_bh, i))); 901 affs_free_block(sb, ext_key); 902 ext_key = be32_to_cpu(AFFS_TAIL(sb, ext_bh)->extension); 903 affs_brelse(ext_bh); 904 } 905 affs_free_prealloc(inode); 906 } 907