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