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