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