LCOV - code coverage report
Current view: top level - fs/f2fs - inline.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 314 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 20 0.0 %
Branches: 0 166 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * fs/f2fs/inline.c
       4                 :            :  * Copyright (c) 2013, Intel Corporation
       5                 :            :  * Authors: Huajun Li <huajun.li@intel.com>
       6                 :            :  *          Haicheng Li <haicheng.li@intel.com>
       7                 :            :  */
       8                 :            : 
       9                 :            : #include <linux/fs.h>
      10                 :            : #include <linux/f2fs_fs.h>
      11                 :            : 
      12                 :            : #include "f2fs.h"
      13                 :            : #include "node.h"
      14                 :            : 
      15                 :          0 : bool f2fs_may_inline_data(struct inode *inode)
      16                 :            : {
      17         [ #  # ]:          0 :         if (f2fs_is_atomic_file(inode))
      18                 :            :                 return false;
      19                 :            : 
      20         [ #  # ]:          0 :         if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))
      21                 :            :                 return false;
      22                 :            : 
      23         [ #  # ]:          0 :         if (i_size_read(inode) > MAX_INLINE_DATA(inode))
      24                 :            :                 return false;
      25                 :            : 
      26         [ #  # ]:          0 :         if (f2fs_post_read_required(inode))
      27                 :            :                 return false;
      28                 :            : 
      29                 :          0 :         return true;
      30                 :            : }
      31                 :            : 
      32                 :          0 : bool f2fs_may_inline_dentry(struct inode *inode)
      33                 :            : {
      34         [ #  # ]:          0 :         if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY))
      35                 :            :                 return false;
      36                 :            : 
      37         [ #  # ]:          0 :         if (!S_ISDIR(inode->i_mode))
      38                 :            :                 return false;
      39                 :            : 
      40                 :          0 :         return true;
      41                 :            : }
      42                 :            : 
      43                 :          0 : void f2fs_do_read_inline_data(struct page *page, struct page *ipage)
      44                 :            : {
      45                 :          0 :         struct inode *inode = page->mapping->host;
      46                 :            :         void *src_addr, *dst_addr;
      47                 :            : 
      48         [ #  # ]:          0 :         if (PageUptodate(page))
      49                 :          0 :                 return;
      50                 :            : 
      51         [ #  # ]:          0 :         f2fs_bug_on(F2FS_P_SB(page), page->index);
      52                 :            : 
      53                 :          0 :         zero_user_segment(page, MAX_INLINE_DATA(inode), PAGE_SIZE);
      54                 :            : 
      55                 :            :         /* Copy the whole inline data block */
      56                 :            :         src_addr = inline_data_addr(inode, ipage);
      57                 :          0 :         dst_addr = kmap_atomic(page);
      58                 :          0 :         memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
      59                 :          0 :         flush_dcache_page(page);
      60                 :            :         kunmap_atomic(dst_addr);
      61         [ #  # ]:          0 :         if (!PageUptodate(page))
      62                 :            :                 SetPageUptodate(page);
      63                 :            : }
      64                 :            : 
      65                 :          0 : void f2fs_truncate_inline_inode(struct inode *inode,
      66                 :            :                                         struct page *ipage, u64 from)
      67                 :            : {
      68                 :            :         void *addr;
      69                 :            : 
      70         [ #  # ]:          0 :         if (from >= MAX_INLINE_DATA(inode))
      71                 :          0 :                 return;
      72                 :            : 
      73                 :            :         addr = inline_data_addr(inode, ipage);
      74                 :            : 
      75                 :          0 :         f2fs_wait_on_page_writeback(ipage, NODE, true, true);
      76                 :          0 :         memset(addr + from, 0, MAX_INLINE_DATA(inode) - from);
      77                 :          0 :         set_page_dirty(ipage);
      78                 :            : 
      79         [ #  # ]:          0 :         if (from == 0)
      80                 :          0 :                 clear_inode_flag(inode, FI_DATA_EXIST);
      81                 :            : }
      82                 :            : 
      83                 :          0 : int f2fs_read_inline_data(struct inode *inode, struct page *page)
      84                 :            : {
      85                 :            :         struct page *ipage;
      86                 :            : 
      87                 :          0 :         ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino);
      88         [ #  # ]:          0 :         if (IS_ERR(ipage)) {
      89                 :          0 :                 unlock_page(page);
      90                 :          0 :                 return PTR_ERR(ipage);
      91                 :            :         }
      92                 :            : 
      93         [ #  # ]:          0 :         if (!f2fs_has_inline_data(inode)) {
      94                 :          0 :                 f2fs_put_page(ipage, 1);
      95                 :          0 :                 return -EAGAIN;
      96                 :            :         }
      97                 :            : 
      98         [ #  # ]:          0 :         if (page->index)
      99                 :            :                 zero_user_segment(page, 0, PAGE_SIZE);
     100                 :            :         else
     101                 :          0 :                 f2fs_do_read_inline_data(page, ipage);
     102                 :            : 
     103         [ #  # ]:          0 :         if (!PageUptodate(page))
     104                 :            :                 SetPageUptodate(page);
     105                 :          0 :         f2fs_put_page(ipage, 1);
     106                 :          0 :         unlock_page(page);
     107                 :          0 :         return 0;
     108                 :            : }
     109                 :            : 
     110                 :          0 : int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
     111                 :            : {
     112                 :          0 :         struct f2fs_io_info fio = {
     113                 :          0 :                 .sbi = F2FS_I_SB(dn->inode),
     114                 :          0 :                 .ino = dn->inode->i_ino,
     115                 :            :                 .type = DATA,
     116                 :            :                 .op = REQ_OP_WRITE,
     117                 :            :                 .op_flags = REQ_SYNC | REQ_PRIO,
     118                 :            :                 .page = page,
     119                 :            :                 .encrypted_page = NULL,
     120                 :            :                 .io_type = FS_DATA_IO,
     121                 :            :         };
     122                 :            :         struct node_info ni;
     123                 :            :         int dirty, err;
     124                 :            : 
     125         [ #  # ]:          0 :         if (!f2fs_exist_data(dn->inode))
     126                 :            :                 goto clear_out;
     127                 :            : 
     128                 :          0 :         err = f2fs_reserve_block(dn, 0);
     129         [ #  # ]:          0 :         if (err)
     130                 :            :                 return err;
     131                 :            : 
     132                 :          0 :         err = f2fs_get_node_info(fio.sbi, dn->nid, &ni);
     133         [ #  # ]:          0 :         if (err) {
     134                 :          0 :                 f2fs_truncate_data_blocks_range(dn, 1);
     135                 :          0 :                 f2fs_put_dnode(dn);
     136                 :          0 :                 return err;
     137                 :            :         }
     138                 :            : 
     139                 :          0 :         fio.version = ni.version;
     140                 :            : 
     141         [ #  # ]:          0 :         if (unlikely(dn->data_blkaddr != NEW_ADDR)) {
     142                 :          0 :                 f2fs_put_dnode(dn);
     143                 :          0 :                 set_sbi_flag(fio.sbi, SBI_NEED_FSCK);
     144                 :          0 :                 f2fs_warn(fio.sbi, "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.",
     145                 :            :                           __func__, dn->inode->i_ino, dn->data_blkaddr);
     146                 :          0 :                 return -EFSCORRUPTED;
     147                 :            :         }
     148                 :            : 
     149         [ #  # ]:          0 :         f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
     150                 :            : 
     151                 :          0 :         f2fs_do_read_inline_data(page, dn->inode_page);
     152                 :          0 :         set_page_dirty(page);
     153                 :            : 
     154                 :            :         /* clear dirty state */
     155                 :          0 :         dirty = clear_page_dirty_for_io(page);
     156                 :            : 
     157                 :            :         /* write data page to try to make data consistent */
     158                 :            :         set_page_writeback(page);
     159                 :            :         ClearPageError(page);
     160                 :          0 :         fio.old_blkaddr = dn->data_blkaddr;
     161                 :          0 :         set_inode_flag(dn->inode, FI_HOT_DATA);
     162                 :          0 :         f2fs_outplace_write_data(dn, &fio);
     163                 :          0 :         f2fs_wait_on_page_writeback(page, DATA, true, true);
     164         [ #  # ]:          0 :         if (dirty) {
     165                 :          0 :                 inode_dec_dirty_pages(dn->inode);
     166                 :          0 :                 f2fs_remove_dirty_inode(dn->inode);
     167                 :            :         }
     168                 :            : 
     169                 :            :         /* this converted inline_data should be recovered. */
     170                 :          0 :         set_inode_flag(dn->inode, FI_APPEND_WRITE);
     171                 :            : 
     172                 :            :         /* clear inline data and flag after data writeback */
     173                 :          0 :         f2fs_truncate_inline_inode(dn->inode, dn->inode_page, 0);
     174                 :          0 :         clear_inline_node(dn->inode_page);
     175                 :            : clear_out:
     176         [ #  # ]:          0 :         stat_dec_inline_inode(dn->inode);
     177                 :          0 :         clear_inode_flag(dn->inode, FI_INLINE_DATA);
     178                 :          0 :         f2fs_put_dnode(dn);
     179                 :          0 :         return 0;
     180                 :            : }
     181                 :            : 
     182                 :          0 : int f2fs_convert_inline_inode(struct inode *inode)
     183                 :            : {
     184                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
     185                 :            :         struct dnode_of_data dn;
     186                 :            :         struct page *ipage, *page;
     187                 :            :         int err = 0;
     188                 :            : 
     189         [ #  # ]:          0 :         if (!f2fs_has_inline_data(inode))
     190                 :            :                 return 0;
     191                 :            : 
     192                 :          0 :         page = f2fs_grab_cache_page(inode->i_mapping, 0, false);
     193         [ #  # ]:          0 :         if (!page)
     194                 :            :                 return -ENOMEM;
     195                 :            : 
     196                 :            :         f2fs_lock_op(sbi);
     197                 :            : 
     198                 :          0 :         ipage = f2fs_get_node_page(sbi, inode->i_ino);
     199         [ #  # ]:          0 :         if (IS_ERR(ipage)) {
     200                 :            :                 err = PTR_ERR(ipage);
     201                 :          0 :                 goto out;
     202                 :            :         }
     203                 :            : 
     204                 :            :         set_new_dnode(&dn, inode, ipage, ipage, 0);
     205                 :            : 
     206         [ #  # ]:          0 :         if (f2fs_has_inline_data(inode))
     207                 :          0 :                 err = f2fs_convert_inline_page(&dn, page);
     208                 :            : 
     209                 :          0 :         f2fs_put_dnode(&dn);
     210                 :            : out:
     211                 :            :         f2fs_unlock_op(sbi);
     212                 :            : 
     213                 :          0 :         f2fs_put_page(page, 1);
     214                 :            : 
     215                 :          0 :         f2fs_balance_fs(sbi, dn.node_changed);
     216                 :            : 
     217                 :          0 :         return err;
     218                 :            : }
     219                 :            : 
     220                 :          0 : int f2fs_write_inline_data(struct inode *inode, struct page *page)
     221                 :            : {
     222                 :            :         void *src_addr, *dst_addr;
     223                 :            :         struct dnode_of_data dn;
     224                 :            :         int err;
     225                 :            : 
     226                 :            :         set_new_dnode(&dn, inode, NULL, NULL, 0);
     227                 :          0 :         err = f2fs_get_dnode_of_data(&dn, 0, LOOKUP_NODE);
     228         [ #  # ]:          0 :         if (err)
     229                 :            :                 return err;
     230                 :            : 
     231         [ #  # ]:          0 :         if (!f2fs_has_inline_data(inode)) {
     232                 :          0 :                 f2fs_put_dnode(&dn);
     233                 :          0 :                 return -EAGAIN;
     234                 :            :         }
     235                 :            : 
     236         [ #  # ]:          0 :         f2fs_bug_on(F2FS_I_SB(inode), page->index);
     237                 :            : 
     238                 :          0 :         f2fs_wait_on_page_writeback(dn.inode_page, NODE, true, true);
     239                 :          0 :         src_addr = kmap_atomic(page);
     240                 :          0 :         dst_addr = inline_data_addr(inode, dn.inode_page);
     241                 :          0 :         memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
     242                 :            :         kunmap_atomic(src_addr);
     243                 :          0 :         set_page_dirty(dn.inode_page);
     244                 :            : 
     245                 :          0 :         f2fs_clear_page_cache_dirty_tag(page);
     246                 :            : 
     247                 :          0 :         set_inode_flag(inode, FI_APPEND_WRITE);
     248                 :          0 :         set_inode_flag(inode, FI_DATA_EXIST);
     249                 :            : 
     250                 :          0 :         clear_inline_node(dn.inode_page);
     251                 :          0 :         f2fs_put_dnode(&dn);
     252                 :          0 :         return 0;
     253                 :            : }
     254                 :            : 
     255                 :          0 : bool f2fs_recover_inline_data(struct inode *inode, struct page *npage)
     256                 :            : {
     257                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
     258                 :            :         struct f2fs_inode *ri = NULL;
     259                 :            :         void *src_addr, *dst_addr;
     260                 :            :         struct page *ipage;
     261                 :            : 
     262                 :            :         /*
     263                 :            :          * The inline_data recovery policy is as follows.
     264                 :            :          * [prev.] [next] of inline_data flag
     265                 :            :          *    o       o  -> recover inline_data
     266                 :            :          *    o       x  -> remove inline_data, and then recover data blocks
     267                 :            :          *    x       o  -> remove inline_data, and then recover inline_data
     268                 :            :          *    x       x  -> recover data blocks
     269                 :            :          */
     270         [ #  # ]:          0 :         if (IS_INODE(npage))
     271                 :          0 :                 ri = F2FS_INODE(npage);
     272                 :            : 
     273   [ #  #  #  # ]:          0 :         if (f2fs_has_inline_data(inode) &&
     274         [ #  # ]:          0 :                         ri && (ri->i_inline & F2FS_INLINE_DATA)) {
     275                 :            : process_inline:
     276                 :          0 :                 ipage = f2fs_get_node_page(sbi, inode->i_ino);
     277         [ #  # ]:          0 :                 f2fs_bug_on(sbi, IS_ERR(ipage));
     278                 :            : 
     279                 :          0 :                 f2fs_wait_on_page_writeback(ipage, NODE, true, true);
     280                 :            : 
     281                 :            :                 src_addr = inline_data_addr(inode, npage);
     282                 :            :                 dst_addr = inline_data_addr(inode, ipage);
     283                 :          0 :                 memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
     284                 :            : 
     285                 :          0 :                 set_inode_flag(inode, FI_INLINE_DATA);
     286                 :          0 :                 set_inode_flag(inode, FI_DATA_EXIST);
     287                 :            : 
     288                 :          0 :                 set_page_dirty(ipage);
     289                 :          0 :                 f2fs_put_page(ipage, 1);
     290                 :          0 :                 return true;
     291                 :            :         }
     292                 :            : 
     293         [ #  # ]:          0 :         if (f2fs_has_inline_data(inode)) {
     294                 :          0 :                 ipage = f2fs_get_node_page(sbi, inode->i_ino);
     295         [ #  # ]:          0 :                 f2fs_bug_on(sbi, IS_ERR(ipage));
     296                 :          0 :                 f2fs_truncate_inline_inode(inode, ipage, 0);
     297                 :          0 :                 clear_inode_flag(inode, FI_INLINE_DATA);
     298                 :          0 :                 f2fs_put_page(ipage, 1);
     299   [ #  #  #  # ]:          0 :         } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
     300         [ #  # ]:          0 :                 if (f2fs_truncate_blocks(inode, 0, false))
     301                 :            :                         return false;
     302                 :            :                 goto process_inline;
     303                 :            :         }
     304                 :            :         return false;
     305                 :            : }
     306                 :            : 
     307                 :          0 : struct f2fs_dir_entry *f2fs_find_in_inline_dir(struct inode *dir,
     308                 :            :                         struct fscrypt_name *fname, struct page **res_page)
     309                 :            : {
     310                 :          0 :         struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
     311                 :          0 :         struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
     312                 :            :         struct f2fs_dir_entry *de;
     313                 :            :         struct f2fs_dentry_ptr d;
     314                 :            :         struct page *ipage;
     315                 :            :         void *inline_dentry;
     316                 :            :         f2fs_hash_t namehash;
     317                 :            : 
     318                 :          0 :         ipage = f2fs_get_node_page(sbi, dir->i_ino);
     319         [ #  # ]:          0 :         if (IS_ERR(ipage)) {
     320                 :          0 :                 *res_page = ipage;
     321                 :          0 :                 return NULL;
     322                 :            :         }
     323                 :            : 
     324                 :          0 :         namehash = f2fs_dentry_hash(dir, &name, fname);
     325                 :            : 
     326                 :            :         inline_dentry = inline_data_addr(dir, ipage);
     327                 :            : 
     328                 :          0 :         make_dentry_ptr_inline(dir, &d, inline_dentry);
     329                 :          0 :         de = f2fs_find_target_dentry(fname, namehash, NULL, &d);
     330                 :          0 :         unlock_page(ipage);
     331         [ #  # ]:          0 :         if (de)
     332                 :          0 :                 *res_page = ipage;
     333                 :            :         else
     334                 :          0 :                 f2fs_put_page(ipage, 0);
     335                 :            : 
     336                 :          0 :         return de;
     337                 :            : }
     338                 :            : 
     339                 :          0 : int f2fs_make_empty_inline_dir(struct inode *inode, struct inode *parent,
     340                 :            :                                                         struct page *ipage)
     341                 :            : {
     342                 :            :         struct f2fs_dentry_ptr d;
     343                 :            :         void *inline_dentry;
     344                 :            : 
     345                 :            :         inline_dentry = inline_data_addr(inode, ipage);
     346                 :            : 
     347                 :          0 :         make_dentry_ptr_inline(inode, &d, inline_dentry);
     348                 :          0 :         f2fs_do_make_empty_dir(inode, parent, &d);
     349                 :            : 
     350                 :          0 :         set_page_dirty(ipage);
     351                 :            : 
     352                 :            :         /* update i_size to MAX_INLINE_DATA */
     353         [ #  # ]:          0 :         if (i_size_read(inode) < MAX_INLINE_DATA(inode))
     354                 :          0 :                 f2fs_i_size_write(inode, MAX_INLINE_DATA(inode));
     355                 :          0 :         return 0;
     356                 :            : }
     357                 :            : 
     358                 :            : /*
     359                 :            :  * NOTE: ipage is grabbed by caller, but if any error occurs, we should
     360                 :            :  * release ipage in this function.
     361                 :            :  */
     362                 :          0 : static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
     363                 :            :                                                         void *inline_dentry)
     364                 :            : {
     365                 :            :         struct page *page;
     366                 :            :         struct dnode_of_data dn;
     367                 :            :         struct f2fs_dentry_block *dentry_blk;
     368                 :            :         struct f2fs_dentry_ptr src, dst;
     369                 :            :         int err;
     370                 :            : 
     371                 :          0 :         page = f2fs_grab_cache_page(dir->i_mapping, 0, false);
     372         [ #  # ]:          0 :         if (!page) {
     373                 :          0 :                 f2fs_put_page(ipage, 1);
     374                 :          0 :                 return -ENOMEM;
     375                 :            :         }
     376                 :            : 
     377                 :            :         set_new_dnode(&dn, dir, ipage, NULL, 0);
     378                 :          0 :         err = f2fs_reserve_block(&dn, 0);
     379         [ #  # ]:          0 :         if (err)
     380                 :            :                 goto out;
     381                 :            : 
     382         [ #  # ]:          0 :         if (unlikely(dn.data_blkaddr != NEW_ADDR)) {
     383                 :          0 :                 f2fs_put_dnode(&dn);
     384                 :            :                 set_sbi_flag(F2FS_P_SB(page), SBI_NEED_FSCK);
     385                 :          0 :                 f2fs_warn(F2FS_P_SB(page), "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.",
     386                 :            :                           __func__, dir->i_ino, dn.data_blkaddr);
     387                 :            :                 err = -EFSCORRUPTED;
     388                 :          0 :                 goto out;
     389                 :            :         }
     390                 :            : 
     391                 :          0 :         f2fs_wait_on_page_writeback(page, DATA, true, true);
     392                 :            : 
     393                 :            :         dentry_blk = page_address(page);
     394                 :            : 
     395                 :          0 :         make_dentry_ptr_inline(dir, &src, inline_dentry);
     396                 :            :         make_dentry_ptr_block(dir, &dst, dentry_blk);
     397                 :            : 
     398                 :            :         /* copy data from inline dentry block to new dentry block */
     399                 :          0 :         memcpy(dst.bitmap, src.bitmap, src.nr_bitmap);
     400                 :          0 :         memset(dst.bitmap + src.nr_bitmap, 0, dst.nr_bitmap - src.nr_bitmap);
     401                 :            :         /*
     402                 :            :          * we do not need to zero out remainder part of dentry and filename
     403                 :            :          * field, since we have used bitmap for marking the usage status of
     404                 :            :          * them, besides, we can also ignore copying/zeroing reserved space
     405                 :            :          * of dentry block, because them haven't been used so far.
     406                 :            :          */
     407                 :          0 :         memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max);
     408                 :          0 :         memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN);
     409                 :            : 
     410         [ #  # ]:          0 :         if (!PageUptodate(page))
     411                 :            :                 SetPageUptodate(page);
     412                 :          0 :         set_page_dirty(page);
     413                 :            : 
     414                 :            :         /* clear inline dir and flag after data writeback */
     415                 :          0 :         f2fs_truncate_inline_inode(dir, ipage, 0);
     416                 :            : 
     417         [ #  # ]:          0 :         stat_dec_inline_dir(dir);
     418                 :          0 :         clear_inode_flag(dir, FI_INLINE_DENTRY);
     419                 :            : 
     420                 :            :         /*
     421                 :            :          * should retrieve reserved space which was used to keep
     422                 :            :          * inline_dentry's structure for backward compatibility.
     423                 :            :          */
     424   [ #  #  #  # ]:          0 :         if (!f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(dir)) &&
     425                 :            :                         !f2fs_has_inline_xattr(dir))
     426                 :          0 :                 F2FS_I(dir)->i_inline_xattr_size = 0;
     427                 :            : 
     428                 :            :         f2fs_i_depth_write(dir, 1);
     429         [ #  # ]:          0 :         if (i_size_read(dir) < PAGE_SIZE)
     430                 :          0 :                 f2fs_i_size_write(dir, PAGE_SIZE);
     431                 :            : out:
     432                 :          0 :         f2fs_put_page(page, 1);
     433                 :          0 :         return err;
     434                 :            : }
     435                 :            : 
     436                 :          0 : static int f2fs_add_inline_entries(struct inode *dir, void *inline_dentry)
     437                 :            : {
     438                 :            :         struct f2fs_dentry_ptr d;
     439                 :            :         unsigned long bit_pos = 0;
     440                 :            :         int err = 0;
     441                 :            : 
     442                 :          0 :         make_dentry_ptr_inline(dir, &d, inline_dentry);
     443                 :            : 
     444         [ #  # ]:          0 :         while (bit_pos < d.max) {
     445                 :            :                 struct f2fs_dir_entry *de;
     446                 :            :                 struct qstr new_name;
     447                 :            :                 nid_t ino;
     448                 :            :                 umode_t fake_mode;
     449                 :            : 
     450         [ #  # ]:          0 :                 if (!test_bit_le(bit_pos, d.bitmap)) {
     451                 :          0 :                         bit_pos++;
     452                 :          0 :                         continue;
     453                 :            :                 }
     454                 :            : 
     455                 :          0 :                 de = &d.dentry[bit_pos];
     456                 :            : 
     457         [ #  # ]:          0 :                 if (unlikely(!de->name_len)) {
     458                 :          0 :                         bit_pos++;
     459                 :          0 :                         continue;
     460                 :            :                 }
     461                 :            : 
     462                 :          0 :                 new_name.name = d.filename[bit_pos];
     463                 :          0 :                 new_name.len = le16_to_cpu(de->name_len);
     464                 :            : 
     465                 :          0 :                 ino = le32_to_cpu(de->ino);
     466                 :          0 :                 fake_mode = f2fs_get_de_type(de) << S_SHIFT;
     467                 :            : 
     468                 :          0 :                 err = f2fs_add_regular_entry(dir, &new_name, NULL, NULL,
     469                 :            :                                                         ino, fake_mode);
     470         [ #  # ]:          0 :                 if (err)
     471                 :            :                         goto punch_dentry_pages;
     472                 :            : 
     473                 :          0 :                 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
     474                 :            :         }
     475                 :            :         return 0;
     476                 :            : punch_dentry_pages:
     477                 :          0 :         truncate_inode_pages(&dir->i_data, 0);
     478                 :          0 :         f2fs_truncate_blocks(dir, 0, false);
     479                 :          0 :         f2fs_remove_dirty_inode(dir);
     480                 :          0 :         return err;
     481                 :            : }
     482                 :            : 
     483                 :          0 : static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
     484                 :            :                                                         void *inline_dentry)
     485                 :            : {
     486                 :            :         void *backup_dentry;
     487                 :            :         int err;
     488                 :            : 
     489                 :          0 :         backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir),
     490                 :          0 :                                 MAX_INLINE_DATA(dir), GFP_F2FS_ZERO);
     491         [ #  # ]:          0 :         if (!backup_dentry) {
     492                 :          0 :                 f2fs_put_page(ipage, 1);
     493                 :          0 :                 return -ENOMEM;
     494                 :            :         }
     495                 :            : 
     496                 :          0 :         memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA(dir));
     497                 :          0 :         f2fs_truncate_inline_inode(dir, ipage, 0);
     498                 :            : 
     499                 :          0 :         unlock_page(ipage);
     500                 :            : 
     501                 :          0 :         err = f2fs_add_inline_entries(dir, backup_dentry);
     502         [ #  # ]:          0 :         if (err)
     503                 :            :                 goto recover;
     504                 :            : 
     505                 :          0 :         lock_page(ipage);
     506                 :            : 
     507         [ #  # ]:          0 :         stat_dec_inline_dir(dir);
     508                 :          0 :         clear_inode_flag(dir, FI_INLINE_DENTRY);
     509                 :            : 
     510                 :            :         /*
     511                 :            :          * should retrieve reserved space which was used to keep
     512                 :            :          * inline_dentry's structure for backward compatibility.
     513                 :            :          */
     514   [ #  #  #  # ]:          0 :         if (!f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(dir)) &&
     515                 :            :                         !f2fs_has_inline_xattr(dir))
     516                 :          0 :                 F2FS_I(dir)->i_inline_xattr_size = 0;
     517                 :            : 
     518                 :          0 :         kvfree(backup_dentry);
     519                 :          0 :         return 0;
     520                 :            : recover:
     521                 :          0 :         lock_page(ipage);
     522                 :          0 :         f2fs_wait_on_page_writeback(ipage, NODE, true, true);
     523                 :          0 :         memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA(dir));
     524                 :            :         f2fs_i_depth_write(dir, 0);
     525                 :          0 :         f2fs_i_size_write(dir, MAX_INLINE_DATA(dir));
     526                 :          0 :         set_page_dirty(ipage);
     527                 :          0 :         f2fs_put_page(ipage, 1);
     528                 :            : 
     529                 :          0 :         kvfree(backup_dentry);
     530                 :          0 :         return err;
     531                 :            : }
     532                 :            : 
     533                 :          0 : static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
     534                 :            :                                                         void *inline_dentry)
     535                 :            : {
     536         [ #  # ]:          0 :         if (!F2FS_I(dir)->i_dir_level)
     537                 :          0 :                 return f2fs_move_inline_dirents(dir, ipage, inline_dentry);
     538                 :            :         else
     539                 :          0 :                 return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry);
     540                 :            : }
     541                 :            : 
     542                 :          0 : int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
     543                 :            :                                 const struct qstr *orig_name,
     544                 :            :                                 struct inode *inode, nid_t ino, umode_t mode)
     545                 :            : {
     546                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     547                 :            :         struct page *ipage;
     548                 :            :         unsigned int bit_pos;
     549                 :            :         f2fs_hash_t name_hash;
     550                 :            :         void *inline_dentry = NULL;
     551                 :            :         struct f2fs_dentry_ptr d;
     552                 :          0 :         int slots = GET_DENTRY_SLOTS(new_name->len);
     553                 :            :         struct page *page = NULL;
     554                 :            :         int err = 0;
     555                 :            : 
     556                 :          0 :         ipage = f2fs_get_node_page(sbi, dir->i_ino);
     557         [ #  # ]:          0 :         if (IS_ERR(ipage))
     558                 :          0 :                 return PTR_ERR(ipage);
     559                 :            : 
     560                 :            :         inline_dentry = inline_data_addr(dir, ipage);
     561                 :          0 :         make_dentry_ptr_inline(dir, &d, inline_dentry);
     562                 :            : 
     563                 :          0 :         bit_pos = f2fs_room_for_filename(d.bitmap, slots, d.max);
     564         [ #  # ]:          0 :         if (bit_pos >= d.max) {
     565                 :          0 :                 err = f2fs_convert_inline_dir(dir, ipage, inline_dentry);
     566         [ #  # ]:          0 :                 if (err)
     567                 :            :                         return err;
     568                 :            :                 err = -EAGAIN;
     569                 :            :                 goto out;
     570                 :            :         }
     571                 :            : 
     572         [ #  # ]:          0 :         if (inode) {
     573                 :          0 :                 down_write(&F2FS_I(inode)->i_sem);
     574                 :          0 :                 page = f2fs_init_inode_metadata(inode, dir, new_name,
     575                 :            :                                                 orig_name, ipage);
     576         [ #  # ]:          0 :                 if (IS_ERR(page)) {
     577                 :            :                         err = PTR_ERR(page);
     578                 :          0 :                         goto fail;
     579                 :            :                 }
     580                 :            :         }
     581                 :            : 
     582                 :          0 :         f2fs_wait_on_page_writeback(ipage, NODE, true, true);
     583                 :            : 
     584                 :          0 :         name_hash = f2fs_dentry_hash(dir, new_name, NULL);
     585                 :          0 :         f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos);
     586                 :            : 
     587                 :          0 :         set_page_dirty(ipage);
     588                 :            : 
     589                 :            :         /* we don't need to mark_inode_dirty now */
     590         [ #  # ]:          0 :         if (inode) {
     591                 :          0 :                 f2fs_i_pino_write(inode, dir->i_ino);
     592                 :            : 
     593                 :            :                 /* synchronize inode page's data from inode cache */
     594         [ #  # ]:          0 :                 if (is_inode_flag_set(inode, FI_NEW_INODE))
     595                 :          0 :                         f2fs_update_inode(inode, page);
     596                 :            : 
     597                 :          0 :                 f2fs_put_page(page, 1);
     598                 :            :         }
     599                 :            : 
     600                 :          0 :         f2fs_update_parent_metadata(dir, inode, 0);
     601                 :            : fail:
     602         [ #  # ]:          0 :         if (inode)
     603                 :          0 :                 up_write(&F2FS_I(inode)->i_sem);
     604                 :            : out:
     605                 :          0 :         f2fs_put_page(ipage, 1);
     606                 :          0 :         return err;
     607                 :            : }
     608                 :            : 
     609                 :          0 : void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
     610                 :            :                                         struct inode *dir, struct inode *inode)
     611                 :            : {
     612                 :            :         struct f2fs_dentry_ptr d;
     613                 :            :         void *inline_dentry;
     614                 :          0 :         int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
     615                 :            :         unsigned int bit_pos;
     616                 :            :         int i;
     617                 :            : 
     618                 :          0 :         lock_page(page);
     619                 :          0 :         f2fs_wait_on_page_writeback(page, NODE, true, true);
     620                 :            : 
     621                 :            :         inline_dentry = inline_data_addr(dir, page);
     622                 :          0 :         make_dentry_ptr_inline(dir, &d, inline_dentry);
     623                 :            : 
     624                 :          0 :         bit_pos = dentry - d.dentry;
     625         [ #  # ]:          0 :         for (i = 0; i < slots; i++)
     626                 :          0 :                 __clear_bit_le(bit_pos + i, d.bitmap);
     627                 :            : 
     628                 :          0 :         set_page_dirty(page);
     629                 :          0 :         f2fs_put_page(page, 1);
     630                 :            : 
     631                 :          0 :         dir->i_ctime = dir->i_mtime = current_time(dir);
     632                 :          0 :         f2fs_mark_inode_dirty_sync(dir, false);
     633                 :            : 
     634         [ #  # ]:          0 :         if (inode)
     635                 :          0 :                 f2fs_drop_nlink(dir, inode);
     636                 :          0 : }
     637                 :            : 
     638                 :          0 : bool f2fs_empty_inline_dir(struct inode *dir)
     639                 :            : {
     640                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     641                 :            :         struct page *ipage;
     642                 :            :         unsigned int bit_pos = 2;
     643                 :            :         void *inline_dentry;
     644                 :            :         struct f2fs_dentry_ptr d;
     645                 :            : 
     646                 :          0 :         ipage = f2fs_get_node_page(sbi, dir->i_ino);
     647         [ #  # ]:          0 :         if (IS_ERR(ipage))
     648                 :            :                 return false;
     649                 :            : 
     650                 :            :         inline_dentry = inline_data_addr(dir, ipage);
     651                 :          0 :         make_dentry_ptr_inline(dir, &d, inline_dentry);
     652                 :            : 
     653                 :          0 :         bit_pos = find_next_bit_le(d.bitmap, d.max, bit_pos);
     654                 :            : 
     655                 :          0 :         f2fs_put_page(ipage, 1);
     656                 :            : 
     657         [ #  # ]:          0 :         if (bit_pos < d.max)
     658                 :            :                 return false;
     659                 :            : 
     660                 :          0 :         return true;
     661                 :            : }
     662                 :            : 
     663                 :          0 : int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
     664                 :            :                                 struct fscrypt_str *fstr)
     665                 :            : {
     666                 :            :         struct inode *inode = file_inode(file);
     667                 :            :         struct page *ipage = NULL;
     668                 :            :         struct f2fs_dentry_ptr d;
     669                 :            :         void *inline_dentry = NULL;
     670                 :            :         int err;
     671                 :            : 
     672                 :          0 :         make_dentry_ptr_inline(inode, &d, inline_dentry);
     673                 :            : 
     674         [ #  # ]:          0 :         if (ctx->pos == d.max)
     675                 :            :                 return 0;
     676                 :            : 
     677                 :          0 :         ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino);
     678         [ #  # ]:          0 :         if (IS_ERR(ipage))
     679                 :          0 :                 return PTR_ERR(ipage);
     680                 :            : 
     681                 :            :         /*
     682                 :            :          * f2fs_readdir was protected by inode.i_rwsem, it is safe to access
     683                 :            :          * ipage without page's lock held.
     684                 :            :          */
     685                 :          0 :         unlock_page(ipage);
     686                 :            : 
     687                 :            :         inline_dentry = inline_data_addr(inode, ipage);
     688                 :            : 
     689                 :          0 :         make_dentry_ptr_inline(inode, &d, inline_dentry);
     690                 :            : 
     691                 :          0 :         err = f2fs_fill_dentries(ctx, &d, 0, fstr);
     692         [ #  # ]:          0 :         if (!err)
     693                 :          0 :                 ctx->pos = d.max;
     694                 :            : 
     695                 :          0 :         f2fs_put_page(ipage, 0);
     696                 :          0 :         return err < 0 ? err : 0;
     697                 :            : }
     698                 :            : 
     699                 :          0 : int f2fs_inline_data_fiemap(struct inode *inode,
     700                 :            :                 struct fiemap_extent_info *fieinfo, __u64 start, __u64 len)
     701                 :            : {
     702                 :            :         __u64 byteaddr, ilen;
     703                 :            :         __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED |
     704                 :            :                 FIEMAP_EXTENT_LAST;
     705                 :            :         struct node_info ni;
     706                 :            :         struct page *ipage;
     707                 :            :         int err = 0;
     708                 :            : 
     709                 :          0 :         ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino);
     710         [ #  # ]:          0 :         if (IS_ERR(ipage))
     711                 :          0 :                 return PTR_ERR(ipage);
     712                 :            : 
     713   [ #  #  #  # ]:          0 :         if ((S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
     714                 :            :                                 !f2fs_has_inline_data(inode)) {
     715                 :            :                 err = -EAGAIN;
     716                 :            :                 goto out;
     717                 :            :         }
     718                 :            : 
     719   [ #  #  #  # ]:          0 :         if (S_ISDIR(inode->i_mode) && !f2fs_has_inline_dentry(inode)) {
     720                 :            :                 err = -EAGAIN;
     721                 :            :                 goto out;
     722                 :            :         }
     723                 :            : 
     724                 :          0 :         ilen = min_t(size_t, MAX_INLINE_DATA(inode), i_size_read(inode));
     725         [ #  # ]:          0 :         if (start >= ilen)
     726                 :            :                 goto out;
     727         [ #  # ]:          0 :         if (start + len < ilen)
     728                 :            :                 ilen = start + len;
     729                 :          0 :         ilen -= start;
     730                 :            : 
     731                 :          0 :         err = f2fs_get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni);
     732         [ #  # ]:          0 :         if (err)
     733                 :            :                 goto out;
     734                 :            : 
     735                 :          0 :         byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;
     736                 :          0 :         byteaddr += (char *)inline_data_addr(inode, ipage) -
     737                 :            :                                         (char *)F2FS_INODE(ipage);
     738                 :          0 :         err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
     739                 :            : out:
     740                 :          0 :         f2fs_put_page(ipage, 1);
     741                 :          0 :         return err;
     742                 :            : }

Generated by: LCOV version 1.14