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