fs/ext4/migrate.c

   1 /*
   2  * Copyright IBM Corporation, 2007
   3  * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2.1 of the GNU Lesser General Public License
   7  * as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12  *
  13  */
  14
  15 #include <linux/slab.h>
  16 #include "ext4_jbd2.h"
  17 #include "ext4_extents.h"
  18
  19 /*
  20  * The contiguous blocks details which can be
  21  * represented by a single extent
  22  */
  23 struct migrate_struct {
  24         ext4_lblk_t first_block, last_block, curr_block;
  25         ext4_fsblk_t first_pblock, last_pblock;
  26 };
  27
  28 static int finish_range(handle_t *handle, struct inode *inode,
  29                                 struct migrate_struct *lb)
  30
  31 {
  32         int retval = 0, needed;
  33         struct ext4_extent newext;
  34         struct ext4_ext_path *path;
  35         if (lb->first_pblock == 0)
  36                 return 0;
  37
  38         /* Add the extent to temp inode*/
  39         newext.ee_block = cpu_to_le32(lb->first_block);
  40         newext.ee_len   = cpu_to_le16(lb->last_block - lb->first_block + 1);
  41         ext4_ext_store_pblock(&newext, lb->first_pblock);
  42         /* Locking only for convinience since we are operating on temp inode */
  43         down_write(&EXT4_I(inode)->i_data_sem);
  44         path = ext4_ext_find_extent(inode, lb->first_block, NULL, 0);
  45
  46         if (IS_ERR(path)) {
  47                 retval = PTR_ERR(path);
  48                 path = NULL;
  49                 goto err_out;
  50         }
  51
  52         /*
  53          * Calculate the credit needed to inserting this extent
  54          * Since we are doing this in loop we may accumalate extra
  55          * credit. But below we try to not accumalate too much
  56          * of them by restarting the journal.
  57          */
  58         needed = ext4_ext_calc_credits_for_single_extent(inode,
  59                     lb->last_block - lb->first_block + 1, path);
  60
  61         /*
  62          * Make sure the credit we accumalated is not really high
  63          */
  64         if (needed && ext4_handle_has_enough_credits(handle,
  65                                                 EXT4_RESERVE_TRANS_BLOCKS)) {
  66                 up_write((&EXT4_I(inode)->i_data_sem));
  67                 retval = ext4_journal_restart(handle, needed);
  68                 down_write((&EXT4_I(inode)->i_data_sem));
  69                 if (retval)
  70                         goto err_out;
  71         } else if (needed) {
  72                 retval = ext4_journal_extend(handle, needed);
  73                 if (retval) {
  74                         /*
  75                          * IF not able to extend the journal restart the journal
  76                          */
  77                         up_write((&EXT4_I(inode)->i_data_sem));
  78                         retval = ext4_journal_restart(handle, needed);
  79                         down_write((&EXT4_I(inode)->i_data_sem));
  80                         if (retval)
  81                                 goto err_out;
  82                 }
  83         }
  84         retval = ext4_ext_insert_extent(handle, inode, &path, &newext, 0);
  85 err_out:
  86         up_write((&EXT4_I(inode)->i_data_sem));
  87         ext4_ext_drop_refs(path);
  88         kfree(path);
  89         lb->first_pblock = 0;
  90         return retval;
  91 }
  92
  93 static int update_extent_range(handle_t *handle, struct inode *inode,
  94                                ext4_fsblk_t pblock, struct migrate_struct *lb)
  95 {
  96         int retval;
  97         /*
  98          * See if we can add on to the existing range (if it exists)
  99          */
 100         if (lb->first_pblock &&
 101                 (lb->last_pblock+1 == pblock) &&
 102                 (lb->last_block+1 == lb->curr_block)) {
 103                 lb->last_pblock = pblock;
 104                 lb->last_block = lb->curr_block;
 105                 lb->curr_block++;
 106                 return 0;
 107         }
 108         /*
 109          * Start a new range.
 110          */
 111         retval = finish_range(handle, inode, lb);
 112         lb->first_pblock = lb->last_pblock = pblock;
 113         lb->first_block = lb->last_block = lb->curr_block;
 114         lb->curr_block++;
 115         return retval;
 116 }
 117
 118 static int update_ind_extent_range(handle_t *handle, struct inode *inode,
 119                                    ext4_fsblk_t pblock,
 120                                    struct migrate_struct *lb)
 121 {
 122         struct buffer_head *bh;
 123         __le32 *i_data;
 124         int i, retval = 0;
 125         unsigned long max_entries = inode->i_sb->s_blocksize >> 2;
 126
 127         bh = sb_bread(inode->i_sb, pblock);
 128         if (!bh)
 129                 return -EIO;
 130
 131         i_data = (__le32 *)bh->b_data;
 132         for (i = 0; i < max_entries; i++) {
 133                 if (i_data[i]) {
 134                         retval = update_extent_range(handle, inode,
 135                                                 le32_to_cpu(i_data[i]), lb);
 136                         if (retval)
 137                                 break;
 138                 } else {
 139                         lb->curr_block++;
 140                 }
 141         }
 142         put_bh(bh);
 143         return retval;
 144
 145 }
 146
 147 static int update_dind_extent_range(handle_t *handle, struct inode *inode,
 148                                     ext4_fsblk_t pblock,
 149                                     struct migrate_struct *lb)
 150 {
 151         struct buffer_head *bh;
 152         __le32 *i_data;
 153         int i, retval = 0;
 154         unsigned long max_entries = inode->i_sb->s_blocksize >> 2;
 155
 156         bh = sb_bread(inode->i_sb, pblock);
 157         if (!bh)
 158                 return -EIO;
 159
 160         i_data = (__le32 *)bh->b_data;
 161         for (i = 0; i < max_entries; i++) {
 162                 if (i_data[i]) {
 163                         retval = update_ind_extent_range(handle, inode,
 164                                                 le32_to_cpu(i_data[i]), lb);
 165                         if (retval)
 166                                 break;
 167                 } else {
 168                         /* Only update the file block number */
 169                         lb->curr_block += max_entries;
 170                 }
 171         }
 172         put_bh(bh);
 173         return retval;
 174
 175 }
 176
 177 static int update_tind_extent_range(handle_t *handle, struct inode *inode,
 178                                     ext4_fsblk_t pblock,
 179                                     struct migrate_struct *lb)
 180 {
 181         struct buffer_head *bh;
 182         __le32 *i_data;
 183         int i, retval = 0;
 184         unsigned long max_entries = inode->i_sb->s_blocksize >> 2;
 185
 186         bh = sb_bread(inode->i_sb, pblock);
 187         if (!bh)
 188                 return -EIO;
 189
 190         i_data = (__le32 *)bh->b_data;
 191         for (i = 0; i < max_entries; i++) {
 192                 if (i_data[i]) {
 193                         retval = update_dind_extent_range(handle, inode,
 194                                                 le32_to_cpu(i_data[i]), lb);
 195                         if (retval)
 196                                 break;
 197                 } else {
 198                         /* Only update the file block number */
 199                         lb->curr_block += max_entries * max_entries;
 200                 }
 201         }
 202         put_bh(bh);
 203         return retval;
 204
 205 }
 206
 207 static int extend_credit_for_blkdel(handle_t *handle, struct inode *inode)
 208 {
 209         int retval = 0, needed;
 210
 211         if (ext4_handle_has_enough_credits(handle, EXT4_RESERVE_TRANS_BLOCKS+1))
 212                 return 0;
 213         /*
 214          * We are freeing a blocks. During this we touch
 215          * superblock, group descriptor and block bitmap.
 216          * So allocate a credit of 3. We may update
 217          * quota (user and group).
 218          */
 219         needed = 3 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
 220
 221         if (ext4_journal_extend(handle, needed) != 0)
 222                 retval = ext4_journal_restart(handle, needed);
 223
 224         return retval;
 225 }
 226
 227 static int free_dind_blocks(handle_t *handle,
 228                                 struct inode *inode, __le32 i_data)
 229 {
 230         int i;
 231         __le32 *tmp_idata;
 232         struct buffer_head *bh;
 233         unsigned long max_entries = inode->i_sb->s_blocksize >> 2;
 234
 235         bh = sb_bread(inode->i_sb, le32_to_cpu(i_data));
 236         if (!bh)
 237                 return -EIO;
 238
 239         tmp_idata = (__le32 *)bh->b_data;
 240         for (i = 0; i < max_entries; i++) {
 241                 if (tmp_idata[i]) {
 242                         extend_credit_for_blkdel(handle, inode);
 243                         ext4_free_blocks(handle, inode, NULL,
 244                                          le32_to_cpu(tmp_idata[i]), 1,
 245                                          EXT4_FREE_BLOCKS_METADATA |
 246                                          EXT4_FREE_BLOCKS_FORGET);
 247                 }
 248         }
 249         put_bh(bh);
 250         extend_credit_for_blkdel(handle, inode);
 251         ext4_free_blocks(handle, inode, NULL, le32_to_cpu(i_data), 1,
 252                          EXT4_FREE_BLOCKS_METADATA |
 253                          EXT4_FREE_BLOCKS_FORGET);
 254         return 0;
 255 }
 256
 257 static int free_tind_blocks(handle_t *handle,
 258                                 struct inode *inode, __le32 i_data)
 259 {
 260         int i, retval = 0;
 261         __le32 *tmp_idata;
 262         struct buffer_head *bh;
 263         unsigned long max_entries = inode->i_sb->s_blocksize >> 2;
 264
 265         bh = sb_bread(inode->i_sb, le32_to_cpu(i_data));
 266         if (!bh)
 267                 return -EIO;
 268
 269         tmp_idata = (__le32 *)bh->b_data;
 270         for (i = 0; i < max_entries; i++) {
 271                 if (tmp_idata[i]) {
 272                         retval = free_dind_blocks(handle,
 273                                         inode, tmp_idata[i]);
 274                         if (retval) {
 275                                 put_bh(bh);
 276                                 return retval;
 277                         }
 278                 }
 279         }
 280         put_bh(bh);
 281         extend_credit_for_blkdel(handle, inode);
 282         ext4_free_blocks(handle, inode, NULL, le32_to_cpu(i_data), 1,
 283                          EXT4_FREE_BLOCKS_METADATA |
 284                          EXT4_FREE_BLOCKS_FORGET);
 285         return 0;
 286 }
 287
 288 static int free_ind_block(handle_t *handle, struct inode *inode, __le32 *i_data)
 289 {
 290         int retval;
 291
 292         /* ei->i_data[EXT4_IND_BLOCK] */
 293         if (i_data[0]) {
 294                 extend_credit_for_blkdel(handle, inode);
 295                 ext4_free_blocks(handle, inode, NULL,
 296                                 le32_to_cpu(i_data[0]), 1,
 297                                  EXT4_FREE_BLOCKS_METADATA |
 298                                  EXT4_FREE_BLOCKS_FORGET);
 299         }
 300
 301         /* ei->i_data[EXT4_DIND_BLOCK] */
 302         if (i_data[1]) {
 303                 retval = free_dind_blocks(handle, inode, i_data[1]);
 304                 if (retval)
 305                         return retval;
 306         }
 307
 308         /* ei->i_data[EXT4_TIND_BLOCK] */
 309         if (i_data[2]) {
 310                 retval = free_tind_blocks(handle, inode, i_data[2]);
 311                 if (retval)
 312                         return retval;
 313         }
 314         return 0;
 315 }
 316
 317 static int ext4_ext_swap_inode_data(handle_t *handle, struct inode *inode,
 318                                                 struct inode *tmp_inode)
 319 {
 320         int retval;
 321         __le32  i_data[3];
 322         struct ext4_inode_info *ei = EXT4_I(inode);
 323         struct ext4_inode_info *tmp_ei = EXT4_I(tmp_inode);
 324
 325         /*
 326          * One credit accounted for writing the
 327          * i_data field of the original inode
 328          */
 329         retval = ext4_journal_extend(handle, 1);
 330         if (retval) {
 331                 retval = ext4_journal_restart(handle, 1);
 332                 if (retval)
 333                         goto err_out;
 334         }
 335
 336         i_data[0] = ei->i_data[EXT4_IND_BLOCK];
 337         i_data[1] = ei->i_data[EXT4_DIND_BLOCK];
 338         i_data[2] = ei->i_data[EXT4_TIND_BLOCK];
 339
 340         down_write(&EXT4_I(inode)->i_data_sem);
 341         /*
 342          * if EXT4_STATE_EXT_MIGRATE is cleared a block allocation
 343          * happened after we started the migrate. We need to
 344          * fail the migrate
 345          */
 346         if (!ext4_test_inode_state(inode, EXT4_STATE_EXT_MIGRATE)) {
 347                 retval = -EAGAIN;
 348                 up_write(&EXT4_I(inode)->i_data_sem);
 349                 goto err_out;
 350         } else
 351                 ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
 352         /*
 353          * We have the extent map build with the tmp inode.
 354          * Now copy the i_data across
 355          */
 356         ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS);
 357         memcpy(ei->i_data, tmp_ei->i_data, sizeof(ei->i_data));
 358
 359         /*
 360          * Update i_blocks with the new blocks that got
 361          * allocated while adding extents for extent index
 362          * blocks.
 363          *
 364          * While converting to extents we need not
 365          * update the orignal inode i_blocks for extent blocks
 366          * via quota APIs. The quota update happened via tmp_inode already.
 367          */
 368         spin_lock(&inode->i_lock);
 369         inode->i_blocks += tmp_inode->i_blocks;
 370         spin_unlock(&inode->i_lock);
 371         up_write(&EXT4_I(inode)->i_data_sem);
 372
 373         /*
 374          * We mark the inode dirty after, because we decrement the
 375          * i_blocks when freeing the indirect meta-data blocks
 376          */
 377         retval = free_ind_block(handle, inode, i_data);
 378         ext4_mark_inode_dirty(handle, inode);
 379
 380 err_out:
 381         return retval;
 382 }
 383
 384 static int free_ext_idx(handle_t *handle, struct inode *inode,
 385                                         struct ext4_extent_idx *ix)
 386 {
 387         int i, retval = 0;
 388         ext4_fsblk_t block;
 389         struct buffer_head *bh;
 390         struct ext4_extent_header *eh;
 391
 392         block = ext4_idx_pblock(ix);
 393         bh = sb_bread(inode->i_sb, block);
 394         if (!bh)
 395                 return -EIO;
 396
 397         eh = (struct ext4_extent_header *)bh->b_data;
 398         if (eh->eh_depth != 0) {
 399                 ix = EXT_FIRST_INDEX(eh);
 400                 for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ix++) {
 401                         retval = free_ext_idx(handle, inode, ix);
 402                         if (retval)
 403                                 break;
 404                 }
 405         }
 406         put_bh(bh);
 407         extend_credit_for_blkdel(handle, inode);
 408         ext4_free_blocks(handle, inode, NULL, block, 1,
 409                          EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET);
 410         return retval;
 411 }
 412
 413 /*
 414  * Free the extent meta data blocks only
 415  */
 416 static int free_ext_block(handle_t *handle, struct inode *inode)
 417 {
 418         int i, retval = 0;
 419         struct ext4_inode_info *ei = EXT4_I(inode);
 420         struct ext4_extent_header *eh = (struct ext4_extent_header *)ei->i_data;
 421         struct ext4_extent_idx *ix;
 422         if (eh->eh_depth == 0)
 423                 /*
 424                  * No extra blocks allocated for extent meta data
 425                  */
 426                 return 0;
 427         ix = EXT_FIRST_INDEX(eh);
 428         for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ix++) {
 429                 retval = free_ext_idx(handle, inode, ix);
 430                 if (retval)
 431                         return retval;
 432         }
 433         return retval;
 434 }
 435
 436 int ext4_ext_migrate(struct inode *inode)
 437 {
 438         handle_t *handle;
 439         int retval = 0, i;
 440         __le32 *i_data;
 441         struct ext4_inode_info *ei;
 442         struct inode *tmp_inode = NULL;
 443         struct migrate_struct lb;
 444         unsigned long max_entries;
 445         __u32 goal;
 446         uid_t owner[2];
 447
 448         /*
 449          * If the filesystem does not support extents, or the inode
 450          * already is extent-based, error out.
 451          */
 452         if (!EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb,
 453                                        EXT4_FEATURE_INCOMPAT_EXTENTS) ||
 454             (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
 455                 return -EINVAL;
 456
 457         if (S_ISLNK(inode->i_mode) && inode->i_blocks == 0)
 458                 /*
 459                  * don't migrate fast symlink
 460                  */
 461                 return retval;
 462
 463         /*
 464          * Worst case we can touch the allocation bitmaps, a bgd
 465          * block, and a block to link in the orphan list.  We do need
 466          * need to worry about credits for modifying the quota inode.
 467          */
 468         handle = ext4_journal_start(inode, EXT4_HT_MIGRATE,
 469                 4 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb));
 470
 471         if (IS_ERR(handle)) {
 472                 retval = PTR_ERR(handle);
 473                 return retval;
 474         }
 475         goal = (((inode->i_ino - 1) / EXT4_INODES_PER_GROUP(inode->i_sb)) *
 476                 EXT4_INODES_PER_GROUP(inode->i_sb)) + 1;
 477         owner[0] = i_uid_read(inode);
 478         owner[1] = i_gid_read(inode);
 479         tmp_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
 480                                    S_IFREG, NULL, goal, owner);
 481         if (IS_ERR(tmp_inode)) {
 482                 retval = PTR_ERR(tmp_inode);
 483                 ext4_journal_stop(handle);
 484                 return retval;
 485         }
 486         i_size_write(tmp_inode, i_size_read(inode));
 487         /*
 488          * Set the i_nlink to zero so it will be deleted later
 489          * when we drop inode reference.
 490          */
 491         clear_nlink(tmp_inode);
 492
 493         ext4_ext_tree_init(handle, tmp_inode);
 494         ext4_orphan_add(handle, tmp_inode);
 495         ext4_journal_stop(handle);
 496
 497         /*
 498          * start with one credit accounted for
 499          * superblock modification.
 500          *
 501          * For the tmp_inode we already have committed the
 502          * transaction that created the inode. Later as and
 503          * when we add extents we extent the journal
 504          */
 505         /*
 506          * Even though we take i_mutex we can still cause block
 507          * allocation via mmap write to holes. If we have allocated
 508          * new blocks we fail migrate.  New block allocation will
 509          * clear EXT4_STATE_EXT_MIGRATE flag.  The flag is updated
 510          * with i_data_sem held to prevent racing with block
 511          * allocation.
 512          */
 513         down_read(&EXT4_I(inode)->i_data_sem);
 514         ext4_set_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
 515         up_read((&EXT4_I(inode)->i_data_sem));
 516
 517         handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, 1);
 518         if (IS_ERR(handle)) {
 519                 /*
 520                  * It is impossible to update on-disk structures without
 521                  * a handle, so just rollback in-core changes and live other
 522                  * work to orphan_list_cleanup()
 523                  */
 524                 ext4_orphan_del(NULL, tmp_inode);
 525                 retval = PTR_ERR(handle);
 526                 goto out;
 527         }
 528
 529         ei = EXT4_I(inode);
 530         i_data = ei->i_data;
 531         memset(&lb, 0, sizeof(lb));
 532
 533         /* 32 bit block address 4 bytes */
 534         max_entries = inode->i_sb->s_blocksize >> 2;
 535         for (i = 0; i < EXT4_NDIR_BLOCKS; i++) {
 536                 if (i_data[i]) {
 537                         retval = update_extent_range(handle, tmp_inode,
 538                                                 le32_to_cpu(i_data[i]), &lb);
 539                         if (retval)
 540                                 goto err_out;
 541                 } else
 542                         lb.curr_block++;
 543         }
 544         if (i_data[EXT4_IND_BLOCK]) {
 545                 retval = update_ind_extent_range(handle, tmp_inode,
 546                                 le32_to_cpu(i_data[EXT4_IND_BLOCK]), &lb);
 547                         if (retval)
 548                                 goto err_out;
 549         } else
 550                 lb.curr_block += max_entries;
 551         if (i_data[EXT4_DIND_BLOCK]) {
 552                 retval = update_dind_extent_range(handle, tmp_inode,
 553                                 le32_to_cpu(i_data[EXT4_DIND_BLOCK]), &lb);
 554                         if (retval)
 555                                 goto err_out;
 556         } else
 557                 lb.curr_block += max_entries * max_entries;
 558         if (i_data[EXT4_TIND_BLOCK]) {
 559                 retval = update_tind_extent_range(handle, tmp_inode,
 560                                 le32_to_cpu(i_data[EXT4_TIND_BLOCK]), &lb);
 561                         if (retval)
 562                                 goto err_out;
 563         }
 564         /*
 565          * Build the last extent
 566          */
 567         retval = finish_range(handle, tmp_inode, &lb);
 568 err_out:
 569         if (retval)
 570                 /*
 571                  * Failure case delete the extent information with the
 572                  * tmp_inode
 573                  */
 574                 free_ext_block(handle, tmp_inode);
 575         else {
 576                 retval = ext4_ext_swap_inode_data(handle, inode, tmp_inode);
 577                 if (retval)
 578                         /*
 579                          * if we fail to swap inode data free the extent
 580                          * details of the tmp inode
 581                          */
 582                         free_ext_block(handle, tmp_inode);
 583         }
 584
 585         /* We mark the tmp_inode dirty via ext4_ext_tree_init. */
 586         if (ext4_journal_extend(handle, 1) != 0)
 587                 ext4_journal_restart(handle, 1);
 588
 589         /*
 590          * Mark the tmp_inode as of size zero
 591          */
 592         i_size_write(tmp_inode, 0);
 593
 594         /*
 595          * set the  i_blocks count to zero
 596          * so that the ext4_delete_inode does the
 597          * right job
 598          *
 599          * We don't need to take the i_lock because
 600          * the inode is not visible to user space.
 601          */
 602         tmp_inode->i_blocks = 0;
 603
 604         /* Reset the extent details */
 605         ext4_ext_tree_init(handle, tmp_inode);
 606         ext4_journal_stop(handle);
 607 out:
 608         unlock_new_inode(tmp_inode);
 609         iput(tmp_inode);
 610
 611         return retval;
 612 }
 613
 614 /*
 615  * Migrate a simple extent-based inode to use the i_blocks[] array
 616  */
 617 int ext4_ind_migrate(struct inode *inode)
 618 {
 619         struct ext4_extent_header       *eh;
 620         struct ext4_super_block         *es = EXT4_SB(inode->i_sb)->s_es;
 621         struct ext4_inode_info          *ei = EXT4_I(inode);
 622         struct ext4_extent              *ex;
 623         unsigned int                    i, len;
 624         ext4_fsblk_t                    blk;
 625         handle_t                        *handle;
 626         int                             ret;
 627
 628         if (!EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb,
 629                                        EXT4_FEATURE_INCOMPAT_EXTENTS) ||
 630             (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
 631                 return -EINVAL;
 632
 633         if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
 634                                        EXT4_FEATURE_RO_COMPAT_BIGALLOC))
 635                 return -EOPNOTSUPP;
 636
 637         handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, 1);
 638         if (IS_ERR(handle))
 639                 return PTR_ERR(handle);
 640
 641         down_write(&EXT4_I(inode)->i_data_sem);
 642         ret = ext4_ext_check_inode(inode);
 643         if (ret)
 644                 goto errout;
 645
 646         eh = ext_inode_hdr(inode);
 647         ex  = EXT_FIRST_EXTENT(eh);
 648         if (ext4_blocks_count(es) > EXT4_MAX_BLOCK_FILE_PHYS ||
 649             eh->eh_depth != 0 || le16_to_cpu(eh->eh_entries) > 1) {
 650                 ret = -EOPNOTSUPP;
 651                 goto errout;
 652         }
 653         if (eh->eh_entries == 0)
 654                 blk = len = 0;
 655         else {
 656                 len = le16_to_cpu(ex->ee_len);
 657                 blk = ext4_ext_pblock(ex);
 658                 if (len > EXT4_NDIR_BLOCKS) {
 659                         ret = -EOPNOTSUPP;
 660                         goto errout;
 661                 }
 662         }
 663
 664         ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
 665         memset(ei->i_data, 0, sizeof(ei->i_data));
 666         for (i=0; i < len; i++)
 667                 ei->i_data[i] = cpu_to_le32(blk++);
 668         ext4_mark_inode_dirty(handle, inode);
 669 errout:
 670         ext4_journal_stop(handle);
 671         up_write(&EXT4_I(inode)->i_data_sem);
 672         return ret;
 673 }