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