git.oblomov.eu Git - linux-2.6/blob - fs/udf/inode.c

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