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