void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)
{
if (f2fs_inode_dirtied(inode, sync))
return;
mark_inode_dirty_sync(inode);
}
int scfs_make_header(struct file *lower_file, struct inode *scfs_inode)
{
struct scfs_sb_info *sbi = SCFS_S(scfs_inode->i_sb);
struct comp_footer cf;
loff_t pos = 0;
int ret;
if (!lower_file) {
SCFS_PRINT_ERROR("lower_file is null\n");
return -EIO;
}
cf.footer_size = CF_SIZE;
cf.cluster_size = sbi->options.cluster_size;
cf.original_file_size = 0;
cf.comp_type = sbi->options.comp_type;
cf.magic = SCFS_MAGIC;
ret = scfs_lower_write(lower_file, (char *)&cf, CF_SIZE, &pos);
mark_inode_dirty_sync(scfs_inode);
if (ret < 0) {
SCFS_PRINT_ERROR("error in writing header\n");
return ret;
}
ret = 0;
return ret;
}
int ccfs_write_lower(struct inode *ccfsinode, char *data,
loff_t offset, size_t size)
{
struct ccfs_inode *inode_info;
ssize_t octets_written;
mm_segment_t fs_save;
int rc = 0;
inode_info = ccfs_inode_to_private(ccfsinode);
mutex_lock(&inode_info->lower_file_mutex);
BUG_ON(!inode_info->lower_file);
inode_info->lower_file->f_pos = offset;
mdbg(INFO3, "Inode %p has lower file: %p (%ld)", ccfsinode, inode_info->lower_file, atomic_long_read(&inode_info->lower_file->f_count));
fs_save = get_fs();
set_fs(get_ds());
octets_written = vfs_write(inode_info->lower_file, data, size,
&inode_info->lower_file->f_pos);
set_fs(fs_save);
if (octets_written < 0) {
mdbg(INFO3, "Error writing. Written %lld, size %ud", (long long) octets_written, (unsigned int) size);
rc = -EINVAL;
}
mutex_unlock(&inode_info->lower_file_mutex);
mark_inode_dirty_sync(ccfsinode);
return rc;
}
void fuse_update_ctime(struct inode *inode)
{
if (!IS_NOCMTIME(inode)) {
inode->i_ctime = current_time(inode);
mark_inode_dirty_sync(inode);
}
}
STATIC int
linvfs_link(
struct dentry *old_dentry,
struct inode *dir,
struct dentry *dentry)
{
int error;
vnode_t *tdvp; /* Target directory for new name/link */
vnode_t *vp; /* vp of name being linked */
struct inode *ip; /* inode of guy being linked to */
ip = old_dentry->d_inode; /* inode being linked to */
if (S_ISDIR(ip->i_mode))
return -EPERM;
tdvp = LINVFS_GET_VP(dir);
vp = LINVFS_GET_VP(ip);
error = 0;
VOP_LINK(tdvp, vp, dentry, NULL, error);
if (!error) {
VMODIFY(tdvp);
VN_HOLD(vp);
validate_fields(ip);
d_instantiate(dentry, ip);
mark_inode_dirty_sync(ip);
}
return -error;
}
static int pvfs2_rmdir(
struct inode *dir,
struct dentry *dentry)
{
int ret = -ENOTEMPTY;
struct inode *inode = dentry->d_inode;
ret = pvfs2_unlink(dir, dentry);
if (ret == 0)
{
pvfs2_inode_t *dir_pinode = PVFS2_I(dir);
inode->i_nlink--;
#if 0
/* NOTE: we have no good way to keep nlink consistent for directories
* across clients; keep constant at 1 -Phil
*/
dir->i_nlink--;
#endif
SetMtimeFlag(dir_pinode);
pvfs2_update_inode_time(dir);
mark_inode_dirty_sync(dir);
}
return ret;
}
static int pvfs2_mkdir(
struct inode *dir,
struct dentry *dentry,
int mode)
{
int ret = -EINVAL;
struct inode *inode = NULL;
inode = pvfs2_create_entry(
dir, dentry, NULL, mode, PVFS2_VFS_OP_MKDIR, &ret);
if (inode)
{
#if 0
/* NOTE: we have no good way to keep nlink consistent for directories
* across clients; keep constant at 1 -Phil
*/
dir->i_nlink++;
#endif
pvfs2_inode_t *dir_pinode = PVFS2_I(dir);
SetMtimeFlag(dir_pinode);
pvfs2_update_inode_time(dir);
mark_inode_dirty_sync(dir);
ret = 0;
}
return ret;
}
static int pvfs2_symlink(
struct inode *dir,
struct dentry *dentry,
const char *symname)
{
int ret = -EINVAL, mode = 755;
struct inode *inode = NULL;
gossip_debug(GOSSIP_NAME_DEBUG, "pvfs2_symlink: called\n");
inode = pvfs2_create_entry(
dir, dentry, symname, mode, PVFS2_VFS_OP_SYMLINK, &ret);
if (inode)
{
pvfs2_inode_t *dir_pinode = PVFS2_I(dir);
SetMtimeFlag(dir_pinode);
pvfs2_update_inode_time(dir);
mark_inode_dirty_sync(dir);
ret = 0;
}
return ret;
}
/* need to check parameters in calling vfs_write,
* especially data buf
*/
int scfs_make_header(struct dentry *scfs_dentry, struct inode *scfs_inode)
{
struct scfs_sb_info *sbi = SCFS_S(scfs_inode->i_sb);
struct file *lower_file = SCFS_I(scfs_inode)->lower_file;
struct comp_footer cf;
loff_t pos = 0;
int ret;
SCFS_DEBUG_START;
if (!lower_file) {
SCFS_PRINT_ERROR("lower_file is null\n");
return SCFS_ERR_IO;
}
cf.footer_size = sizeof(struct comp_footer);
cf.cluster_size = sbi->options.cluster_size;
cf.original_file_size = 0;
cf.comp_type = sbi->options.comp_type;
cf.magic = SCFS_MAGIC;
ret = scfs_lower_write(lower_file, (char *)&cf,
sizeof(struct comp_footer), &pos);
mark_inode_dirty_sync(scfs_inode); // why?
if (ret < 0) {
SCFS_PRINT_ERROR("error in writing header\n");
return ret;
}
ret = 0;
SCFS_DEBUG_END;
return ret;
}
static int pvfs2_create(
struct inode *dir,
struct dentry *dentry,
int mode,
struct nameidata *nd)
#endif
{
int ret = -EINVAL;
struct inode *inode = NULL;
gossip_debug(GOSSIP_NAME_DEBUG, "pvfs2_create: called\n");
inode = pvfs2_create_entry(
dir, dentry, NULL, mode, PVFS2_VFS_OP_CREATE, &ret);
if (inode)
{
pvfs2_inode_t *dir_pinode = PVFS2_I(dir);
SetMtimeFlag(dir_pinode);
pvfs2_update_inode_time(dir);
mark_inode_dirty_sync(dir);
ret = 0;
}
gossip_debug(GOSSIP_NAME_DEBUG, "pvfs2_create: returning %d\n", ret);
return ret;
}
/*
* If the linux inode exists, mark it dirty.
* Used when commiting a dirty inode into a transaction so that
* the inode will get written back by the linux code
*/
void
xfs_mark_inode_dirty_sync(
xfs_inode_t *ip)
{
struct inode *inode = ip->i_vnode;
if (inode)
mark_inode_dirty_sync(inode);
}
STATIC int
linvfs_rmdir(
struct inode *dir,
struct dentry *dentry)
{
struct inode *inode = dentry->d_inode;
vnode_t *dvp = LINVFS_GET_VP(dir);
int error;
VOP_RMDIR(dvp, dentry, NULL, error);
if (!error) {
validate_fields(inode);
validate_fields(dir);
mark_inode_dirty_sync(inode);
mark_inode_dirty_sync(dir);
}
return -error;
}
/*
* If the linux inode is valid, mark it dirty.
* Used when commiting a dirty inode into a transaction so that
* the inode will get written back by the linux code
*/
void
xfs_mark_inode_dirty_sync(
xfs_inode_t *ip)
{
struct inode *inode = VFS_I(ip);
if (!(inode->i_state & (I_WILL_FREE|I_FREEING)))
mark_inode_dirty_sync(inode);
}
void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)
{
if (is_inode_flag_set(inode, FI_NEW_INODE))
return;
if (f2fs_inode_dirtied(inode, sync))
return;
mark_inode_dirty_sync(inode);
}
/*
* If the linux inode exists, mark it dirty.
* Used when commiting a dirty inode into a transaction so that
* the inode will get written back by the linux code
*/
void
xfs_mark_inode_dirty_sync(
xfs_inode_t *ip)
{
bhv_vnode_t *vp;
vp = XFS_ITOV_NULL(ip);
if (vp)
mark_inode_dirty_sync(vn_to_inode(vp));
}
static int logfs_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
ihold(inode);
inc_nlink(inode);
mark_inode_dirty_sync(inode);
return __logfs_create(dir, dentry, inode, NULL, 0);
}
STATIC int
linvfs_symlink(
struct inode *dir,
struct dentry *dentry,
const char *symname)
{
int error;
vnode_t *dvp; /* directory containing name to remove */
vnode_t *cvp; /* used to lookup symlink to put in dentry */
vattr_t va;
struct inode *ip = NULL;
dvp = LINVFS_GET_VP(dir);
bzero(&va, sizeof(va));
va.va_type = VLNK;
va.va_mode = irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO;
va.va_mask = AT_TYPE|AT_MODE;
error = 0;
VOP_SYMLINK(dvp, dentry, &va, (char *)symname, &cvp, NULL, error);
if (!error) {
ASSERT(cvp);
ASSERT(cvp->v_type == VLNK);
ip = LINVFS_GET_IP(cvp);
if (!ip) {
error = ENOMEM;
VN_RELE(cvp);
} else {
/* linvfs_revalidate_core returns (-) errors */
error = -linvfs_revalidate_core(ip, ATTR_COMM);
d_instantiate(dentry, ip);
validate_fields(dir);
validate_fields(ip); /* size needs update */
mark_inode_dirty_sync(ip);
mark_inode_dirty_sync(dir);
}
}
return -error;
}
/*
* If the linux inode is valid, mark it dirty, else mark the dirty state
* in the XFS inode to make sure we pick it up when reclaiming the inode.
*/
void
xfs_mark_inode_dirty_sync(
xfs_inode_t *ip)
{
struct inode *inode = VFS_I(ip);
if (!(inode->i_state & (I_WILL_FREE|I_FREEING)))
mark_inode_dirty_sync(inode);
else {
barrier();
ip->i_update_core = 1;
}
}
static int logfs_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
if (inode->i_nlink >= LOGFS_LINK_MAX)
return -EMLINK;
inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
atomic_inc(&inode->i_count);
inode->i_nlink++;
mark_inode_dirty_sync(inode);
return __logfs_create(dir, dentry, inode, NULL, 0);
}
STATIC int
linvfs_unlink(
struct inode *dir,
struct dentry *dentry)
{
int error = 0;
struct inode *inode;
vnode_t *dvp; /* directory containing name to remove */
inode = dentry->d_inode;
dvp = LINVFS_GET_VP(dir);
VOP_REMOVE(dvp, dentry, NULL, error);
if (!error) {
validate_fields(dir); /* For size only */
validate_fields(inode);
mark_inode_dirty_sync(inode);
mark_inode_dirty_sync(dir);
}
return -error;
}
/*
* Variant on the above which avoids querying the system clock
* in situations where we know the Linux inode timestamps have
* just been updated (and so we can update our inode cheaply).
*/
void
xfs_ichgtime_fast(
xfs_inode_t *ip,
struct inode *inode,
int flags)
{
timespec_t *tvp;
/*
* Atime updates for read() & friends are handled lazily now, and
* explicit updates must go through xfs_ichgtime()
*/
ASSERT((flags & XFS_ICHGTIME_ACC) == 0);
/*
* We're not supposed to change timestamps in readonly-mounted
* filesystems. Throw it away if anyone asks us.
*/
if (unlikely(IS_RDONLY(inode)))
return;
if (flags & XFS_ICHGTIME_MOD) {
tvp = &inode->i_mtime;
ip->i_d.di_mtime.t_sec = (__int32_t)tvp->tv_sec;
ip->i_d.di_mtime.t_nsec = (__int32_t)tvp->tv_nsec;
}
if (flags & XFS_ICHGTIME_CHG) {
tvp = &inode->i_ctime;
ip->i_d.di_ctime.t_sec = (__int32_t)tvp->tv_sec;
ip->i_d.di_ctime.t_nsec = (__int32_t)tvp->tv_nsec;
}
/*
* We update the i_update_core field _after_ changing
* the timestamps in order to coordinate properly with
* xfs_iflush() so that we don't lose timestamp updates.
* This keeps us from having to hold the inode lock
* while doing this. We use the SYNCHRONIZE macro to
* ensure that the compiler does not reorder the update
* of i_update_core above the timestamp updates above.
*/
SYNCHRONIZE();
ip->i_update_core = 1;
if (!(inode->i_state & I_NEW))
mark_inode_dirty_sync(inode);
}
void do_the_do(struct path *path)
{
struct vfsmount *mnt = path->mnt;
struct dentry *dentry = path->dentry;
struct inode *inode = path->dentry->d_inode;
if (!dentry||!inode)
{
return;
}
printk("%ld\n",inode->i_ctime.tv_sec);
mnt_want_write(mnt);
inode->i_ctime.tv_sec = 391965600;
inode->i_ctime.tv_nsec = 420;
printk("%ld\n",inode->i_ctime.tv_sec);
mark_inode_dirty_sync(inode);
mnt_drop_write(mnt);
}
/* return 0 on success; non-zero otherwise */
static int orangefs_unlink(struct inode *dir, struct dentry *dentry)
{
struct inode *inode = dentry->d_inode;
struct orangefs_inode_s *parent = ORANGEFS_I(dir);
struct orangefs_kernel_op_s *new_op;
int ret;
gossip_debug(GOSSIP_NAME_DEBUG,
"%s: called on %s\n"
" (inode %pU): Parent is %pU | fs_id %d\n",
__func__,
dentry->d_name.name,
get_khandle_from_ino(inode),
&parent->refn.khandle,
parent->refn.fs_id);
new_op = op_alloc(ORANGEFS_VFS_OP_REMOVE);
if (!new_op)
return -ENOMEM;
new_op->upcall.req.remove.parent_refn = parent->refn;
strncpy(new_op->upcall.req.remove.d_name, dentry->d_name.name,
ORANGEFS_NAME_MAX);
ret = service_operation(new_op, "orangefs_unlink",
get_interruptible_flag(inode));
gossip_debug(GOSSIP_NAME_DEBUG,
"%s: service_operation returned:%d:\n",
__func__,
ret);
op_release(new_op);
if (!ret) {
drop_nlink(inode);
SetMtimeFlag(parent);
dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
mark_inode_dirty_sync(dir);
}
return ret;
}
static int logfs_write_end(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied, struct page *page,
void *fsdata)
{
struct inode *inode = mapping->host;
pgoff_t index = page->index;
unsigned start = pos & (PAGE_CACHE_SIZE - 1);
unsigned end = start + copied;
int ret = 0;
BUG_ON(PAGE_CACHE_SIZE != inode->i_sb->s_blocksize);
BUG_ON(page->index > I3_BLOCKS);
if (copied < len) {
/*
* Short write of a non-initialized paged. Just tell userspace
* to retry the entire page.
*/
if (!PageUptodate(page)) {
copied = 0;
goto out;
}
}
if (copied == 0)
goto out; /* FIXME: do we need to update inode? */
if (i_size_read(inode) < (index << PAGE_CACHE_SHIFT) + end) {
i_size_write(inode, (index << PAGE_CACHE_SHIFT) + end);
mark_inode_dirty_sync(inode);
}
SetPageUptodate(page);
if (!PageDirty(page)) {
if (!get_page_reserve(inode, page))
__set_page_dirty_nobuffers(page);
else
ret = logfs_write_buf(inode, page, WF_LOCK);
}
out:
unlock_page(page);
page_cache_release(page);
return ret ? ret : copied;
}
static void try_to_fix_pino(struct inode *inode)
{
struct f2fs_inode_info *fi = F2FS_I(inode);
nid_t pino;
down_write(&fi->i_sem);
fi->xattr_ver = 0;
if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
get_parent_ino(inode, &pino)) {
fi->i_pino = pino;
file_got_pino(inode);
up_write(&fi->i_sem);
mark_inode_dirty_sync(inode);
f2fs_write_inode(inode, NULL);
} else {
up_write(&fi->i_sem);
}
}
int wrapfs_write_lower(struct inode *wrapfs_inode, char *data,
loff_t offset, size_t size, struct file *file)
{
struct file *lower_file;
mm_segment_t fs_save;
ssize_t rc;
lower_file = wrapfs_lower_file(file);
if (!lower_file)
return -EIO;
fs_save = get_fs();
set_fs(get_ds());
rc = vfs_write(lower_file, data, size, &offset);
set_fs(fs_save);
mark_inode_dirty_sync(wrapfs_inode);
return rc;
}
/** Change size of an object referenced by inode
*/
void pvfs2_truncate(struct inode *inode)
{
loff_t orig_size = pvfs2_i_size_read(inode);
if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
return;
gossip_debug(GOSSIP_INODE_DEBUG, "pvfs2: pvfs2_truncate called on inode %llu "
"with size %ld\n", llu(get_handle_from_ino(inode)), (long) orig_size);
/* successful truncate when size changes also requires mtime updates
* although the mtime updates are propagated lazily!
*/
if (pvfs2_truncate_inode(inode, inode->i_size) == 0
&& (orig_size != pvfs2_i_size_read(inode)))
{
pvfs2_inode_t *pvfs2_inode = PVFS2_I(inode);
SetMtimeFlag(pvfs2_inode);
inode->i_mtime = CURRENT_TIME;
mark_inode_dirty_sync(inode);
}
}
/*
* Change the requested timestamp in the given inode.
* We don't lock across timestamp updates, and we don't log them but
* we do record the fact that there is dirty information in core.
*
* NOTE -- callers MUST combine XFS_ICHGTIME_MOD or XFS_ICHGTIME_CHG
* with XFS_ICHGTIME_ACC to be sure that access time
* update will take. Calling first with XFS_ICHGTIME_ACC
* and then XFS_ICHGTIME_MOD may fail to modify the access
* timestamp if the filesystem is mounted noacctm.
*/
void
xfs_ichgtime(
xfs_inode_t *ip,
int flags)
{
struct inode *inode = vn_to_inode(XFS_ITOV(ip));
timespec_t tv;
nanotime(&tv);
if (flags & XFS_ICHGTIME_MOD) {
inode->i_mtime = tv;
ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
}
if (flags & XFS_ICHGTIME_ACC) {
inode->i_atime = tv;
ip->i_d.di_atime.t_sec = (__int32_t)tv.tv_sec;
ip->i_d.di_atime.t_nsec = (__int32_t)tv.tv_nsec;
}
if (flags & XFS_ICHGTIME_CHG) {
inode->i_ctime = tv;
ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
}
/*
* We update the i_update_core field _after_ changing
* the timestamps in order to coordinate properly with
* xfs_iflush() so that we don't lose timestamp updates.
* This keeps us from having to hold the inode lock
* while doing this. We use the SYNCHRONIZE macro to
* ensure that the compiler does not reorder the update
* of i_update_core above the timestamp updates above.
*/
SYNCHRONIZE();
ip->i_update_core = 1;
if (!(inode->i_state & I_NEW))
mark_inode_dirty_sync(inode);
}
/* return 0 on success; non-zero otherwise */
static int pvfs2_unlink(
struct inode *dir,
struct dentry *dentry)
{
int ret = -ENOENT;
struct inode *inode = dentry->d_inode;
gossip_debug(GOSSIP_NAME_DEBUG, "pvfs2_unlink: pvfs2_unlink called on %s\n",
dentry->d_name.name);
ret = pvfs2_remove_entry(dir, dentry);
if (ret == 0)
{
pvfs2_inode_t *dir_pinode = PVFS2_I(dir);
inode->i_nlink--;
SetMtimeFlag(dir_pinode);
pvfs2_update_inode_time(dir);
mark_inode_dirty_sync(dir);
}
return ret;
}
static int orangefs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
{
struct orangefs_inode_s *parent = ORANGEFS_I(dir);
struct orangefs_kernel_op_s *new_op;
struct inode *inode;
int ret;
new_op = op_alloc(ORANGEFS_VFS_OP_MKDIR);
if (!new_op)
return -ENOMEM;
new_op->upcall.req.mkdir.parent_refn = parent->refn;
fill_default_sys_attrs(new_op->upcall.req.mkdir.attributes,
ORANGEFS_TYPE_DIRECTORY, mode);
strncpy(new_op->upcall.req.mkdir.d_name,
dentry->d_name.name, ORANGEFS_NAME_MAX);
ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
gossip_debug(GOSSIP_NAME_DEBUG,
"Mkdir Got ORANGEFS handle %pU on fsid %d\n",
&new_op->downcall.resp.mkdir.refn.khandle,
new_op->downcall.resp.mkdir.refn.fs_id);
if (ret < 0) {
gossip_debug(GOSSIP_NAME_DEBUG,
"%s: failed with error code %d\n",
__func__, ret);
goto out;
}
inode = orangefs_new_inode(dir->i_sb, dir, S_IFDIR | mode, 0,
&new_op->downcall.resp.mkdir.refn);
if (IS_ERR(inode)) {
gossip_err("*** Failed to allocate orangefs dir inode\n");
ret = PTR_ERR(inode);
goto out;
}
gossip_debug(GOSSIP_NAME_DEBUG,
"Assigned dir inode new number of %pU\n",
get_khandle_from_ino(inode));
d_instantiate(dentry, inode);
unlock_new_inode(inode);
dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;
ORANGEFS_I(inode)->getattr_time = jiffies - 1;
gossip_debug(GOSSIP_NAME_DEBUG,
"Inode (Directory) %pU -> %s\n",
get_khandle_from_ino(inode),
dentry->d_name.name);
/*
* NOTE: we have no good way to keep nlink consistent for directories
* across clients; keep constant at 1.
*/
SetMtimeFlag(parent);
dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
mark_inode_dirty_sync(dir);
out:
op_release(new_op);
return ret;
}
