1 /* 2 * inode.c 3 * 4 * PURPOSE 5 * Inode handling routines for the OSTA-UDF(tm) filesystem. 6 * 7 * COPYRIGHT 8 * This file is distributed under the terms of the GNU General Public 9 * License (GPL). Copies of the GPL can be obtained from: 10 * ftp://prep.ai.mit.edu/pub/gnu/GPL 11 * Each contributing author retains all rights to their own work. 12 * 13 * (C) 1998 Dave Boynton 14 * (C) 1998-2004 Ben Fennema 15 * (C) 1999-2000 Stelias Computing Inc 16 * 17 * HISTORY 18 * 19 * 10/04/98 dgb Added rudimentary directory functions 20 * 10/07/98 Fully working udf_block_map! It works! 21 * 11/25/98 bmap altered to better support extents 22 * 12/06/98 blf partition support in udf_iget, udf_block_map 23 * and udf_read_inode 24 * 12/12/98 rewrote udf_block_map to handle next extents and descs across 25 * block boundaries (which is not actually allowed) 26 * 12/20/98 added support for strategy 4096 27 * 03/07/99 rewrote udf_block_map (again) 28 * New funcs, inode_bmap, udf_next_aext 29 * 04/19/99 Support for writing device EA's for major/minor # 30 */ 31 32 #include "udfdecl.h" 33 #include <linux/mm.h> 34 #include <linux/module.h> 35 #include <linux/pagemap.h> 36 #include <linux/buffer_head.h> 37 #include <linux/writeback.h> 38 #include <linux/slab.h> 39 #include <linux/crc-itu-t.h> 40 #include <linux/mpage.h> 41 42 #include "udf_i.h" 43 #include "udf_sb.h" 44 45 MODULE_AUTHOR("Ben Fennema"); 46 MODULE_DESCRIPTION("Universal Disk Format Filesystem"); 47 MODULE_LICENSE("GPL"); 48 49 #define EXTENT_MERGE_SIZE 5 50 51 static umode_t udf_convert_permissions(struct fileEntry *); 52 static int udf_update_inode(struct inode *, int); 53 static void udf_fill_inode(struct inode *, struct buffer_head *); 54 static int udf_sync_inode(struct inode *inode); 55 static int udf_alloc_i_data(struct inode *inode, size_t size); 56 static sector_t inode_getblk(struct inode *, sector_t, int *, int *); 57 static int8_t udf_insert_aext(struct inode *, struct extent_position, 58 struct kernel_lb_addr, uint32_t); 59 static void udf_split_extents(struct inode *, int *, int, int, 60 struct kernel_long_ad[EXTENT_MERGE_SIZE], int *); 61 static void udf_prealloc_extents(struct inode *, int, int, 62 struct kernel_long_ad[EXTENT_MERGE_SIZE], int *); 63 static void udf_merge_extents(struct inode *, 64 struct kernel_long_ad[EXTENT_MERGE_SIZE], int *); 65 static void udf_update_extents(struct inode *, 66 struct kernel_long_ad[EXTENT_MERGE_SIZE], int, int, 67 struct extent_position *); 68 static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int); 69 70 71 void udf_evict_inode(struct inode *inode) 72 { 73 struct udf_inode_info *iinfo = UDF_I(inode); 74 int want_delete = 0; 75 76 if (!inode->i_nlink && !is_bad_inode(inode)) { 77 want_delete = 1; 78 udf_setsize(inode, 0); 79 udf_update_inode(inode, IS_SYNC(inode)); 80 } else 81 truncate_inode_pages(&inode->i_data, 0); 82 invalidate_inode_buffers(inode); 83 clear_inode(inode); 84 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB && 85 inode->i_size != iinfo->i_lenExtents) { 86 udf_warn(inode->i_sb, "Inode %lu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n", 87 inode->i_ino, inode->i_mode, 88 (unsigned long long)inode->i_size, 89 (unsigned long long)iinfo->i_lenExtents); 90 } 91 kfree(iinfo->i_ext.i_data); 92 iinfo->i_ext.i_data = NULL; 93 if (want_delete) { 94 udf_free_inode(inode); 95 } 96 } 97 98 static int udf_writepage(struct page *page, struct writeback_control *wbc) 99 { 100 return block_write_full_page(page, udf_get_block, wbc); 101 } 102 103 static int udf_writepages(struct address_space *mapping, 104 struct writeback_control *wbc) 105 { 106 return mpage_writepages(mapping, wbc, udf_get_block); 107 } 108 109 static int udf_readpage(struct file *file, struct page *page) 110 { 111 return mpage_readpage(page, udf_get_block); 112 } 113 114 static int udf_readpages(struct file *file, struct address_space *mapping, 115 struct list_head *pages, unsigned nr_pages) 116 { 117 return mpage_readpages(mapping, pages, nr_pages, udf_get_block); 118 } 119 120 static int udf_write_begin(struct file *file, struct address_space *mapping, 121 loff_t pos, unsigned len, unsigned flags, 122 struct page **pagep, void **fsdata) 123 { 124 int ret; 125 126 ret = block_write_begin(mapping, pos, len, flags, pagep, udf_get_block); 127 if (unlikely(ret)) { 128 struct inode *inode = mapping->host; 129 struct udf_inode_info *iinfo = UDF_I(inode); 130 loff_t isize = inode->i_size; 131 132 if (pos + len > isize) { 133 truncate_pagecache(inode, pos + len, isize); 134 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { 135 down_write(&iinfo->i_data_sem); 136 udf_truncate_extents(inode); 137 up_write(&iinfo->i_data_sem); 138 } 139 } 140 } 141 142 return ret; 143 } 144 145 static sector_t udf_bmap(struct address_space *mapping, sector_t block) 146 { 147 return generic_block_bmap(mapping, block, udf_get_block); 148 } 149 150 const struct address_space_operations udf_aops = { 151 .readpage = udf_readpage, 152 .readpages = udf_readpages, 153 .writepage = udf_writepage, 154 .writepages = udf_writepages, 155 .write_begin = udf_write_begin, 156 .write_end = generic_write_end, 157 .bmap = udf_bmap, 158 }; 159 160 /* 161 * Expand file stored in ICB to a normal one-block-file 162 * 163 * This function requires i_data_sem for writing and releases it. 164 * This function requires i_mutex held 165 */ 166 int udf_expand_file_adinicb(struct inode *inode) 167 { 168 struct page *page; 169 char *kaddr; 170 struct udf_inode_info *iinfo = UDF_I(inode); 171 int err; 172 struct writeback_control udf_wbc = { 173 .sync_mode = WB_SYNC_NONE, 174 .nr_to_write = 1, 175 }; 176 177 if (!iinfo->i_lenAlloc) { 178 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) 179 iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT; 180 else 181 iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG; 182 /* from now on we have normal address_space methods */ 183 inode->i_data.a_ops = &udf_aops; 184 up_write(&iinfo->i_data_sem); 185 mark_inode_dirty(inode); 186 return 0; 187 } 188 /* 189 * Release i_data_sem so that we can lock a page - page lock ranks 190 * above i_data_sem. i_mutex still protects us against file changes. 191 */ 192 up_write(&iinfo->i_data_sem); 193 194 page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS); 195 if (!page) 196 return -ENOMEM; 197 198 if (!PageUptodate(page)) { 199 kaddr = kmap(page); 200 memset(kaddr + iinfo->i_lenAlloc, 0x00, 201 PAGE_CACHE_SIZE - iinfo->i_lenAlloc); 202 memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr, 203 iinfo->i_lenAlloc); 204 flush_dcache_page(page); 205 SetPageUptodate(page); 206 kunmap(page); 207 } 208 down_write(&iinfo->i_data_sem); 209 memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0x00, 210 iinfo->i_lenAlloc); 211 iinfo->i_lenAlloc = 0; 212 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) 213 iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT; 214 else 215 iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG; 216 /* from now on we have normal address_space methods */ 217 inode->i_data.a_ops = &udf_aops; 218 up_write(&iinfo->i_data_sem); 219 err = inode->i_data.a_ops->writepage(page, &udf_wbc); 220 if (err) { 221 /* Restore everything back so that we don't lose data... */ 222 lock_page(page); 223 kaddr = kmap(page); 224 down_write(&iinfo->i_data_sem); 225 memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr, kaddr, 226 inode->i_size); 227 kunmap(page); 228 unlock_page(page); 229 iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB; 230 inode->i_data.a_ops = &udf_adinicb_aops; 231 up_write(&iinfo->i_data_sem); 232 } 233 page_cache_release(page); 234 mark_inode_dirty(inode); 235 236 return err; 237 } 238 239 struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block, 240 int *err) 241 { 242 int newblock; 243 struct buffer_head *dbh = NULL; 244 struct kernel_lb_addr eloc; 245 uint8_t alloctype; 246 struct extent_position epos; 247 248 struct udf_fileident_bh sfibh, dfibh; 249 loff_t f_pos = udf_ext0_offset(inode); 250 int size = udf_ext0_offset(inode) + inode->i_size; 251 struct fileIdentDesc cfi, *sfi, *dfi; 252 struct udf_inode_info *iinfo = UDF_I(inode); 253 254 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) 255 alloctype = ICBTAG_FLAG_AD_SHORT; 256 else 257 alloctype = ICBTAG_FLAG_AD_LONG; 258 259 if (!inode->i_size) { 260 iinfo->i_alloc_type = alloctype; 261 mark_inode_dirty(inode); 262 return NULL; 263 } 264 265 /* alloc block, and copy data to it */ 266 *block = udf_new_block(inode->i_sb, inode, 267 iinfo->i_location.partitionReferenceNum, 268 iinfo->i_location.logicalBlockNum, err); 269 if (!(*block)) 270 return NULL; 271 newblock = udf_get_pblock(inode->i_sb, *block, 272 iinfo->i_location.partitionReferenceNum, 273 0); 274 if (!newblock) 275 return NULL; 276 dbh = udf_tgetblk(inode->i_sb, newblock); 277 if (!dbh) 278 return NULL; 279 lock_buffer(dbh); 280 memset(dbh->b_data, 0x00, inode->i_sb->s_blocksize); 281 set_buffer_uptodate(dbh); 282 unlock_buffer(dbh); 283 mark_buffer_dirty_inode(dbh, inode); 284 285 sfibh.soffset = sfibh.eoffset = 286 f_pos & (inode->i_sb->s_blocksize - 1); 287 sfibh.sbh = sfibh.ebh = NULL; 288 dfibh.soffset = dfibh.eoffset = 0; 289 dfibh.sbh = dfibh.ebh = dbh; 290 while (f_pos < size) { 291 iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB; 292 sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, 293 NULL, NULL, NULL); 294 if (!sfi) { 295 brelse(dbh); 296 return NULL; 297 } 298 iinfo->i_alloc_type = alloctype; 299 sfi->descTag.tagLocation = cpu_to_le32(*block); 300 dfibh.soffset = dfibh.eoffset; 301 dfibh.eoffset += (sfibh.eoffset - sfibh.soffset); 302 dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset); 303 if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse, 304 sfi->fileIdent + 305 le16_to_cpu(sfi->lengthOfImpUse))) { 306 iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB; 307 brelse(dbh); 308 return NULL; 309 } 310 } 311 mark_buffer_dirty_inode(dbh, inode); 312 313 memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0, 314 iinfo->i_lenAlloc); 315 iinfo->i_lenAlloc = 0; 316 eloc.logicalBlockNum = *block; 317 eloc.partitionReferenceNum = 318 iinfo->i_location.partitionReferenceNum; 319 iinfo->i_lenExtents = inode->i_size; 320 epos.bh = NULL; 321 epos.block = iinfo->i_location; 322 epos.offset = udf_file_entry_alloc_offset(inode); 323 udf_add_aext(inode, &epos, &eloc, inode->i_size, 0); 324 /* UniqueID stuff */ 325 326 brelse(epos.bh); 327 mark_inode_dirty(inode); 328 return dbh; 329 } 330 331 static int udf_get_block(struct inode *inode, sector_t block, 332 struct buffer_head *bh_result, int create) 333 { 334 int err, new; 335 sector_t phys = 0; 336 struct udf_inode_info *iinfo; 337 338 if (!create) { 339 phys = udf_block_map(inode, block); 340 if (phys) 341 map_bh(bh_result, inode->i_sb, phys); 342 return 0; 343 } 344 345 err = -EIO; 346 new = 0; 347 iinfo = UDF_I(inode); 348 349 down_write(&iinfo->i_data_sem); 350 if (block == iinfo->i_next_alloc_block + 1) { 351 iinfo->i_next_alloc_block++; 352 iinfo->i_next_alloc_goal++; 353 } 354 355 356 phys = inode_getblk(inode, block, &err, &new); 357 if (!phys) 358 goto abort; 359 360 if (new) 361 set_buffer_new(bh_result); 362 map_bh(bh_result, inode->i_sb, phys); 363 364 abort: 365 up_write(&iinfo->i_data_sem); 366 return err; 367 } 368 369 static struct buffer_head *udf_getblk(struct inode *inode, long block, 370 int create, int *err) 371 { 372 struct buffer_head *bh; 373 struct buffer_head dummy; 374 375 dummy.b_state = 0; 376 dummy.b_blocknr = -1000; 377 *err = udf_get_block(inode, block, &dummy, create); 378 if (!*err && buffer_mapped(&dummy)) { 379 bh = sb_getblk(inode->i_sb, dummy.b_blocknr); 380 if (buffer_new(&dummy)) { 381 lock_buffer(bh); 382 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize); 383 set_buffer_uptodate(bh); 384 unlock_buffer(bh); 385 mark_buffer_dirty_inode(bh, inode); 386 } 387 return bh; 388 } 389 390 return NULL; 391 } 392 393 /* Extend the file by 'blocks' blocks, return the number of extents added */ 394 static int udf_do_extend_file(struct inode *inode, 395 struct extent_position *last_pos, 396 struct kernel_long_ad *last_ext, 397 sector_t blocks) 398 { 399 sector_t add; 400 int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK); 401 struct super_block *sb = inode->i_sb; 402 struct kernel_lb_addr prealloc_loc = {}; 403 int prealloc_len = 0; 404 struct udf_inode_info *iinfo; 405 int err; 406 407 /* The previous extent is fake and we should not extend by anything 408 * - there's nothing to do... */ 409 if (!blocks && fake) 410 return 0; 411 412 iinfo = UDF_I(inode); 413 /* Round the last extent up to a multiple of block size */ 414 if (last_ext->extLength & (sb->s_blocksize - 1)) { 415 last_ext->extLength = 416 (last_ext->extLength & UDF_EXTENT_FLAG_MASK) | 417 (((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) + 418 sb->s_blocksize - 1) & ~(sb->s_blocksize - 1)); 419 iinfo->i_lenExtents = 420 (iinfo->i_lenExtents + sb->s_blocksize - 1) & 421 ~(sb->s_blocksize - 1); 422 } 423 424 /* Last extent are just preallocated blocks? */ 425 if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == 426 EXT_NOT_RECORDED_ALLOCATED) { 427 /* Save the extent so that we can reattach it to the end */ 428 prealloc_loc = last_ext->extLocation; 429 prealloc_len = last_ext->extLength; 430 /* Mark the extent as a hole */ 431 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | 432 (last_ext->extLength & UDF_EXTENT_LENGTH_MASK); 433 last_ext->extLocation.logicalBlockNum = 0; 434 last_ext->extLocation.partitionReferenceNum = 0; 435 } 436 437 /* Can we merge with the previous extent? */ 438 if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == 439 EXT_NOT_RECORDED_NOT_ALLOCATED) { 440 add = ((1 << 30) - sb->s_blocksize - 441 (last_ext->extLength & UDF_EXTENT_LENGTH_MASK)) >> 442 sb->s_blocksize_bits; 443 if (add > blocks) 444 add = blocks; 445 blocks -= add; 446 last_ext->extLength += add << sb->s_blocksize_bits; 447 } 448 449 if (fake) { 450 udf_add_aext(inode, last_pos, &last_ext->extLocation, 451 last_ext->extLength, 1); 452 count++; 453 } else 454 udf_write_aext(inode, last_pos, &last_ext->extLocation, 455 last_ext->extLength, 1); 456 457 /* Managed to do everything necessary? */ 458 if (!blocks) 459 goto out; 460 461 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */ 462 last_ext->extLocation.logicalBlockNum = 0; 463 last_ext->extLocation.partitionReferenceNum = 0; 464 add = (1 << (30-sb->s_blocksize_bits)) - 1; 465 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | 466 (add << sb->s_blocksize_bits); 467 468 /* Create enough extents to cover the whole hole */ 469 while (blocks > add) { 470 blocks -= add; 471 err = udf_add_aext(inode, last_pos, &last_ext->extLocation, 472 last_ext->extLength, 1); 473 if (err) 474 return err; 475 count++; 476 } 477 if (blocks) { 478 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | 479 (blocks << sb->s_blocksize_bits); 480 err = udf_add_aext(inode, last_pos, &last_ext->extLocation, 481 last_ext->extLength, 1); 482 if (err) 483 return err; 484 count++; 485 } 486 487 out: 488 /* Do we have some preallocated blocks saved? */ 489 if (prealloc_len) { 490 err = udf_add_aext(inode, last_pos, &prealloc_loc, 491 prealloc_len, 1); 492 if (err) 493 return err; 494 last_ext->extLocation = prealloc_loc; 495 last_ext->extLength = prealloc_len; 496 count++; 497 } 498 499 /* last_pos should point to the last written extent... */ 500 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 501 last_pos->offset -= sizeof(struct short_ad); 502 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 503 last_pos->offset -= sizeof(struct long_ad); 504 else 505 return -EIO; 506 507 return count; 508 } 509 510 static int udf_extend_file(struct inode *inode, loff_t newsize) 511 { 512 513 struct extent_position epos; 514 struct kernel_lb_addr eloc; 515 uint32_t elen; 516 int8_t etype; 517 struct super_block *sb = inode->i_sb; 518 sector_t first_block = newsize >> sb->s_blocksize_bits, offset; 519 int adsize; 520 struct udf_inode_info *iinfo = UDF_I(inode); 521 struct kernel_long_ad extent; 522 int err; 523 524 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 525 adsize = sizeof(struct short_ad); 526 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 527 adsize = sizeof(struct long_ad); 528 else 529 BUG(); 530 531 etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset); 532 533 /* File has extent covering the new size (could happen when extending 534 * inside a block)? */ 535 if (etype != -1) 536 return 0; 537 if (newsize & (sb->s_blocksize - 1)) 538 offset++; 539 /* Extended file just to the boundary of the last file block? */ 540 if (offset == 0) 541 return 0; 542 543 /* Truncate is extending the file by 'offset' blocks */ 544 if ((!epos.bh && epos.offset == udf_file_entry_alloc_offset(inode)) || 545 (epos.bh && epos.offset == sizeof(struct allocExtDesc))) { 546 /* File has no extents at all or has empty last 547 * indirect extent! Create a fake extent... */ 548 extent.extLocation.logicalBlockNum = 0; 549 extent.extLocation.partitionReferenceNum = 0; 550 extent.extLength = EXT_NOT_RECORDED_NOT_ALLOCATED; 551 } else { 552 epos.offset -= adsize; 553 etype = udf_next_aext(inode, &epos, &extent.extLocation, 554 &extent.extLength, 0); 555 extent.extLength |= etype << 30; 556 } 557 err = udf_do_extend_file(inode, &epos, &extent, offset); 558 if (err < 0) 559 goto out; 560 err = 0; 561 iinfo->i_lenExtents = newsize; 562 out: 563 brelse(epos.bh); 564 return err; 565 } 566 567 static sector_t inode_getblk(struct inode *inode, sector_t block, 568 int *err, int *new) 569 { 570 static sector_t last_block; 571 struct kernel_long_ad laarr[EXTENT_MERGE_SIZE]; 572 struct extent_position prev_epos, cur_epos, next_epos; 573 int count = 0, startnum = 0, endnum = 0; 574 uint32_t elen = 0, tmpelen; 575 struct kernel_lb_addr eloc, tmpeloc; 576 int c = 1; 577 loff_t lbcount = 0, b_off = 0; 578 uint32_t newblocknum, newblock; 579 sector_t offset = 0; 580 int8_t etype; 581 struct udf_inode_info *iinfo = UDF_I(inode); 582 int goal = 0, pgoal = iinfo->i_location.logicalBlockNum; 583 int lastblock = 0; 584 585 *err = 0; 586 *new = 0; 587 prev_epos.offset = udf_file_entry_alloc_offset(inode); 588 prev_epos.block = iinfo->i_location; 589 prev_epos.bh = NULL; 590 cur_epos = next_epos = prev_epos; 591 b_off = (loff_t)block << inode->i_sb->s_blocksize_bits; 592 593 /* find the extent which contains the block we are looking for. 594 alternate between laarr[0] and laarr[1] for locations of the 595 current extent, and the previous extent */ 596 do { 597 if (prev_epos.bh != cur_epos.bh) { 598 brelse(prev_epos.bh); 599 get_bh(cur_epos.bh); 600 prev_epos.bh = cur_epos.bh; 601 } 602 if (cur_epos.bh != next_epos.bh) { 603 brelse(cur_epos.bh); 604 get_bh(next_epos.bh); 605 cur_epos.bh = next_epos.bh; 606 } 607 608 lbcount += elen; 609 610 prev_epos.block = cur_epos.block; 611 cur_epos.block = next_epos.block; 612 613 prev_epos.offset = cur_epos.offset; 614 cur_epos.offset = next_epos.offset; 615 616 etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1); 617 if (etype == -1) 618 break; 619 620 c = !c; 621 622 laarr[c].extLength = (etype << 30) | elen; 623 laarr[c].extLocation = eloc; 624 625 if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) 626 pgoal = eloc.logicalBlockNum + 627 ((elen + inode->i_sb->s_blocksize - 1) >> 628 inode->i_sb->s_blocksize_bits); 629 630 count++; 631 } while (lbcount + elen <= b_off); 632 633 b_off -= lbcount; 634 offset = b_off >> inode->i_sb->s_blocksize_bits; 635 /* 636 * Move prev_epos and cur_epos into indirect extent if we are at 637 * the pointer to it 638 */ 639 udf_next_aext(inode, &prev_epos, &tmpeloc, &tmpelen, 0); 640 udf_next_aext(inode, &cur_epos, &tmpeloc, &tmpelen, 0); 641 642 /* if the extent is allocated and recorded, return the block 643 if the extent is not a multiple of the blocksize, round up */ 644 645 if (etype == (EXT_RECORDED_ALLOCATED >> 30)) { 646 if (elen & (inode->i_sb->s_blocksize - 1)) { 647 elen = EXT_RECORDED_ALLOCATED | 648 ((elen + inode->i_sb->s_blocksize - 1) & 649 ~(inode->i_sb->s_blocksize - 1)); 650 udf_write_aext(inode, &cur_epos, &eloc, elen, 1); 651 } 652 brelse(prev_epos.bh); 653 brelse(cur_epos.bh); 654 brelse(next_epos.bh); 655 newblock = udf_get_lb_pblock(inode->i_sb, &eloc, offset); 656 return newblock; 657 } 658 659 last_block = block; 660 /* Are we beyond EOF? */ 661 if (etype == -1) { 662 int ret; 663 664 if (count) { 665 if (c) 666 laarr[0] = laarr[1]; 667 startnum = 1; 668 } else { 669 /* Create a fake extent when there's not one */ 670 memset(&laarr[0].extLocation, 0x00, 671 sizeof(struct kernel_lb_addr)); 672 laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED; 673 /* Will udf_do_extend_file() create real extent from 674 a fake one? */ 675 startnum = (offset > 0); 676 } 677 /* Create extents for the hole between EOF and offset */ 678 ret = udf_do_extend_file(inode, &prev_epos, laarr, offset); 679 if (ret < 0) { 680 brelse(prev_epos.bh); 681 brelse(cur_epos.bh); 682 brelse(next_epos.bh); 683 *err = ret; 684 return 0; 685 } 686 c = 0; 687 offset = 0; 688 count += ret; 689 /* We are not covered by a preallocated extent? */ 690 if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) != 691 EXT_NOT_RECORDED_ALLOCATED) { 692 /* Is there any real extent? - otherwise we overwrite 693 * the fake one... */ 694 if (count) 695 c = !c; 696 laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | 697 inode->i_sb->s_blocksize; 698 memset(&laarr[c].extLocation, 0x00, 699 sizeof(struct kernel_lb_addr)); 700 count++; 701 endnum++; 702 } 703 endnum = c + 1; 704 lastblock = 1; 705 } else { 706 endnum = startnum = ((count > 2) ? 2 : count); 707 708 /* if the current extent is in position 0, 709 swap it with the previous */ 710 if (!c && count != 1) { 711 laarr[2] = laarr[0]; 712 laarr[0] = laarr[1]; 713 laarr[1] = laarr[2]; 714 c = 1; 715 } 716 717 /* if the current block is located in an extent, 718 read the next extent */ 719 etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0); 720 if (etype != -1) { 721 laarr[c + 1].extLength = (etype << 30) | elen; 722 laarr[c + 1].extLocation = eloc; 723 count++; 724 startnum++; 725 endnum++; 726 } else 727 lastblock = 1; 728 } 729 730 /* if the current extent is not recorded but allocated, get the 731 * block in the extent corresponding to the requested block */ 732 if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) 733 newblocknum = laarr[c].extLocation.logicalBlockNum + offset; 734 else { /* otherwise, allocate a new block */ 735 if (iinfo->i_next_alloc_block == block) 736 goal = iinfo->i_next_alloc_goal; 737 738 if (!goal) { 739 if (!(goal = pgoal)) /* XXX: what was intended here? */ 740 goal = iinfo->i_location.logicalBlockNum + 1; 741 } 742 743 newblocknum = udf_new_block(inode->i_sb, inode, 744 iinfo->i_location.partitionReferenceNum, 745 goal, err); 746 if (!newblocknum) { 747 brelse(prev_epos.bh); 748 *err = -ENOSPC; 749 return 0; 750 } 751 iinfo->i_lenExtents += inode->i_sb->s_blocksize; 752 } 753 754 /* if the extent the requsted block is located in contains multiple 755 * blocks, split the extent into at most three extents. blocks prior 756 * to requested block, requested block, and blocks after requested 757 * block */ 758 udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum); 759 760 #ifdef UDF_PREALLOCATE 761 /* We preallocate blocks only for regular files. It also makes sense 762 * for directories but there's a problem when to drop the 763 * preallocation. We might use some delayed work for that but I feel 764 * it's overengineering for a filesystem like UDF. */ 765 if (S_ISREG(inode->i_mode)) 766 udf_prealloc_extents(inode, c, lastblock, laarr, &endnum); 767 #endif 768 769 /* merge any continuous blocks in laarr */ 770 udf_merge_extents(inode, laarr, &endnum); 771 772 /* write back the new extents, inserting new extents if the new number 773 * of extents is greater than the old number, and deleting extents if 774 * the new number of extents is less than the old number */ 775 udf_update_extents(inode, laarr, startnum, endnum, &prev_epos); 776 777 brelse(prev_epos.bh); 778 779 newblock = udf_get_pblock(inode->i_sb, newblocknum, 780 iinfo->i_location.partitionReferenceNum, 0); 781 if (!newblock) { 782 *err = -EIO; 783 return 0; 784 } 785 *new = 1; 786 iinfo->i_next_alloc_block = block; 787 iinfo->i_next_alloc_goal = newblocknum; 788 inode->i_ctime = current_fs_time(inode->i_sb); 789 790 if (IS_SYNC(inode)) 791 udf_sync_inode(inode); 792 else 793 mark_inode_dirty(inode); 794 795 return newblock; 796 } 797 798 static void udf_split_extents(struct inode *inode, int *c, int offset, 799 int newblocknum, 800 struct kernel_long_ad laarr[EXTENT_MERGE_SIZE], 801 int *endnum) 802 { 803 unsigned long blocksize = inode->i_sb->s_blocksize; 804 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; 805 806 if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) || 807 (laarr[*c].extLength >> 30) == 808 (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) { 809 int curr = *c; 810 int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) + 811 blocksize - 1) >> blocksize_bits; 812 int8_t etype = (laarr[curr].extLength >> 30); 813 814 if (blen == 1) 815 ; 816 else if (!offset || blen == offset + 1) { 817 laarr[curr + 2] = laarr[curr + 1]; 818 laarr[curr + 1] = laarr[curr]; 819 } else { 820 laarr[curr + 3] = laarr[curr + 1]; 821 laarr[curr + 2] = laarr[curr + 1] = laarr[curr]; 822 } 823 824 if (offset) { 825 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) { 826 udf_free_blocks(inode->i_sb, inode, 827 &laarr[curr].extLocation, 828 0, offset); 829 laarr[curr].extLength = 830 EXT_NOT_RECORDED_NOT_ALLOCATED | 831 (offset << blocksize_bits); 832 laarr[curr].extLocation.logicalBlockNum = 0; 833 laarr[curr].extLocation. 834 partitionReferenceNum = 0; 835 } else 836 laarr[curr].extLength = (etype << 30) | 837 (offset << blocksize_bits); 838 curr++; 839 (*c)++; 840 (*endnum)++; 841 } 842 843 laarr[curr].extLocation.logicalBlockNum = newblocknum; 844 if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) 845 laarr[curr].extLocation.partitionReferenceNum = 846 UDF_I(inode)->i_location.partitionReferenceNum; 847 laarr[curr].extLength = EXT_RECORDED_ALLOCATED | 848 blocksize; 849 curr++; 850 851 if (blen != offset + 1) { 852 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) 853 laarr[curr].extLocation.logicalBlockNum += 854 offset + 1; 855 laarr[curr].extLength = (etype << 30) | 856 ((blen - (offset + 1)) << blocksize_bits); 857 curr++; 858 (*endnum)++; 859 } 860 } 861 } 862 863 static void udf_prealloc_extents(struct inode *inode, int c, int lastblock, 864 struct kernel_long_ad laarr[EXTENT_MERGE_SIZE], 865 int *endnum) 866 { 867 int start, length = 0, currlength = 0, i; 868 869 if (*endnum >= (c + 1)) { 870 if (!lastblock) 871 return; 872 else 873 start = c; 874 } else { 875 if ((laarr[c + 1].extLength >> 30) == 876 (EXT_NOT_RECORDED_ALLOCATED >> 30)) { 877 start = c + 1; 878 length = currlength = 879 (((laarr[c + 1].extLength & 880 UDF_EXTENT_LENGTH_MASK) + 881 inode->i_sb->s_blocksize - 1) >> 882 inode->i_sb->s_blocksize_bits); 883 } else 884 start = c; 885 } 886 887 for (i = start + 1; i <= *endnum; i++) { 888 if (i == *endnum) { 889 if (lastblock) 890 length += UDF_DEFAULT_PREALLOC_BLOCKS; 891 } else if ((laarr[i].extLength >> 30) == 892 (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) { 893 length += (((laarr[i].extLength & 894 UDF_EXTENT_LENGTH_MASK) + 895 inode->i_sb->s_blocksize - 1) >> 896 inode->i_sb->s_blocksize_bits); 897 } else 898 break; 899 } 900 901 if (length) { 902 int next = laarr[start].extLocation.logicalBlockNum + 903 (((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) + 904 inode->i_sb->s_blocksize - 1) >> 905 inode->i_sb->s_blocksize_bits); 906 int numalloc = udf_prealloc_blocks(inode->i_sb, inode, 907 laarr[start].extLocation.partitionReferenceNum, 908 next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ? 909 length : UDF_DEFAULT_PREALLOC_BLOCKS) - 910 currlength); 911 if (numalloc) { 912 if (start == (c + 1)) 913 laarr[start].extLength += 914 (numalloc << 915 inode->i_sb->s_blocksize_bits); 916 else { 917 memmove(&laarr[c + 2], &laarr[c + 1], 918 sizeof(struct long_ad) * (*endnum - (c + 1))); 919 (*endnum)++; 920 laarr[c + 1].extLocation.logicalBlockNum = next; 921 laarr[c + 1].extLocation.partitionReferenceNum = 922 laarr[c].extLocation. 923 partitionReferenceNum; 924 laarr[c + 1].extLength = 925 EXT_NOT_RECORDED_ALLOCATED | 926 (numalloc << 927 inode->i_sb->s_blocksize_bits); 928 start = c + 1; 929 } 930 931 for (i = start + 1; numalloc && i < *endnum; i++) { 932 int elen = ((laarr[i].extLength & 933 UDF_EXTENT_LENGTH_MASK) + 934 inode->i_sb->s_blocksize - 1) >> 935 inode->i_sb->s_blocksize_bits; 936 937 if (elen > numalloc) { 938 laarr[i].extLength -= 939 (numalloc << 940 inode->i_sb->s_blocksize_bits); 941 numalloc = 0; 942 } else { 943 numalloc -= elen; 944 if (*endnum > (i + 1)) 945 memmove(&laarr[i], 946 &laarr[i + 1], 947 sizeof(struct long_ad) * 948 (*endnum - (i + 1))); 949 i--; 950 (*endnum)--; 951 } 952 } 953 UDF_I(inode)->i_lenExtents += 954 numalloc << inode->i_sb->s_blocksize_bits; 955 } 956 } 957 } 958 959 static void udf_merge_extents(struct inode *inode, 960 struct kernel_long_ad laarr[EXTENT_MERGE_SIZE], 961 int *endnum) 962 { 963 int i; 964 unsigned long blocksize = inode->i_sb->s_blocksize; 965 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; 966 967 for (i = 0; i < (*endnum - 1); i++) { 968 struct kernel_long_ad *li /*l[i]*/ = &laarr[i]; 969 struct kernel_long_ad *lip1 /*l[i plus 1]*/ = &laarr[i + 1]; 970 971 if (((li->extLength >> 30) == (lip1->extLength >> 30)) && 972 (((li->extLength >> 30) == 973 (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) || 974 ((lip1->extLocation.logicalBlockNum - 975 li->extLocation.logicalBlockNum) == 976 (((li->extLength & UDF_EXTENT_LENGTH_MASK) + 977 blocksize - 1) >> blocksize_bits)))) { 978 979 if (((li->extLength & UDF_EXTENT_LENGTH_MASK) + 980 (lip1->extLength & UDF_EXTENT_LENGTH_MASK) + 981 blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) { 982 lip1->extLength = (lip1->extLength - 983 (li->extLength & 984 UDF_EXTENT_LENGTH_MASK) + 985 UDF_EXTENT_LENGTH_MASK) & 986 ~(blocksize - 1); 987 li->extLength = (li->extLength & 988 UDF_EXTENT_FLAG_MASK) + 989 (UDF_EXTENT_LENGTH_MASK + 1) - 990 blocksize; 991 lip1->extLocation.logicalBlockNum = 992 li->extLocation.logicalBlockNum + 993 ((li->extLength & 994 UDF_EXTENT_LENGTH_MASK) >> 995 blocksize_bits); 996 } else { 997 li->extLength = lip1->extLength + 998 (((li->extLength & 999 UDF_EXTENT_LENGTH_MASK) + 1000 blocksize - 1) & ~(blocksize - 1)); 1001 if (*endnum > (i + 2)) 1002 memmove(&laarr[i + 1], &laarr[i + 2], 1003 sizeof(struct long_ad) * 1004 (*endnum - (i + 2))); 1005 i--; 1006 (*endnum)--; 1007 } 1008 } else if (((li->extLength >> 30) == 1009 (EXT_NOT_RECORDED_ALLOCATED >> 30)) && 1010 ((lip1->extLength >> 30) == 1011 (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) { 1012 udf_free_blocks(inode->i_sb, inode, &li->extLocation, 0, 1013 ((li->extLength & 1014 UDF_EXTENT_LENGTH_MASK) + 1015 blocksize - 1) >> blocksize_bits); 1016 li->extLocation.logicalBlockNum = 0; 1017 li->extLocation.partitionReferenceNum = 0; 1018 1019 if (((li->extLength & UDF_EXTENT_LENGTH_MASK) + 1020 (lip1->extLength & UDF_EXTENT_LENGTH_MASK) + 1021 blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) { 1022 lip1->extLength = (lip1->extLength - 1023 (li->extLength & 1024 UDF_EXTENT_LENGTH_MASK) + 1025 UDF_EXTENT_LENGTH_MASK) & 1026 ~(blocksize - 1); 1027 li->extLength = (li->extLength & 1028 UDF_EXTENT_FLAG_MASK) + 1029 (UDF_EXTENT_LENGTH_MASK + 1) - 1030 blocksize; 1031 } else { 1032 li->extLength = lip1->extLength + 1033 (((li->extLength & 1034 UDF_EXTENT_LENGTH_MASK) + 1035 blocksize - 1) & ~(blocksize - 1)); 1036 if (*endnum > (i + 2)) 1037 memmove(&laarr[i + 1], &laarr[i + 2], 1038 sizeof(struct long_ad) * 1039 (*endnum - (i + 2))); 1040 i--; 1041 (*endnum)--; 1042 } 1043 } else if ((li->extLength >> 30) == 1044 (EXT_NOT_RECORDED_ALLOCATED >> 30)) { 1045 udf_free_blocks(inode->i_sb, inode, 1046 &li->extLocation, 0, 1047 ((li->extLength & 1048 UDF_EXTENT_LENGTH_MASK) + 1049 blocksize - 1) >> blocksize_bits); 1050 li->extLocation.logicalBlockNum = 0; 1051 li->extLocation.partitionReferenceNum = 0; 1052 li->extLength = (li->extLength & 1053 UDF_EXTENT_LENGTH_MASK) | 1054 EXT_NOT_RECORDED_NOT_ALLOCATED; 1055 } 1056 } 1057 } 1058 1059 static void udf_update_extents(struct inode *inode, 1060 struct kernel_long_ad laarr[EXTENT_MERGE_SIZE], 1061 int startnum, int endnum, 1062 struct extent_position *epos) 1063 { 1064 int start = 0, i; 1065 struct kernel_lb_addr tmploc; 1066 uint32_t tmplen; 1067 1068 if (startnum > endnum) { 1069 for (i = 0; i < (startnum - endnum); i++) 1070 udf_delete_aext(inode, *epos, laarr[i].extLocation, 1071 laarr[i].extLength); 1072 } else if (startnum < endnum) { 1073 for (i = 0; i < (endnum - startnum); i++) { 1074 udf_insert_aext(inode, *epos, laarr[i].extLocation, 1075 laarr[i].extLength); 1076 udf_next_aext(inode, epos, &laarr[i].extLocation, 1077 &laarr[i].extLength, 1); 1078 start++; 1079 } 1080 } 1081 1082 for (i = start; i < endnum; i++) { 1083 udf_next_aext(inode, epos, &tmploc, &tmplen, 0); 1084 udf_write_aext(inode, epos, &laarr[i].extLocation, 1085 laarr[i].extLength, 1); 1086 } 1087 } 1088 1089 struct buffer_head *udf_bread(struct inode *inode, int block, 1090 int create, int *err) 1091 { 1092 struct buffer_head *bh = NULL; 1093 1094 bh = udf_getblk(inode, block, create, err); 1095 if (!bh) 1096 return NULL; 1097 1098 if (buffer_uptodate(bh)) 1099 return bh; 1100 1101 ll_rw_block(READ, 1, &bh); 1102 1103 wait_on_buffer(bh); 1104 if (buffer_uptodate(bh)) 1105 return bh; 1106 1107 brelse(bh); 1108 *err = -EIO; 1109 return NULL; 1110 } 1111 1112 int udf_setsize(struct inode *inode, loff_t newsize) 1113 { 1114 int err; 1115 struct udf_inode_info *iinfo; 1116 int bsize = 1 << inode->i_blkbits; 1117 1118 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 1119 S_ISLNK(inode->i_mode))) 1120 return -EINVAL; 1121 if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) 1122 return -EPERM; 1123 1124 iinfo = UDF_I(inode); 1125 if (newsize > inode->i_size) { 1126 down_write(&iinfo->i_data_sem); 1127 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { 1128 if (bsize < 1129 (udf_file_entry_alloc_offset(inode) + newsize)) { 1130 err = udf_expand_file_adinicb(inode); 1131 if (err) 1132 return err; 1133 down_write(&iinfo->i_data_sem); 1134 } else { 1135 iinfo->i_lenAlloc = newsize; 1136 goto set_size; 1137 } 1138 } 1139 err = udf_extend_file(inode, newsize); 1140 if (err) { 1141 up_write(&iinfo->i_data_sem); 1142 return err; 1143 } 1144 set_size: 1145 truncate_setsize(inode, newsize); 1146 up_write(&iinfo->i_data_sem); 1147 } else { 1148 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { 1149 down_write(&iinfo->i_data_sem); 1150 memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr + newsize, 1151 0x00, bsize - newsize - 1152 udf_file_entry_alloc_offset(inode)); 1153 iinfo->i_lenAlloc = newsize; 1154 truncate_setsize(inode, newsize); 1155 up_write(&iinfo->i_data_sem); 1156 goto update_time; 1157 } 1158 err = block_truncate_page(inode->i_mapping, newsize, 1159 udf_get_block); 1160 if (err) 1161 return err; 1162 down_write(&iinfo->i_data_sem); 1163 truncate_setsize(inode, newsize); 1164 udf_truncate_extents(inode); 1165 up_write(&iinfo->i_data_sem); 1166 } 1167 update_time: 1168 inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb); 1169 if (IS_SYNC(inode)) 1170 udf_sync_inode(inode); 1171 else 1172 mark_inode_dirty(inode); 1173 return 0; 1174 } 1175 1176 static void __udf_read_inode(struct inode *inode) 1177 { 1178 struct buffer_head *bh = NULL; 1179 struct fileEntry *fe; 1180 uint16_t ident; 1181 struct udf_inode_info *iinfo = UDF_I(inode); 1182 1183 /* 1184 * Set defaults, but the inode is still incomplete! 1185 * Note: get_new_inode() sets the following on a new inode: 1186 * i_sb = sb 1187 * i_no = ino 1188 * i_flags = sb->s_flags 1189 * i_state = 0 1190 * clean_inode(): zero fills and sets 1191 * i_count = 1 1192 * i_nlink = 1 1193 * i_op = NULL; 1194 */ 1195 bh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 0, &ident); 1196 if (!bh) { 1197 udf_err(inode->i_sb, "(ino %ld) failed !bh\n", inode->i_ino); 1198 make_bad_inode(inode); 1199 return; 1200 } 1201 1202 if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE && 1203 ident != TAG_IDENT_USE) { 1204 udf_err(inode->i_sb, "(ino %ld) failed ident=%d\n", 1205 inode->i_ino, ident); 1206 brelse(bh); 1207 make_bad_inode(inode); 1208 return; 1209 } 1210 1211 fe = (struct fileEntry *)bh->b_data; 1212 1213 if (fe->icbTag.strategyType == cpu_to_le16(4096)) { 1214 struct buffer_head *ibh; 1215 1216 ibh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 1, 1217 &ident); 1218 if (ident == TAG_IDENT_IE && ibh) { 1219 struct buffer_head *nbh = NULL; 1220 struct kernel_lb_addr loc; 1221 struct indirectEntry *ie; 1222 1223 ie = (struct indirectEntry *)ibh->b_data; 1224 loc = lelb_to_cpu(ie->indirectICB.extLocation); 1225 1226 if (ie->indirectICB.extLength && 1227 (nbh = udf_read_ptagged(inode->i_sb, &loc, 0, 1228 &ident))) { 1229 if (ident == TAG_IDENT_FE || 1230 ident == TAG_IDENT_EFE) { 1231 memcpy(&iinfo->i_location, 1232 &loc, 1233 sizeof(struct kernel_lb_addr)); 1234 brelse(bh); 1235 brelse(ibh); 1236 brelse(nbh); 1237 __udf_read_inode(inode); 1238 return; 1239 } 1240 brelse(nbh); 1241 } 1242 } 1243 brelse(ibh); 1244 } else if (fe->icbTag.strategyType != cpu_to_le16(4)) { 1245 udf_err(inode->i_sb, "unsupported strategy type: %d\n", 1246 le16_to_cpu(fe->icbTag.strategyType)); 1247 brelse(bh); 1248 make_bad_inode(inode); 1249 return; 1250 } 1251 udf_fill_inode(inode, bh); 1252 1253 brelse(bh); 1254 } 1255 1256 static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) 1257 { 1258 struct fileEntry *fe; 1259 struct extendedFileEntry *efe; 1260 struct udf_sb_info *sbi = UDF_SB(inode->i_sb); 1261 struct udf_inode_info *iinfo = UDF_I(inode); 1262 unsigned int link_count; 1263 1264 fe = (struct fileEntry *)bh->b_data; 1265 efe = (struct extendedFileEntry *)bh->b_data; 1266 1267 if (fe->icbTag.strategyType == cpu_to_le16(4)) 1268 iinfo->i_strat4096 = 0; 1269 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */ 1270 iinfo->i_strat4096 = 1; 1271 1272 iinfo->i_alloc_type = le16_to_cpu(fe->icbTag.flags) & 1273 ICBTAG_FLAG_AD_MASK; 1274 iinfo->i_unique = 0; 1275 iinfo->i_lenEAttr = 0; 1276 iinfo->i_lenExtents = 0; 1277 iinfo->i_lenAlloc = 0; 1278 iinfo->i_next_alloc_block = 0; 1279 iinfo->i_next_alloc_goal = 0; 1280 if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) { 1281 iinfo->i_efe = 1; 1282 iinfo->i_use = 0; 1283 if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - 1284 sizeof(struct extendedFileEntry))) { 1285 make_bad_inode(inode); 1286 return; 1287 } 1288 memcpy(iinfo->i_ext.i_data, 1289 bh->b_data + sizeof(struct extendedFileEntry), 1290 inode->i_sb->s_blocksize - 1291 sizeof(struct extendedFileEntry)); 1292 } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) { 1293 iinfo->i_efe = 0; 1294 iinfo->i_use = 0; 1295 if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - 1296 sizeof(struct fileEntry))) { 1297 make_bad_inode(inode); 1298 return; 1299 } 1300 memcpy(iinfo->i_ext.i_data, 1301 bh->b_data + sizeof(struct fileEntry), 1302 inode->i_sb->s_blocksize - sizeof(struct fileEntry)); 1303 } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) { 1304 iinfo->i_efe = 0; 1305 iinfo->i_use = 1; 1306 iinfo->i_lenAlloc = le32_to_cpu( 1307 ((struct unallocSpaceEntry *)bh->b_data)-> 1308 lengthAllocDescs); 1309 if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - 1310 sizeof(struct unallocSpaceEntry))) { 1311 make_bad_inode(inode); 1312 return; 1313 } 1314 memcpy(iinfo->i_ext.i_data, 1315 bh->b_data + sizeof(struct unallocSpaceEntry), 1316 inode->i_sb->s_blocksize - 1317 sizeof(struct unallocSpaceEntry)); 1318 return; 1319 } 1320 1321 read_lock(&sbi->s_cred_lock); 1322 inode->i_uid = le32_to_cpu(fe->uid); 1323 if (inode->i_uid == -1 || 1324 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_IGNORE) || 1325 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_SET)) 1326 inode->i_uid = UDF_SB(inode->i_sb)->s_uid; 1327 1328 inode->i_gid = le32_to_cpu(fe->gid); 1329 if (inode->i_gid == -1 || 1330 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_IGNORE) || 1331 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_SET)) 1332 inode->i_gid = UDF_SB(inode->i_sb)->s_gid; 1333 1334 if (fe->icbTag.fileType != ICBTAG_FILE_TYPE_DIRECTORY && 1335 sbi->s_fmode != UDF_INVALID_MODE) 1336 inode->i_mode = sbi->s_fmode; 1337 else if (fe->icbTag.fileType == ICBTAG_FILE_TYPE_DIRECTORY && 1338 sbi->s_dmode != UDF_INVALID_MODE) 1339 inode->i_mode = sbi->s_dmode; 1340 else 1341 inode->i_mode = udf_convert_permissions(fe); 1342 inode->i_mode &= ~sbi->s_umask; 1343 read_unlock(&sbi->s_cred_lock); 1344 1345 link_count = le16_to_cpu(fe->fileLinkCount); 1346 if (!link_count) 1347 link_count = 1; 1348 set_nlink(inode, link_count); 1349 1350 inode->i_size = le64_to_cpu(fe->informationLength); 1351 iinfo->i_lenExtents = inode->i_size; 1352 1353 if (iinfo->i_efe == 0) { 1354 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) << 1355 (inode->i_sb->s_blocksize_bits - 9); 1356 1357 if (!udf_disk_stamp_to_time(&inode->i_atime, fe->accessTime)) 1358 inode->i_atime = sbi->s_record_time; 1359 1360 if (!udf_disk_stamp_to_time(&inode->i_mtime, 1361 fe->modificationTime)) 1362 inode->i_mtime = sbi->s_record_time; 1363 1364 if (!udf_disk_stamp_to_time(&inode->i_ctime, fe->attrTime)) 1365 inode->i_ctime = sbi->s_record_time; 1366 1367 iinfo->i_unique = le64_to_cpu(fe->uniqueID); 1368 iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr); 1369 iinfo->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs); 1370 iinfo->i_checkpoint = le32_to_cpu(fe->checkpoint); 1371 } else { 1372 inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) << 1373 (inode->i_sb->s_blocksize_bits - 9); 1374 1375 if (!udf_disk_stamp_to_time(&inode->i_atime, efe->accessTime)) 1376 inode->i_atime = sbi->s_record_time; 1377 1378 if (!udf_disk_stamp_to_time(&inode->i_mtime, 1379 efe->modificationTime)) 1380 inode->i_mtime = sbi->s_record_time; 1381 1382 if (!udf_disk_stamp_to_time(&iinfo->i_crtime, efe->createTime)) 1383 iinfo->i_crtime = sbi->s_record_time; 1384 1385 if (!udf_disk_stamp_to_time(&inode->i_ctime, efe->attrTime)) 1386 inode->i_ctime = sbi->s_record_time; 1387 1388 iinfo->i_unique = le64_to_cpu(efe->uniqueID); 1389 iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr); 1390 iinfo->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs); 1391 iinfo->i_checkpoint = le32_to_cpu(efe->checkpoint); 1392 } 1393 1394 switch (fe->icbTag.fileType) { 1395 case ICBTAG_FILE_TYPE_DIRECTORY: 1396 inode->i_op = &udf_dir_inode_operations; 1397 inode->i_fop = &udf_dir_operations; 1398 inode->i_mode |= S_IFDIR; 1399 inc_nlink(inode); 1400 break; 1401 case ICBTAG_FILE_TYPE_REALTIME: 1402 case ICBTAG_FILE_TYPE_REGULAR: 1403 case ICBTAG_FILE_TYPE_UNDEF: 1404 case ICBTAG_FILE_TYPE_VAT20: 1405 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1406 inode->i_data.a_ops = &udf_adinicb_aops; 1407 else 1408 inode->i_data.a_ops = &udf_aops; 1409 inode->i_op = &udf_file_inode_operations; 1410 inode->i_fop = &udf_file_operations; 1411 inode->i_mode |= S_IFREG; 1412 break; 1413 case ICBTAG_FILE_TYPE_BLOCK: 1414 inode->i_mode |= S_IFBLK; 1415 break; 1416 case ICBTAG_FILE_TYPE_CHAR: 1417 inode->i_mode |= S_IFCHR; 1418 break; 1419 case ICBTAG_FILE_TYPE_FIFO: 1420 init_special_inode(inode, inode->i_mode | S_IFIFO, 0); 1421 break; 1422 case ICBTAG_FILE_TYPE_SOCKET: 1423 init_special_inode(inode, inode->i_mode | S_IFSOCK, 0); 1424 break; 1425 case ICBTAG_FILE_TYPE_SYMLINK: 1426 inode->i_data.a_ops = &udf_symlink_aops; 1427 inode->i_op = &udf_symlink_inode_operations; 1428 inode->i_mode = S_IFLNK | S_IRWXUGO; 1429 break; 1430 case ICBTAG_FILE_TYPE_MAIN: 1431 udf_debug("METADATA FILE-----\n"); 1432 break; 1433 case ICBTAG_FILE_TYPE_MIRROR: 1434 udf_debug("METADATA MIRROR FILE-----\n"); 1435 break; 1436 case ICBTAG_FILE_TYPE_BITMAP: 1437 udf_debug("METADATA BITMAP FILE-----\n"); 1438 break; 1439 default: 1440 udf_err(inode->i_sb, "(ino %ld) failed unknown file type=%d\n", 1441 inode->i_ino, fe->icbTag.fileType); 1442 make_bad_inode(inode); 1443 return; 1444 } 1445 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { 1446 struct deviceSpec *dsea = 1447 (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1); 1448 if (dsea) { 1449 init_special_inode(inode, inode->i_mode, 1450 MKDEV(le32_to_cpu(dsea->majorDeviceIdent), 1451 le32_to_cpu(dsea->minorDeviceIdent))); 1452 /* Developer ID ??? */ 1453 } else 1454 make_bad_inode(inode); 1455 } 1456 } 1457 1458 static int udf_alloc_i_data(struct inode *inode, size_t size) 1459 { 1460 struct udf_inode_info *iinfo = UDF_I(inode); 1461 iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL); 1462 1463 if (!iinfo->i_ext.i_data) { 1464 udf_err(inode->i_sb, "(ino %ld) no free memory\n", 1465 inode->i_ino); 1466 return -ENOMEM; 1467 } 1468 1469 return 0; 1470 } 1471 1472 static umode_t udf_convert_permissions(struct fileEntry *fe) 1473 { 1474 umode_t mode; 1475 uint32_t permissions; 1476 uint32_t flags; 1477 1478 permissions = le32_to_cpu(fe->permissions); 1479 flags = le16_to_cpu(fe->icbTag.flags); 1480 1481 mode = ((permissions) & S_IRWXO) | 1482 ((permissions >> 2) & S_IRWXG) | 1483 ((permissions >> 4) & S_IRWXU) | 1484 ((flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) | 1485 ((flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) | 1486 ((flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0); 1487 1488 return mode; 1489 } 1490 1491 int udf_write_inode(struct inode *inode, struct writeback_control *wbc) 1492 { 1493 return udf_update_inode(inode, wbc->sync_mode == WB_SYNC_ALL); 1494 } 1495 1496 static int udf_sync_inode(struct inode *inode) 1497 { 1498 return udf_update_inode(inode, 1); 1499 } 1500 1501 static int udf_update_inode(struct inode *inode, int do_sync) 1502 { 1503 struct buffer_head *bh = NULL; 1504 struct fileEntry *fe; 1505 struct extendedFileEntry *efe; 1506 uint64_t lb_recorded; 1507 uint32_t udfperms; 1508 uint16_t icbflags; 1509 uint16_t crclen; 1510 int err = 0; 1511 struct udf_sb_info *sbi = UDF_SB(inode->i_sb); 1512 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; 1513 struct udf_inode_info *iinfo = UDF_I(inode); 1514 1515 bh = udf_tgetblk(inode->i_sb, 1516 udf_get_lb_pblock(inode->i_sb, &iinfo->i_location, 0)); 1517 if (!bh) { 1518 udf_debug("getblk failure\n"); 1519 return -ENOMEM; 1520 } 1521 1522 lock_buffer(bh); 1523 memset(bh->b_data, 0, inode->i_sb->s_blocksize); 1524 fe = (struct fileEntry *)bh->b_data; 1525 efe = (struct extendedFileEntry *)bh->b_data; 1526 1527 if (iinfo->i_use) { 1528 struct unallocSpaceEntry *use = 1529 (struct unallocSpaceEntry *)bh->b_data; 1530 1531 use->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc); 1532 memcpy(bh->b_data + sizeof(struct unallocSpaceEntry), 1533 iinfo->i_ext.i_data, inode->i_sb->s_blocksize - 1534 sizeof(struct unallocSpaceEntry)); 1535 use->descTag.tagIdent = cpu_to_le16(TAG_IDENT_USE); 1536 use->descTag.tagLocation = 1537 cpu_to_le32(iinfo->i_location.logicalBlockNum); 1538 crclen = sizeof(struct unallocSpaceEntry) + 1539 iinfo->i_lenAlloc - sizeof(struct tag); 1540 use->descTag.descCRCLength = cpu_to_le16(crclen); 1541 use->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)use + 1542 sizeof(struct tag), 1543 crclen)); 1544 use->descTag.tagChecksum = udf_tag_checksum(&use->descTag); 1545 1546 goto out; 1547 } 1548 1549 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET)) 1550 fe->uid = cpu_to_le32(-1); 1551 else 1552 fe->uid = cpu_to_le32(inode->i_uid); 1553 1554 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET)) 1555 fe->gid = cpu_to_le32(-1); 1556 else 1557 fe->gid = cpu_to_le32(inode->i_gid); 1558 1559 udfperms = ((inode->i_mode & S_IRWXO)) | 1560 ((inode->i_mode & S_IRWXG) << 2) | 1561 ((inode->i_mode & S_IRWXU) << 4); 1562 1563 udfperms |= (le32_to_cpu(fe->permissions) & 1564 (FE_PERM_O_DELETE | FE_PERM_O_CHATTR | 1565 FE_PERM_G_DELETE | FE_PERM_G_CHATTR | 1566 FE_PERM_U_DELETE | FE_PERM_U_CHATTR)); 1567 fe->permissions = cpu_to_le32(udfperms); 1568 1569 if (S_ISDIR(inode->i_mode)) 1570 fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1); 1571 else 1572 fe->fileLinkCount = cpu_to_le16(inode->i_nlink); 1573 1574 fe->informationLength = cpu_to_le64(inode->i_size); 1575 1576 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { 1577 struct regid *eid; 1578 struct deviceSpec *dsea = 1579 (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1); 1580 if (!dsea) { 1581 dsea = (struct deviceSpec *) 1582 udf_add_extendedattr(inode, 1583 sizeof(struct deviceSpec) + 1584 sizeof(struct regid), 12, 0x3); 1585 dsea->attrType = cpu_to_le32(12); 1586 dsea->attrSubtype = 1; 1587 dsea->attrLength = cpu_to_le32( 1588 sizeof(struct deviceSpec) + 1589 sizeof(struct regid)); 1590 dsea->impUseLength = cpu_to_le32(sizeof(struct regid)); 1591 } 1592 eid = (struct regid *)dsea->impUse; 1593 memset(eid, 0, sizeof(struct regid)); 1594 strcpy(eid->ident, UDF_ID_DEVELOPER); 1595 eid->identSuffix[0] = UDF_OS_CLASS_UNIX; 1596 eid->identSuffix[1] = UDF_OS_ID_LINUX; 1597 dsea->majorDeviceIdent = cpu_to_le32(imajor(inode)); 1598 dsea->minorDeviceIdent = cpu_to_le32(iminor(inode)); 1599 } 1600 1601 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1602 lb_recorded = 0; /* No extents => no blocks! */ 1603 else 1604 lb_recorded = 1605 (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >> 1606 (blocksize_bits - 9); 1607 1608 if (iinfo->i_efe == 0) { 1609 memcpy(bh->b_data + sizeof(struct fileEntry), 1610 iinfo->i_ext.i_data, 1611 inode->i_sb->s_blocksize - sizeof(struct fileEntry)); 1612 fe->logicalBlocksRecorded = cpu_to_le64(lb_recorded); 1613 1614 udf_time_to_disk_stamp(&fe->accessTime, inode->i_atime); 1615 udf_time_to_disk_stamp(&fe->modificationTime, inode->i_mtime); 1616 udf_time_to_disk_stamp(&fe->attrTime, inode->i_ctime); 1617 memset(&(fe->impIdent), 0, sizeof(struct regid)); 1618 strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER); 1619 fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; 1620 fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; 1621 fe->uniqueID = cpu_to_le64(iinfo->i_unique); 1622 fe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr); 1623 fe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc); 1624 fe->checkpoint = cpu_to_le32(iinfo->i_checkpoint); 1625 fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE); 1626 crclen = sizeof(struct fileEntry); 1627 } else { 1628 memcpy(bh->b_data + sizeof(struct extendedFileEntry), 1629 iinfo->i_ext.i_data, 1630 inode->i_sb->s_blocksize - 1631 sizeof(struct extendedFileEntry)); 1632 efe->objectSize = cpu_to_le64(inode->i_size); 1633 efe->logicalBlocksRecorded = cpu_to_le64(lb_recorded); 1634 1635 if (iinfo->i_crtime.tv_sec > inode->i_atime.tv_sec || 1636 (iinfo->i_crtime.tv_sec == inode->i_atime.tv_sec && 1637 iinfo->i_crtime.tv_nsec > inode->i_atime.tv_nsec)) 1638 iinfo->i_crtime = inode->i_atime; 1639 1640 if (iinfo->i_crtime.tv_sec > inode->i_mtime.tv_sec || 1641 (iinfo->i_crtime.tv_sec == inode->i_mtime.tv_sec && 1642 iinfo->i_crtime.tv_nsec > inode->i_mtime.tv_nsec)) 1643 iinfo->i_crtime = inode->i_mtime; 1644 1645 if (iinfo->i_crtime.tv_sec > inode->i_ctime.tv_sec || 1646 (iinfo->i_crtime.tv_sec == inode->i_ctime.tv_sec && 1647 iinfo->i_crtime.tv_nsec > inode->i_ctime.tv_nsec)) 1648 iinfo->i_crtime = inode->i_ctime; 1649 1650 udf_time_to_disk_stamp(&efe->accessTime, inode->i_atime); 1651 udf_time_to_disk_stamp(&efe->modificationTime, inode->i_mtime); 1652 udf_time_to_disk_stamp(&efe->createTime, iinfo->i_crtime); 1653 udf_time_to_disk_stamp(&efe->attrTime, inode->i_ctime); 1654 1655 memset(&(efe->impIdent), 0, sizeof(struct regid)); 1656 strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER); 1657 efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; 1658 efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; 1659 efe->uniqueID = cpu_to_le64(iinfo->i_unique); 1660 efe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr); 1661 efe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc); 1662 efe->checkpoint = cpu_to_le32(iinfo->i_checkpoint); 1663 efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE); 1664 crclen = sizeof(struct extendedFileEntry); 1665 } 1666 if (iinfo->i_strat4096) { 1667 fe->icbTag.strategyType = cpu_to_le16(4096); 1668 fe->icbTag.strategyParameter = cpu_to_le16(1); 1669 fe->icbTag.numEntries = cpu_to_le16(2); 1670 } else { 1671 fe->icbTag.strategyType = cpu_to_le16(4); 1672 fe->icbTag.numEntries = cpu_to_le16(1); 1673 } 1674 1675 if (S_ISDIR(inode->i_mode)) 1676 fe->icbTag.fileType = ICBTAG_FILE_TYPE_DIRECTORY; 1677 else if (S_ISREG(inode->i_mode)) 1678 fe->icbTag.fileType = ICBTAG_FILE_TYPE_REGULAR; 1679 else if (S_ISLNK(inode->i_mode)) 1680 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SYMLINK; 1681 else if (S_ISBLK(inode->i_mode)) 1682 fe->icbTag.fileType = ICBTAG_FILE_TYPE_BLOCK; 1683 else if (S_ISCHR(inode->i_mode)) 1684 fe->icbTag.fileType = ICBTAG_FILE_TYPE_CHAR; 1685 else if (S_ISFIFO(inode->i_mode)) 1686 fe->icbTag.fileType = ICBTAG_FILE_TYPE_FIFO; 1687 else if (S_ISSOCK(inode->i_mode)) 1688 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET; 1689 1690 icbflags = iinfo->i_alloc_type | 1691 ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) | 1692 ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) | 1693 ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) | 1694 (le16_to_cpu(fe->icbTag.flags) & 1695 ~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID | 1696 ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY)); 1697 1698 fe->icbTag.flags = cpu_to_le16(icbflags); 1699 if (sbi->s_udfrev >= 0x0200) 1700 fe->descTag.descVersion = cpu_to_le16(3); 1701 else 1702 fe->descTag.descVersion = cpu_to_le16(2); 1703 fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number); 1704 fe->descTag.tagLocation = cpu_to_le32( 1705 iinfo->i_location.logicalBlockNum); 1706 crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc - sizeof(struct tag); 1707 fe->descTag.descCRCLength = cpu_to_le16(crclen); 1708 fe->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)fe + sizeof(struct tag), 1709 crclen)); 1710 fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag); 1711 1712 out: 1713 set_buffer_uptodate(bh); 1714 unlock_buffer(bh); 1715 1716 /* write the data blocks */ 1717 mark_buffer_dirty(bh); 1718 if (do_sync) { 1719 sync_dirty_buffer(bh); 1720 if (buffer_write_io_error(bh)) { 1721 udf_warn(inode->i_sb, "IO error syncing udf inode [%08lx]\n", 1722 inode->i_ino); 1723 err = -EIO; 1724 } 1725 } 1726 brelse(bh); 1727 1728 return err; 1729 } 1730 1731 struct inode *udf_iget(struct super_block *sb, struct kernel_lb_addr *ino) 1732 { 1733 unsigned long block = udf_get_lb_pblock(sb, ino, 0); 1734 struct inode *inode = iget_locked(sb, block); 1735 1736 if (!inode) 1737 return NULL; 1738 1739 if (inode->i_state & I_NEW) { 1740 memcpy(&UDF_I(inode)->i_location, ino, sizeof(struct kernel_lb_addr)); 1741 __udf_read_inode(inode); 1742 unlock_new_inode(inode); 1743 } 1744 1745 if (is_bad_inode(inode)) 1746 goto out_iput; 1747 1748 if (ino->logicalBlockNum >= UDF_SB(sb)-> 1749 s_partmaps[ino->partitionReferenceNum].s_partition_len) { 1750 udf_debug("block=%d, partition=%d out of range\n", 1751 ino->logicalBlockNum, ino->partitionReferenceNum); 1752 make_bad_inode(inode); 1753 goto out_iput; 1754 } 1755 1756 return inode; 1757 1758 out_iput: 1759 iput(inode); 1760 return NULL; 1761 } 1762 1763 int udf_add_aext(struct inode *inode, struct extent_position *epos, 1764 struct kernel_lb_addr *eloc, uint32_t elen, int inc) 1765 { 1766 int adsize; 1767 struct short_ad *sad = NULL; 1768 struct long_ad *lad = NULL; 1769 struct allocExtDesc *aed; 1770 uint8_t *ptr; 1771 struct udf_inode_info *iinfo = UDF_I(inode); 1772 1773 if (!epos->bh) 1774 ptr = iinfo->i_ext.i_data + epos->offset - 1775 udf_file_entry_alloc_offset(inode) + 1776 iinfo->i_lenEAttr; 1777 else 1778 ptr = epos->bh->b_data + epos->offset; 1779 1780 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 1781 adsize = sizeof(struct short_ad); 1782 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 1783 adsize = sizeof(struct long_ad); 1784 else 1785 return -EIO; 1786 1787 if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize) { 1788 unsigned char *sptr, *dptr; 1789 struct buffer_head *nbh; 1790 int err, loffset; 1791 struct kernel_lb_addr obloc = epos->block; 1792 1793 epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL, 1794 obloc.partitionReferenceNum, 1795 obloc.logicalBlockNum, &err); 1796 if (!epos->block.logicalBlockNum) 1797 return -ENOSPC; 1798 nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb, 1799 &epos->block, 1800 0)); 1801 if (!nbh) 1802 return -EIO; 1803 lock_buffer(nbh); 1804 memset(nbh->b_data, 0x00, inode->i_sb->s_blocksize); 1805 set_buffer_uptodate(nbh); 1806 unlock_buffer(nbh); 1807 mark_buffer_dirty_inode(nbh, inode); 1808 1809 aed = (struct allocExtDesc *)(nbh->b_data); 1810 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) 1811 aed->previousAllocExtLocation = 1812 cpu_to_le32(obloc.logicalBlockNum); 1813 if (epos->offset + adsize > inode->i_sb->s_blocksize) { 1814 loffset = epos->offset; 1815 aed->lengthAllocDescs = cpu_to_le32(adsize); 1816 sptr = ptr - adsize; 1817 dptr = nbh->b_data + sizeof(struct allocExtDesc); 1818 memcpy(dptr, sptr, adsize); 1819 epos->offset = sizeof(struct allocExtDesc) + adsize; 1820 } else { 1821 loffset = epos->offset + adsize; 1822 aed->lengthAllocDescs = cpu_to_le32(0); 1823 sptr = ptr; 1824 epos->offset = sizeof(struct allocExtDesc); 1825 1826 if (epos->bh) { 1827 aed = (struct allocExtDesc *)epos->bh->b_data; 1828 le32_add_cpu(&aed->lengthAllocDescs, adsize); 1829 } else { 1830 iinfo->i_lenAlloc += adsize; 1831 mark_inode_dirty(inode); 1832 } 1833 } 1834 if (UDF_SB(inode->i_sb)->s_udfrev >= 0x0200) 1835 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1, 1836 epos->block.logicalBlockNum, sizeof(struct tag)); 1837 else 1838 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1, 1839 epos->block.logicalBlockNum, sizeof(struct tag)); 1840 switch (iinfo->i_alloc_type) { 1841 case ICBTAG_FLAG_AD_SHORT: 1842 sad = (struct short_ad *)sptr; 1843 sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS | 1844 inode->i_sb->s_blocksize); 1845 sad->extPosition = 1846 cpu_to_le32(epos->block.logicalBlockNum); 1847 break; 1848 case ICBTAG_FLAG_AD_LONG: 1849 lad = (struct long_ad *)sptr; 1850 lad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS | 1851 inode->i_sb->s_blocksize); 1852 lad->extLocation = cpu_to_lelb(epos->block); 1853 memset(lad->impUse, 0x00, sizeof(lad->impUse)); 1854 break; 1855 } 1856 if (epos->bh) { 1857 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || 1858 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) 1859 udf_update_tag(epos->bh->b_data, loffset); 1860 else 1861 udf_update_tag(epos->bh->b_data, 1862 sizeof(struct allocExtDesc)); 1863 mark_buffer_dirty_inode(epos->bh, inode); 1864 brelse(epos->bh); 1865 } else { 1866 mark_inode_dirty(inode); 1867 } 1868 epos->bh = nbh; 1869 } 1870 1871 udf_write_aext(inode, epos, eloc, elen, inc); 1872 1873 if (!epos->bh) { 1874 iinfo->i_lenAlloc += adsize; 1875 mark_inode_dirty(inode); 1876 } else { 1877 aed = (struct allocExtDesc *)epos->bh->b_data; 1878 le32_add_cpu(&aed->lengthAllocDescs, adsize); 1879 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || 1880 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) 1881 udf_update_tag(epos->bh->b_data, 1882 epos->offset + (inc ? 0 : adsize)); 1883 else 1884 udf_update_tag(epos->bh->b_data, 1885 sizeof(struct allocExtDesc)); 1886 mark_buffer_dirty_inode(epos->bh, inode); 1887 } 1888 1889 return 0; 1890 } 1891 1892 void udf_write_aext(struct inode *inode, struct extent_position *epos, 1893 struct kernel_lb_addr *eloc, uint32_t elen, int inc) 1894 { 1895 int adsize; 1896 uint8_t *ptr; 1897 struct short_ad *sad; 1898 struct long_ad *lad; 1899 struct udf_inode_info *iinfo = UDF_I(inode); 1900 1901 if (!epos->bh) 1902 ptr = iinfo->i_ext.i_data + epos->offset - 1903 udf_file_entry_alloc_offset(inode) + 1904 iinfo->i_lenEAttr; 1905 else 1906 ptr = epos->bh->b_data + epos->offset; 1907 1908 switch (iinfo->i_alloc_type) { 1909 case ICBTAG_FLAG_AD_SHORT: 1910 sad = (struct short_ad *)ptr; 1911 sad->extLength = cpu_to_le32(elen); 1912 sad->extPosition = cpu_to_le32(eloc->logicalBlockNum); 1913 adsize = sizeof(struct short_ad); 1914 break; 1915 case ICBTAG_FLAG_AD_LONG: 1916 lad = (struct long_ad *)ptr; 1917 lad->extLength = cpu_to_le32(elen); 1918 lad->extLocation = cpu_to_lelb(*eloc); 1919 memset(lad->impUse, 0x00, sizeof(lad->impUse)); 1920 adsize = sizeof(struct long_ad); 1921 break; 1922 default: 1923 return; 1924 } 1925 1926 if (epos->bh) { 1927 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || 1928 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) { 1929 struct allocExtDesc *aed = 1930 (struct allocExtDesc *)epos->bh->b_data; 1931 udf_update_tag(epos->bh->b_data, 1932 le32_to_cpu(aed->lengthAllocDescs) + 1933 sizeof(struct allocExtDesc)); 1934 } 1935 mark_buffer_dirty_inode(epos->bh, inode); 1936 } else { 1937 mark_inode_dirty(inode); 1938 } 1939 1940 if (inc) 1941 epos->offset += adsize; 1942 } 1943 1944 int8_t udf_next_aext(struct inode *inode, struct extent_position *epos, 1945 struct kernel_lb_addr *eloc, uint32_t *elen, int inc) 1946 { 1947 int8_t etype; 1948 1949 while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) == 1950 (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) { 1951 int block; 1952 epos->block = *eloc; 1953 epos->offset = sizeof(struct allocExtDesc); 1954 brelse(epos->bh); 1955 block = udf_get_lb_pblock(inode->i_sb, &epos->block, 0); 1956 epos->bh = udf_tread(inode->i_sb, block); 1957 if (!epos->bh) { 1958 udf_debug("reading block %d failed!\n", block); 1959 return -1; 1960 } 1961 } 1962 1963 return etype; 1964 } 1965 1966 int8_t udf_current_aext(struct inode *inode, struct extent_position *epos, 1967 struct kernel_lb_addr *eloc, uint32_t *elen, int inc) 1968 { 1969 int alen; 1970 int8_t etype; 1971 uint8_t *ptr; 1972 struct short_ad *sad; 1973 struct long_ad *lad; 1974 struct udf_inode_info *iinfo = UDF_I(inode); 1975 1976 if (!epos->bh) { 1977 if (!epos->offset) 1978 epos->offset = udf_file_entry_alloc_offset(inode); 1979 ptr = iinfo->i_ext.i_data + epos->offset - 1980 udf_file_entry_alloc_offset(inode) + 1981 iinfo->i_lenEAttr; 1982 alen = udf_file_entry_alloc_offset(inode) + 1983 iinfo->i_lenAlloc; 1984 } else { 1985 if (!epos->offset) 1986 epos->offset = sizeof(struct allocExtDesc); 1987 ptr = epos->bh->b_data + epos->offset; 1988 alen = sizeof(struct allocExtDesc) + 1989 le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)-> 1990 lengthAllocDescs); 1991 } 1992 1993 switch (iinfo->i_alloc_type) { 1994 case ICBTAG_FLAG_AD_SHORT: 1995 sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc); 1996 if (!sad) 1997 return -1; 1998 etype = le32_to_cpu(sad->extLength) >> 30; 1999 eloc->logicalBlockNum = le32_to_cpu(sad->extPosition); 2000 eloc->partitionReferenceNum = 2001 iinfo->i_location.partitionReferenceNum; 2002 *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK; 2003 break; 2004 case ICBTAG_FLAG_AD_LONG: 2005 lad = udf_get_filelongad(ptr, alen, &epos->offset, inc); 2006 if (!lad) 2007 return -1; 2008 etype = le32_to_cpu(lad->extLength) >> 30; 2009 *eloc = lelb_to_cpu(lad->extLocation); 2010 *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK; 2011 break; 2012 default: 2013 udf_debug("alloc_type = %d unsupported\n", iinfo->i_alloc_type); 2014 return -1; 2015 } 2016 2017 return etype; 2018 } 2019 2020 static int8_t udf_insert_aext(struct inode *inode, struct extent_position epos, 2021 struct kernel_lb_addr neloc, uint32_t nelen) 2022 { 2023 struct kernel_lb_addr oeloc; 2024 uint32_t oelen; 2025 int8_t etype; 2026 2027 if (epos.bh) 2028 get_bh(epos.bh); 2029 2030 while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) { 2031 udf_write_aext(inode, &epos, &neloc, nelen, 1); 2032 neloc = oeloc; 2033 nelen = (etype << 30) | oelen; 2034 } 2035 udf_add_aext(inode, &epos, &neloc, nelen, 1); 2036 brelse(epos.bh); 2037 2038 return (nelen >> 30); 2039 } 2040 2041 int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, 2042 struct kernel_lb_addr eloc, uint32_t elen) 2043 { 2044 struct extent_position oepos; 2045 int adsize; 2046 int8_t etype; 2047 struct allocExtDesc *aed; 2048 struct udf_inode_info *iinfo; 2049 2050 if (epos.bh) { 2051 get_bh(epos.bh); 2052 get_bh(epos.bh); 2053 } 2054 2055 iinfo = UDF_I(inode); 2056 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 2057 adsize = sizeof(struct short_ad); 2058 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 2059 adsize = sizeof(struct long_ad); 2060 else 2061 adsize = 0; 2062 2063 oepos = epos; 2064 if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1) 2065 return -1; 2066 2067 while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) { 2068 udf_write_aext(inode, &oepos, &eloc, (etype << 30) | elen, 1); 2069 if (oepos.bh != epos.bh) { 2070 oepos.block = epos.block; 2071 brelse(oepos.bh); 2072 get_bh(epos.bh); 2073 oepos.bh = epos.bh; 2074 oepos.offset = epos.offset - adsize; 2075 } 2076 } 2077 memset(&eloc, 0x00, sizeof(struct kernel_lb_addr)); 2078 elen = 0; 2079 2080 if (epos.bh != oepos.bh) { 2081 udf_free_blocks(inode->i_sb, inode, &epos.block, 0, 1); 2082 udf_write_aext(inode, &oepos, &eloc, elen, 1); 2083 udf_write_aext(inode, &oepos, &eloc, elen, 1); 2084 if (!oepos.bh) { 2085 iinfo->i_lenAlloc -= (adsize * 2); 2086 mark_inode_dirty(inode); 2087 } else { 2088 aed = (struct allocExtDesc *)oepos.bh->b_data; 2089 le32_add_cpu(&aed->lengthAllocDescs, -(2 * adsize)); 2090 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || 2091 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) 2092 udf_update_tag(oepos.bh->b_data, 2093 oepos.offset - (2 * adsize)); 2094 else 2095 udf_update_tag(oepos.bh->b_data, 2096 sizeof(struct allocExtDesc)); 2097 mark_buffer_dirty_inode(oepos.bh, inode); 2098 } 2099 } else { 2100 udf_write_aext(inode, &oepos, &eloc, elen, 1); 2101 if (!oepos.bh) { 2102 iinfo->i_lenAlloc -= adsize; 2103 mark_inode_dirty(inode); 2104 } else { 2105 aed = (struct allocExtDesc *)oepos.bh->b_data; 2106 le32_add_cpu(&aed->lengthAllocDescs, -adsize); 2107 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || 2108 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) 2109 udf_update_tag(oepos.bh->b_data, 2110 epos.offset - adsize); 2111 else 2112 udf_update_tag(oepos.bh->b_data, 2113 sizeof(struct allocExtDesc)); 2114 mark_buffer_dirty_inode(oepos.bh, inode); 2115 } 2116 } 2117 2118 brelse(epos.bh); 2119 brelse(oepos.bh); 2120 2121 return (elen >> 30); 2122 } 2123 2124 int8_t inode_bmap(struct inode *inode, sector_t block, 2125 struct extent_position *pos, struct kernel_lb_addr *eloc, 2126 uint32_t *elen, sector_t *offset) 2127 { 2128 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; 2129 loff_t lbcount = 0, bcount = 2130 (loff_t) block << blocksize_bits; 2131 int8_t etype; 2132 struct udf_inode_info *iinfo; 2133 2134 iinfo = UDF_I(inode); 2135 pos->offset = 0; 2136 pos->block = iinfo->i_location; 2137 pos->bh = NULL; 2138 *elen = 0; 2139 2140 do { 2141 etype = udf_next_aext(inode, pos, eloc, elen, 1); 2142 if (etype == -1) { 2143 *offset = (bcount - lbcount) >> blocksize_bits; 2144 iinfo->i_lenExtents = lbcount; 2145 return -1; 2146 } 2147 lbcount += *elen; 2148 } while (lbcount <= bcount); 2149 2150 *offset = (bcount + *elen - lbcount) >> blocksize_bits; 2151 2152 return etype; 2153 } 2154 2155 long udf_block_map(struct inode *inode, sector_t block) 2156 { 2157 struct kernel_lb_addr eloc; 2158 uint32_t elen; 2159 sector_t offset; 2160 struct extent_position epos = {}; 2161 int ret; 2162 2163 down_read(&UDF_I(inode)->i_data_sem); 2164 2165 if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) == 2166 (EXT_RECORDED_ALLOCATED >> 30)) 2167 ret = udf_get_lb_pblock(inode->i_sb, &eloc, offset); 2168 else 2169 ret = 0; 2170 2171 up_read(&UDF_I(inode)->i_data_sem); 2172 brelse(epos.bh); 2173 2174 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV)) 2175 return udf_fixed_to_variable(ret); 2176 else 2177 return ret; 2178 } 2179