cregit-Linux how code gets into the kernel

Release 4.10 fs/ext4/fsync.c

Directory: fs/ext4
 *  linux/fs/ext4/fsync.c
 *  Copyright (C) 1993  Stephen Tweedie (
 *  from
 *  Copyright (C) 1992  Remy Card (
 *                      Laboratoire MASI - Institut Blaise Pascal
 *                      Universite Pierre et Marie Curie (Paris VI)
 *  from
 *  linux/fs/minix/truncate.c   Copyright (C) 1991, 1992  Linus Torvalds
 *  ext4fs fsync primitive
 *  Big-endian to little-endian byte-swapping/bitmaps by
 *        David S. Miller (, 1995
 *  Removed unnecessary code duplication for little endian machines
 *  and excessive __inline__s.
 *        Andi Kleen, 1997
 * Major simplications and cleanup - we only need to do the metadata, because
 * we can depend on generic_block_fdatasync() to sync the data blocks.

#include <linux/time.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/writeback.h>
#include <linux/blkdev.h>

#include "ext4.h"
#include "ext4_jbd2.h"

#include <trace/events/ext4.h>

 * If we're not journaling and this is a just-created file, we have to
 * sync our parent directory (if it was freshly created) since
 * otherwise it will only be written by writeback, leaving a huge
 * window during which a crash may lose the file.  This may apply for
 * the parent directory's parent as well, and so on recursively, if
 * they are also freshly created.

static int ext4_sync_parent(struct inode *inode) { struct dentry *dentry = NULL; struct inode *next; int ret = 0; if (!ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) return 0; inode = igrab(inode); while (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) { ext4_clear_inode_state(inode, EXT4_STATE_NEWENTRY); dentry = d_find_any_alias(inode); if (!dentry) break; next = igrab(d_inode(dentry->d_parent)); dput(dentry); if (!next) break; iput(inode); inode = next; /* * The directory inode may have gone through rmdir by now. But * the inode itself and its blocks are still allocated (we hold * a reference to the inode so it didn't go through * ext4_evict_inode()) and so we are safe to flush metadata * blocks and the inode. */ ret = sync_mapping_buffers(inode->i_mapping); if (ret) break; ret = sync_inode_metadata(inode, 1); if (ret) break; } iput(inode); return ret; }


theodore tsotheodore tso5738.51%114.29%
frank mayharfrank mayhar5637.84%114.29%
curt wohlgemuthcurt wohlgemuth2818.92%114.29%
david howellsdavid howells32.03%114.29%
guo chaoguo chao21.35%114.29%
jan karajan kara10.68%114.29%
al viroal viro10.68%114.29%

/* * akpm: A new design for ext4_sync_file(). * * This is only called from sys_fsync(), sys_fdatasync() and sys_msync(). * There cannot be a transaction open by this task. * Another task could have dirtied this inode. Its data can be in any * state in the journalling system. * * What we do is just kick off a commit and wait on it. This will snapshot the * inode to disk. */
int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync) { struct inode *inode = file->f_mapping->host; struct ext4_inode_info *ei = EXT4_I(inode); journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; int ret = 0, err; tid_t commit_tid; bool needs_barrier = false; J_ASSERT(ext4_journal_current_handle() == NULL); trace_ext4_sync_file_enter(file, datasync); if (inode->i_sb->s_flags & MS_RDONLY) { /* Make sure that we read updated s_mount_flags value */ smp_rmb(); if (EXT4_SB(inode->i_sb)->s_mount_flags & EXT4_MF_FS_ABORTED) ret = -EROFS; goto out; } if (!journal) { ret = __generic_file_fsync(file, start, end, datasync); if (!ret) ret = ext4_sync_parent(inode); if (test_opt(inode->i_sb, BARRIER)) goto issue_flush; goto out; } ret = filemap_write_and_wait_range(inode->i_mapping, start, end); if (ret) return ret; /* * data=writeback,ordered: * The caller's filemap_fdatawrite()/wait will sync the data. * Metadata is in the journal, we wait for proper transaction to * commit here. * * data=journal: * filemap_fdatawrite won't do anything (the buffers are clean). * ext4_force_commit will write the file data into the journal and * will wait on that. * filemap_fdatawait() will encounter a ton of newly-dirtied pages * (they were dirtied by commit). But that's OK - the blocks are * safe in-journal, which is all fsync() needs to ensure. */ if (ext4_should_journal_data(inode)) { ret = ext4_force_commit(inode->i_sb); goto out; } commit_tid = datasync ? ei->i_datasync_tid : ei->i_sync_tid; if (journal->j_flags & JBD2_BARRIER && !jbd2_trans_will_send_data_barrier(journal, commit_tid)) needs_barrier = true; ret = jbd2_complete_transaction(journal, commit_tid); if (needs_barrier) { issue_flush: err = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); if (!ret) ret = err; } out: trace_ext4_sync_file_exit(inode, ret); return ret; }


jan karajan kara9632.43%417.39%
dave kleikampdave kleikamp4715.88%14.35%
theodore tsotheodore tso4214.19%626.09%
dmitriy monakhovdmitriy monakhov289.46%313.04%
eric sandeeneric sandeen279.12%14.35%
jiaying zhangjiaying zhang206.76%14.35%
frank mayharfrank mayhar155.07%14.35%
josef bacikjosef bacik82.70%14.35%
christoph hellwigchristoph hellwig41.35%14.35%
mingming caomingming cao41.35%14.35%
hisashi hifumihisashi hifumi20.68%14.35%
curt wohlgemuthcurt wohlgemuth20.68%14.35%
aneesh kumaraneesh kumar10.34%14.35%

Overall Contributors

theodore tsotheodore tso10422.08%724.14%
jan karajan kara9720.59%517.24%
frank mayharfrank mayhar7215.29%13.45%
dave kleikampdave kleikamp6313.38%13.45%
eric sandeeneric sandeen306.37%13.45%
curt wohlgemuthcurt wohlgemuth306.37%13.45%
dmitriy monakhovdmitriy monakhov285.94%310.34%
jiaying zhangjiaying zhang204.25%13.45%
josef bacikjosef bacik81.70%13.45%
mingming caomingming cao51.06%13.45%
christoph hellwigchristoph hellwig40.85%13.45%
david howellsdavid howells30.64%13.45%
guo chaoguo chao20.42%13.45%
hisashi hifumihisashi hifumi20.42%13.45%
andy lutomirskiandy lutomirski10.21%13.45%
aneesh kumaraneesh kumar10.21%13.45%
al viroal viro10.21%13.45%
Directory: fs/ext4
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.