LCOV - code coverage report
Current view: top level - fs/ext4 - inline.c (source / functions) Hit Total Coverage
Test: landlock.info Lines: 7 1078 0.6 %
Date: 2021-04-22 12:43:58 Functions: 1 38 2.6 %

          Line data    Source code
       1             : // SPDX-License-Identifier: LGPL-2.1
       2             : /*
       3             :  * Copyright (c) 2012 Taobao.
       4             :  * Written by Tao Ma <boyu.mt@taobao.com>
       5             :  */
       6             : 
       7             : #include <linux/iomap.h>
       8             : #include <linux/fiemap.h>
       9             : #include <linux/iversion.h>
      10             : 
      11             : #include "ext4_jbd2.h"
      12             : #include "ext4.h"
      13             : #include "xattr.h"
      14             : #include "truncate.h"
      15             : 
      16             : #define EXT4_XATTR_SYSTEM_DATA  "data"
      17             : #define EXT4_MIN_INLINE_DATA_SIZE       ((sizeof(__le32) * EXT4_N_BLOCKS))
      18             : #define EXT4_INLINE_DOTDOT_OFFSET       2
      19             : #define EXT4_INLINE_DOTDOT_SIZE         4
      20             : 
      21           0 : static int ext4_get_inline_size(struct inode *inode)
      22             : {
      23           0 :         if (EXT4_I(inode)->i_inline_off)
      24           0 :                 return EXT4_I(inode)->i_inline_size;
      25             : 
      26             :         return 0;
      27             : }
      28             : 
      29           0 : static int get_max_inline_xattr_value_size(struct inode *inode,
      30             :                                            struct ext4_iloc *iloc)
      31             : {
      32           0 :         struct ext4_xattr_ibody_header *header;
      33           0 :         struct ext4_xattr_entry *entry;
      34           0 :         struct ext4_inode *raw_inode;
      35           0 :         int free, min_offs;
      36             : 
      37           0 :         min_offs = EXT4_SB(inode->i_sb)->s_inode_size -
      38           0 :                         EXT4_GOOD_OLD_INODE_SIZE -
      39           0 :                         EXT4_I(inode)->i_extra_isize -
      40             :                         sizeof(struct ext4_xattr_ibody_header);
      41             : 
      42             :         /*
      43             :          * We need to subtract another sizeof(__u32) since an in-inode xattr
      44             :          * needs an empty 4 bytes to indicate the gap between the xattr entry
      45             :          * and the name/value pair.
      46             :          */
      47           0 :         if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
      48           0 :                 return EXT4_XATTR_SIZE(min_offs -
      49             :                         EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA)) -
      50             :                         EXT4_XATTR_ROUND - sizeof(__u32));
      51             : 
      52           0 :         raw_inode = ext4_raw_inode(iloc);
      53           0 :         header = IHDR(inode, raw_inode);
      54           0 :         entry = IFIRST(header);
      55             : 
      56             :         /* Compute min_offs. */
      57           0 :         for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
      58           0 :                 if (!entry->e_value_inum && entry->e_value_size) {
      59           0 :                         size_t offs = le16_to_cpu(entry->e_value_offs);
      60           0 :                         if (offs < min_offs)
      61           0 :                                 min_offs = offs;
      62             :                 }
      63             :         }
      64           0 :         free = min_offs -
      65           0 :                 ((void *)entry - (void *)IFIRST(header)) - sizeof(__u32);
      66             : 
      67           0 :         if (EXT4_I(inode)->i_inline_off) {
      68           0 :                 entry = (struct ext4_xattr_entry *)
      69           0 :                         ((void *)raw_inode + EXT4_I(inode)->i_inline_off);
      70             : 
      71           0 :                 free += EXT4_XATTR_SIZE(le32_to_cpu(entry->e_value_size));
      72           0 :                 goto out;
      73             :         }
      74             : 
      75           0 :         free -= EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA));
      76             : 
      77           0 :         if (free > EXT4_XATTR_ROUND)
      78           0 :                 free = EXT4_XATTR_SIZE(free - EXT4_XATTR_ROUND);
      79             :         else
      80             :                 free = 0;
      81             : 
      82             : out:
      83             :         return free;
      84             : }
      85             : 
      86             : /*
      87             :  * Get the maximum size we now can store in an inode.
      88             :  * If we can't find the space for a xattr entry, don't use the space
      89             :  * of the extents since we have no space to indicate the inline data.
      90             :  */
      91           0 : int ext4_get_max_inline_size(struct inode *inode)
      92             : {
      93           0 :         int error, max_inline_size;
      94           0 :         struct ext4_iloc iloc;
      95             : 
      96           0 :         if (EXT4_I(inode)->i_extra_isize == 0)
      97             :                 return 0;
      98             : 
      99           0 :         error = ext4_get_inode_loc(inode, &iloc);
     100           0 :         if (error) {
     101           0 :                 ext4_error_inode_err(inode, __func__, __LINE__, 0, -error,
     102             :                                      "can't get inode location %lu",
     103             :                                      inode->i_ino);
     104           0 :                 return 0;
     105             :         }
     106             : 
     107           0 :         down_read(&EXT4_I(inode)->xattr_sem);
     108           0 :         max_inline_size = get_max_inline_xattr_value_size(inode, &iloc);
     109           0 :         up_read(&EXT4_I(inode)->xattr_sem);
     110             : 
     111           0 :         brelse(iloc.bh);
     112             : 
     113           0 :         if (!max_inline_size)
     114             :                 return 0;
     115             : 
     116           0 :         return max_inline_size + EXT4_MIN_INLINE_DATA_SIZE;
     117             : }
     118             : 
     119             : /*
     120             :  * this function does not take xattr_sem, which is OK because it is
     121             :  * currently only used in a code path coming form ext4_iget, before
     122             :  * the new inode has been unlocked
     123             :  */
     124           0 : int ext4_find_inline_data_nolock(struct inode *inode)
     125             : {
     126           0 :         struct ext4_xattr_ibody_find is = {
     127             :                 .s = { .not_found = -ENODATA, },
     128             :         };
     129           0 :         struct ext4_xattr_info i = {
     130             :                 .name_index = EXT4_XATTR_INDEX_SYSTEM,
     131             :                 .name = EXT4_XATTR_SYSTEM_DATA,
     132             :         };
     133           0 :         int error;
     134             : 
     135           0 :         if (EXT4_I(inode)->i_extra_isize == 0)
     136             :                 return 0;
     137             : 
     138           0 :         error = ext4_get_inode_loc(inode, &is.iloc);
     139           0 :         if (error)
     140             :                 return error;
     141             : 
     142           0 :         error = ext4_xattr_ibody_find(inode, &i, &is);
     143           0 :         if (error)
     144           0 :                 goto out;
     145             : 
     146           0 :         if (!is.s.not_found) {
     147           0 :                 if (is.s.here->e_value_inum) {
     148           0 :                         EXT4_ERROR_INODE(inode, "inline data xattr refers "
     149             :                                          "to an external xattr inode");
     150           0 :                         error = -EFSCORRUPTED;
     151           0 :                         goto out;
     152             :                 }
     153           0 :                 EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here -
     154           0 :                                         (void *)ext4_raw_inode(&is.iloc));
     155           0 :                 EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE +
     156           0 :                                 le32_to_cpu(is.s.here->e_value_size);
     157           0 :                 ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
     158             :         }
     159           0 : out:
     160           0 :         brelse(is.iloc.bh);
     161             :         return error;
     162             : }
     163             : 
     164           0 : static int ext4_read_inline_data(struct inode *inode, void *buffer,
     165             :                                  unsigned int len,
     166             :                                  struct ext4_iloc *iloc)
     167             : {
     168           0 :         struct ext4_xattr_entry *entry;
     169           0 :         struct ext4_xattr_ibody_header *header;
     170           0 :         int cp_len = 0;
     171           0 :         struct ext4_inode *raw_inode;
     172             : 
     173           0 :         if (!len)
     174             :                 return 0;
     175             : 
     176           0 :         BUG_ON(len > EXT4_I(inode)->i_inline_size);
     177             : 
     178           0 :         cp_len = len < EXT4_MIN_INLINE_DATA_SIZE ?
     179           0 :                         len : EXT4_MIN_INLINE_DATA_SIZE;
     180             : 
     181           0 :         raw_inode = ext4_raw_inode(iloc);
     182           0 :         memcpy(buffer, (void *)(raw_inode->i_block), cp_len);
     183             : 
     184           0 :         len -= cp_len;
     185           0 :         buffer += cp_len;
     186             : 
     187           0 :         if (!len)
     188           0 :                 goto out;
     189             : 
     190           0 :         header = IHDR(inode, raw_inode);
     191           0 :         entry = (struct ext4_xattr_entry *)((void *)raw_inode +
     192           0 :                                             EXT4_I(inode)->i_inline_off);
     193           0 :         len = min_t(unsigned int, len,
     194             :                     (unsigned int)le32_to_cpu(entry->e_value_size));
     195             : 
     196           0 :         memcpy(buffer,
     197           0 :                (void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs), len);
     198           0 :         cp_len += len;
     199             : 
     200             : out:
     201             :         return cp_len;
     202             : }
     203             : 
     204             : /*
     205             :  * write the buffer to the inline inode.
     206             :  * If 'create' is set, we don't need to do the extra copy in the xattr
     207             :  * value since it is already handled by ext4_xattr_ibody_inline_set.
     208             :  * That saves us one memcpy.
     209             :  */
     210           0 : static void ext4_write_inline_data(struct inode *inode, struct ext4_iloc *iloc,
     211             :                                    void *buffer, loff_t pos, unsigned int len)
     212             : {
     213           0 :         struct ext4_xattr_entry *entry;
     214           0 :         struct ext4_xattr_ibody_header *header;
     215           0 :         struct ext4_inode *raw_inode;
     216           0 :         int cp_len = 0;
     217             : 
     218           0 :         if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
     219             :                 return;
     220             : 
     221           0 :         BUG_ON(!EXT4_I(inode)->i_inline_off);
     222           0 :         BUG_ON(pos + len > EXT4_I(inode)->i_inline_size);
     223             : 
     224           0 :         raw_inode = ext4_raw_inode(iloc);
     225           0 :         buffer += pos;
     226             : 
     227           0 :         if (pos < EXT4_MIN_INLINE_DATA_SIZE) {
     228           0 :                 cp_len = pos + len > EXT4_MIN_INLINE_DATA_SIZE ?
     229           0 :                          EXT4_MIN_INLINE_DATA_SIZE - pos : len;
     230           0 :                 memcpy((void *)raw_inode->i_block + pos, buffer, cp_len);
     231             : 
     232           0 :                 len -= cp_len;
     233           0 :                 buffer += cp_len;
     234           0 :                 pos += cp_len;
     235             :         }
     236             : 
     237           0 :         if (!len)
     238             :                 return;
     239             : 
     240           0 :         pos -= EXT4_MIN_INLINE_DATA_SIZE;
     241           0 :         header = IHDR(inode, raw_inode);
     242           0 :         entry = (struct ext4_xattr_entry *)((void *)raw_inode +
     243           0 :                                             EXT4_I(inode)->i_inline_off);
     244             : 
     245           0 :         memcpy((void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs) + pos,
     246             :                buffer, len);
     247             : }
     248             : 
     249           0 : static int ext4_create_inline_data(handle_t *handle,
     250             :                                    struct inode *inode, unsigned len)
     251             : {
     252           0 :         int error;
     253           0 :         void *value = NULL;
     254           0 :         struct ext4_xattr_ibody_find is = {
     255             :                 .s = { .not_found = -ENODATA, },
     256             :         };
     257           0 :         struct ext4_xattr_info i = {
     258             :                 .name_index = EXT4_XATTR_INDEX_SYSTEM,
     259             :                 .name = EXT4_XATTR_SYSTEM_DATA,
     260             :         };
     261             : 
     262           0 :         error = ext4_get_inode_loc(inode, &is.iloc);
     263           0 :         if (error)
     264             :                 return error;
     265             : 
     266           0 :         BUFFER_TRACE(is.iloc.bh, "get_write_access");
     267           0 :         error = ext4_journal_get_write_access(handle, is.iloc.bh);
     268           0 :         if (error)
     269           0 :                 goto out;
     270             : 
     271           0 :         if (len > EXT4_MIN_INLINE_DATA_SIZE) {
     272           0 :                 value = EXT4_ZERO_XATTR_VALUE;
     273           0 :                 len -= EXT4_MIN_INLINE_DATA_SIZE;
     274             :         } else {
     275             :                 value = "";
     276             :                 len = 0;
     277             :         }
     278             : 
     279             :         /* Insert the xttr entry. */
     280           0 :         i.value = value;
     281           0 :         i.value_len = len;
     282             : 
     283           0 :         error = ext4_xattr_ibody_find(inode, &i, &is);
     284           0 :         if (error)
     285           0 :                 goto out;
     286             : 
     287           0 :         BUG_ON(!is.s.not_found);
     288             : 
     289           0 :         error = ext4_xattr_ibody_inline_set(handle, inode, &i, &is);
     290           0 :         if (error) {
     291           0 :                 if (error == -ENOSPC)
     292           0 :                         ext4_clear_inode_state(inode,
     293             :                                                EXT4_STATE_MAY_INLINE_DATA);
     294           0 :                 goto out;
     295             :         }
     296             : 
     297           0 :         memset((void *)ext4_raw_inode(&is.iloc)->i_block,
     298             :                 0, EXT4_MIN_INLINE_DATA_SIZE);
     299             : 
     300           0 :         EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here -
     301           0 :                                       (void *)ext4_raw_inode(&is.iloc));
     302           0 :         EXT4_I(inode)->i_inline_size = len + EXT4_MIN_INLINE_DATA_SIZE;
     303           0 :         ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
     304           0 :         ext4_set_inode_flag(inode, EXT4_INODE_INLINE_DATA);
     305           0 :         get_bh(is.iloc.bh);
     306           0 :         error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
     307             : 
     308           0 : out:
     309           0 :         brelse(is.iloc.bh);
     310             :         return error;
     311             : }
     312             : 
     313           0 : static int ext4_update_inline_data(handle_t *handle, struct inode *inode,
     314             :                                    unsigned int len)
     315             : {
     316           0 :         int error;
     317           0 :         void *value = NULL;
     318           0 :         struct ext4_xattr_ibody_find is = {
     319             :                 .s = { .not_found = -ENODATA, },
     320             :         };
     321           0 :         struct ext4_xattr_info i = {
     322             :                 .name_index = EXT4_XATTR_INDEX_SYSTEM,
     323             :                 .name = EXT4_XATTR_SYSTEM_DATA,
     324             :         };
     325             : 
     326             :         /* If the old space is ok, write the data directly. */
     327           0 :         if (len <= EXT4_I(inode)->i_inline_size)
     328             :                 return 0;
     329             : 
     330           0 :         error = ext4_get_inode_loc(inode, &is.iloc);
     331           0 :         if (error)
     332             :                 return error;
     333             : 
     334           0 :         error = ext4_xattr_ibody_find(inode, &i, &is);
     335           0 :         if (error)
     336           0 :                 goto out;
     337             : 
     338           0 :         BUG_ON(is.s.not_found);
     339             : 
     340           0 :         len -= EXT4_MIN_INLINE_DATA_SIZE;
     341           0 :         value = kzalloc(len, GFP_NOFS);
     342           0 :         if (!value) {
     343           0 :                 error = -ENOMEM;
     344           0 :                 goto out;
     345             :         }
     346             : 
     347           0 :         error = ext4_xattr_ibody_get(inode, i.name_index, i.name,
     348             :                                      value, len);
     349           0 :         if (error == -ENODATA)
     350           0 :                 goto out;
     351             : 
     352           0 :         BUFFER_TRACE(is.iloc.bh, "get_write_access");
     353           0 :         error = ext4_journal_get_write_access(handle, is.iloc.bh);
     354           0 :         if (error)
     355           0 :                 goto out;
     356             : 
     357             :         /* Update the xattr entry. */
     358           0 :         i.value = value;
     359           0 :         i.value_len = len;
     360             : 
     361           0 :         error = ext4_xattr_ibody_inline_set(handle, inode, &i, &is);
     362           0 :         if (error)
     363           0 :                 goto out;
     364             : 
     365           0 :         EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here -
     366           0 :                                       (void *)ext4_raw_inode(&is.iloc));
     367           0 :         EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE +
     368           0 :                                 le32_to_cpu(is.s.here->e_value_size);
     369           0 :         ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
     370           0 :         get_bh(is.iloc.bh);
     371           0 :         error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
     372             : 
     373           0 : out:
     374           0 :         kfree(value);
     375           0 :         brelse(is.iloc.bh);
     376             :         return error;
     377             : }
     378             : 
     379           0 : static int ext4_prepare_inline_data(handle_t *handle, struct inode *inode,
     380             :                                     unsigned int len)
     381             : {
     382           0 :         int ret, size, no_expand;
     383           0 :         struct ext4_inode_info *ei = EXT4_I(inode);
     384             : 
     385           0 :         if (!ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA))
     386             :                 return -ENOSPC;
     387             : 
     388           0 :         size = ext4_get_max_inline_size(inode);
     389           0 :         if (size < len)
     390             :                 return -ENOSPC;
     391             : 
     392           0 :         ext4_write_lock_xattr(inode, &no_expand);
     393             : 
     394           0 :         if (ei->i_inline_off)
     395           0 :                 ret = ext4_update_inline_data(handle, inode, len);
     396             :         else
     397           0 :                 ret = ext4_create_inline_data(handle, inode, len);
     398             : 
     399           0 :         ext4_write_unlock_xattr(inode, &no_expand);
     400           0 :         return ret;
     401             : }
     402             : 
     403           0 : static int ext4_destroy_inline_data_nolock(handle_t *handle,
     404             :                                            struct inode *inode)
     405             : {
     406           0 :         struct ext4_inode_info *ei = EXT4_I(inode);
     407           0 :         struct ext4_xattr_ibody_find is = {
     408             :                 .s = { .not_found = 0, },
     409             :         };
     410           0 :         struct ext4_xattr_info i = {
     411             :                 .name_index = EXT4_XATTR_INDEX_SYSTEM,
     412             :                 .name = EXT4_XATTR_SYSTEM_DATA,
     413             :                 .value = NULL,
     414             :                 .value_len = 0,
     415             :         };
     416           0 :         int error;
     417             : 
     418           0 :         if (!ei->i_inline_off)
     419             :                 return 0;
     420             : 
     421           0 :         error = ext4_get_inode_loc(inode, &is.iloc);
     422           0 :         if (error)
     423             :                 return error;
     424             : 
     425           0 :         error = ext4_xattr_ibody_find(inode, &i, &is);
     426           0 :         if (error)
     427           0 :                 goto out;
     428             : 
     429           0 :         BUFFER_TRACE(is.iloc.bh, "get_write_access");
     430           0 :         error = ext4_journal_get_write_access(handle, is.iloc.bh);
     431           0 :         if (error)
     432           0 :                 goto out;
     433             : 
     434           0 :         error = ext4_xattr_ibody_inline_set(handle, inode, &i, &is);
     435           0 :         if (error)
     436           0 :                 goto out;
     437             : 
     438           0 :         memset((void *)ext4_raw_inode(&is.iloc)->i_block,
     439             :                 0, EXT4_MIN_INLINE_DATA_SIZE);
     440           0 :         memset(ei->i_data, 0, EXT4_MIN_INLINE_DATA_SIZE);
     441             : 
     442           0 :         if (ext4_has_feature_extents(inode->i_sb)) {
     443           0 :                 if (S_ISDIR(inode->i_mode) ||
     444           0 :                     S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) {
     445           0 :                         ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS);
     446           0 :                         ext4_ext_tree_init(handle, inode);
     447             :                 }
     448             :         }
     449           0 :         ext4_clear_inode_flag(inode, EXT4_INODE_INLINE_DATA);
     450             : 
     451           0 :         get_bh(is.iloc.bh);
     452           0 :         error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
     453             : 
     454           0 :         EXT4_I(inode)->i_inline_off = 0;
     455           0 :         EXT4_I(inode)->i_inline_size = 0;
     456           0 :         ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
     457           0 : out:
     458           0 :         brelse(is.iloc.bh);
     459           0 :         if (error == -ENODATA)
     460           0 :                 error = 0;
     461             :         return error;
     462             : }
     463             : 
     464           0 : static int ext4_read_inline_page(struct inode *inode, struct page *page)
     465             : {
     466           0 :         void *kaddr;
     467           0 :         int ret = 0;
     468           0 :         size_t len;
     469           0 :         struct ext4_iloc iloc;
     470             : 
     471           0 :         BUG_ON(!PageLocked(page));
     472           0 :         BUG_ON(!ext4_has_inline_data(inode));
     473           0 :         BUG_ON(page->index);
     474             : 
     475           0 :         if (!EXT4_I(inode)->i_inline_off) {
     476           0 :                 ext4_warning(inode->i_sb, "inode %lu doesn't have inline data.",
     477             :                              inode->i_ino);
     478           0 :                 goto out;
     479             :         }
     480             : 
     481           0 :         ret = ext4_get_inode_loc(inode, &iloc);
     482           0 :         if (ret)
     483           0 :                 goto out;
     484             : 
     485           0 :         len = min_t(size_t, ext4_get_inline_size(inode), i_size_read(inode));
     486           0 :         kaddr = kmap_atomic(page);
     487           0 :         ret = ext4_read_inline_data(inode, kaddr, len, &iloc);
     488           0 :         flush_dcache_page(page);
     489           0 :         kunmap_atomic(kaddr);
     490           0 :         zero_user_segment(page, len, PAGE_SIZE);
     491           0 :         SetPageUptodate(page);
     492           0 :         brelse(iloc.bh);
     493             : 
     494           0 : out:
     495           0 :         return ret;
     496             : }
     497             : 
     498           0 : int ext4_readpage_inline(struct inode *inode, struct page *page)
     499             : {
     500           0 :         int ret = 0;
     501             : 
     502           0 :         down_read(&EXT4_I(inode)->xattr_sem);
     503           0 :         if (!ext4_has_inline_data(inode)) {
     504           0 :                 up_read(&EXT4_I(inode)->xattr_sem);
     505           0 :                 return -EAGAIN;
     506             :         }
     507             : 
     508             :         /*
     509             :          * Current inline data can only exist in the 1st page,
     510             :          * So for all the other pages, just set them uptodate.
     511             :          */
     512           0 :         if (!page->index)
     513           0 :                 ret = ext4_read_inline_page(inode, page);
     514           0 :         else if (!PageUptodate(page)) {
     515           0 :                 zero_user_segment(page, 0, PAGE_SIZE);
     516           0 :                 SetPageUptodate(page);
     517             :         }
     518             : 
     519           0 :         up_read(&EXT4_I(inode)->xattr_sem);
     520             : 
     521           0 :         unlock_page(page);
     522           0 :         return ret >= 0 ? 0 : ret;
     523             : }
     524             : 
     525           0 : static int ext4_convert_inline_data_to_extent(struct address_space *mapping,
     526             :                                               struct inode *inode,
     527             :                                               unsigned flags)
     528             : {
     529           0 :         int ret, needed_blocks, no_expand;
     530           0 :         handle_t *handle = NULL;
     531           0 :         int retries = 0, sem_held = 0;
     532           0 :         struct page *page = NULL;
     533           0 :         unsigned from, to;
     534           0 :         struct ext4_iloc iloc;
     535             : 
     536           0 :         if (!ext4_has_inline_data(inode)) {
     537             :                 /*
     538             :                  * clear the flag so that no new write
     539             :                  * will trap here again.
     540             :                  */
     541           0 :                 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
     542           0 :                 return 0;
     543             :         }
     544             : 
     545           0 :         needed_blocks = ext4_writepage_trans_blocks(inode);
     546             : 
     547           0 :         ret = ext4_get_inode_loc(inode, &iloc);
     548           0 :         if (ret)
     549             :                 return ret;
     550             : 
     551           0 : retry:
     552           0 :         handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
     553           0 :         if (IS_ERR(handle)) {
     554           0 :                 ret = PTR_ERR(handle);
     555           0 :                 handle = NULL;
     556           0 :                 goto out;
     557             :         }
     558             : 
     559             :         /* We cannot recurse into the filesystem as the transaction is already
     560             :          * started */
     561           0 :         flags |= AOP_FLAG_NOFS;
     562             : 
     563           0 :         page = grab_cache_page_write_begin(mapping, 0, flags);
     564           0 :         if (!page) {
     565           0 :                 ret = -ENOMEM;
     566           0 :                 goto out;
     567             :         }
     568             : 
     569           0 :         ext4_write_lock_xattr(inode, &no_expand);
     570           0 :         sem_held = 1;
     571             :         /* If some one has already done this for us, just exit. */
     572           0 :         if (!ext4_has_inline_data(inode)) {
     573           0 :                 ret = 0;
     574           0 :                 goto out;
     575             :         }
     576             : 
     577           0 :         from = 0;
     578           0 :         to = ext4_get_inline_size(inode);
     579           0 :         if (!PageUptodate(page)) {
     580           0 :                 ret = ext4_read_inline_page(inode, page);
     581           0 :                 if (ret < 0)
     582           0 :                         goto out;
     583             :         }
     584             : 
     585           0 :         ret = ext4_destroy_inline_data_nolock(handle, inode);
     586           0 :         if (ret)
     587           0 :                 goto out;
     588             : 
     589           0 :         if (ext4_should_dioread_nolock(inode)) {
     590           0 :                 ret = __block_write_begin(page, from, to,
     591             :                                           ext4_get_block_unwritten);
     592             :         } else
     593           0 :                 ret = __block_write_begin(page, from, to, ext4_get_block);
     594             : 
     595           0 :         if (!ret && ext4_should_journal_data(inode)) {
     596           0 :                 ret = ext4_walk_page_buffers(handle, page_buffers(page),
     597             :                                              from, to, NULL,
     598             :                                              do_journal_get_write_access);
     599             :         }
     600             : 
     601           0 :         if (ret) {
     602           0 :                 unlock_page(page);
     603           0 :                 put_page(page);
     604           0 :                 page = NULL;
     605           0 :                 ext4_orphan_add(handle, inode);
     606           0 :                 ext4_write_unlock_xattr(inode, &no_expand);
     607           0 :                 sem_held = 0;
     608           0 :                 ext4_journal_stop(handle);
     609           0 :                 handle = NULL;
     610           0 :                 ext4_truncate_failed_write(inode);
     611             :                 /*
     612             :                  * If truncate failed early the inode might
     613             :                  * still be on the orphan list; we need to
     614             :                  * make sure the inode is removed from the
     615             :                  * orphan list in that case.
     616             :                  */
     617           0 :                 if (inode->i_nlink)
     618           0 :                         ext4_orphan_del(NULL, inode);
     619             :         }
     620             : 
     621           0 :         if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
     622           0 :                 goto retry;
     623             : 
     624           0 :         if (page)
     625           0 :                 block_commit_write(page, from, to);
     626           0 : out:
     627           0 :         if (page) {
     628           0 :                 unlock_page(page);
     629           0 :                 put_page(page);
     630             :         }
     631           0 :         if (sem_held)
     632           0 :                 ext4_write_unlock_xattr(inode, &no_expand);
     633           0 :         if (handle)
     634           0 :                 ext4_journal_stop(handle);
     635           0 :         brelse(iloc.bh);
     636             :         return ret;
     637             : }
     638             : 
     639             : /*
     640             :  * Try to write data in the inode.
     641             :  * If the inode has inline data, check whether the new write can be
     642             :  * in the inode also. If not, create the page the handle, move the data
     643             :  * to the page make it update and let the later codes create extent for it.
     644             :  */
     645           0 : int ext4_try_to_write_inline_data(struct address_space *mapping,
     646             :                                   struct inode *inode,
     647             :                                   loff_t pos, unsigned len,
     648             :                                   unsigned flags,
     649             :                                   struct page **pagep)
     650             : {
     651           0 :         int ret;
     652           0 :         handle_t *handle;
     653           0 :         struct page *page;
     654           0 :         struct ext4_iloc iloc;
     655             : 
     656           0 :         if (pos + len > ext4_get_max_inline_size(inode))
     657           0 :                 goto convert;
     658             : 
     659           0 :         ret = ext4_get_inode_loc(inode, &iloc);
     660           0 :         if (ret)
     661             :                 return ret;
     662             : 
     663             :         /*
     664             :          * The possible write could happen in the inode,
     665             :          * so try to reserve the space in inode first.
     666             :          */
     667           0 :         handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
     668           0 :         if (IS_ERR(handle)) {
     669           0 :                 ret = PTR_ERR(handle);
     670           0 :                 handle = NULL;
     671           0 :                 goto out;
     672             :         }
     673             : 
     674           0 :         ret = ext4_prepare_inline_data(handle, inode, pos + len);
     675           0 :         if (ret && ret != -ENOSPC)
     676           0 :                 goto out;
     677             : 
     678             :         /* We don't have space in inline inode, so convert it to extent. */
     679           0 :         if (ret == -ENOSPC) {
     680           0 :                 ext4_journal_stop(handle);
     681           0 :                 brelse(iloc.bh);
     682           0 :                 goto convert;
     683             :         }
     684             : 
     685           0 :         ret = ext4_journal_get_write_access(handle, iloc.bh);
     686           0 :         if (ret)
     687           0 :                 goto out;
     688             : 
     689           0 :         flags |= AOP_FLAG_NOFS;
     690             : 
     691           0 :         page = grab_cache_page_write_begin(mapping, 0, flags);
     692           0 :         if (!page) {
     693           0 :                 ret = -ENOMEM;
     694           0 :                 goto out;
     695             :         }
     696             : 
     697           0 :         *pagep = page;
     698           0 :         down_read(&EXT4_I(inode)->xattr_sem);
     699           0 :         if (!ext4_has_inline_data(inode)) {
     700           0 :                 ret = 0;
     701           0 :                 unlock_page(page);
     702           0 :                 put_page(page);
     703           0 :                 goto out_up_read;
     704             :         }
     705             : 
     706           0 :         if (!PageUptodate(page)) {
     707           0 :                 ret = ext4_read_inline_page(inode, page);
     708           0 :                 if (ret < 0) {
     709           0 :                         unlock_page(page);
     710           0 :                         put_page(page);
     711           0 :                         goto out_up_read;
     712             :                 }
     713             :         }
     714             : 
     715             :         ret = 1;
     716             :         handle = NULL;
     717           0 : out_up_read:
     718           0 :         up_read(&EXT4_I(inode)->xattr_sem);
     719           0 : out:
     720           0 :         if (handle && (ret != 1))
     721           0 :                 ext4_journal_stop(handle);
     722           0 :         brelse(iloc.bh);
     723             :         return ret;
     724           0 : convert:
     725           0 :         return ext4_convert_inline_data_to_extent(mapping,
     726             :                                                   inode, flags);
     727             : }
     728             : 
     729           0 : int ext4_write_inline_data_end(struct inode *inode, loff_t pos, unsigned len,
     730             :                                unsigned copied, struct page *page)
     731             : {
     732           0 :         int ret, no_expand;
     733           0 :         void *kaddr;
     734           0 :         struct ext4_iloc iloc;
     735             : 
     736           0 :         if (unlikely(copied < len)) {
     737           0 :                 if (!PageUptodate(page)) {
     738           0 :                         copied = 0;
     739           0 :                         goto out;
     740             :                 }
     741             :         }
     742             : 
     743           0 :         ret = ext4_get_inode_loc(inode, &iloc);
     744           0 :         if (ret) {
     745           0 :                 ext4_std_error(inode->i_sb, ret);
     746           0 :                 copied = 0;
     747           0 :                 goto out;
     748             :         }
     749             : 
     750           0 :         ext4_write_lock_xattr(inode, &no_expand);
     751           0 :         BUG_ON(!ext4_has_inline_data(inode));
     752             : 
     753           0 :         kaddr = kmap_atomic(page);
     754           0 :         ext4_write_inline_data(inode, &iloc, kaddr, pos, len);
     755           0 :         kunmap_atomic(kaddr);
     756           0 :         SetPageUptodate(page);
     757             :         /* clear page dirty so that writepages wouldn't work for us. */
     758           0 :         ClearPageDirty(page);
     759             : 
     760           0 :         ext4_write_unlock_xattr(inode, &no_expand);
     761           0 :         brelse(iloc.bh);
     762           0 :         mark_inode_dirty(inode);
     763           0 : out:
     764           0 :         return copied;
     765             : }
     766             : 
     767             : struct buffer_head *
     768           0 : ext4_journalled_write_inline_data(struct inode *inode,
     769             :                                   unsigned len,
     770             :                                   struct page *page)
     771             : {
     772           0 :         int ret, no_expand;
     773           0 :         void *kaddr;
     774           0 :         struct ext4_iloc iloc;
     775             : 
     776           0 :         ret = ext4_get_inode_loc(inode, &iloc);
     777           0 :         if (ret) {
     778           0 :                 ext4_std_error(inode->i_sb, ret);
     779           0 :                 return NULL;
     780             :         }
     781             : 
     782           0 :         ext4_write_lock_xattr(inode, &no_expand);
     783           0 :         kaddr = kmap_atomic(page);
     784           0 :         ext4_write_inline_data(inode, &iloc, kaddr, 0, len);
     785           0 :         kunmap_atomic(kaddr);
     786           0 :         ext4_write_unlock_xattr(inode, &no_expand);
     787             : 
     788           0 :         return iloc.bh;
     789             : }
     790             : 
     791             : /*
     792             :  * Try to make the page cache and handle ready for the inline data case.
     793             :  * We can call this function in 2 cases:
     794             :  * 1. The inode is created and the first write exceeds inline size. We can
     795             :  *    clear the inode state safely.
     796             :  * 2. The inode has inline data, then we need to read the data, make it
     797             :  *    update and dirty so that ext4_da_writepages can handle it. We don't
     798             :  *    need to start the journal since the file's metatdata isn't changed now.
     799             :  */
     800           0 : static int ext4_da_convert_inline_data_to_extent(struct address_space *mapping,
     801             :                                                  struct inode *inode,
     802             :                                                  unsigned flags,
     803             :                                                  void **fsdata)
     804             : {
     805           0 :         int ret = 0, inline_size;
     806           0 :         struct page *page;
     807             : 
     808           0 :         page = grab_cache_page_write_begin(mapping, 0, flags);
     809           0 :         if (!page)
     810             :                 return -ENOMEM;
     811             : 
     812           0 :         down_read(&EXT4_I(inode)->xattr_sem);
     813           0 :         if (!ext4_has_inline_data(inode)) {
     814           0 :                 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
     815           0 :                 goto out;
     816             :         }
     817             : 
     818           0 :         inline_size = ext4_get_inline_size(inode);
     819             : 
     820           0 :         if (!PageUptodate(page)) {
     821           0 :                 ret = ext4_read_inline_page(inode, page);
     822           0 :                 if (ret < 0)
     823           0 :                         goto out;
     824             :         }
     825             : 
     826           0 :         ret = __block_write_begin(page, 0, inline_size,
     827             :                                   ext4_da_get_block_prep);
     828           0 :         if (ret) {
     829           0 :                 up_read(&EXT4_I(inode)->xattr_sem);
     830           0 :                 unlock_page(page);
     831           0 :                 put_page(page);
     832           0 :                 ext4_truncate_failed_write(inode);
     833           0 :                 return ret;
     834             :         }
     835             : 
     836           0 :         SetPageDirty(page);
     837           0 :         SetPageUptodate(page);
     838           0 :         ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
     839           0 :         *fsdata = (void *)CONVERT_INLINE_DATA;
     840             : 
     841           0 : out:
     842           0 :         up_read(&EXT4_I(inode)->xattr_sem);
     843           0 :         if (page) {
     844           0 :                 unlock_page(page);
     845           0 :                 put_page(page);
     846             :         }
     847           0 :         return ret;
     848             : }
     849             : 
     850             : /*
     851             :  * Prepare the write for the inline data.
     852             :  * If the data can be written into the inode, we just read
     853             :  * the page and make it uptodate, and start the journal.
     854             :  * Otherwise read the page, makes it dirty so that it can be
     855             :  * handle in writepages(the i_disksize update is left to the
     856             :  * normal ext4_da_write_end).
     857             :  */
     858           0 : int ext4_da_write_inline_data_begin(struct address_space *mapping,
     859             :                                     struct inode *inode,
     860             :                                     loff_t pos, unsigned len,
     861             :                                     unsigned flags,
     862             :                                     struct page **pagep,
     863             :                                     void **fsdata)
     864             : {
     865           0 :         int ret, inline_size;
     866           0 :         handle_t *handle;
     867           0 :         struct page *page;
     868           0 :         struct ext4_iloc iloc;
     869           0 :         int retries = 0;
     870             : 
     871           0 :         ret = ext4_get_inode_loc(inode, &iloc);
     872           0 :         if (ret)
     873             :                 return ret;
     874             : 
     875           0 : retry_journal:
     876           0 :         handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
     877           0 :         if (IS_ERR(handle)) {
     878           0 :                 ret = PTR_ERR(handle);
     879           0 :                 goto out;
     880             :         }
     881             : 
     882           0 :         inline_size = ext4_get_max_inline_size(inode);
     883             : 
     884           0 :         ret = -ENOSPC;
     885           0 :         if (inline_size >= pos + len) {
     886           0 :                 ret = ext4_prepare_inline_data(handle, inode, pos + len);
     887           0 :                 if (ret && ret != -ENOSPC)
     888           0 :                         goto out_journal;
     889             :         }
     890             : 
     891             :         /*
     892             :          * We cannot recurse into the filesystem as the transaction
     893             :          * is already started.
     894             :          */
     895           0 :         flags |= AOP_FLAG_NOFS;
     896             : 
     897           0 :         if (ret == -ENOSPC) {
     898           0 :                 ext4_journal_stop(handle);
     899           0 :                 ret = ext4_da_convert_inline_data_to_extent(mapping,
     900             :                                                             inode,
     901             :                                                             flags,
     902             :                                                             fsdata);
     903           0 :                 if (ret == -ENOSPC &&
     904           0 :                     ext4_should_retry_alloc(inode->i_sb, &retries))
     905           0 :                         goto retry_journal;
     906           0 :                 goto out;
     907             :         }
     908             : 
     909           0 :         page = grab_cache_page_write_begin(mapping, 0, flags);
     910           0 :         if (!page) {
     911           0 :                 ret = -ENOMEM;
     912           0 :                 goto out_journal;
     913             :         }
     914             : 
     915           0 :         down_read(&EXT4_I(inode)->xattr_sem);
     916           0 :         if (!ext4_has_inline_data(inode)) {
     917           0 :                 ret = 0;
     918           0 :                 goto out_release_page;
     919             :         }
     920             : 
     921           0 :         if (!PageUptodate(page)) {
     922           0 :                 ret = ext4_read_inline_page(inode, page);
     923           0 :                 if (ret < 0)
     924           0 :                         goto out_release_page;
     925             :         }
     926           0 :         ret = ext4_journal_get_write_access(handle, iloc.bh);
     927           0 :         if (ret)
     928           0 :                 goto out_release_page;
     929             : 
     930           0 :         up_read(&EXT4_I(inode)->xattr_sem);
     931           0 :         *pagep = page;
     932           0 :         brelse(iloc.bh);
     933             :         return 1;
     934           0 : out_release_page:
     935           0 :         up_read(&EXT4_I(inode)->xattr_sem);
     936           0 :         unlock_page(page);
     937           0 :         put_page(page);
     938           0 : out_journal:
     939           0 :         ext4_journal_stop(handle);
     940           0 : out:
     941           0 :         brelse(iloc.bh);
     942             :         return ret;
     943             : }
     944             : 
     945           0 : int ext4_da_write_inline_data_end(struct inode *inode, loff_t pos,
     946             :                                   unsigned len, unsigned copied,
     947             :                                   struct page *page)
     948             : {
     949           0 :         int ret;
     950             : 
     951           0 :         ret = ext4_write_inline_data_end(inode, pos, len, copied, page);
     952           0 :         if (ret < 0) {
     953           0 :                 unlock_page(page);
     954           0 :                 put_page(page);
     955           0 :                 return ret;
     956             :         }
     957           0 :         copied = ret;
     958             : 
     959             :         /*
     960             :          * No need to use i_size_read() here, the i_size
     961             :          * cannot change under us because we hold i_mutex.
     962             :          *
     963             :          * But it's important to update i_size while still holding page lock:
     964             :          * page writeout could otherwise come in and zero beyond i_size.
     965             :          */
     966           0 :         if (pos+copied > inode->i_size)
     967           0 :                 i_size_write(inode, pos+copied);
     968           0 :         unlock_page(page);
     969           0 :         put_page(page);
     970             : 
     971             :         /*
     972             :          * Don't mark the inode dirty under page lock. First, it unnecessarily
     973             :          * makes the holding time of page lock longer. Second, it forces lock
     974             :          * ordering of page lock and transaction start for journaling
     975             :          * filesystems.
     976             :          */
     977           0 :         mark_inode_dirty(inode);
     978             : 
     979           0 :         return copied;
     980             : }
     981             : 
     982             : #ifdef INLINE_DIR_DEBUG
     983             : void ext4_show_inline_dir(struct inode *dir, struct buffer_head *bh,
     984             :                           void *inline_start, int inline_size)
     985             : {
     986             :         int offset;
     987             :         unsigned short de_len;
     988             :         struct ext4_dir_entry_2 *de = inline_start;
     989             :         void *dlimit = inline_start + inline_size;
     990             : 
     991             :         trace_printk("inode %lu\n", dir->i_ino);
     992             :         offset = 0;
     993             :         while ((void *)de < dlimit) {
     994             :                 de_len = ext4_rec_len_from_disk(de->rec_len, inline_size);
     995             :                 trace_printk("de: off %u rlen %u name %.*s nlen %u ino %u\n",
     996             :                              offset, de_len, de->name_len, de->name,
     997             :                              de->name_len, le32_to_cpu(de->inode));
     998             :                 if (ext4_check_dir_entry(dir, NULL, de, bh,
     999             :                                          inline_start, inline_size, offset))
    1000             :                         BUG();
    1001             : 
    1002             :                 offset += de_len;
    1003             :                 de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
    1004             :         }
    1005             : }
    1006             : #else
    1007             : #define ext4_show_inline_dir(dir, bh, inline_start, inline_size)
    1008             : #endif
    1009             : 
    1010             : /*
    1011             :  * Add a new entry into a inline dir.
    1012             :  * It will return -ENOSPC if no space is available, and -EIO
    1013             :  * and -EEXIST if directory entry already exists.
    1014             :  */
    1015           0 : static int ext4_add_dirent_to_inline(handle_t *handle,
    1016             :                                      struct ext4_filename *fname,
    1017             :                                      struct inode *dir,
    1018             :                                      struct inode *inode,
    1019             :                                      struct ext4_iloc *iloc,
    1020             :                                      void *inline_start, int inline_size)
    1021             : {
    1022           0 :         int             err;
    1023           0 :         struct ext4_dir_entry_2 *de;
    1024             : 
    1025           0 :         err = ext4_find_dest_de(dir, inode, iloc->bh, inline_start,
    1026             :                                 inline_size, fname, &de);
    1027           0 :         if (err)
    1028             :                 return err;
    1029             : 
    1030           0 :         BUFFER_TRACE(iloc->bh, "get_write_access");
    1031           0 :         err = ext4_journal_get_write_access(handle, iloc->bh);
    1032           0 :         if (err)
    1033             :                 return err;
    1034           0 :         ext4_insert_dentry(inode, de, inline_size, fname);
    1035             : 
    1036           0 :         ext4_show_inline_dir(dir, iloc->bh, inline_start, inline_size);
    1037             : 
    1038             :         /*
    1039             :          * XXX shouldn't update any times until successful
    1040             :          * completion of syscall, but too many callers depend
    1041             :          * on this.
    1042             :          *
    1043             :          * XXX similarly, too many callers depend on
    1044             :          * ext4_new_inode() setting the times, but error
    1045             :          * recovery deletes the inode, so the worst that can
    1046             :          * happen is that the times are slightly out of date
    1047             :          * and/or different from the directory change time.
    1048             :          */
    1049           0 :         dir->i_mtime = dir->i_ctime = current_time(dir);
    1050           0 :         ext4_update_dx_flag(dir);
    1051           0 :         inode_inc_iversion(dir);
    1052           0 :         return 1;
    1053             : }
    1054             : 
    1055           0 : static void *ext4_get_inline_xattr_pos(struct inode *inode,
    1056             :                                        struct ext4_iloc *iloc)
    1057             : {
    1058           0 :         struct ext4_xattr_entry *entry;
    1059           0 :         struct ext4_xattr_ibody_header *header;
    1060             : 
    1061           0 :         BUG_ON(!EXT4_I(inode)->i_inline_off);
    1062             : 
    1063           0 :         header = IHDR(inode, ext4_raw_inode(iloc));
    1064           0 :         entry = (struct ext4_xattr_entry *)((void *)ext4_raw_inode(iloc) +
    1065           0 :                                             EXT4_I(inode)->i_inline_off);
    1066             : 
    1067           0 :         return (void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs);
    1068             : }
    1069             : 
    1070             : /* Set the final de to cover the whole block. */
    1071           0 : static void ext4_update_final_de(void *de_buf, int old_size, int new_size)
    1072             : {
    1073           0 :         struct ext4_dir_entry_2 *de, *prev_de;
    1074           0 :         void *limit;
    1075           0 :         int de_len;
    1076             : 
    1077           0 :         de = (struct ext4_dir_entry_2 *)de_buf;
    1078           0 :         if (old_size) {
    1079           0 :                 limit = de_buf + old_size;
    1080           0 :                 do {
    1081           0 :                         prev_de = de;
    1082           0 :                         de_len = ext4_rec_len_from_disk(de->rec_len, old_size);
    1083           0 :                         de_buf += de_len;
    1084           0 :                         de = (struct ext4_dir_entry_2 *)de_buf;
    1085           0 :                 } while (de_buf < limit);
    1086             : 
    1087           0 :                 prev_de->rec_len = ext4_rec_len_to_disk(de_len + new_size -
    1088             :                                                         old_size, new_size);
    1089             :         } else {
    1090             :                 /* this is just created, so create an empty entry. */
    1091           0 :                 de->inode = 0;
    1092           0 :                 de->rec_len = ext4_rec_len_to_disk(new_size, new_size);
    1093             :         }
    1094           0 : }
    1095             : 
    1096           0 : static int ext4_update_inline_dir(handle_t *handle, struct inode *dir,
    1097             :                                   struct ext4_iloc *iloc)
    1098             : {
    1099           0 :         int ret;
    1100           0 :         int old_size = EXT4_I(dir)->i_inline_size - EXT4_MIN_INLINE_DATA_SIZE;
    1101           0 :         int new_size = get_max_inline_xattr_value_size(dir, iloc);
    1102             : 
    1103           0 :         if (new_size - old_size <= EXT4_DIR_REC_LEN(1))
    1104             :                 return -ENOSPC;
    1105             : 
    1106           0 :         ret = ext4_update_inline_data(handle, dir,
    1107             :                                       new_size + EXT4_MIN_INLINE_DATA_SIZE);
    1108           0 :         if (ret)
    1109             :                 return ret;
    1110             : 
    1111           0 :         ext4_update_final_de(ext4_get_inline_xattr_pos(dir, iloc), old_size,
    1112           0 :                              EXT4_I(dir)->i_inline_size -
    1113             :                                                 EXT4_MIN_INLINE_DATA_SIZE);
    1114           0 :         dir->i_size = EXT4_I(dir)->i_disksize = EXT4_I(dir)->i_inline_size;
    1115           0 :         return 0;
    1116             : }
    1117             : 
    1118           0 : static void ext4_restore_inline_data(handle_t *handle, struct inode *inode,
    1119             :                                      struct ext4_iloc *iloc,
    1120             :                                      void *buf, int inline_size)
    1121             : {
    1122           0 :         ext4_create_inline_data(handle, inode, inline_size);
    1123           0 :         ext4_write_inline_data(inode, iloc, buf, 0, inline_size);
    1124           0 :         ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
    1125           0 : }
    1126             : 
    1127           0 : static int ext4_finish_convert_inline_dir(handle_t *handle,
    1128             :                                           struct inode *inode,
    1129             :                                           struct buffer_head *dir_block,
    1130             :                                           void *buf,
    1131             :                                           int inline_size)
    1132             : {
    1133           0 :         int err, csum_size = 0, header_size = 0;
    1134           0 :         struct ext4_dir_entry_2 *de;
    1135           0 :         void *target = dir_block->b_data;
    1136             : 
    1137             :         /*
    1138             :          * First create "." and ".." and then copy the dir information
    1139             :          * back to the block.
    1140             :          */
    1141           0 :         de = (struct ext4_dir_entry_2 *)target;
    1142           0 :         de = ext4_init_dot_dotdot(inode, de,
    1143           0 :                 inode->i_sb->s_blocksize, csum_size,
    1144           0 :                 le32_to_cpu(((struct ext4_dir_entry_2 *)buf)->inode), 1);
    1145           0 :         header_size = (void *)de - target;
    1146             : 
    1147           0 :         memcpy((void *)de, buf + EXT4_INLINE_DOTDOT_SIZE,
    1148           0 :                 inline_size - EXT4_INLINE_DOTDOT_SIZE);
    1149             : 
    1150           0 :         if (ext4_has_metadata_csum(inode->i_sb))
    1151           0 :                 csum_size = sizeof(struct ext4_dir_entry_tail);
    1152             : 
    1153           0 :         inode->i_size = inode->i_sb->s_blocksize;
    1154           0 :         i_size_write(inode, inode->i_sb->s_blocksize);
    1155           0 :         EXT4_I(inode)->i_disksize = inode->i_sb->s_blocksize;
    1156           0 :         ext4_update_final_de(dir_block->b_data,
    1157           0 :                         inline_size - EXT4_INLINE_DOTDOT_SIZE + header_size,
    1158           0 :                         inode->i_sb->s_blocksize - csum_size);
    1159             : 
    1160           0 :         if (csum_size)
    1161           0 :                 ext4_initialize_dirent_tail(dir_block,
    1162           0 :                                             inode->i_sb->s_blocksize);
    1163           0 :         set_buffer_uptodate(dir_block);
    1164           0 :         err = ext4_handle_dirty_dirblock(handle, inode, dir_block);
    1165           0 :         if (err)
    1166             :                 return err;
    1167           0 :         set_buffer_verified(dir_block);
    1168           0 :         return ext4_mark_inode_dirty(handle, inode);
    1169             : }
    1170             : 
    1171           0 : static int ext4_convert_inline_data_nolock(handle_t *handle,
    1172             :                                            struct inode *inode,
    1173             :                                            struct ext4_iloc *iloc)
    1174             : {
    1175           0 :         int error;
    1176           0 :         void *buf = NULL;
    1177           0 :         struct buffer_head *data_bh = NULL;
    1178           0 :         struct ext4_map_blocks map;
    1179           0 :         int inline_size;
    1180             : 
    1181           0 :         inline_size = ext4_get_inline_size(inode);
    1182           0 :         buf = kmalloc(inline_size, GFP_NOFS);
    1183           0 :         if (!buf) {
    1184           0 :                 error = -ENOMEM;
    1185           0 :                 goto out;
    1186             :         }
    1187             : 
    1188           0 :         error = ext4_read_inline_data(inode, buf, inline_size, iloc);
    1189           0 :         if (error < 0)
    1190           0 :                 goto out;
    1191             : 
    1192             :         /*
    1193             :          * Make sure the inline directory entries pass checks before we try to
    1194             :          * convert them, so that we avoid touching stuff that needs fsck.
    1195             :          */
    1196           0 :         if (S_ISDIR(inode->i_mode)) {
    1197           0 :                 error = ext4_check_all_de(inode, iloc->bh,
    1198             :                                         buf + EXT4_INLINE_DOTDOT_SIZE,
    1199             :                                         inline_size - EXT4_INLINE_DOTDOT_SIZE);
    1200           0 :                 if (error)
    1201           0 :                         goto out;
    1202             :         }
    1203             : 
    1204           0 :         error = ext4_destroy_inline_data_nolock(handle, inode);
    1205           0 :         if (error)
    1206           0 :                 goto out;
    1207             : 
    1208           0 :         map.m_lblk = 0;
    1209           0 :         map.m_len = 1;
    1210           0 :         map.m_flags = 0;
    1211           0 :         error = ext4_map_blocks(handle, inode, &map, EXT4_GET_BLOCKS_CREATE);
    1212           0 :         if (error < 0)
    1213           0 :                 goto out_restore;
    1214           0 :         if (!(map.m_flags & EXT4_MAP_MAPPED)) {
    1215           0 :                 error = -EIO;
    1216           0 :                 goto out_restore;
    1217             :         }
    1218             : 
    1219           0 :         data_bh = sb_getblk(inode->i_sb, map.m_pblk);
    1220           0 :         if (!data_bh) {
    1221           0 :                 error = -ENOMEM;
    1222           0 :                 goto out_restore;
    1223             :         }
    1224             : 
    1225           0 :         lock_buffer(data_bh);
    1226           0 :         error = ext4_journal_get_create_access(handle, data_bh);
    1227           0 :         if (error) {
    1228           0 :                 unlock_buffer(data_bh);
    1229           0 :                 error = -EIO;
    1230           0 :                 goto out_restore;
    1231             :         }
    1232           0 :         memset(data_bh->b_data, 0, inode->i_sb->s_blocksize);
    1233             : 
    1234           0 :         if (!S_ISDIR(inode->i_mode)) {
    1235           0 :                 memcpy(data_bh->b_data, buf, inline_size);
    1236           0 :                 set_buffer_uptodate(data_bh);
    1237           0 :                 error = ext4_handle_dirty_metadata(handle,
    1238             :                                                    inode, data_bh);
    1239             :         } else {
    1240           0 :                 error = ext4_finish_convert_inline_dir(handle, inode, data_bh,
    1241             :                                                        buf, inline_size);
    1242             :         }
    1243             : 
    1244           0 :         unlock_buffer(data_bh);
    1245           0 : out_restore:
    1246           0 :         if (error)
    1247           0 :                 ext4_restore_inline_data(handle, inode, iloc, buf, inline_size);
    1248             : 
    1249           0 : out:
    1250           0 :         brelse(data_bh);
    1251           0 :         kfree(buf);
    1252           0 :         return error;
    1253             : }
    1254             : 
    1255             : /*
    1256             :  * Try to add the new entry to the inline data.
    1257             :  * If succeeds, return 0. If not, extended the inline dir and copied data to
    1258             :  * the new created block.
    1259             :  */
    1260           0 : int ext4_try_add_inline_entry(handle_t *handle, struct ext4_filename *fname,
    1261             :                               struct inode *dir, struct inode *inode)
    1262             : {
    1263           0 :         int ret, ret2, inline_size, no_expand;
    1264           0 :         void *inline_start;
    1265           0 :         struct ext4_iloc iloc;
    1266             : 
    1267           0 :         ret = ext4_get_inode_loc(dir, &iloc);
    1268           0 :         if (ret)
    1269             :                 return ret;
    1270             : 
    1271           0 :         ext4_write_lock_xattr(dir, &no_expand);
    1272           0 :         if (!ext4_has_inline_data(dir))
    1273           0 :                 goto out;
    1274             : 
    1275           0 :         inline_start = (void *)ext4_raw_inode(&iloc)->i_block +
    1276             :                                                  EXT4_INLINE_DOTDOT_SIZE;
    1277           0 :         inline_size = EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DOTDOT_SIZE;
    1278             : 
    1279           0 :         ret = ext4_add_dirent_to_inline(handle, fname, dir, inode, &iloc,
    1280             :                                         inline_start, inline_size);
    1281           0 :         if (ret != -ENOSPC)
    1282           0 :                 goto out;
    1283             : 
    1284             :         /* check whether it can be inserted to inline xattr space. */
    1285           0 :         inline_size = EXT4_I(dir)->i_inline_size -
    1286             :                         EXT4_MIN_INLINE_DATA_SIZE;
    1287           0 :         if (!inline_size) {
    1288             :                 /* Try to use the xattr space.*/
    1289           0 :                 ret = ext4_update_inline_dir(handle, dir, &iloc);
    1290           0 :                 if (ret && ret != -ENOSPC)
    1291           0 :                         goto out;
    1292             : 
    1293           0 :                 inline_size = EXT4_I(dir)->i_inline_size -
    1294             :                                 EXT4_MIN_INLINE_DATA_SIZE;
    1295             :         }
    1296             : 
    1297           0 :         if (inline_size) {
    1298           0 :                 inline_start = ext4_get_inline_xattr_pos(dir, &iloc);
    1299             : 
    1300           0 :                 ret = ext4_add_dirent_to_inline(handle, fname, dir,
    1301             :                                                 inode, &iloc, inline_start,
    1302             :                                                 inline_size);
    1303             : 
    1304           0 :                 if (ret != -ENOSPC)
    1305           0 :                         goto out;
    1306             :         }
    1307             : 
    1308             :         /*
    1309             :          * The inline space is filled up, so create a new block for it.
    1310             :          * As the extent tree will be created, we have to save the inline
    1311             :          * dir first.
    1312             :          */
    1313           0 :         ret = ext4_convert_inline_data_nolock(handle, dir, &iloc);
    1314             : 
    1315           0 : out:
    1316           0 :         ext4_write_unlock_xattr(dir, &no_expand);
    1317           0 :         ret2 = ext4_mark_inode_dirty(handle, dir);
    1318           0 :         if (unlikely(ret2 && !ret))
    1319           0 :                 ret = ret2;
    1320           0 :         brelse(iloc.bh);
    1321             :         return ret;
    1322             : }
    1323             : 
    1324             : /*
    1325             :  * This function fills a red-black tree with information from an
    1326             :  * inlined dir.  It returns the number directory entries loaded
    1327             :  * into the tree.  If there is an error it is returned in err.
    1328             :  */
    1329           0 : int ext4_inlinedir_to_tree(struct file *dir_file,
    1330             :                            struct inode *dir, ext4_lblk_t block,
    1331             :                            struct dx_hash_info *hinfo,
    1332             :                            __u32 start_hash, __u32 start_minor_hash,
    1333             :                            int *has_inline_data)
    1334             : {
    1335           0 :         int err = 0, count = 0;
    1336           0 :         unsigned int parent_ino;
    1337           0 :         int pos;
    1338           0 :         struct ext4_dir_entry_2 *de;
    1339           0 :         struct inode *inode = file_inode(dir_file);
    1340           0 :         int ret, inline_size = 0;
    1341           0 :         struct ext4_iloc iloc;
    1342           0 :         void *dir_buf = NULL;
    1343           0 :         struct ext4_dir_entry_2 fake;
    1344           0 :         struct fscrypt_str tmp_str;
    1345             : 
    1346           0 :         ret = ext4_get_inode_loc(inode, &iloc);
    1347           0 :         if (ret)
    1348             :                 return ret;
    1349             : 
    1350           0 :         down_read(&EXT4_I(inode)->xattr_sem);
    1351           0 :         if (!ext4_has_inline_data(inode)) {
    1352           0 :                 up_read(&EXT4_I(inode)->xattr_sem);
    1353           0 :                 *has_inline_data = 0;
    1354           0 :                 goto out;
    1355             :         }
    1356             : 
    1357           0 :         inline_size = ext4_get_inline_size(inode);
    1358           0 :         dir_buf = kmalloc(inline_size, GFP_NOFS);
    1359           0 :         if (!dir_buf) {
    1360           0 :                 ret = -ENOMEM;
    1361           0 :                 up_read(&EXT4_I(inode)->xattr_sem);
    1362           0 :                 goto out;
    1363             :         }
    1364             : 
    1365           0 :         ret = ext4_read_inline_data(inode, dir_buf, inline_size, &iloc);
    1366           0 :         up_read(&EXT4_I(inode)->xattr_sem);
    1367           0 :         if (ret < 0)
    1368           0 :                 goto out;
    1369             : 
    1370           0 :         pos = 0;
    1371           0 :         parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode);
    1372           0 :         while (pos < inline_size) {
    1373             :                 /*
    1374             :                  * As inlined dir doesn't store any information about '.' and
    1375             :                  * only the inode number of '..' is stored, we have to handle
    1376             :                  * them differently.
    1377             :                  */
    1378           0 :                 if (pos == 0) {
    1379           0 :                         fake.inode = cpu_to_le32(inode->i_ino);
    1380           0 :                         fake.name_len = 1;
    1381           0 :                         strcpy(fake.name, ".");
    1382           0 :                         fake.rec_len = ext4_rec_len_to_disk(
    1383             :                                                 EXT4_DIR_REC_LEN(fake.name_len),
    1384             :                                                 inline_size);
    1385           0 :                         ext4_set_de_type(inode->i_sb, &fake, S_IFDIR);
    1386             :                         de = &fake;
    1387             :                         pos = EXT4_INLINE_DOTDOT_OFFSET;
    1388           0 :                 } else if (pos == EXT4_INLINE_DOTDOT_OFFSET) {
    1389           0 :                         fake.inode = cpu_to_le32(parent_ino);
    1390           0 :                         fake.name_len = 2;
    1391           0 :                         strcpy(fake.name, "..");
    1392           0 :                         fake.rec_len = ext4_rec_len_to_disk(
    1393             :                                                 EXT4_DIR_REC_LEN(fake.name_len),
    1394             :                                                 inline_size);
    1395           0 :                         ext4_set_de_type(inode->i_sb, &fake, S_IFDIR);
    1396             :                         de = &fake;
    1397             :                         pos = EXT4_INLINE_DOTDOT_SIZE;
    1398             :                 } else {
    1399           0 :                         de = (struct ext4_dir_entry_2 *)(dir_buf + pos);
    1400           0 :                         pos += ext4_rec_len_from_disk(de->rec_len, inline_size);
    1401           0 :                         if (ext4_check_dir_entry(inode, dir_file, de,
    1402             :                                          iloc.bh, dir_buf,
    1403             :                                          inline_size, pos)) {
    1404           0 :                                 ret = count;
    1405           0 :                                 goto out;
    1406             :                         }
    1407             :                 }
    1408             : 
    1409           0 :                 ext4fs_dirhash(dir, de->name, de->name_len, hinfo);
    1410           0 :                 if ((hinfo->hash < start_hash) ||
    1411           0 :                     ((hinfo->hash == start_hash) &&
    1412           0 :                      (hinfo->minor_hash < start_minor_hash)))
    1413           0 :                         continue;
    1414           0 :                 if (de->inode == 0)
    1415           0 :                         continue;
    1416           0 :                 tmp_str.name = de->name;
    1417           0 :                 tmp_str.len = de->name_len;
    1418           0 :                 err = ext4_htree_store_dirent(dir_file, hinfo->hash,
    1419             :                                               hinfo->minor_hash, de, &tmp_str);
    1420           0 :                 if (err) {
    1421           0 :                         ret = err;
    1422           0 :                         goto out;
    1423             :                 }
    1424           0 :                 count++;
    1425             :         }
    1426             :         ret = count;
    1427           0 : out:
    1428           0 :         kfree(dir_buf);
    1429           0 :         brelse(iloc.bh);
    1430             :         return ret;
    1431             : }
    1432             : 
    1433             : /*
    1434             :  * So this function is called when the volume is mkfsed with
    1435             :  * dir_index disabled. In order to keep f_pos persistent
    1436             :  * after we convert from an inlined dir to a blocked based,
    1437             :  * we just pretend that we are a normal dir and return the
    1438             :  * offset as if '.' and '..' really take place.
    1439             :  *
    1440             :  */
    1441           0 : int ext4_read_inline_dir(struct file *file,
    1442             :                          struct dir_context *ctx,
    1443             :                          int *has_inline_data)
    1444             : {
    1445           0 :         unsigned int offset, parent_ino;
    1446           0 :         int i;
    1447           0 :         struct ext4_dir_entry_2 *de;
    1448           0 :         struct super_block *sb;
    1449           0 :         struct inode *inode = file_inode(file);
    1450           0 :         int ret, inline_size = 0;
    1451           0 :         struct ext4_iloc iloc;
    1452           0 :         void *dir_buf = NULL;
    1453           0 :         int dotdot_offset, dotdot_size, extra_offset, extra_size;
    1454             : 
    1455           0 :         ret = ext4_get_inode_loc(inode, &iloc);
    1456           0 :         if (ret)
    1457             :                 return ret;
    1458             : 
    1459           0 :         down_read(&EXT4_I(inode)->xattr_sem);
    1460           0 :         if (!ext4_has_inline_data(inode)) {
    1461           0 :                 up_read(&EXT4_I(inode)->xattr_sem);
    1462           0 :                 *has_inline_data = 0;
    1463           0 :                 goto out;
    1464             :         }
    1465             : 
    1466           0 :         inline_size = ext4_get_inline_size(inode);
    1467           0 :         dir_buf = kmalloc(inline_size, GFP_NOFS);
    1468           0 :         if (!dir_buf) {
    1469           0 :                 ret = -ENOMEM;
    1470           0 :                 up_read(&EXT4_I(inode)->xattr_sem);
    1471           0 :                 goto out;
    1472             :         }
    1473             : 
    1474           0 :         ret = ext4_read_inline_data(inode, dir_buf, inline_size, &iloc);
    1475           0 :         up_read(&EXT4_I(inode)->xattr_sem);
    1476           0 :         if (ret < 0)
    1477           0 :                 goto out;
    1478             : 
    1479           0 :         ret = 0;
    1480           0 :         sb = inode->i_sb;
    1481           0 :         parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode);
    1482           0 :         offset = ctx->pos;
    1483             : 
    1484             :         /*
    1485             :          * dotdot_offset and dotdot_size is the real offset and
    1486             :          * size for ".." and "." if the dir is block based while
    1487             :          * the real size for them are only EXT4_INLINE_DOTDOT_SIZE.
    1488             :          * So we will use extra_offset and extra_size to indicate them
    1489             :          * during the inline dir iteration.
    1490             :          */
    1491           0 :         dotdot_offset = EXT4_DIR_REC_LEN(1);
    1492           0 :         dotdot_size = dotdot_offset + EXT4_DIR_REC_LEN(2);
    1493           0 :         extra_offset = dotdot_size - EXT4_INLINE_DOTDOT_SIZE;
    1494           0 :         extra_size = extra_offset + inline_size;
    1495             : 
    1496             :         /*
    1497             :          * If the version has changed since the last call to
    1498             :          * readdir(2), then we might be pointing to an invalid
    1499             :          * dirent right now.  Scan from the start of the inline
    1500             :          * dir to make sure.
    1501             :          */
    1502           0 :         if (!inode_eq_iversion(inode, file->f_version)) {
    1503           0 :                 for (i = 0; i < extra_size && i < offset;) {
    1504             :                         /*
    1505             :                          * "." is with offset 0 and
    1506             :                          * ".." is dotdot_offset.
    1507             :                          */
    1508           0 :                         if (!i) {
    1509           0 :                                 i = dotdot_offset;
    1510           0 :                                 continue;
    1511           0 :                         } else if (i == dotdot_offset) {
    1512           0 :                                 i = dotdot_size;
    1513           0 :                                 continue;
    1514             :                         }
    1515             :                         /* for other entry, the real offset in
    1516             :                          * the buf has to be tuned accordingly.
    1517             :                          */
    1518           0 :                         de = (struct ext4_dir_entry_2 *)
    1519           0 :                                 (dir_buf + i - extra_offset);
    1520             :                         /* It's too expensive to do a full
    1521             :                          * dirent test each time round this
    1522             :                          * loop, but we do have to test at
    1523             :                          * least that it is non-zero.  A
    1524             :                          * failure will be detected in the
    1525             :                          * dirent test below. */
    1526           0 :                         if (ext4_rec_len_from_disk(de->rec_len, extra_size)
    1527             :                                 < EXT4_DIR_REC_LEN(1))
    1528             :                                 break;
    1529           0 :                         i += ext4_rec_len_from_disk(de->rec_len,
    1530             :                                                     extra_size);
    1531             :                 }
    1532           0 :                 offset = i;
    1533           0 :                 ctx->pos = offset;
    1534           0 :                 file->f_version = inode_query_iversion(inode);
    1535             :         }
    1536             : 
    1537           0 :         while (ctx->pos < extra_size) {
    1538           0 :                 if (ctx->pos == 0) {
    1539           0 :                         if (!dir_emit(ctx, ".", 1, inode->i_ino, DT_DIR))
    1540           0 :                                 goto out;
    1541           0 :                         ctx->pos = dotdot_offset;
    1542           0 :                         continue;
    1543             :                 }
    1544             : 
    1545           0 :                 if (ctx->pos == dotdot_offset) {
    1546           0 :                         if (!dir_emit(ctx, "..", 2, parent_ino, DT_DIR))
    1547           0 :                                 goto out;
    1548           0 :                         ctx->pos = dotdot_size;
    1549           0 :                         continue;
    1550             :                 }
    1551             : 
    1552           0 :                 de = (struct ext4_dir_entry_2 *)
    1553           0 :                         (dir_buf + ctx->pos - extra_offset);
    1554           0 :                 if (ext4_check_dir_entry(inode, file, de, iloc.bh, dir_buf,
    1555             :                                          extra_size, ctx->pos))
    1556           0 :                         goto out;
    1557           0 :                 if (le32_to_cpu(de->inode)) {
    1558           0 :                         if (!dir_emit(ctx, de->name, de->name_len,
    1559             :                                       le32_to_cpu(de->inode),
    1560           0 :                                       get_dtype(sb, de->file_type)))
    1561           0 :                                 goto out;
    1562             :                 }
    1563           0 :                 ctx->pos += ext4_rec_len_from_disk(de->rec_len, extra_size);
    1564             :         }
    1565           0 : out:
    1566           0 :         kfree(dir_buf);
    1567           0 :         brelse(iloc.bh);
    1568             :         return ret;
    1569             : }
    1570             : 
    1571           0 : struct buffer_head *ext4_get_first_inline_block(struct inode *inode,
    1572             :                                         struct ext4_dir_entry_2 **parent_de,
    1573             :                                         int *retval)
    1574             : {
    1575           0 :         struct ext4_iloc iloc;
    1576             : 
    1577           0 :         *retval = ext4_get_inode_loc(inode, &iloc);
    1578           0 :         if (*retval)
    1579             :                 return NULL;
    1580             : 
    1581           0 :         *parent_de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block;
    1582             : 
    1583           0 :         return iloc.bh;
    1584             : }
    1585             : 
    1586             : /*
    1587             :  * Try to create the inline data for the new dir.
    1588             :  * If it succeeds, return 0, otherwise return the error.
    1589             :  * In case of ENOSPC, the caller should create the normal disk layout dir.
    1590             :  */
    1591           0 : int ext4_try_create_inline_dir(handle_t *handle, struct inode *parent,
    1592             :                                struct inode *inode)
    1593             : {
    1594           0 :         int ret, inline_size = EXT4_MIN_INLINE_DATA_SIZE;
    1595           0 :         struct ext4_iloc iloc;
    1596           0 :         struct ext4_dir_entry_2 *de;
    1597             : 
    1598           0 :         ret = ext4_get_inode_loc(inode, &iloc);
    1599           0 :         if (ret)
    1600             :                 return ret;
    1601             : 
    1602           0 :         ret = ext4_prepare_inline_data(handle, inode, inline_size);
    1603           0 :         if (ret)
    1604           0 :                 goto out;
    1605             : 
    1606             :         /*
    1607             :          * For inline dir, we only save the inode information for the ".."
    1608             :          * and create a fake dentry to cover the left space.
    1609             :          */
    1610           0 :         de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block;
    1611           0 :         de->inode = cpu_to_le32(parent->i_ino);
    1612           0 :         de = (struct ext4_dir_entry_2 *)((void *)de + EXT4_INLINE_DOTDOT_SIZE);
    1613           0 :         de->inode = 0;
    1614           0 :         de->rec_len = ext4_rec_len_to_disk(
    1615             :                                 inline_size - EXT4_INLINE_DOTDOT_SIZE,
    1616             :                                 inline_size);
    1617           0 :         set_nlink(inode, 2);
    1618           0 :         inode->i_size = EXT4_I(inode)->i_disksize = inline_size;
    1619           0 : out:
    1620           0 :         brelse(iloc.bh);
    1621             :         return ret;
    1622             : }
    1623             : 
    1624           0 : struct buffer_head *ext4_find_inline_entry(struct inode *dir,
    1625             :                                         struct ext4_filename *fname,
    1626             :                                         struct ext4_dir_entry_2 **res_dir,
    1627             :                                         int *has_inline_data)
    1628             : {
    1629           0 :         int ret;
    1630           0 :         struct ext4_iloc iloc;
    1631           0 :         void *inline_start;
    1632           0 :         int inline_size;
    1633             : 
    1634           0 :         if (ext4_get_inode_loc(dir, &iloc))
    1635             :                 return NULL;
    1636             : 
    1637           0 :         down_read(&EXT4_I(dir)->xattr_sem);
    1638           0 :         if (!ext4_has_inline_data(dir)) {
    1639           0 :                 *has_inline_data = 0;
    1640           0 :                 goto out;
    1641             :         }
    1642             : 
    1643           0 :         inline_start = (void *)ext4_raw_inode(&iloc)->i_block +
    1644             :                                                 EXT4_INLINE_DOTDOT_SIZE;
    1645           0 :         inline_size = EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DOTDOT_SIZE;
    1646           0 :         ret = ext4_search_dir(iloc.bh, inline_start, inline_size,
    1647             :                               dir, fname, 0, res_dir);
    1648           0 :         if (ret == 1)
    1649           0 :                 goto out_find;
    1650           0 :         if (ret < 0)
    1651           0 :                 goto out;
    1652             : 
    1653           0 :         if (ext4_get_inline_size(dir) == EXT4_MIN_INLINE_DATA_SIZE)
    1654           0 :                 goto out;
    1655             : 
    1656           0 :         inline_start = ext4_get_inline_xattr_pos(dir, &iloc);
    1657           0 :         inline_size = ext4_get_inline_size(dir) - EXT4_MIN_INLINE_DATA_SIZE;
    1658             : 
    1659           0 :         ret = ext4_search_dir(iloc.bh, inline_start, inline_size,
    1660             :                               dir, fname, 0, res_dir);
    1661           0 :         if (ret == 1)
    1662           0 :                 goto out_find;
    1663             : 
    1664           0 : out:
    1665           0 :         brelse(iloc.bh);
    1666           0 :         iloc.bh = NULL;
    1667           0 : out_find:
    1668           0 :         up_read(&EXT4_I(dir)->xattr_sem);
    1669           0 :         return iloc.bh;
    1670             : }
    1671             : 
    1672           0 : int ext4_delete_inline_entry(handle_t *handle,
    1673             :                              struct inode *dir,
    1674             :                              struct ext4_dir_entry_2 *de_del,
    1675             :                              struct buffer_head *bh,
    1676             :                              int *has_inline_data)
    1677             : {
    1678           0 :         int err, inline_size, no_expand;
    1679           0 :         struct ext4_iloc iloc;
    1680           0 :         void *inline_start;
    1681             : 
    1682           0 :         err = ext4_get_inode_loc(dir, &iloc);
    1683           0 :         if (err)
    1684             :                 return err;
    1685             : 
    1686           0 :         ext4_write_lock_xattr(dir, &no_expand);
    1687           0 :         if (!ext4_has_inline_data(dir)) {
    1688           0 :                 *has_inline_data = 0;
    1689           0 :                 goto out;
    1690             :         }
    1691             : 
    1692           0 :         if ((void *)de_del - ((void *)ext4_raw_inode(&iloc)->i_block) <
    1693             :                 EXT4_MIN_INLINE_DATA_SIZE) {
    1694           0 :                 inline_start = (void *)ext4_raw_inode(&iloc)->i_block +
    1695             :                                         EXT4_INLINE_DOTDOT_SIZE;
    1696           0 :                 inline_size = EXT4_MIN_INLINE_DATA_SIZE -
    1697             :                                 EXT4_INLINE_DOTDOT_SIZE;
    1698             :         } else {
    1699           0 :                 inline_start = ext4_get_inline_xattr_pos(dir, &iloc);
    1700           0 :                 inline_size = ext4_get_inline_size(dir) -
    1701             :                                 EXT4_MIN_INLINE_DATA_SIZE;
    1702             :         }
    1703             : 
    1704           0 :         BUFFER_TRACE(bh, "get_write_access");
    1705           0 :         err = ext4_journal_get_write_access(handle, bh);
    1706           0 :         if (err)
    1707           0 :                 goto out;
    1708             : 
    1709           0 :         err = ext4_generic_delete_entry(dir, de_del, bh,
    1710             :                                         inline_start, inline_size, 0);
    1711           0 :         if (err)
    1712           0 :                 goto out;
    1713             : 
    1714           0 :         ext4_show_inline_dir(dir, iloc.bh, inline_start, inline_size);
    1715           0 : out:
    1716           0 :         ext4_write_unlock_xattr(dir, &no_expand);
    1717           0 :         if (likely(err == 0))
    1718           0 :                 err = ext4_mark_inode_dirty(handle, dir);
    1719           0 :         brelse(iloc.bh);
    1720           0 :         if (err != -ENOENT)
    1721           0 :                 ext4_std_error(dir->i_sb, err);
    1722             :         return err;
    1723             : }
    1724             : 
    1725             : /*
    1726             :  * Get the inline dentry at offset.
    1727             :  */
    1728             : static inline struct ext4_dir_entry_2 *
    1729           0 : ext4_get_inline_entry(struct inode *inode,
    1730             :                       struct ext4_iloc *iloc,
    1731             :                       unsigned int offset,
    1732             :                       void **inline_start,
    1733             :                       int *inline_size)
    1734             : {
    1735           0 :         void *inline_pos;
    1736             : 
    1737           0 :         BUG_ON(offset > ext4_get_inline_size(inode));
    1738             : 
    1739           0 :         if (offset < EXT4_MIN_INLINE_DATA_SIZE) {
    1740           0 :                 inline_pos = (void *)ext4_raw_inode(iloc)->i_block;
    1741           0 :                 *inline_size = EXT4_MIN_INLINE_DATA_SIZE;
    1742             :         } else {
    1743           0 :                 inline_pos = ext4_get_inline_xattr_pos(inode, iloc);
    1744           0 :                 offset -= EXT4_MIN_INLINE_DATA_SIZE;
    1745           0 :                 *inline_size = ext4_get_inline_size(inode) -
    1746             :                                 EXT4_MIN_INLINE_DATA_SIZE;
    1747             :         }
    1748             : 
    1749           0 :         if (inline_start)
    1750           0 :                 *inline_start = inline_pos;
    1751           0 :         return (struct ext4_dir_entry_2 *)(inline_pos + offset);
    1752             : }
    1753             : 
    1754           0 : bool empty_inline_dir(struct inode *dir, int *has_inline_data)
    1755             : {
    1756           0 :         int err, inline_size;
    1757           0 :         struct ext4_iloc iloc;
    1758           0 :         size_t inline_len;
    1759           0 :         void *inline_pos;
    1760           0 :         unsigned int offset;
    1761           0 :         struct ext4_dir_entry_2 *de;
    1762           0 :         bool ret = true;
    1763             : 
    1764           0 :         err = ext4_get_inode_loc(dir, &iloc);
    1765           0 :         if (err) {
    1766           0 :                 EXT4_ERROR_INODE_ERR(dir, -err,
    1767             :                                      "error %d getting inode %lu block",
    1768             :                                      err, dir->i_ino);
    1769           0 :                 return true;
    1770             :         }
    1771             : 
    1772           0 :         down_read(&EXT4_I(dir)->xattr_sem);
    1773           0 :         if (!ext4_has_inline_data(dir)) {
    1774           0 :                 *has_inline_data = 0;
    1775           0 :                 goto out;
    1776             :         }
    1777             : 
    1778           0 :         de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block;
    1779           0 :         if (!le32_to_cpu(de->inode)) {
    1780           0 :                 ext4_warning(dir->i_sb,
    1781             :                              "bad inline directory (dir #%lu) - no `..'",
    1782             :                              dir->i_ino);
    1783           0 :                 ret = true;
    1784           0 :                 goto out;
    1785             :         }
    1786             : 
    1787           0 :         inline_len = ext4_get_inline_size(dir);
    1788           0 :         offset = EXT4_INLINE_DOTDOT_SIZE;
    1789           0 :         while (offset < inline_len) {
    1790           0 :                 de = ext4_get_inline_entry(dir, &iloc, offset,
    1791             :                                            &inline_pos, &inline_size);
    1792           0 :                 if (ext4_check_dir_entry(dir, NULL, de,
    1793             :                                          iloc.bh, inline_pos,
    1794             :                                          inline_size, offset)) {
    1795           0 :                         ext4_warning(dir->i_sb,
    1796             :                                      "bad inline directory (dir #%lu) - "
    1797             :                                      "inode %u, rec_len %u, name_len %d"
    1798             :                                      "inline size %d",
    1799             :                                      dir->i_ino, le32_to_cpu(de->inode),
    1800             :                                      le16_to_cpu(de->rec_len), de->name_len,
    1801             :                                      inline_size);
    1802           0 :                         ret = true;
    1803           0 :                         goto out;
    1804             :                 }
    1805           0 :                 if (le32_to_cpu(de->inode)) {
    1806           0 :                         ret = false;
    1807           0 :                         goto out;
    1808             :                 }
    1809           0 :                 offset += ext4_rec_len_from_disk(de->rec_len, inline_size);
    1810             :         }
    1811             : 
    1812           0 : out:
    1813           0 :         up_read(&EXT4_I(dir)->xattr_sem);
    1814           0 :         brelse(iloc.bh);
    1815             :         return ret;
    1816             : }
    1817             : 
    1818           0 : int ext4_destroy_inline_data(handle_t *handle, struct inode *inode)
    1819             : {
    1820           0 :         int ret, no_expand;
    1821             : 
    1822           0 :         ext4_write_lock_xattr(inode, &no_expand);
    1823           0 :         ret = ext4_destroy_inline_data_nolock(handle, inode);
    1824           0 :         ext4_write_unlock_xattr(inode, &no_expand);
    1825             : 
    1826           0 :         return ret;
    1827             : }
    1828             : 
    1829           0 : int ext4_inline_data_iomap(struct inode *inode, struct iomap *iomap)
    1830             : {
    1831           0 :         __u64 addr;
    1832           0 :         int error = -EAGAIN;
    1833           0 :         struct ext4_iloc iloc;
    1834             : 
    1835           0 :         down_read(&EXT4_I(inode)->xattr_sem);
    1836           0 :         if (!ext4_has_inline_data(inode))
    1837           0 :                 goto out;
    1838             : 
    1839           0 :         error = ext4_get_inode_loc(inode, &iloc);
    1840           0 :         if (error)
    1841           0 :                 goto out;
    1842             : 
    1843           0 :         addr = (__u64)iloc.bh->b_blocknr << inode->i_sb->s_blocksize_bits;
    1844           0 :         addr += (char *)ext4_raw_inode(&iloc) - iloc.bh->b_data;
    1845           0 :         addr += offsetof(struct ext4_inode, i_block);
    1846             : 
    1847           0 :         brelse(iloc.bh);
    1848             : 
    1849           0 :         iomap->addr = addr;
    1850           0 :         iomap->offset = 0;
    1851           0 :         iomap->length = min_t(loff_t, ext4_get_inline_size(inode),
    1852             :                               i_size_read(inode));
    1853           0 :         iomap->type = IOMAP_INLINE;
    1854           0 :         iomap->flags = 0;
    1855             : 
    1856           0 : out:
    1857           0 :         up_read(&EXT4_I(inode)->xattr_sem);
    1858           0 :         return error;
    1859             : }
    1860             : 
    1861           0 : int ext4_inline_data_truncate(struct inode *inode, int *has_inline)
    1862             : {
    1863           0 :         handle_t *handle;
    1864           0 :         int inline_size, value_len, needed_blocks, no_expand, err = 0;
    1865           0 :         size_t i_size;
    1866           0 :         void *value = NULL;
    1867           0 :         struct ext4_xattr_ibody_find is = {
    1868             :                 .s = { .not_found = -ENODATA, },
    1869             :         };
    1870           0 :         struct ext4_xattr_info i = {
    1871             :                 .name_index = EXT4_XATTR_INDEX_SYSTEM,
    1872             :                 .name = EXT4_XATTR_SYSTEM_DATA,
    1873             :         };
    1874             : 
    1875             : 
    1876           0 :         needed_blocks = ext4_writepage_trans_blocks(inode);
    1877           0 :         handle = ext4_journal_start(inode, EXT4_HT_INODE, needed_blocks);
    1878           0 :         if (IS_ERR(handle))
    1879           0 :                 return PTR_ERR(handle);
    1880             : 
    1881           0 :         ext4_write_lock_xattr(inode, &no_expand);
    1882           0 :         if (!ext4_has_inline_data(inode)) {
    1883           0 :                 ext4_write_unlock_xattr(inode, &no_expand);
    1884           0 :                 *has_inline = 0;
    1885           0 :                 ext4_journal_stop(handle);
    1886           0 :                 return 0;
    1887             :         }
    1888             : 
    1889           0 :         if ((err = ext4_orphan_add(handle, inode)) != 0)
    1890           0 :                 goto out;
    1891             : 
    1892           0 :         if ((err = ext4_get_inode_loc(inode, &is.iloc)) != 0)
    1893           0 :                 goto out;
    1894             : 
    1895           0 :         down_write(&EXT4_I(inode)->i_data_sem);
    1896           0 :         i_size = inode->i_size;
    1897           0 :         inline_size = ext4_get_inline_size(inode);
    1898           0 :         EXT4_I(inode)->i_disksize = i_size;
    1899             : 
    1900           0 :         if (i_size < inline_size) {
    1901             :                 /* Clear the content in the xattr space. */
    1902           0 :                 if (inline_size > EXT4_MIN_INLINE_DATA_SIZE) {
    1903           0 :                         if ((err = ext4_xattr_ibody_find(inode, &i, &is)) != 0)
    1904           0 :                                 goto out_error;
    1905             : 
    1906           0 :                         BUG_ON(is.s.not_found);
    1907             : 
    1908           0 :                         value_len = le32_to_cpu(is.s.here->e_value_size);
    1909           0 :                         value = kmalloc(value_len, GFP_NOFS);
    1910           0 :                         if (!value) {
    1911           0 :                                 err = -ENOMEM;
    1912           0 :                                 goto out_error;
    1913             :                         }
    1914             : 
    1915           0 :                         err = ext4_xattr_ibody_get(inode, i.name_index,
    1916             :                                                    i.name, value, value_len);
    1917           0 :                         if (err <= 0)
    1918           0 :                                 goto out_error;
    1919             : 
    1920           0 :                         i.value = value;
    1921           0 :                         i.value_len = i_size > EXT4_MIN_INLINE_DATA_SIZE ?
    1922           0 :                                         i_size - EXT4_MIN_INLINE_DATA_SIZE : 0;
    1923           0 :                         err = ext4_xattr_ibody_inline_set(handle, inode,
    1924             :                                                           &i, &is);
    1925           0 :                         if (err)
    1926           0 :                                 goto out_error;
    1927             :                 }
    1928             : 
    1929             :                 /* Clear the content within i_blocks. */
    1930           0 :                 if (i_size < EXT4_MIN_INLINE_DATA_SIZE) {
    1931           0 :                         void *p = (void *) ext4_raw_inode(&is.iloc)->i_block;
    1932           0 :                         memset(p + i_size, 0,
    1933             :                                EXT4_MIN_INLINE_DATA_SIZE - i_size);
    1934             :                 }
    1935             : 
    1936           0 :                 EXT4_I(inode)->i_inline_size = i_size <
    1937             :                                         EXT4_MIN_INLINE_DATA_SIZE ?
    1938           0 :                                         EXT4_MIN_INLINE_DATA_SIZE : i_size;
    1939             :         }
    1940             : 
    1941           0 : out_error:
    1942           0 :         up_write(&EXT4_I(inode)->i_data_sem);
    1943           0 : out:
    1944           0 :         brelse(is.iloc.bh);
    1945           0 :         ext4_write_unlock_xattr(inode, &no_expand);
    1946           0 :         kfree(value);
    1947           0 :         if (inode->i_nlink)
    1948           0 :                 ext4_orphan_del(handle, inode);
    1949             : 
    1950           0 :         if (err == 0) {
    1951           0 :                 inode->i_mtime = inode->i_ctime = current_time(inode);
    1952           0 :                 err = ext4_mark_inode_dirty(handle, inode);
    1953           0 :                 if (IS_SYNC(inode))
    1954           0 :                         ext4_handle_sync(handle);
    1955             :         }
    1956           0 :         ext4_journal_stop(handle);
    1957           0 :         return err;
    1958             : }
    1959             : 
    1960         304 : int ext4_convert_inline_data(struct inode *inode)
    1961             : {
    1962         304 :         int error, needed_blocks, no_expand;
    1963         304 :         handle_t *handle;
    1964         304 :         struct ext4_iloc iloc;
    1965             : 
    1966         304 :         if (!ext4_has_inline_data(inode)) {
    1967         304 :                 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
    1968         304 :                 return 0;
    1969             :         }
    1970             : 
    1971           0 :         needed_blocks = ext4_writepage_trans_blocks(inode);
    1972             : 
    1973           0 :         iloc.bh = NULL;
    1974           0 :         error = ext4_get_inode_loc(inode, &iloc);
    1975           0 :         if (error)
    1976             :                 return error;
    1977             : 
    1978           0 :         handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
    1979           0 :         if (IS_ERR(handle)) {
    1980           0 :                 error = PTR_ERR(handle);
    1981           0 :                 goto out_free;
    1982             :         }
    1983             : 
    1984           0 :         ext4_write_lock_xattr(inode, &no_expand);
    1985           0 :         if (ext4_has_inline_data(inode))
    1986           0 :                 error = ext4_convert_inline_data_nolock(handle, inode, &iloc);
    1987           0 :         ext4_write_unlock_xattr(inode, &no_expand);
    1988           0 :         ext4_journal_stop(handle);
    1989           0 : out_free:
    1990           0 :         brelse(iloc.bh);
    1991             :         return error;
    1992             : }

Generated by: LCOV version 1.14