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