1 /* 2 * fs/f2fs/inline.c 3 * Copyright (c) 2013, Intel Corporation 4 * Authors: Huajun Li <huajun.li@intel.com> 5 * Haicheng Li <haicheng.li@intel.com> 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11 #include <linux/fs.h> 12 #include <linux/f2fs_fs.h> 13 14 #include "f2fs.h" 15 16 bool f2fs_may_inline(struct inode *inode) 17 { 18 block_t nr_blocks; 19 loff_t i_size; 20 21 if (!test_opt(F2FS_I_SB(inode), INLINE_DATA)) 22 return false; 23 24 if (f2fs_is_atomic_file(inode)) 25 return false; 26 27 nr_blocks = F2FS_I(inode)->i_xattr_nid ? 3 : 2; 28 if (inode->i_blocks > nr_blocks) 29 return false; 30 31 i_size = i_size_read(inode); 32 if (i_size > MAX_INLINE_DATA) 33 return false; 34 35 return true; 36 } 37 38 int f2fs_read_inline_data(struct inode *inode, struct page *page) 39 { 40 struct page *ipage; 41 void *src_addr, *dst_addr; 42 43 if (page->index) { 44 zero_user_segment(page, 0, PAGE_CACHE_SIZE); 45 goto out; 46 } 47 48 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); 49 if (IS_ERR(ipage)) { 50 unlock_page(page); 51 return PTR_ERR(ipage); 52 } 53 54 zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE); 55 56 /* Copy the whole inline data block */ 57 src_addr = inline_data_addr(ipage); 58 dst_addr = kmap(page); 59 memcpy(dst_addr, src_addr, MAX_INLINE_DATA); 60 kunmap(page); 61 f2fs_put_page(ipage, 1); 62 63 out: 64 SetPageUptodate(page); 65 unlock_page(page); 66 67 return 0; 68 } 69 70 static int __f2fs_convert_inline_data(struct inode *inode, struct page *page) 71 { 72 int err = 0; 73 struct page *ipage; 74 struct dnode_of_data dn; 75 void *src_addr, *dst_addr; 76 block_t new_blk_addr; 77 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 78 struct f2fs_io_info fio = { 79 .type = DATA, 80 .rw = WRITE_SYNC | REQ_PRIO, 81 }; 82 83 f2fs_lock_op(sbi); 84 ipage = get_node_page(sbi, inode->i_ino); 85 if (IS_ERR(ipage)) { 86 err = PTR_ERR(ipage); 87 goto out; 88 } 89 90 /* someone else converted inline_data already */ 91 if (!f2fs_has_inline_data(inode)) 92 goto out; 93 94 /* 95 * i_addr[0] is not used for inline data, 96 * so reserving new block will not destroy inline data 97 */ 98 set_new_dnode(&dn, inode, ipage, NULL, 0); 99 err = f2fs_reserve_block(&dn, 0); 100 if (err) 101 goto out; 102 103 f2fs_wait_on_page_writeback(page, DATA); 104 zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE); 105 106 /* Copy the whole inline data block */ 107 src_addr = inline_data_addr(ipage); 108 dst_addr = kmap(page); 109 memcpy(dst_addr, src_addr, MAX_INLINE_DATA); 110 kunmap(page); 111 SetPageUptodate(page); 112 113 /* write data page to try to make data consistent */ 114 set_page_writeback(page); 115 write_data_page(page, &dn, &new_blk_addr, &fio); 116 update_extent_cache(new_blk_addr, &dn); 117 f2fs_wait_on_page_writeback(page, DATA); 118 119 /* clear inline data and flag after data writeback */ 120 zero_user_segment(ipage, INLINE_DATA_OFFSET, 121 INLINE_DATA_OFFSET + MAX_INLINE_DATA); 122 clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA); 123 stat_dec_inline_inode(inode); 124 125 sync_inode_page(&dn); 126 f2fs_put_dnode(&dn); 127 out: 128 f2fs_unlock_op(sbi); 129 return err; 130 } 131 132 int f2fs_convert_inline_data(struct inode *inode, pgoff_t to_size, 133 struct page *page) 134 { 135 struct page *new_page = page; 136 int err; 137 138 if (!f2fs_has_inline_data(inode)) 139 return 0; 140 else if (to_size <= MAX_INLINE_DATA) 141 return 0; 142 143 if (!page || page->index != 0) { 144 new_page = grab_cache_page(inode->i_mapping, 0); 145 if (!new_page) 146 return -ENOMEM; 147 } 148 149 err = __f2fs_convert_inline_data(inode, new_page); 150 if (!page || page->index != 0) 151 f2fs_put_page(new_page, 1); 152 return err; 153 } 154 155 int f2fs_write_inline_data(struct inode *inode, 156 struct page *page, unsigned size) 157 { 158 void *src_addr, *dst_addr; 159 struct page *ipage; 160 struct dnode_of_data dn; 161 int err; 162 163 set_new_dnode(&dn, inode, NULL, NULL, 0); 164 err = get_dnode_of_data(&dn, 0, LOOKUP_NODE); 165 if (err) 166 return err; 167 ipage = dn.inode_page; 168 169 f2fs_wait_on_page_writeback(ipage, NODE); 170 zero_user_segment(ipage, INLINE_DATA_OFFSET, 171 INLINE_DATA_OFFSET + MAX_INLINE_DATA); 172 src_addr = kmap(page); 173 dst_addr = inline_data_addr(ipage); 174 memcpy(dst_addr, src_addr, size); 175 kunmap(page); 176 177 /* Release the first data block if it is allocated */ 178 if (!f2fs_has_inline_data(inode)) { 179 truncate_data_blocks_range(&dn, 1); 180 set_inode_flag(F2FS_I(inode), FI_INLINE_DATA); 181 stat_inc_inline_inode(inode); 182 } 183 184 set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE); 185 sync_inode_page(&dn); 186 f2fs_put_dnode(&dn); 187 188 return 0; 189 } 190 191 void truncate_inline_data(struct inode *inode, u64 from) 192 { 193 struct page *ipage; 194 195 if (from >= MAX_INLINE_DATA) 196 return; 197 198 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); 199 if (IS_ERR(ipage)) 200 return; 201 202 f2fs_wait_on_page_writeback(ipage, NODE); 203 204 zero_user_segment(ipage, INLINE_DATA_OFFSET + from, 205 INLINE_DATA_OFFSET + MAX_INLINE_DATA); 206 set_page_dirty(ipage); 207 f2fs_put_page(ipage, 1); 208 } 209 210 bool recover_inline_data(struct inode *inode, struct page *npage) 211 { 212 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 213 struct f2fs_inode *ri = NULL; 214 void *src_addr, *dst_addr; 215 struct page *ipage; 216 217 /* 218 * The inline_data recovery policy is as follows. 219 * [prev.] [next] of inline_data flag 220 * o o -> recover inline_data 221 * o x -> remove inline_data, and then recover data blocks 222 * x o -> remove inline_data, and then recover inline_data 223 * x x -> recover data blocks 224 */ 225 if (IS_INODE(npage)) 226 ri = F2FS_INODE(npage); 227 228 if (f2fs_has_inline_data(inode) && 229 ri && (ri->i_inline & F2FS_INLINE_DATA)) { 230 process_inline: 231 ipage = get_node_page(sbi, inode->i_ino); 232 f2fs_bug_on(sbi, IS_ERR(ipage)); 233 234 f2fs_wait_on_page_writeback(ipage, NODE); 235 236 src_addr = inline_data_addr(npage); 237 dst_addr = inline_data_addr(ipage); 238 memcpy(dst_addr, src_addr, MAX_INLINE_DATA); 239 update_inode(inode, ipage); 240 f2fs_put_page(ipage, 1); 241 return true; 242 } 243 244 if (f2fs_has_inline_data(inode)) { 245 ipage = get_node_page(sbi, inode->i_ino); 246 f2fs_bug_on(sbi, IS_ERR(ipage)); 247 f2fs_wait_on_page_writeback(ipage, NODE); 248 zero_user_segment(ipage, INLINE_DATA_OFFSET, 249 INLINE_DATA_OFFSET + MAX_INLINE_DATA); 250 clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA); 251 update_inode(inode, ipage); 252 f2fs_put_page(ipage, 1); 253 } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) { 254 truncate_blocks(inode, 0, false); 255 set_inode_flag(F2FS_I(inode), FI_INLINE_DATA); 256 goto process_inline; 257 } 258 return false; 259 } 260