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