~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/f2fs/inline.c

Version: ~ [ linux-5.14-rc1 ] ~ [ linux-5.13.1 ] ~ [ linux-5.12.16 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.49 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.131 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.197 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.239 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.275 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.275 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include "node.h"
 16 
 17 bool f2fs_may_inline_data(struct inode *inode)
 18 {
 19         if (f2fs_is_atomic_file(inode))
 20                 return false;
 21 
 22         if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))
 23                 return false;
 24 
 25         if (i_size_read(inode) > MAX_INLINE_DATA)
 26                 return false;
 27 
 28         if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
 29                 return false;
 30 
 31         return true;
 32 }
 33 
 34 bool f2fs_may_inline_dentry(struct inode *inode)
 35 {
 36         if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY))
 37                 return false;
 38 
 39         if (!S_ISDIR(inode->i_mode))
 40                 return false;
 41 
 42         return true;
 43 }
 44 
 45 void read_inline_data(struct page *page, struct page *ipage)
 46 {
 47         void *src_addr, *dst_addr;
 48 
 49         if (PageUptodate(page))
 50                 return;
 51 
 52         f2fs_bug_on(F2FS_P_SB(page), page->index);
 53 
 54         zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE);
 55 
 56         /* Copy the whole inline data block */
 57         src_addr = inline_data_addr(ipage);
 58         dst_addr = kmap_atomic(page);
 59         memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
 60         flush_dcache_page(page);
 61         kunmap_atomic(dst_addr);
 62         SetPageUptodate(page);
 63 }
 64 
 65 bool truncate_inline_inode(struct page *ipage, u64 from)
 66 {
 67         void *addr;
 68 
 69         if (from >= MAX_INLINE_DATA)
 70                 return false;
 71 
 72         addr = inline_data_addr(ipage);
 73 
 74         f2fs_wait_on_page_writeback(ipage, NODE, true);
 75         memset(addr + from, 0, MAX_INLINE_DATA - from);
 76 
 77         return true;
 78 }
 79 
 80 int f2fs_read_inline_data(struct inode *inode, struct page *page)
 81 {
 82         struct page *ipage;
 83 
 84         ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
 85         if (IS_ERR(ipage)) {
 86                 unlock_page(page);
 87                 return PTR_ERR(ipage);
 88         }
 89 
 90         if (!f2fs_has_inline_data(inode)) {
 91                 f2fs_put_page(ipage, 1);
 92                 return -EAGAIN;
 93         }
 94 
 95         if (page->index)
 96                 zero_user_segment(page, 0, PAGE_SIZE);
 97         else
 98                 read_inline_data(page, ipage);
 99 
100         SetPageUptodate(page);
101         f2fs_put_page(ipage, 1);
102         unlock_page(page);
103         return 0;
104 }
105 
106 int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
107 {
108         struct f2fs_io_info fio = {
109                 .sbi = F2FS_I_SB(dn->inode),
110                 .type = DATA,
111                 .rw = WRITE_SYNC | REQ_PRIO,
112                 .page = page,
113                 .encrypted_page = NULL,
114         };
115         int dirty, err;
116 
117         if (!f2fs_exist_data(dn->inode))
118                 goto clear_out;
119 
120         err = f2fs_reserve_block(dn, 0);
121         if (err)
122                 return err;
123 
124         f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
125 
126         read_inline_data(page, dn->inode_page);
127         set_page_dirty(page);
128 
129         /* clear dirty state */
130         dirty = clear_page_dirty_for_io(page);
131 
132         /* write data page to try to make data consistent */
133         set_page_writeback(page);
134         fio.old_blkaddr = dn->data_blkaddr;
135         write_data_page(dn, &fio);
136         f2fs_wait_on_page_writeback(page, DATA, true);
137         if (dirty)
138                 inode_dec_dirty_pages(dn->inode);
139 
140         /* this converted inline_data should be recovered. */
141         set_inode_flag(F2FS_I(dn->inode), FI_APPEND_WRITE);
142 
143         /* clear inline data and flag after data writeback */
144         truncate_inline_inode(dn->inode_page, 0);
145         clear_inline_node(dn->inode_page);
146 clear_out:
147         stat_dec_inline_inode(dn->inode);
148         f2fs_clear_inline_inode(dn->inode);
149         sync_inode_page(dn);
150         f2fs_put_dnode(dn);
151         return 0;
152 }
153 
154 int f2fs_convert_inline_inode(struct inode *inode)
155 {
156         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
157         struct dnode_of_data dn;
158         struct page *ipage, *page;
159         int err = 0;
160 
161         if (!f2fs_has_inline_data(inode))
162                 return 0;
163 
164         page = grab_cache_page(inode->i_mapping, 0);
165         if (!page)
166                 return -ENOMEM;
167 
168         f2fs_lock_op(sbi);
169 
170         ipage = get_node_page(sbi, inode->i_ino);
171         if (IS_ERR(ipage)) {
172                 err = PTR_ERR(ipage);
173                 goto out;
174         }
175 
176         set_new_dnode(&dn, inode, ipage, ipage, 0);
177 
178         if (f2fs_has_inline_data(inode))
179                 err = f2fs_convert_inline_page(&dn, page);
180 
181         f2fs_put_dnode(&dn);
182 out:
183         f2fs_unlock_op(sbi);
184 
185         f2fs_put_page(page, 1);
186 
187         f2fs_balance_fs(sbi, dn.node_changed);
188 
189         return err;
190 }
191 
192 int f2fs_write_inline_data(struct inode *inode, struct page *page)
193 {
194         void *src_addr, *dst_addr;
195         struct dnode_of_data dn;
196         int err;
197 
198         set_new_dnode(&dn, inode, NULL, NULL, 0);
199         err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
200         if (err)
201                 return err;
202 
203         if (!f2fs_has_inline_data(inode)) {
204                 f2fs_put_dnode(&dn);
205                 return -EAGAIN;
206         }
207 
208         f2fs_bug_on(F2FS_I_SB(inode), page->index);
209 
210         f2fs_wait_on_page_writeback(dn.inode_page, NODE, true);
211         src_addr = kmap_atomic(page);
212         dst_addr = inline_data_addr(dn.inode_page);
213         memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
214         kunmap_atomic(src_addr);
215 
216         set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
217         set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
218 
219         sync_inode_page(&dn);
220         clear_inline_node(dn.inode_page);
221         f2fs_put_dnode(&dn);
222         return 0;
223 }
224 
225 bool recover_inline_data(struct inode *inode, struct page *npage)
226 {
227         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
228         struct f2fs_inode *ri = NULL;
229         void *src_addr, *dst_addr;
230         struct page *ipage;
231 
232         /*
233          * The inline_data recovery policy is as follows.
234          * [prev.] [next] of inline_data flag
235          *    o       o  -> recover inline_data
236          *    o       x  -> remove inline_data, and then recover data blocks
237          *    x       o  -> remove inline_data, and then recover inline_data
238          *    x       x  -> recover data blocks
239          */
240         if (IS_INODE(npage))
241                 ri = F2FS_INODE(npage);
242 
243         if (f2fs_has_inline_data(inode) &&
244                         ri && (ri->i_inline & F2FS_INLINE_DATA)) {
245 process_inline:
246                 ipage = get_node_page(sbi, inode->i_ino);
247                 f2fs_bug_on(sbi, IS_ERR(ipage));
248 
249                 f2fs_wait_on_page_writeback(ipage, NODE, true);
250 
251                 src_addr = inline_data_addr(npage);
252                 dst_addr = inline_data_addr(ipage);
253                 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
254 
255                 set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
256                 set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
257 
258                 update_inode(inode, ipage);
259                 f2fs_put_page(ipage, 1);
260                 return true;
261         }
262 
263         if (f2fs_has_inline_data(inode)) {
264                 ipage = get_node_page(sbi, inode->i_ino);
265                 f2fs_bug_on(sbi, IS_ERR(ipage));
266                 if (!truncate_inline_inode(ipage, 0))
267                         return false;
268                 f2fs_clear_inline_inode(inode);
269                 update_inode(inode, ipage);
270                 f2fs_put_page(ipage, 1);
271         } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
272                 if (truncate_blocks(inode, 0, false))
273                         return false;
274                 goto process_inline;
275         }
276         return false;
277 }
278 
279 struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
280                         struct fscrypt_name *fname, struct page **res_page)
281 {
282         struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
283         struct f2fs_inline_dentry *inline_dentry;
284         struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
285         struct f2fs_dir_entry *de;
286         struct f2fs_dentry_ptr d;
287         struct page *ipage;
288         f2fs_hash_t namehash;
289 
290         ipage = get_node_page(sbi, dir->i_ino);
291         if (IS_ERR(ipage))
292                 return NULL;
293 
294         namehash = f2fs_dentry_hash(&name);
295 
296         inline_dentry = inline_data_addr(ipage);
297 
298         make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2);
299         de = find_target_dentry(fname, namehash, NULL, &d);
300         unlock_page(ipage);
301         if (de)
302                 *res_page = ipage;
303         else
304                 f2fs_put_page(ipage, 0);
305 
306         /*
307          * For the most part, it should be a bug when name_len is zero.
308          * We stop here for figuring out where the bugs has occurred.
309          */
310         f2fs_bug_on(sbi, d.max < 0);
311         return de;
312 }
313 
314 struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *dir,
315                                                         struct page **p)
316 {
317         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
318         struct page *ipage;
319         struct f2fs_dir_entry *de;
320         struct f2fs_inline_dentry *dentry_blk;
321 
322         ipage = get_node_page(sbi, dir->i_ino);
323         if (IS_ERR(ipage))
324                 return NULL;
325 
326         dentry_blk = inline_data_addr(ipage);
327         de = &dentry_blk->dentry[1];
328         *p = ipage;
329         unlock_page(ipage);
330         return de;
331 }
332 
333 int make_empty_inline_dir(struct inode *inode, struct inode *parent,
334                                                         struct page *ipage)
335 {
336         struct f2fs_inline_dentry *dentry_blk;
337         struct f2fs_dentry_ptr d;
338 
339         dentry_blk = inline_data_addr(ipage);
340 
341         make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
342         do_make_empty_dir(inode, parent, &d);
343 
344         set_page_dirty(ipage);
345 
346         /* update i_size to MAX_INLINE_DATA */
347         if (i_size_read(inode) < MAX_INLINE_DATA) {
348                 i_size_write(inode, MAX_INLINE_DATA);
349                 set_inode_flag(F2FS_I(inode), FI_UPDATE_DIR);
350         }
351         return 0;
352 }
353 
354 /*
355  * NOTE: ipage is grabbed by caller, but if any error occurs, we should
356  * release ipage in this function.
357  */
358 static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
359                                 struct f2fs_inline_dentry *inline_dentry)
360 {
361         struct page *page;
362         struct dnode_of_data dn;
363         struct f2fs_dentry_block *dentry_blk;
364         int err;
365 
366         page = grab_cache_page(dir->i_mapping, 0);
367         if (!page) {
368                 f2fs_put_page(ipage, 1);
369                 return -ENOMEM;
370         }
371 
372         set_new_dnode(&dn, dir, ipage, NULL, 0);
373         err = f2fs_reserve_block(&dn, 0);
374         if (err)
375                 goto out;
376 
377         f2fs_wait_on_page_writeback(page, DATA, true);
378         zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE);
379 
380         dentry_blk = kmap_atomic(page);
381 
382         /* copy data from inline dentry block to new dentry block */
383         memcpy(dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap,
384                                         INLINE_DENTRY_BITMAP_SIZE);
385         memset(dentry_blk->dentry_bitmap + INLINE_DENTRY_BITMAP_SIZE, 0,
386                         SIZE_OF_DENTRY_BITMAP - INLINE_DENTRY_BITMAP_SIZE);
387         /*
388          * we do not need to zero out remainder part of dentry and filename
389          * field, since we have used bitmap for marking the usage status of
390          * them, besides, we can also ignore copying/zeroing reserved space
391          * of dentry block, because them haven't been used so far.
392          */
393         memcpy(dentry_blk->dentry, inline_dentry->dentry,
394                         sizeof(struct f2fs_dir_entry) * NR_INLINE_DENTRY);
395         memcpy(dentry_blk->filename, inline_dentry->filename,
396                                         NR_INLINE_DENTRY * F2FS_SLOT_LEN);
397 
398         kunmap_atomic(dentry_blk);
399         SetPageUptodate(page);
400         set_page_dirty(page);
401 
402         /* clear inline dir and flag after data writeback */
403         truncate_inline_inode(ipage, 0);
404 
405         stat_dec_inline_dir(dir);
406         clear_inode_flag(F2FS_I(dir), FI_INLINE_DENTRY);
407 
408         if (i_size_read(dir) < PAGE_SIZE) {
409                 i_size_write(dir, PAGE_SIZE);
410                 set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
411         }
412 
413         sync_inode_page(&dn);
414 out:
415         f2fs_put_page(page, 1);
416         return err;
417 }
418 
419 int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,
420                         struct inode *inode, nid_t ino, umode_t mode)
421 {
422         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
423         struct page *ipage;
424         unsigned int bit_pos;
425         f2fs_hash_t name_hash;
426         size_t namelen = name->len;
427         struct f2fs_inline_dentry *dentry_blk = NULL;
428         struct f2fs_dentry_ptr d;
429         int slots = GET_DENTRY_SLOTS(namelen);
430         struct page *page = NULL;
431         int err = 0;
432 
433         ipage = get_node_page(sbi, dir->i_ino);
434         if (IS_ERR(ipage))
435                 return PTR_ERR(ipage);
436 
437         dentry_blk = inline_data_addr(ipage);
438         bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,
439                                                 slots, NR_INLINE_DENTRY);
440         if (bit_pos >= NR_INLINE_DENTRY) {
441                 err = f2fs_convert_inline_dir(dir, ipage, dentry_blk);
442                 if (err)
443                         return err;
444                 err = -EAGAIN;
445                 goto out;
446         }
447 
448         if (inode) {
449                 down_write(&F2FS_I(inode)->i_sem);
450                 page = init_inode_metadata(inode, dir, name, ipage);
451                 if (IS_ERR(page)) {
452                         err = PTR_ERR(page);
453                         goto fail;
454                 }
455         }
456 
457         f2fs_wait_on_page_writeback(ipage, NODE, true);
458 
459         name_hash = f2fs_dentry_hash(name);
460         make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
461         f2fs_update_dentry(ino, mode, &d, name, name_hash, bit_pos);
462 
463         set_page_dirty(ipage);
464 
465         /* we don't need to mark_inode_dirty now */
466         if (inode) {
467                 F2FS_I(inode)->i_pino = dir->i_ino;
468                 update_inode(inode, page);
469                 f2fs_put_page(page, 1);
470         }
471 
472         update_parent_metadata(dir, inode, 0);
473 fail:
474         if (inode)
475                 up_write(&F2FS_I(inode)->i_sem);
476 
477         if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
478                 update_inode(dir, ipage);
479                 clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
480         }
481 out:
482         f2fs_put_page(ipage, 1);
483         return err;
484 }
485 
486 void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
487                                         struct inode *dir, struct inode *inode)
488 {
489         struct f2fs_inline_dentry *inline_dentry;
490         int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
491         unsigned int bit_pos;
492         int i;
493 
494         lock_page(page);
495         f2fs_wait_on_page_writeback(page, NODE, true);
496 
497         inline_dentry = inline_data_addr(page);
498         bit_pos = dentry - inline_dentry->dentry;
499         for (i = 0; i < slots; i++)
500                 test_and_clear_bit_le(bit_pos + i,
501                                 &inline_dentry->dentry_bitmap);
502 
503         set_page_dirty(page);
504 
505         dir->i_ctime = dir->i_mtime = CURRENT_TIME;
506 
507         if (inode)
508                 f2fs_drop_nlink(dir, inode, page);
509 
510         f2fs_put_page(page, 1);
511 }
512 
513 bool f2fs_empty_inline_dir(struct inode *dir)
514 {
515         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
516         struct page *ipage;
517         unsigned int bit_pos = 2;
518         struct f2fs_inline_dentry *dentry_blk;
519 
520         ipage = get_node_page(sbi, dir->i_ino);
521         if (IS_ERR(ipage))
522                 return false;
523 
524         dentry_blk = inline_data_addr(ipage);
525         bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
526                                         NR_INLINE_DENTRY,
527                                         bit_pos);
528 
529         f2fs_put_page(ipage, 1);
530 
531         if (bit_pos < NR_INLINE_DENTRY)
532                 return false;
533 
534         return true;
535 }
536 
537 int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
538                                 struct fscrypt_str *fstr)
539 {
540         struct inode *inode = file_inode(file);
541         struct f2fs_inline_dentry *inline_dentry = NULL;
542         struct page *ipage = NULL;
543         struct f2fs_dentry_ptr d;
544 
545         if (ctx->pos == NR_INLINE_DENTRY)
546                 return 0;
547 
548         ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
549         if (IS_ERR(ipage))
550                 return PTR_ERR(ipage);
551 
552         inline_dentry = inline_data_addr(ipage);
553 
554         make_dentry_ptr(inode, &d, (void *)inline_dentry, 2);
555 
556         if (!f2fs_fill_dentries(ctx, &d, 0, fstr))
557                 ctx->pos = NR_INLINE_DENTRY;
558 
559         f2fs_put_page(ipage, 1);
560         return 0;
561 }
562 
563 int f2fs_inline_data_fiemap(struct inode *inode,
564                 struct fiemap_extent_info *fieinfo, __u64 start, __u64 len)
565 {
566         __u64 byteaddr, ilen;
567         __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED |
568                 FIEMAP_EXTENT_LAST;
569         struct node_info ni;
570         struct page *ipage;
571         int err = 0;
572 
573         ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
574         if (IS_ERR(ipage))
575                 return PTR_ERR(ipage);
576 
577         if (!f2fs_has_inline_data(inode)) {
578                 err = -EAGAIN;
579                 goto out;
580         }
581 
582         ilen = min_t(size_t, MAX_INLINE_DATA, i_size_read(inode));
583         if (start >= ilen)
584                 goto out;
585         if (start + len < ilen)
586                 ilen = start + len;
587         ilen -= start;
588 
589         get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni);
590         byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;
591         byteaddr += (char *)inline_data_addr(ipage) - (char *)F2FS_INODE(ipage);
592         err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
593 out:
594         f2fs_put_page(ipage, 1);
595         return err;
596 }
597 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp