cregit-Linux how code gets into the kernel

Release 4.10 fs/f2fs/inline.c

Directory: fs/f2fs
/*
 * fs/f2fs/inline.c
 * Copyright (c) 2013, Intel Corporation
 * Authors: Huajun Li <huajun.li@intel.com>
 *          Haicheng Li <haicheng.li@intel.com>
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/fs.h>
#include <linux/f2fs_fs.h>

#include "f2fs.h"
#include "node.h"


bool f2fs_may_inline_data(struct inode *inode) { if (f2fs_is_atomic_file(inode)) return false; if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) return false; if (i_size_read(inode) > MAX_INLINE_DATA) return false; if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) return false; return true; }

Contributors

PersonTokensPropCommitsCommitProp
jaegeuk kimjaegeuk kim4257.53%571.43%
huajun lihuajun li2331.51%114.29%
wanpeng liwanpeng li810.96%114.29%
Total73100.00%7100.00%


bool f2fs_may_inline_dentry(struct inode *inode) { if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY)) return false; if (!S_ISDIR(inode->i_mode)) return false; return true; }

Contributors

PersonTokensPropCommitsCommitProp
jaegeuk kimjaegeuk kim42100.00%1100.00%
Total42100.00%1100.00%


void read_inline_data(struct page *page, struct page *ipage) { void *src_addr, *dst_addr; if (PageUptodate(page)) return; f2fs_bug_on(F2FS_P_SB(page), page->index); zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE); /* Copy the whole inline data block */ src_addr = inline_data_addr(ipage); dst_addr = kmap_atomic(page); memcpy(dst_addr, src_addr, MAX_INLINE_DATA); flush_dcache_page(page); kunmap_atomic(dst_addr); if (!PageUptodate(page)) SetPageUptodate(page); }

Contributors

PersonTokensPropCommitsCommitProp
jaegeuk kimjaegeuk kim6869.39%240.00%
huajun lihuajun li1616.33%120.00%
chao yuchao yu1313.27%120.00%
kirill a. shutemovkirill a. shutemov11.02%120.00%
Total98100.00%5100.00%


bool truncate_inline_inode(struct page *ipage, u64 from) { void *addr; if (from >= MAX_INLINE_DATA) return false; addr = inline_data_addr(ipage); f2fs_wait_on_page_writeback(ipage, NODE, true); memset(addr + from, 0, MAX_INLINE_DATA - from); set_page_dirty(ipage); return true; }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu5688.89%250.00%
jaegeuk kimjaegeuk kim711.11%250.00%
Total63100.00%4100.00%


int f2fs_read_inline_data(struct inode *inode, struct page *page) { struct page *ipage; ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); if (IS_ERR(ipage)) { unlock_page(page); return PTR_ERR(ipage); } if (!f2fs_has_inline_data(inode)) { f2fs_put_page(ipage, 1); return -EAGAIN; } if (page->index) zero_user_segment(page, 0, PAGE_SIZE); else read_inline_data(page, ipage); if (!PageUptodate(page)) SetPageUptodate(page); f2fs_put_page(ipage, 1); unlock_page(page); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
jaegeuk kimjaegeuk kim6450.79%457.14%
huajun lihuajun li5442.86%114.29%
chao yuchao yu75.56%114.29%
kirill a. shutemovkirill a. shutemov10.79%114.29%
Total126100.00%7100.00%


int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) { struct f2fs_io_info fio = { .sbi = F2FS_I_SB(dn->inode), .type = DATA, .op = REQ_OP_WRITE, .op_flags = REQ_SYNC | REQ_PRIO, .page = page, .encrypted_page = NULL, }; int dirty, err; if (!f2fs_exist_data(dn->inode)) goto clear_out; err = f2fs_reserve_block(dn, 0); if (err) return err; f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page)); read_inline_data(page, dn->inode_page); set_page_dirty(page); /* clear dirty state */ dirty = clear_page_dirty_for_io(page); /* write data page to try to make data consistent */ set_page_writeback(page); fio.old_blkaddr = dn->data_blkaddr; write_data_page(dn, &fio); f2fs_wait_on_page_writeback(page, DATA, true); if (dirty) { inode_dec_dirty_pages(dn->inode); remove_dirty_inode(dn->inode); } /* this converted inline_data should be recovered. */ set_inode_flag(dn->inode, FI_APPEND_WRITE); /* clear inline data and flag after data writeback */ truncate_inline_inode(dn->inode_page, 0); clear_inline_node(dn->inode_page); clear_out: stat_dec_inline_inode(dn->inode); f2fs_clear_inline_inode(dn->inode); f2fs_put_dnode(dn); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
jaegeuk kimjaegeuk kim12052.40%1463.64%
huajun lihuajun li8034.93%14.55%
chao yuchao yu135.68%313.64%
yunlei heyunlei he83.49%14.55%
michael christiemichael christie62.62%14.55%
shawn linshawn lin10.44%14.55%
christoph hellwigchristoph hellwig10.44%14.55%
Total229100.00%22100.00%


int f2fs_convert_inline_inode(struct inode *inode) { struct f2fs_sb_info *sbi = F2FS_I_SB(inode); struct dnode_of_data dn; struct page *ipage, *page; int err = 0; if (!f2fs_has_inline_data(inode)) return 0; page = f2fs_grab_cache_page(inode->i_mapping, 0, false); if (!page) return -ENOMEM; f2fs_lock_op(sbi); ipage = get_node_page(sbi, inode->i_ino); if (IS_ERR(ipage)) { err = PTR_ERR(ipage); goto out; } set_new_dnode(&dn, inode, ipage, ipage, 0); if (f2fs_has_inline_data(inode)) err = f2fs_convert_inline_page(&dn, page); f2fs_put_dnode(&dn); out: f2fs_unlock_op(sbi); f2fs_put_page(page, 1); f2fs_balance_fs(sbi, dn.node_changed); return err; }

Contributors

PersonTokensPropCommitsCommitProp
jaegeuk kimjaegeuk kim12876.19%888.89%
huajun lihuajun li4023.81%111.11%
Total168100.00%9100.00%


int f2fs_write_inline_data(struct inode *inode, struct page *page) { void *src_addr, *dst_addr; struct dnode_of_data dn; int err; set_new_dnode(&dn, inode, NULL, NULL, 0); err = get_dnode_of_data(&dn, 0, LOOKUP_NODE); if (err) return err; if (!f2fs_has_inline_data(inode)) { f2fs_put_dnode(&dn); return -EAGAIN; } f2fs_bug_on(F2FS_I_SB(inode), page->index); f2fs_wait_on_page_writeback(dn.inode_page, NODE, true); src_addr = kmap_atomic(page); dst_addr = inline_data_addr(dn.inode_page); memcpy(dst_addr, src_addr, MAX_INLINE_DATA); kunmap_atomic(src_addr); set_page_dirty(dn.inode_page); set_inode_flag(inode, FI_APPEND_WRITE); set_inode_flag(inode, FI_DATA_EXIST); clear_inline_node(dn.inode_page); f2fs_put_dnode(&dn); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
huajun lihuajun li9454.65%111.11%
jaegeuk kimjaegeuk kim7845.35%888.89%
Total172100.00%9100.00%


bool recover_inline_data(struct inode *inode, struct page *npage) { struct f2fs_sb_info *sbi = F2FS_I_SB(inode); struct f2fs_inode *ri = NULL; void *src_addr, *dst_addr; struct page *ipage; /* * The inline_data recovery policy is as follows. * [prev.] [next] of inline_data flag * o o -> recover inline_data * o x -> remove inline_data, and then recover data blocks * x o -> remove inline_data, and then recover inline_data * x x -> recover data blocks */ if (IS_INODE(npage)) ri = F2FS_INODE(npage); if (f2fs_has_inline_data(inode) && ri && (ri->i_inline & F2FS_INLINE_DATA)) { process_inline: ipage = get_node_page(sbi, inode->i_ino); f2fs_bug_on(sbi, IS_ERR(ipage)); f2fs_wait_on_page_writeback(ipage, NODE, true); src_addr = inline_data_addr(npage); dst_addr = inline_data_addr(ipage); memcpy(dst_addr, src_addr, MAX_INLINE_DATA); set_inode_flag(inode, FI_INLINE_DATA); set_inode_flag(inode, FI_DATA_EXIST); set_page_dirty(ipage); f2fs_put_page(ipage, 1); return true; } if (f2fs_has_inline_data(inode)) { ipage = get_node_page(sbi, inode->i_ino); f2fs_bug_on(sbi, IS_ERR(ipage)); if (!truncate_inline_inode(ipage, 0)) return false; f2fs_clear_inline_inode(inode); f2fs_put_page(ipage, 1); } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) { if (truncate_blocks(inode, 0, false)) return false; goto process_inline; } return false; }

Contributors

PersonTokensPropCommitsCommitProp
jaegeuk kimjaegeuk kim23693.65%981.82%
nicholas krausenicholas krause135.16%19.09%
chao yuchao yu31.19%19.09%
Total252100.00%11100.00%


struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir, struct fscrypt_name *fname, struct page **res_page) { struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); struct f2fs_inline_dentry *inline_dentry; struct qstr name = FSTR_TO_QSTR(&fname->disk_name); struct f2fs_dir_entry *de; struct f2fs_dentry_ptr d; struct page *ipage; f2fs_hash_t namehash; ipage = get_node_page(sbi, dir->i_ino); if (IS_ERR(ipage)) { *res_page = ipage; return NULL; } namehash = f2fs_dentry_hash(&name); inline_dentry = inline_data_addr(ipage); make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2); de = find_target_dentry(fname, namehash, NULL, &d); unlock_page(ipage); if (de) *res_page = ipage; else f2fs_put_page(ipage, 0); return de; }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu9154.49%114.29%
jaegeuk kimjaegeuk kim7645.51%685.71%
Total167100.00%7100.00%


int make_empty_inline_dir(struct inode *inode, struct inode *parent, struct page *ipage) { struct f2fs_inline_dentry *dentry_blk; struct f2fs_dentry_ptr d; dentry_blk = inline_data_addr(ipage); make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2); do_make_empty_dir(inode, parent, &d); set_page_dirty(ipage); /* update i_size to MAX_INLINE_DATA */ if (i_size_read(inode) < MAX_INLINE_DATA) f2fs_i_size_write(inode, MAX_INLINE_DATA); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu7282.76%125.00%
jaegeuk kimjaegeuk kim1517.24%375.00%
Total87100.00%4100.00%

/* * NOTE: ipage is grabbed by caller, but if any error occurs, we should * release ipage in this function. */
static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage, struct f2fs_inline_dentry *inline_dentry) { struct page *page; struct dnode_of_data dn; struct f2fs_dentry_block *dentry_blk; int err; page = f2fs_grab_cache_page(dir->i_mapping, 0, false); if (!page) { f2fs_put_page(ipage, 1); return -ENOMEM; } set_new_dnode(&dn, dir, ipage, NULL, 0); err = f2fs_reserve_block(&dn, 0); if (err) goto out; f2fs_wait_on_page_writeback(page, DATA, true); zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE); dentry_blk = kmap_atomic(page); /* copy data from inline dentry block to new dentry block */ memcpy(dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap, INLINE_DENTRY_BITMAP_SIZE); memset(dentry_blk->dentry_bitmap + INLINE_DENTRY_BITMAP_SIZE, 0, SIZE_OF_DENTRY_BITMAP - INLINE_DENTRY_BITMAP_SIZE); /* * we do not need to zero out remainder part of dentry and filename * field, since we have used bitmap for marking the usage status of * them, besides, we can also ignore copying/zeroing reserved space * of dentry block, because them haven't been used so far. */ memcpy(dentry_blk->dentry, inline_dentry->dentry, sizeof(struct f2fs_dir_entry) * NR_INLINE_DENTRY); memcpy(dentry_blk->filename, inline_dentry->filename, NR_INLINE_DENTRY * F2FS_SLOT_LEN); kunmap_atomic(dentry_blk); if (!PageUptodate(page)) SetPageUptodate(page); set_page_dirty(page); /* clear inline dir and flag after data writeback */ truncate_inline_inode(ipage, 0); stat_dec_inline_dir(dir); clear_inode_flag(dir, FI_INLINE_DENTRY); f2fs_i_depth_write(dir, 1); if (i_size_read(dir) < PAGE_SIZE) f2fs_i_size_write(dir, PAGE_SIZE); out: f2fs_put_page(page, 1); return err; }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu23889.14%743.75%
jaegeuk kimjaegeuk kim269.74%850.00%
kirill a. shutemovkirill a. shutemov31.12%16.25%
Total267100.00%16100.00%


static int f2fs_add_inline_entries(struct inode *dir, struct f2fs_inline_dentry *inline_dentry) { struct f2fs_dentry_ptr d; unsigned long bit_pos = 0; int err = 0; make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2); while (bit_pos < d.max) { struct f2fs_dir_entry *de; struct qstr new_name; nid_t ino; umode_t fake_mode; if (!test_bit_le(bit_pos, d.bitmap)) { bit_pos++; continue; } de = &d.dentry[bit_pos]; if (unlikely(!de->name_len)) { bit_pos++; continue; } new_name.name = d.filename[bit_pos]; new_name.len = le16_to_cpu(de->name_len); ino = le32_to_cpu(de->ino); fake_mode = get_de_type(de) << S_SHIFT; err = f2fs_add_regular_entry(dir, &new_name, NULL, NULL, ino, fake_mode); if (err) goto punch_dentry_pages; bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); } return 0; punch_dentry_pages: truncate_inode_pages(&dir->i_data, 0); truncate_blocks(dir, 0, false); remove_dirty_inode(dir); return err; }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu22298.67%375.00%
eric biggerseric biggers31.33%125.00%
Total225100.00%4100.00%


static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage, struct f2fs_inline_dentry *inline_dentry) { struct f2fs_inline_dentry *backup_dentry; int err; backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir), sizeof(struct f2fs_inline_dentry), GFP_F2FS_ZERO); if (!backup_dentry) { f2fs_put_page(ipage, 1); return -ENOMEM; } memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA); truncate_inline_inode(ipage, 0); unlock_page(ipage); err = f2fs_add_inline_entries(dir, backup_dentry); if (err) goto recover; lock_page(ipage); stat_dec_inline_dir(dir); clear_inode_flag(dir, FI_INLINE_DENTRY); kfree(backup_dentry); return 0; recover: lock_page(ipage); memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA); f2fs_i_depth_write(dir, 0); f2fs_i_size_write(dir, MAX_INLINE_DATA); set_page_dirty(ipage); f2fs_put_page(ipage, 1); kfree(backup_dentry); return err; }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu16995.48%337.50%
jaegeuk kimjaegeuk kim84.52%562.50%
Total177100.00%8100.00%


static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage, struct f2fs_inline_dentry *inline_dentry) { if (!F2FS_I(dir)->i_dir_level) return f2fs_move_inline_dirents(dir, ipage, inline_dentry); else return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry); }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu52100.00%1100.00%
Total52100.00%1100.00%


int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name, const struct qstr *orig_name, struct inode *inode, nid_t ino, umode_t mode) { struct f2fs_sb_info *sbi = F2FS_I_SB(dir); struct page *ipage; unsigned int bit_pos; f2fs_hash_t name_hash; struct f2fs_inline_dentry *dentry_blk = NULL; struct f2fs_dentry_ptr d; int slots = GET_DENTRY_SLOTS(new_name->len); struct page *page = NULL; int err = 0; ipage = get_node_page(sbi, dir->i_ino); if (IS_ERR(ipage)) return PTR_ERR(ipage); dentry_blk = inline_data_addr(ipage); bit_pos = room_for_filename(&dentry_blk->dentry_bitmap, slots, NR_INLINE_DENTRY); if (bit_pos >= NR_INLINE_DENTRY) { err = f2fs_convert_inline_dir(dir, ipage, dentry_blk); if (err) return err; err = -EAGAIN; goto out; } if (inode) { down_write(&F2FS_I(inode)->i_sem); page = init_inode_metadata(inode, dir, new_name, orig_name, ipage); if (IS_ERR(page)) { err = PTR_ERR(page); goto fail; } if (f2fs_encrypted_inode(dir)) file_set_enc_name(inode); } f2fs_wait_on_page_writeback(ipage, NODE, true); name_hash = f2fs_dentry_hash(new_name); make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2); f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos); set_page_dirty(ipage); /* we don't need to mark_inode_dirty now */ if (inode) { f2fs_i_pino_write(inode, dir->i_ino); f2fs_put_page(page, 1); } update_parent_metadata(dir, inode, 0); fail: if (inode) up_write(&F2FS_I(inode)->i_sem); out: f2fs_put_page(ipage, 1); return err; }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu28482.56%436.36%
jaegeuk kimjaegeuk kim4813.95%654.55%
shuoran liushuoran liu123.49%19.09%
Total344100.00%11100.00%


void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page, struct inode *dir, struct inode *inode) { struct f2fs_inline_dentry *inline_dentry; int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len)); unsigned int bit_pos; int i; lock_page(page); f2fs_wait_on_page_writeback(page, NODE, true); inline_dentry = inline_data_addr(page); bit_pos = dentry - inline_dentry->dentry; for (i = 0; i < slots; i++) __clear_bit_le(bit_pos + i, &inline_dentry->dentry_bitmap); set_page_dirty(page); f2fs_put_page(page, 1); dir->i_ctime = dir->i_mtime = current_time(dir); f2fs_mark_inode_dirty_sync(dir, false); if (inode) f2fs_drop_nlink(dir, inode); }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu12585.03%111.11%
jaegeuk kimjaegeuk kim1812.24%777.78%
deepa dinamanideepa dinamani42.72%111.11%
Total147100.00%9100.00%


bool f2fs_empty_inline_dir(struct inode *dir) { struct f2fs_sb_info *sbi = F2FS_I_SB(dir); struct page *ipage; unsigned int bit_pos = 2; struct f2fs_inline_dentry *dentry_blk; ipage = get_node_page(sbi, dir->i_ino); if (IS_ERR(ipage)) return false; dentry_blk = inline_data_addr(ipage); bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, NR_INLINE_DENTRY, bit_pos); f2fs_put_page(ipage, 1); if (bit_pos < NR_INLINE_DENTRY) return false; return true; }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu97100.00%1100.00%
Total97100.00%1100.00%


int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx, struct fscrypt_str *fstr) { struct inode *inode = file_inode(file); struct f2fs_inline_dentry *inline_dentry = NULL; struct page *ipage = NULL; struct f2fs_dentry_ptr d; int err; if (ctx->pos == NR_INLINE_DENTRY) return 0; ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); if (IS_ERR(ipage)) return PTR_ERR(ipage); inline_dentry = inline_data_addr(ipage); make_dentry_ptr(inode, &d, (void *)inline_dentry, 2); err = f2fs_fill_dentries(ctx, &d, 0, fstr); if (!err) ctx->pos = NR_INLINE_DENTRY; f2fs_put_page(ipage, 1); return err < 0 ? err : 0; }

Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu11776.47%233.33%
jaegeuk kimjaegeuk kim3623.53%466.67%
Total153100.00%6100.00%


int f2fs_inline_data_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, __u64 start, __u64 len) { __u64 byteaddr, ilen; __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED | FIEMAP_EXTENT_LAST; struct node_info ni; struct page *ipage; int err = 0; ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); if (IS_ERR(ipage)) return PTR_ERR(ipage); if (!f2fs_has_inline_data(inode)) { err = -EAGAIN; goto out; } ilen = min_t(size_t, MAX_INLINE_DATA, i_size_read(inode)); if (start >= ilen) goto out; if (start + len < ilen) ilen = start + len; ilen -= start; get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni); byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits; byteaddr += (char *)inline_data_addr(ipage) - (char *)F2FS_INODE(ipage); err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags); out: f2fs_put_page(ipage, 1); return err; }

Contributors

PersonTokensPropCommitsCommitProp
jaegeuk kimjaegeuk kim212100.00%1100.00%
Total212100.00%1100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
chao yuchao yu156049.29%1820.22%
jaegeuk kimjaegeuk kim122738.77%6067.42%
huajun lihuajun li31710.02%11.12%
nicholas krausenicholas krause130.41%11.12%
shuoran liushuoran liu120.38%11.12%
wanpeng liwanpeng li80.25%11.12%
yunlei heyunlei he80.25%11.12%
michael christiemichael christie60.19%11.12%
kirill a. shutemovkirill a. shutemov50.16%11.12%
deepa dinamanideepa dinamani40.13%11.12%
eric biggerseric biggers30.09%11.12%
christoph hellwigchristoph hellwig10.03%11.12%
shawn linshawn lin10.03%11.12%
Total3165100.00%89100.00%
Directory: fs/f2fs
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.