inode.c revision 2c2111c2bd821d3e7cf5a6a37a112a620fd947a3
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 43MODULE_AUTHOR("Ben Fennema"); 44MODULE_DESCRIPTION("Universal Disk Format Filesystem"); 45MODULE_LICENSE("GPL"); 46 47#define EXTENT_MERGE_SIZE 5 48 49static mode_t udf_convert_permissions(struct fileEntry *); 50static int udf_update_inode(struct inode *, int); 51static void udf_fill_inode(struct inode *, struct buffer_head *); 52static struct buffer_head *inode_getblk(struct inode *, long, int *, 53 long *, int *); 54static int8_t udf_insert_aext(struct inode *, kernel_lb_addr, int, 55 kernel_lb_addr, uint32_t, struct buffer_head *); 56static void udf_split_extents(struct inode *, int *, int, int, 57 kernel_long_ad [EXTENT_MERGE_SIZE], int *); 58static void udf_prealloc_extents(struct inode *, int, int, 59 kernel_long_ad [EXTENT_MERGE_SIZE], int *); 60static void udf_merge_extents(struct inode *, 61 kernel_long_ad [EXTENT_MERGE_SIZE], int *); 62static void udf_update_extents(struct inode *, 63 kernel_long_ad [EXTENT_MERGE_SIZE], int, int, 64 kernel_lb_addr, uint32_t, struct buffer_head **); 65static 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 */ 83void 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; 99no_delete: 100 clear_inode(inode); 101} 102 103void 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 115static int udf_writepage(struct page *page, struct writeback_control *wbc) 116{ 117 return block_write_full_page(page, udf_get_block, wbc); 118} 119 120static int udf_readpage(struct file *file, struct page *page) 121{ 122 return block_read_full_page(page, udf_get_block); 123} 124 125static 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 130static sector_t udf_bmap(struct address_space *mapping, sector_t block) 131{ 132 return generic_block_bmap(mapping,block,udf_get_block); 133} 134 135struct 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 144void 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 194struct 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 283static 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); 323abort: 324 unlock_kernel(); 325 return err; 326 327abort_negative: 328 udf_warning(inode->i_sb, "udf_get_block", "block < 0"); 329 goto abort; 330} 331 332static struct buffer_head * 333udf_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 357static 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 557static 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 619static 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 711static 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 796static 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 832struct 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 852void 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 900static 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 inode->i_blksize = PAGE_SIZE; 920 921 bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident); 922 923 if (!bh) 924 { 925 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n", 926 inode->i_ino); 927 make_bad_inode(inode); 928 return; 929 } 930 931 if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE && 932 ident != TAG_IDENT_USE) 933 { 934 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%d\n", 935 inode->i_ino, ident); 936 udf_release_data(bh); 937 make_bad_inode(inode); 938 return; 939 } 940 941 fe = (struct fileEntry *)bh->b_data; 942 943 if (le16_to_cpu(fe->icbTag.strategyType) == 4096) 944 { 945 struct buffer_head *ibh = NULL, *nbh = NULL; 946 struct indirectEntry *ie; 947 948 ibh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 1, &ident); 949 if (ident == TAG_IDENT_IE) 950 { 951 if (ibh) 952 { 953 kernel_lb_addr loc; 954 ie = (struct indirectEntry *)ibh->b_data; 955 956 loc = lelb_to_cpu(ie->indirectICB.extLocation); 957 958 if (ie->indirectICB.extLength && 959 (nbh = udf_read_ptagged(inode->i_sb, loc, 0, &ident))) 960 { 961 if (ident == TAG_IDENT_FE || 962 ident == TAG_IDENT_EFE) 963 { 964 memcpy(&UDF_I_LOCATION(inode), &loc, sizeof(kernel_lb_addr)); 965 udf_release_data(bh); 966 udf_release_data(ibh); 967 udf_release_data(nbh); 968 __udf_read_inode(inode); 969 return; 970 } 971 else 972 { 973 udf_release_data(nbh); 974 udf_release_data(ibh); 975 } 976 } 977 else 978 udf_release_data(ibh); 979 } 980 } 981 else 982 udf_release_data(ibh); 983 } 984 else if (le16_to_cpu(fe->icbTag.strategyType) != 4) 985 { 986 printk(KERN_ERR "udf: unsupported strategy type: %d\n", 987 le16_to_cpu(fe->icbTag.strategyType)); 988 udf_release_data(bh); 989 make_bad_inode(inode); 990 return; 991 } 992 udf_fill_inode(inode, bh); 993 udf_release_data(bh); 994} 995 996static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) 997{ 998 struct fileEntry *fe; 999 struct extendedFileEntry *efe; 1000 time_t convtime; 1001 long convtime_usec; 1002 int offset; 1003 1004 fe = (struct fileEntry *)bh->b_data; 1005 efe = (struct extendedFileEntry *)bh->b_data; 1006 1007 if (le16_to_cpu(fe->icbTag.strategyType) == 4) 1008 UDF_I_STRAT4096(inode) = 0; 1009 else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */ 1010 UDF_I_STRAT4096(inode) = 1; 1011 1012 UDF_I_ALLOCTYPE(inode) = le16_to_cpu(fe->icbTag.flags) & ICBTAG_FLAG_AD_MASK; 1013 UDF_I_UNIQUE(inode) = 0; 1014 UDF_I_LENEATTR(inode) = 0; 1015 UDF_I_LENEXTENTS(inode) = 0; 1016 UDF_I_LENALLOC(inode) = 0; 1017 UDF_I_NEXT_ALLOC_BLOCK(inode) = 0; 1018 UDF_I_NEXT_ALLOC_GOAL(inode) = 0; 1019 if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_EFE) 1020 { 1021 UDF_I_EFE(inode) = 1; 1022 UDF_I_USE(inode) = 0; 1023 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL); 1024 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct extendedFileEntry), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry)); 1025 } 1026 else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE) 1027 { 1028 UDF_I_EFE(inode) = 0; 1029 UDF_I_USE(inode) = 0; 1030 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL); 1031 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct fileEntry), inode->i_sb->s_blocksize - sizeof(struct fileEntry)); 1032 } 1033 else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) 1034 { 1035 UDF_I_EFE(inode) = 0; 1036 UDF_I_USE(inode) = 1; 1037 UDF_I_LENALLOC(inode) = 1038 le32_to_cpu( 1039 ((struct unallocSpaceEntry *)bh->b_data)->lengthAllocDescs); 1040 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry), GFP_KERNEL); 1041 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct unallocSpaceEntry), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry)); 1042 return; 1043 } 1044 1045 inode->i_uid = le32_to_cpu(fe->uid); 1046 if (inode->i_uid == -1 || UDF_QUERY_FLAG(inode->i_sb, 1047 UDF_FLAG_UID_IGNORE)) 1048 inode->i_uid = UDF_SB(inode->i_sb)->s_uid; 1049 1050 inode->i_gid = le32_to_cpu(fe->gid); 1051 if (inode->i_gid == -1 || UDF_QUERY_FLAG(inode->i_sb, 1052 UDF_FLAG_GID_IGNORE)) 1053 inode->i_gid = UDF_SB(inode->i_sb)->s_gid; 1054 1055 inode->i_nlink = le16_to_cpu(fe->fileLinkCount); 1056 if (!inode->i_nlink) 1057 inode->i_nlink = 1; 1058 1059 inode->i_size = le64_to_cpu(fe->informationLength); 1060 UDF_I_LENEXTENTS(inode) = inode->i_size; 1061 1062 inode->i_mode = udf_convert_permissions(fe); 1063 inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask; 1064 1065 if (UDF_I_EFE(inode) == 0) 1066 { 1067 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) << 1068 (inode->i_sb->s_blocksize_bits - 9); 1069 1070 if ( udf_stamp_to_time(&convtime, &convtime_usec, 1071 lets_to_cpu(fe->accessTime)) ) 1072 { 1073 inode->i_atime.tv_sec = convtime; 1074 inode->i_atime.tv_nsec = convtime_usec * 1000; 1075 } 1076 else 1077 { 1078 inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb); 1079 } 1080 1081 if ( udf_stamp_to_time(&convtime, &convtime_usec, 1082 lets_to_cpu(fe->modificationTime)) ) 1083 { 1084 inode->i_mtime.tv_sec = convtime; 1085 inode->i_mtime.tv_nsec = convtime_usec * 1000; 1086 } 1087 else 1088 { 1089 inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb); 1090 } 1091 1092 if ( udf_stamp_to_time(&convtime, &convtime_usec, 1093 lets_to_cpu(fe->attrTime)) ) 1094 { 1095 inode->i_ctime.tv_sec = convtime; 1096 inode->i_ctime.tv_nsec = convtime_usec * 1000; 1097 } 1098 else 1099 { 1100 inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb); 1101 } 1102 1103 UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID); 1104 UDF_I_LENEATTR(inode) = le32_to_cpu(fe->lengthExtendedAttr); 1105 UDF_I_LENALLOC(inode) = le32_to_cpu(fe->lengthAllocDescs); 1106 offset = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode); 1107 } 1108 else 1109 { 1110 inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) << 1111 (inode->i_sb->s_blocksize_bits - 9); 1112 1113 if ( udf_stamp_to_time(&convtime, &convtime_usec, 1114 lets_to_cpu(efe->accessTime)) ) 1115 { 1116 inode->i_atime.tv_sec = convtime; 1117 inode->i_atime.tv_nsec = convtime_usec * 1000; 1118 } 1119 else 1120 { 1121 inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb); 1122 } 1123 1124 if ( udf_stamp_to_time(&convtime, &convtime_usec, 1125 lets_to_cpu(efe->modificationTime)) ) 1126 { 1127 inode->i_mtime.tv_sec = convtime; 1128 inode->i_mtime.tv_nsec = convtime_usec * 1000; 1129 } 1130 else 1131 { 1132 inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb); 1133 } 1134 1135 if ( udf_stamp_to_time(&convtime, &convtime_usec, 1136 lets_to_cpu(efe->createTime)) ) 1137 { 1138 UDF_I_CRTIME(inode).tv_sec = convtime; 1139 UDF_I_CRTIME(inode).tv_nsec = convtime_usec * 1000; 1140 } 1141 else 1142 { 1143 UDF_I_CRTIME(inode) = UDF_SB_RECORDTIME(inode->i_sb); 1144 } 1145 1146 if ( udf_stamp_to_time(&convtime, &convtime_usec, 1147 lets_to_cpu(efe->attrTime)) ) 1148 { 1149 inode->i_ctime.tv_sec = convtime; 1150 inode->i_ctime.tv_nsec = convtime_usec * 1000; 1151 } 1152 else 1153 { 1154 inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb); 1155 } 1156 1157 UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID); 1158 UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr); 1159 UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs); 1160 offset = sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode); 1161 } 1162 1163 switch (fe->icbTag.fileType) 1164 { 1165 case ICBTAG_FILE_TYPE_DIRECTORY: 1166 { 1167 inode->i_op = &udf_dir_inode_operations; 1168 inode->i_fop = &udf_dir_operations; 1169 inode->i_mode |= S_IFDIR; 1170 inode->i_nlink ++; 1171 break; 1172 } 1173 case ICBTAG_FILE_TYPE_REALTIME: 1174 case ICBTAG_FILE_TYPE_REGULAR: 1175 case ICBTAG_FILE_TYPE_UNDEF: 1176 { 1177 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) 1178 inode->i_data.a_ops = &udf_adinicb_aops; 1179 else 1180 inode->i_data.a_ops = &udf_aops; 1181 inode->i_op = &udf_file_inode_operations; 1182 inode->i_fop = &udf_file_operations; 1183 inode->i_mode |= S_IFREG; 1184 break; 1185 } 1186 case ICBTAG_FILE_TYPE_BLOCK: 1187 { 1188 inode->i_mode |= S_IFBLK; 1189 break; 1190 } 1191 case ICBTAG_FILE_TYPE_CHAR: 1192 { 1193 inode->i_mode |= S_IFCHR; 1194 break; 1195 } 1196 case ICBTAG_FILE_TYPE_FIFO: 1197 { 1198 init_special_inode(inode, inode->i_mode | S_IFIFO, 0); 1199 break; 1200 } 1201 case ICBTAG_FILE_TYPE_SOCKET: 1202 { 1203 init_special_inode(inode, inode->i_mode | S_IFSOCK, 0); 1204 break; 1205 } 1206 case ICBTAG_FILE_TYPE_SYMLINK: 1207 { 1208 inode->i_data.a_ops = &udf_symlink_aops; 1209 inode->i_op = &page_symlink_inode_operations; 1210 inode->i_mode = S_IFLNK|S_IRWXUGO; 1211 break; 1212 } 1213 default: 1214 { 1215 printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n", 1216 inode->i_ino, fe->icbTag.fileType); 1217 make_bad_inode(inode); 1218 return; 1219 } 1220 } 1221 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) 1222 { 1223 struct deviceSpec *dsea = 1224 (struct deviceSpec *) 1225 udf_get_extendedattr(inode, 12, 1); 1226 1227 if (dsea) 1228 { 1229 init_special_inode(inode, inode->i_mode, MKDEV( 1230 le32_to_cpu(dsea->majorDeviceIdent), 1231 le32_to_cpu(dsea->minorDeviceIdent))); 1232 /* Developer ID ??? */ 1233 } 1234 else 1235 { 1236 make_bad_inode(inode); 1237 } 1238 } 1239} 1240 1241static mode_t 1242udf_convert_permissions(struct fileEntry *fe) 1243{ 1244 mode_t mode; 1245 uint32_t permissions; 1246 uint32_t flags; 1247 1248 permissions = le32_to_cpu(fe->permissions); 1249 flags = le16_to_cpu(fe->icbTag.flags); 1250 1251 mode = (( permissions ) & S_IRWXO) | 1252 (( permissions >> 2 ) & S_IRWXG) | 1253 (( permissions >> 4 ) & S_IRWXU) | 1254 (( flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) | 1255 (( flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) | 1256 (( flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0); 1257 1258 return mode; 1259} 1260 1261/* 1262 * udf_write_inode 1263 * 1264 * PURPOSE 1265 * Write out the specified inode. 1266 * 1267 * DESCRIPTION 1268 * This routine is called whenever an inode is synced. 1269 * Currently this routine is just a placeholder. 1270 * 1271 * HISTORY 1272 * July 1, 1997 - Andrew E. Mileski 1273 * Written, tested, and released. 1274 */ 1275 1276int udf_write_inode(struct inode * inode, int sync) 1277{ 1278 int ret; 1279 lock_kernel(); 1280 ret = udf_update_inode(inode, sync); 1281 unlock_kernel(); 1282 return ret; 1283} 1284 1285int udf_sync_inode(struct inode * inode) 1286{ 1287 return udf_update_inode(inode, 1); 1288} 1289 1290static int 1291udf_update_inode(struct inode *inode, int do_sync) 1292{ 1293 struct buffer_head *bh = NULL; 1294 struct fileEntry *fe; 1295 struct extendedFileEntry *efe; 1296 uint32_t udfperms; 1297 uint16_t icbflags; 1298 uint16_t crclen; 1299 int i; 1300 kernel_timestamp cpu_time; 1301 int err = 0; 1302 1303 bh = udf_tread(inode->i_sb, 1304 udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0)); 1305 1306 if (!bh) 1307 { 1308 udf_debug("bread failure\n"); 1309 return -EIO; 1310 } 1311 1312 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize); 1313 1314 fe = (struct fileEntry *)bh->b_data; 1315 efe = (struct extendedFileEntry *)bh->b_data; 1316 1317 if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) 1318 { 1319 struct unallocSpaceEntry *use = 1320 (struct unallocSpaceEntry *)bh->b_data; 1321 1322 use->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode)); 1323 memcpy(bh->b_data + sizeof(struct unallocSpaceEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry)); 1324 crclen = sizeof(struct unallocSpaceEntry) + UDF_I_LENALLOC(inode) - 1325 sizeof(tag); 1326 use->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum); 1327 use->descTag.descCRCLength = cpu_to_le16(crclen); 1328 use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use + sizeof(tag), crclen, 0)); 1329 1330 use->descTag.tagChecksum = 0; 1331 for (i=0; i<16; i++) 1332 if (i != 4) 1333 use->descTag.tagChecksum += ((uint8_t *)&(use->descTag))[i]; 1334 1335 mark_buffer_dirty(bh); 1336 udf_release_data(bh); 1337 return err; 1338 } 1339 1340 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET)) 1341 fe->uid = cpu_to_le32(-1); 1342 else fe->uid = cpu_to_le32(inode->i_uid); 1343 1344 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET)) 1345 fe->gid = cpu_to_le32(-1); 1346 else fe->gid = cpu_to_le32(inode->i_gid); 1347 1348 udfperms = ((inode->i_mode & S_IRWXO) ) | 1349 ((inode->i_mode & S_IRWXG) << 2) | 1350 ((inode->i_mode & S_IRWXU) << 4); 1351 1352 udfperms |= (le32_to_cpu(fe->permissions) & 1353 (FE_PERM_O_DELETE | FE_PERM_O_CHATTR | 1354 FE_PERM_G_DELETE | FE_PERM_G_CHATTR | 1355 FE_PERM_U_DELETE | FE_PERM_U_CHATTR)); 1356 fe->permissions = cpu_to_le32(udfperms); 1357 1358 if (S_ISDIR(inode->i_mode)) 1359 fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1); 1360 else 1361 fe->fileLinkCount = cpu_to_le16(inode->i_nlink); 1362 1363 fe->informationLength = cpu_to_le64(inode->i_size); 1364 1365 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) 1366 { 1367 regid *eid; 1368 struct deviceSpec *dsea = 1369 (struct deviceSpec *) 1370 udf_get_extendedattr(inode, 12, 1); 1371 1372 if (!dsea) 1373 { 1374 dsea = (struct deviceSpec *) 1375 udf_add_extendedattr(inode, 1376 sizeof(struct deviceSpec) + 1377 sizeof(regid), 12, 0x3); 1378 dsea->attrType = cpu_to_le32(12); 1379 dsea->attrSubtype = 1; 1380 dsea->attrLength = cpu_to_le32(sizeof(struct deviceSpec) + 1381 sizeof(regid)); 1382 dsea->impUseLength = cpu_to_le32(sizeof(regid)); 1383 } 1384 eid = (regid *)dsea->impUse; 1385 memset(eid, 0, sizeof(regid)); 1386 strcpy(eid->ident, UDF_ID_DEVELOPER); 1387 eid->identSuffix[0] = UDF_OS_CLASS_UNIX; 1388 eid->identSuffix[1] = UDF_OS_ID_LINUX; 1389 dsea->majorDeviceIdent = cpu_to_le32(imajor(inode)); 1390 dsea->minorDeviceIdent = cpu_to_le32(iminor(inode)); 1391 } 1392 1393 if (UDF_I_EFE(inode) == 0) 1394 { 1395 memcpy(bh->b_data + sizeof(struct fileEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct fileEntry)); 1396 fe->logicalBlocksRecorded = cpu_to_le64( 1397 (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >> 1398 (inode->i_sb->s_blocksize_bits - 9)); 1399 1400 if (udf_time_to_stamp(&cpu_time, inode->i_atime)) 1401 fe->accessTime = cpu_to_lets(cpu_time); 1402 if (udf_time_to_stamp(&cpu_time, inode->i_mtime)) 1403 fe->modificationTime = cpu_to_lets(cpu_time); 1404 if (udf_time_to_stamp(&cpu_time, inode->i_ctime)) 1405 fe->attrTime = cpu_to_lets(cpu_time); 1406 memset(&(fe->impIdent), 0, sizeof(regid)); 1407 strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER); 1408 fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; 1409 fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; 1410 fe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode)); 1411 fe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode)); 1412 fe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode)); 1413 fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE); 1414 crclen = sizeof(struct fileEntry); 1415 } 1416 else 1417 { 1418 memcpy(bh->b_data + sizeof(struct extendedFileEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry)); 1419 efe->objectSize = cpu_to_le64(inode->i_size); 1420 efe->logicalBlocksRecorded = cpu_to_le64( 1421 (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >> 1422 (inode->i_sb->s_blocksize_bits - 9)); 1423 1424 if (UDF_I_CRTIME(inode).tv_sec > inode->i_atime.tv_sec || 1425 (UDF_I_CRTIME(inode).tv_sec == inode->i_atime.tv_sec && 1426 UDF_I_CRTIME(inode).tv_nsec > inode->i_atime.tv_nsec)) 1427 { 1428 UDF_I_CRTIME(inode) = inode->i_atime; 1429 } 1430 if (UDF_I_CRTIME(inode).tv_sec > inode->i_mtime.tv_sec || 1431 (UDF_I_CRTIME(inode).tv_sec == inode->i_mtime.tv_sec && 1432 UDF_I_CRTIME(inode).tv_nsec > inode->i_mtime.tv_nsec)) 1433 { 1434 UDF_I_CRTIME(inode) = inode->i_mtime; 1435 } 1436 if (UDF_I_CRTIME(inode).tv_sec > inode->i_ctime.tv_sec || 1437 (UDF_I_CRTIME(inode).tv_sec == inode->i_ctime.tv_sec && 1438 UDF_I_CRTIME(inode).tv_nsec > inode->i_ctime.tv_nsec)) 1439 { 1440 UDF_I_CRTIME(inode) = inode->i_ctime; 1441 } 1442 1443 if (udf_time_to_stamp(&cpu_time, inode->i_atime)) 1444 efe->accessTime = cpu_to_lets(cpu_time); 1445 if (udf_time_to_stamp(&cpu_time, inode->i_mtime)) 1446 efe->modificationTime = cpu_to_lets(cpu_time); 1447 if (udf_time_to_stamp(&cpu_time, UDF_I_CRTIME(inode))) 1448 efe->createTime = cpu_to_lets(cpu_time); 1449 if (udf_time_to_stamp(&cpu_time, inode->i_ctime)) 1450 efe->attrTime = cpu_to_lets(cpu_time); 1451 1452 memset(&(efe->impIdent), 0, sizeof(regid)); 1453 strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER); 1454 efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; 1455 efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; 1456 efe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode)); 1457 efe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode)); 1458 efe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode)); 1459 efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE); 1460 crclen = sizeof(struct extendedFileEntry); 1461 } 1462 if (UDF_I_STRAT4096(inode)) 1463 { 1464 fe->icbTag.strategyType = cpu_to_le16(4096); 1465 fe->icbTag.strategyParameter = cpu_to_le16(1); 1466 fe->icbTag.numEntries = cpu_to_le16(2); 1467 } 1468 else 1469 { 1470 fe->icbTag.strategyType = cpu_to_le16(4); 1471 fe->icbTag.numEntries = cpu_to_le16(1); 1472 } 1473 1474 if (S_ISDIR(inode->i_mode)) 1475 fe->icbTag.fileType = ICBTAG_FILE_TYPE_DIRECTORY; 1476 else if (S_ISREG(inode->i_mode)) 1477 fe->icbTag.fileType = ICBTAG_FILE_TYPE_REGULAR; 1478 else if (S_ISLNK(inode->i_mode)) 1479 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SYMLINK; 1480 else if (S_ISBLK(inode->i_mode)) 1481 fe->icbTag.fileType = ICBTAG_FILE_TYPE_BLOCK; 1482 else if (S_ISCHR(inode->i_mode)) 1483 fe->icbTag.fileType = ICBTAG_FILE_TYPE_CHAR; 1484 else if (S_ISFIFO(inode->i_mode)) 1485 fe->icbTag.fileType = ICBTAG_FILE_TYPE_FIFO; 1486 else if (S_ISSOCK(inode->i_mode)) 1487 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET; 1488 1489 icbflags = UDF_I_ALLOCTYPE(inode) | 1490 ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) | 1491 ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) | 1492 ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) | 1493 (le16_to_cpu(fe->icbTag.flags) & 1494 ~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID | 1495 ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY)); 1496 1497 fe->icbTag.flags = cpu_to_le16(icbflags); 1498 if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200) 1499 fe->descTag.descVersion = cpu_to_le16(3); 1500 else 1501 fe->descTag.descVersion = cpu_to_le16(2); 1502 fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb)); 1503 fe->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum); 1504 crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag); 1505 fe->descTag.descCRCLength = cpu_to_le16(crclen); 1506 fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag), crclen, 0)); 1507 1508 fe->descTag.tagChecksum = 0; 1509 for (i=0; i<16; i++) 1510 if (i != 4) 1511 fe->descTag.tagChecksum += ((uint8_t *)&(fe->descTag))[i]; 1512 1513 /* write the data blocks */ 1514 mark_buffer_dirty(bh); 1515 if (do_sync) 1516 { 1517 sync_dirty_buffer(bh); 1518 if (buffer_req(bh) && !buffer_uptodate(bh)) 1519 { 1520 printk("IO error syncing udf inode [%s:%08lx]\n", 1521 inode->i_sb->s_id, inode->i_ino); 1522 err = -EIO; 1523 } 1524 } 1525 udf_release_data(bh); 1526 return err; 1527} 1528 1529struct inode * 1530udf_iget(struct super_block *sb, kernel_lb_addr ino) 1531{ 1532 unsigned long block = udf_get_lb_pblock(sb, ino, 0); 1533 struct inode *inode = iget_locked(sb, block); 1534 1535 if (!inode) 1536 return NULL; 1537 1538 if (inode->i_state & I_NEW) { 1539 memcpy(&UDF_I_LOCATION(inode), &ino, sizeof(kernel_lb_addr)); 1540 __udf_read_inode(inode); 1541 unlock_new_inode(inode); 1542 } 1543 1544 if (is_bad_inode(inode)) 1545 goto out_iput; 1546 1547 if (ino.logicalBlockNum >= UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) { 1548 udf_debug("block=%d, partition=%d out of range\n", 1549 ino.logicalBlockNum, ino.partitionReferenceNum); 1550 make_bad_inode(inode); 1551 goto out_iput; 1552 } 1553 1554 return inode; 1555 1556 out_iput: 1557 iput(inode); 1558 return NULL; 1559} 1560 1561int8_t udf_add_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset, 1562 kernel_lb_addr eloc, uint32_t elen, struct buffer_head **bh, int inc) 1563{ 1564 int adsize; 1565 short_ad *sad = NULL; 1566 long_ad *lad = NULL; 1567 struct allocExtDesc *aed; 1568 int8_t etype; 1569 uint8_t *ptr; 1570 1571 if (!*bh) 1572 ptr = UDF_I_DATA(inode) + *extoffset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode); 1573 else 1574 ptr = (*bh)->b_data + *extoffset; 1575 1576 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT) 1577 adsize = sizeof(short_ad); 1578 else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG) 1579 adsize = sizeof(long_ad); 1580 else 1581 return -1; 1582 1583 if (*extoffset + (2 * adsize) > inode->i_sb->s_blocksize) 1584 { 1585 char *sptr, *dptr; 1586 struct buffer_head *nbh; 1587 int err, loffset; 1588 kernel_lb_addr obloc = *bloc; 1589 1590 if (!(bloc->logicalBlockNum = udf_new_block(inode->i_sb, NULL, 1591 obloc.partitionReferenceNum, obloc.logicalBlockNum, &err))) 1592 { 1593 return -1; 1594 } 1595 if (!(nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb, 1596 *bloc, 0)))) 1597 { 1598 return -1; 1599 } 1600 lock_buffer(nbh); 1601 memset(nbh->b_data, 0x00, inode->i_sb->s_blocksize); 1602 set_buffer_uptodate(nbh); 1603 unlock_buffer(nbh); 1604 mark_buffer_dirty_inode(nbh, inode); 1605 1606 aed = (struct allocExtDesc *)(nbh->b_data); 1607 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) 1608 aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum); 1609 if (*extoffset + adsize > inode->i_sb->s_blocksize) 1610 { 1611 loffset = *extoffset; 1612 aed->lengthAllocDescs = cpu_to_le32(adsize); 1613 sptr = ptr - adsize; 1614 dptr = nbh->b_data + sizeof(struct allocExtDesc); 1615 memcpy(dptr, sptr, adsize); 1616 *extoffset = sizeof(struct allocExtDesc) + adsize; 1617 } 1618 else 1619 { 1620 loffset = *extoffset + adsize; 1621 aed->lengthAllocDescs = cpu_to_le32(0); 1622 sptr = ptr; 1623 *extoffset = sizeof(struct allocExtDesc); 1624 1625 if (*bh) 1626 { 1627 aed = (struct allocExtDesc *)(*bh)->b_data; 1628 aed->lengthAllocDescs = 1629 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize); 1630 } 1631 else 1632 { 1633 UDF_I_LENALLOC(inode) += adsize; 1634 mark_inode_dirty(inode); 1635 } 1636 } 1637 if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200) 1638 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1, 1639 bloc->logicalBlockNum, sizeof(tag)); 1640 else 1641 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1, 1642 bloc->logicalBlockNum, sizeof(tag)); 1643 switch (UDF_I_ALLOCTYPE(inode)) 1644 { 1645 case ICBTAG_FLAG_AD_SHORT: 1646 { 1647 sad = (short_ad *)sptr; 1648 sad->extLength = cpu_to_le32( 1649 EXT_NEXT_EXTENT_ALLOCDECS | 1650 inode->i_sb->s_blocksize); 1651 sad->extPosition = cpu_to_le32(bloc->logicalBlockNum); 1652 break; 1653 } 1654 case ICBTAG_FLAG_AD_LONG: 1655 { 1656 lad = (long_ad *)sptr; 1657 lad->extLength = cpu_to_le32( 1658 EXT_NEXT_EXTENT_ALLOCDECS | 1659 inode->i_sb->s_blocksize); 1660 lad->extLocation = cpu_to_lelb(*bloc); 1661 memset(lad->impUse, 0x00, sizeof(lad->impUse)); 1662 break; 1663 } 1664 } 1665 if (*bh) 1666 { 1667 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) 1668 udf_update_tag((*bh)->b_data, loffset); 1669 else 1670 udf_update_tag((*bh)->b_data, sizeof(struct allocExtDesc)); 1671 mark_buffer_dirty_inode(*bh, inode); 1672 udf_release_data(*bh); 1673 } 1674 else 1675 mark_inode_dirty(inode); 1676 *bh = nbh; 1677 } 1678 1679 etype = udf_write_aext(inode, *bloc, extoffset, eloc, elen, *bh, inc); 1680 1681 if (!*bh) 1682 { 1683 UDF_I_LENALLOC(inode) += adsize; 1684 mark_inode_dirty(inode); 1685 } 1686 else 1687 { 1688 aed = (struct allocExtDesc *)(*bh)->b_data; 1689 aed->lengthAllocDescs = 1690 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize); 1691 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) 1692 udf_update_tag((*bh)->b_data, *extoffset + (inc ? 0 : adsize)); 1693 else 1694 udf_update_tag((*bh)->b_data, sizeof(struct allocExtDesc)); 1695 mark_buffer_dirty_inode(*bh, inode); 1696 } 1697 1698 return etype; 1699} 1700 1701int8_t udf_write_aext(struct inode *inode, kernel_lb_addr bloc, int *extoffset, 1702 kernel_lb_addr eloc, uint32_t elen, struct buffer_head *bh, int inc) 1703{ 1704 int adsize; 1705 uint8_t *ptr; 1706 1707 if (!bh) 1708 ptr = UDF_I_DATA(inode) + *extoffset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode); 1709 else 1710 { 1711 ptr = bh->b_data + *extoffset; 1712 atomic_inc(&bh->b_count); 1713 } 1714 1715 switch (UDF_I_ALLOCTYPE(inode)) 1716 { 1717 case ICBTAG_FLAG_AD_SHORT: 1718 { 1719 short_ad *sad = (short_ad *)ptr; 1720 sad->extLength = cpu_to_le32(elen); 1721 sad->extPosition = cpu_to_le32(eloc.logicalBlockNum); 1722 adsize = sizeof(short_ad); 1723 break; 1724 } 1725 case ICBTAG_FLAG_AD_LONG: 1726 { 1727 long_ad *lad = (long_ad *)ptr; 1728 lad->extLength = cpu_to_le32(elen); 1729 lad->extLocation = cpu_to_lelb(eloc); 1730 memset(lad->impUse, 0x00, sizeof(lad->impUse)); 1731 adsize = sizeof(long_ad); 1732 break; 1733 } 1734 default: 1735 return -1; 1736 } 1737 1738 if (bh) 1739 { 1740 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) 1741 { 1742 struct allocExtDesc *aed = (struct allocExtDesc *)(bh)->b_data; 1743 udf_update_tag((bh)->b_data, 1744 le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc)); 1745 } 1746 mark_buffer_dirty_inode(bh, inode); 1747 udf_release_data(bh); 1748 } 1749 else 1750 mark_inode_dirty(inode); 1751 1752 if (inc) 1753 *extoffset += adsize; 1754 return (elen >> 30); 1755} 1756 1757int8_t udf_next_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset, 1758 kernel_lb_addr *eloc, uint32_t *elen, struct buffer_head **bh, int inc) 1759{ 1760 int8_t etype; 1761 1762 while ((etype = udf_current_aext(inode, bloc, extoffset, eloc, elen, bh, inc)) == 1763 (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) 1764 { 1765 *bloc = *eloc; 1766 *extoffset = sizeof(struct allocExtDesc); 1767 udf_release_data(*bh); 1768 if (!(*bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, *bloc, 0)))) 1769 { 1770 udf_debug("reading block %d failed!\n", 1771 udf_get_lb_pblock(inode->i_sb, *bloc, 0)); 1772 return -1; 1773 } 1774 } 1775 1776 return etype; 1777} 1778 1779int8_t udf_current_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset, 1780 kernel_lb_addr *eloc, uint32_t *elen, struct buffer_head **bh, int inc) 1781{ 1782 int alen; 1783 int8_t etype; 1784 uint8_t *ptr; 1785 1786 if (!*bh) 1787 { 1788 if (!(*extoffset)) 1789 *extoffset = udf_file_entry_alloc_offset(inode); 1790 ptr = UDF_I_DATA(inode) + *extoffset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode); 1791 alen = udf_file_entry_alloc_offset(inode) + UDF_I_LENALLOC(inode); 1792 } 1793 else 1794 { 1795 if (!(*extoffset)) 1796 *extoffset = sizeof(struct allocExtDesc); 1797 ptr = (*bh)->b_data + *extoffset; 1798 alen = sizeof(struct allocExtDesc) + le32_to_cpu(((struct allocExtDesc *)(*bh)->b_data)->lengthAllocDescs); 1799 } 1800 1801 switch (UDF_I_ALLOCTYPE(inode)) 1802 { 1803 case ICBTAG_FLAG_AD_SHORT: 1804 { 1805 short_ad *sad; 1806 1807 if (!(sad = udf_get_fileshortad(ptr, alen, extoffset, inc))) 1808 return -1; 1809 1810 etype = le32_to_cpu(sad->extLength) >> 30; 1811 eloc->logicalBlockNum = le32_to_cpu(sad->extPosition); 1812 eloc->partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum; 1813 *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK; 1814 break; 1815 } 1816 case ICBTAG_FLAG_AD_LONG: 1817 { 1818 long_ad *lad; 1819 1820 if (!(lad = udf_get_filelongad(ptr, alen, extoffset, inc))) 1821 return -1; 1822 1823 etype = le32_to_cpu(lad->extLength) >> 30; 1824 *eloc = lelb_to_cpu(lad->extLocation); 1825 *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK; 1826 break; 1827 } 1828 default: 1829 { 1830 udf_debug("alloc_type = %d unsupported\n", UDF_I_ALLOCTYPE(inode)); 1831 return -1; 1832 } 1833 } 1834 1835 return etype; 1836} 1837 1838static int8_t 1839udf_insert_aext(struct inode *inode, kernel_lb_addr bloc, int extoffset, 1840 kernel_lb_addr neloc, uint32_t nelen, struct buffer_head *bh) 1841{ 1842 kernel_lb_addr oeloc; 1843 uint32_t oelen; 1844 int8_t etype; 1845 1846 if (bh) 1847 atomic_inc(&bh->b_count); 1848 1849 while ((etype = udf_next_aext(inode, &bloc, &extoffset, &oeloc, &oelen, &bh, 0)) != -1) 1850 { 1851 udf_write_aext(inode, bloc, &extoffset, neloc, nelen, bh, 1); 1852 1853 neloc = oeloc; 1854 nelen = (etype << 30) | oelen; 1855 } 1856 udf_add_aext(inode, &bloc, &extoffset, neloc, nelen, &bh, 1); 1857 udf_release_data(bh); 1858 return (nelen >> 30); 1859} 1860 1861int8_t udf_delete_aext(struct inode *inode, kernel_lb_addr nbloc, int nextoffset, 1862 kernel_lb_addr eloc, uint32_t elen, struct buffer_head *nbh) 1863{ 1864 struct buffer_head *obh; 1865 kernel_lb_addr obloc; 1866 int oextoffset, adsize; 1867 int8_t etype; 1868 struct allocExtDesc *aed; 1869 1870 if (nbh) 1871 { 1872 atomic_inc(&nbh->b_count); 1873 atomic_inc(&nbh->b_count); 1874 } 1875 1876 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT) 1877 adsize = sizeof(short_ad); 1878 else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG) 1879 adsize = sizeof(long_ad); 1880 else 1881 adsize = 0; 1882 1883 obh = nbh; 1884 obloc = nbloc; 1885 oextoffset = nextoffset; 1886 1887 if (udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1) == -1) 1888 return -1; 1889 1890 while ((etype = udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1)) != -1) 1891 { 1892 udf_write_aext(inode, obloc, &oextoffset, eloc, (etype << 30) | elen, obh, 1); 1893 if (obh != nbh) 1894 { 1895 obloc = nbloc; 1896 udf_release_data(obh); 1897 atomic_inc(&nbh->b_count); 1898 obh = nbh; 1899 oextoffset = nextoffset - adsize; 1900 } 1901 } 1902 memset(&eloc, 0x00, sizeof(kernel_lb_addr)); 1903 elen = 0; 1904 1905 if (nbh != obh) 1906 { 1907 udf_free_blocks(inode->i_sb, inode, nbloc, 0, 1); 1908 udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1); 1909 udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1); 1910 if (!obh) 1911 { 1912 UDF_I_LENALLOC(inode) -= (adsize * 2); 1913 mark_inode_dirty(inode); 1914 } 1915 else 1916 { 1917 aed = (struct allocExtDesc *)(obh)->b_data; 1918 aed->lengthAllocDescs = 1919 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2*adsize)); 1920 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) 1921 udf_update_tag((obh)->b_data, oextoffset - (2*adsize)); 1922 else 1923 udf_update_tag((obh)->b_data, sizeof(struct allocExtDesc)); 1924 mark_buffer_dirty_inode(obh, inode); 1925 } 1926 } 1927 else 1928 { 1929 udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1); 1930 if (!obh) 1931 { 1932 UDF_I_LENALLOC(inode) -= adsize; 1933 mark_inode_dirty(inode); 1934 } 1935 else 1936 { 1937 aed = (struct allocExtDesc *)(obh)->b_data; 1938 aed->lengthAllocDescs = 1939 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize); 1940 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) 1941 udf_update_tag((obh)->b_data, oextoffset - adsize); 1942 else 1943 udf_update_tag((obh)->b_data, sizeof(struct allocExtDesc)); 1944 mark_buffer_dirty_inode(obh, inode); 1945 } 1946 } 1947 1948 udf_release_data(nbh); 1949 udf_release_data(obh); 1950 return (elen >> 30); 1951} 1952 1953int8_t inode_bmap(struct inode *inode, int block, kernel_lb_addr *bloc, uint32_t *extoffset, 1954 kernel_lb_addr *eloc, uint32_t *elen, uint32_t *offset, struct buffer_head **bh) 1955{ 1956 uint64_t lbcount = 0, bcount = (uint64_t)block << inode->i_sb->s_blocksize_bits; 1957 int8_t etype; 1958 1959 if (block < 0) 1960 { 1961 printk(KERN_ERR "udf: inode_bmap: block < 0\n"); 1962 return -1; 1963 } 1964 1965 *extoffset = 0; 1966 *elen = 0; 1967 *bloc = UDF_I_LOCATION(inode); 1968 1969 do 1970 { 1971 if ((etype = udf_next_aext(inode, bloc, extoffset, eloc, elen, bh, 1)) == -1) 1972 { 1973 *offset = bcount - lbcount; 1974 UDF_I_LENEXTENTS(inode) = lbcount; 1975 return -1; 1976 } 1977 lbcount += *elen; 1978 } while (lbcount <= bcount); 1979 1980 *offset = bcount + *elen - lbcount; 1981 1982 return etype; 1983} 1984 1985long udf_block_map(struct inode *inode, long block) 1986{ 1987 kernel_lb_addr eloc, bloc; 1988 uint32_t offset, extoffset, elen; 1989 struct buffer_head *bh = NULL; 1990 int ret; 1991 1992 lock_kernel(); 1993 1994 if (inode_bmap(inode, block, &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30)) 1995 ret = udf_get_lb_pblock(inode->i_sb, eloc, offset >> inode->i_sb->s_blocksize_bits); 1996 else 1997 ret = 0; 1998 1999 unlock_kernel(); 2000 udf_release_data(bh); 2001 2002 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV)) 2003 return udf_fixed_to_variable(ret); 2004 else 2005 return ret; 2006} 2007