LXR linux/fs/udf/truncate.c

   1/*
   2 * truncate.c
   3 *
   4 * PURPOSE
   5 *      Truncate 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) 1999-2004 Ben Fennema
  14 *  (C) 1999 Stelias Computing Inc
  15 *
  16 * HISTORY
  17 *
  18 *  02/24/99 blf  Created.
  19 *
  20 */
  21
  22#include "udfdecl.h"
  23#include <linux/fs.h>
  24#include <linux/mm.h>
  25#include <linux/buffer_head.h>
  26
  27#include "udf_i.h"
  28#include "udf_sb.h"
  29
  30static void extent_trunc(struct inode *inode, struct extent_position *epos,
  31                         struct kernel_lb_addr *eloc, int8_t etype, uint32_t elen,
  32                         uint32_t nelen)
  33{
  34        struct kernel_lb_addr neloc = {};
  35        int last_block = (elen + inode->i_sb->s_blocksize - 1) >>
  36                inode->i_sb->s_blocksize_bits;
  37        int first_block = (nelen + inode->i_sb->s_blocksize - 1) >>
  38                inode->i_sb->s_blocksize_bits;
  39
  40        if (nelen) {
  41                if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
  42                        udf_free_blocks(inode->i_sb, inode, eloc, 0,
  43                                        last_block);
  44                        etype = (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30);
  45                } else
  46                        neloc = *eloc;
  47                nelen = (etype << 30) | nelen;
  48        }
  49
  50        if (elen != nelen) {
  51                udf_write_aext(inode, epos, &neloc, nelen, 0);
  52                if (last_block - first_block > 0) {
  53                        if (etype == (EXT_RECORDED_ALLOCATED >> 30))
  54                                mark_inode_dirty(inode);
  55
  56                        if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
  57                                udf_free_blocks(inode->i_sb, inode, eloc,
  58                                                first_block,
  59                                                last_block - first_block);
  60                }
  61        }
  62}
  63
  64/*
  65 * Truncate the last extent to match i_size. This function assumes
  66 * that preallocation extent is already truncated.
  67 */
  68void udf_truncate_tail_extent(struct inode *inode)
  69{
  70        struct extent_position epos = {};
  71        struct kernel_lb_addr eloc;
  72        uint32_t elen, nelen;
  73        uint64_t lbcount = 0;
  74        int8_t etype = -1, netype;
  75        int adsize;
  76        struct udf_inode_info *iinfo = UDF_I(inode);
  77
  78        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
  79            inode->i_size == iinfo->i_lenExtents)
  80                return;
  81        /* Are we going to delete the file anyway? */
  82        if (inode->i_nlink == 0)
  83                return;
  84
  85        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
  86                adsize = sizeof(struct short_ad);
  87        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
  88                adsize = sizeof(struct long_ad);
  89        else
  90                BUG();
  91
  92        /* Find the last extent in the file */
  93        while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
  94                etype = netype;
  95                lbcount += elen;
  96                if (lbcount > inode->i_size) {
  97                        if (lbcount - inode->i_size >= inode->i_sb->s_blocksize)
  98                                udf_warn(inode->i_sb,
  99                                         "Too long extent after EOF in inode %u: i_size: %lld lbcount: %lld extent %u+%u\n",
 100                                         (unsigned)inode->i_ino,
 101                                         (long long)inode->i_size,
 102                                         (long long)lbcount,
 103                                         (unsigned)eloc.logicalBlockNum,
 104                                         (unsigned)elen);
 105                        nelen = elen - (lbcount - inode->i_size);
 106                        epos.offset -= adsize;
 107                        extent_trunc(inode, &epos, &eloc, etype, elen, nelen);
 108                        epos.offset += adsize;
 109                        if (udf_next_aext(inode, &epos, &eloc, &elen, 1) != -1)
 110                                udf_err(inode->i_sb,
 111                                        "Extent after EOF in inode %u\n",
 112                                        (unsigned)inode->i_ino);
 113                        break;
 114                }
 115        }
 116        /* This inode entry is in-memory only and thus we don't have to mark
 117         * the inode dirty */
 118        iinfo->i_lenExtents = inode->i_size;
 119        brelse(epos.bh);
 120}
 121
 122void udf_discard_prealloc(struct inode *inode)
 123{
 124        struct extent_position epos = { NULL, 0, {0, 0} };
 125        struct kernel_lb_addr eloc;
 126        uint32_t elen;
 127        uint64_t lbcount = 0;
 128        int8_t etype = -1, netype;
 129        int adsize;
 130        struct udf_inode_info *iinfo = UDF_I(inode);
 131
 132        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
 133            inode->i_size == iinfo->i_lenExtents)
 134                return;
 135
 136        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
 137                adsize = sizeof(struct short_ad);
 138        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
 139                adsize = sizeof(struct long_ad);
 140        else
 141                adsize = 0;
 142
 143        epos.block = iinfo->i_location;
 144
 145        /* Find the last extent in the file */
 146        while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
 147                etype = netype;
 148                lbcount += elen;
 149        }
 150        if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
 151                epos.offset -= adsize;
 152                lbcount -= elen;
 153                extent_trunc(inode, &epos, &eloc, etype, elen, 0);
 154                if (!epos.bh) {
 155                        iinfo->i_lenAlloc =
 156                                epos.offset -
 157                                udf_file_entry_alloc_offset(inode);
 158                        mark_inode_dirty(inode);
 159                } else {
 160                        struct allocExtDesc *aed =
 161                                (struct allocExtDesc *)(epos.bh->b_data);
 162                        aed->lengthAllocDescs =
 163                                cpu_to_le32(epos.offset -
 164                                            sizeof(struct allocExtDesc));
 165                        if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
 166                            UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
 167                                udf_update_tag(epos.bh->b_data, epos.offset);
 168                        else
 169                                udf_update_tag(epos.bh->b_data,
 170                                               sizeof(struct allocExtDesc));
 171                        mark_buffer_dirty_inode(epos.bh, inode);
 172                }
 173        }
 174        /* This inode entry is in-memory only and thus we don't have to mark
 175         * the inode dirty */
 176        iinfo->i_lenExtents = lbcount;
 177        brelse(epos.bh);
 178}
 179
 180static void udf_update_alloc_ext_desc(struct inode *inode,
 181                                      struct extent_position *epos,
 182                                      u32 lenalloc)
 183{
 184        struct super_block *sb = inode->i_sb;
 185        struct udf_sb_info *sbi = UDF_SB(sb);
 186
 187        struct allocExtDesc *aed = (struct allocExtDesc *) (epos->bh->b_data);
 188        int len = sizeof(struct allocExtDesc);
 189
 190        aed->lengthAllocDescs = cpu_to_le32(lenalloc);
 191        if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) || sbi->s_udfrev >= 0x0201)
 192                len += lenalloc;
 193
 194        udf_update_tag(epos->bh->b_data, len);
 195        mark_buffer_dirty_inode(epos->bh, inode);
 196}
 197
 198/*
 199 * Truncate extents of inode to inode->i_size. This function can be used only
 200 * for making file shorter. For making file longer, udf_extend_file() has to
 201 * be used.
 202 */
 203void udf_truncate_extents(struct inode *inode)
 204{
 205        struct extent_position epos;
 206        struct kernel_lb_addr eloc, neloc = {};
 207        uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc;
 208        int8_t etype;
 209        struct super_block *sb = inode->i_sb;
 210        sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset;
 211        loff_t byte_offset;
 212        int adsize;
 213        struct udf_inode_info *iinfo = UDF_I(inode);
 214
 215        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
 216                adsize = sizeof(struct short_ad);
 217        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
 218                adsize = sizeof(struct long_ad);
 219        else
 220                BUG();
 221
 222        etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset);
 223        byte_offset = (offset << sb->s_blocksize_bits) +
 224                (inode->i_size & (sb->s_blocksize - 1));
 225        if (etype == -1) {
 226                /* We should extend the file? */
 227                WARN_ON(byte_offset);
 228                return;
 229        }
 230        epos.offset -= adsize;
 231        extent_trunc(inode, &epos, &eloc, etype, elen, byte_offset);
 232        epos.offset += adsize;
 233        if (byte_offset)
 234                lenalloc = epos.offset;
 235        else
 236                lenalloc = epos.offset - adsize;
 237
 238        if (!epos.bh)
 239                lenalloc -= udf_file_entry_alloc_offset(inode);
 240        else
 241                lenalloc -= sizeof(struct allocExtDesc);
 242
 243        while ((etype = udf_current_aext(inode, &epos, &eloc,
 244                                         &elen, 0)) != -1) {
 245                if (etype == (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
 246                        udf_write_aext(inode, &epos, &neloc, nelen, 0);
 247                        if (indirect_ext_len) {
 248                                /* We managed to free all extents in the
 249                                 * indirect extent - free it too */
 250                                BUG_ON(!epos.bh);
 251                                udf_free_blocks(sb, NULL, &epos.block,
 252                                                0, indirect_ext_len);
 253                        } else if (!epos.bh) {
 254                                iinfo->i_lenAlloc = lenalloc;
 255                                mark_inode_dirty(inode);
 256                        } else
 257                                udf_update_alloc_ext_desc(inode,
 258                                                &epos, lenalloc);
 259                        brelse(epos.bh);
 260                        epos.offset = sizeof(struct allocExtDesc);
 261                        epos.block = eloc;
 262                        epos.bh = udf_tread(sb,
 263                                        udf_get_lb_pblock(sb, &eloc, 0));
 264                        if (elen)
 265                                indirect_ext_len =
 266                                        (elen + sb->s_blocksize - 1) >>
 267                                        sb->s_blocksize_bits;
 268                        else
 269                                indirect_ext_len = 1;
 270                } else {
 271                        extent_trunc(inode, &epos, &eloc, etype, elen, 0);
 272                        epos.offset += adsize;
 273                }
 274        }
 275
 276        if (indirect_ext_len) {
 277                BUG_ON(!epos.bh);
 278                udf_free_blocks(sb, NULL, &epos.block, 0, indirect_ext_len);
 279        } else if (!epos.bh) {
 280                iinfo->i_lenAlloc = lenalloc;
 281                mark_inode_dirty(inode);
 282        } else
 283                udf_update_alloc_ext_desc(inode, &epos, lenalloc);
 284        iinfo->i_lenExtents = inode->i_size;
 285
 286        brelse(epos.bh);
 287}
 288