cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

file.c (3878B)

      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 *   Copyright (C) International Business Machines Corp., 2000-2002
      4 *   Portions Copyright (C) Christoph Hellwig, 2001-2002
      5 */
      6
      7#include <linux/mm.h>
      8#include <linux/fs.h>
      9#include <linux/posix_acl.h>
     10#include <linux/quotaops.h>
     11#include "jfs_incore.h"
     12#include "jfs_inode.h"
     13#include "jfs_dmap.h"
     14#include "jfs_txnmgr.h"
     15#include "jfs_xattr.h"
     16#include "jfs_acl.h"
     17#include "jfs_debug.h"
     18
     19int jfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
     20{
     21	struct inode *inode = file->f_mapping->host;
     22	int rc = 0;
     23
     24	rc = file_write_and_wait_range(file, start, end);
     25	if (rc)
     26		return rc;
     27
     28	inode_lock(inode);
     29	if (!(inode->i_state & I_DIRTY_ALL) ||
     30	    (datasync && !(inode->i_state & I_DIRTY_DATASYNC))) {
     31		/* Make sure committed changes hit the disk */
     32		jfs_flush_journal(JFS_SBI(inode->i_sb)->log, 1);
     33		inode_unlock(inode);
     34		return rc;
     35	}
     36
     37	rc |= jfs_commit_inode(inode, 1);
     38	inode_unlock(inode);
     39
     40	return rc ? -EIO : 0;
     41}
     42
     43static int jfs_open(struct inode *inode, struct file *file)
     44{
     45	int rc;
     46
     47	if ((rc = dquot_file_open(inode, file)))
     48		return rc;
     49
     50	/*
     51	 * We attempt to allow only one "active" file open per aggregate
     52	 * group.  Otherwise, appending to files in parallel can cause
     53	 * fragmentation within the files.
     54	 *
     55	 * If the file is empty, it was probably just created and going
     56	 * to be written to.  If it has a size, we'll hold off until the
     57	 * file is actually grown.
     58	 */
     59	if (S_ISREG(inode->i_mode) && file->f_mode & FMODE_WRITE &&
     60	    (inode->i_size == 0)) {
     61		struct jfs_inode_info *ji = JFS_IP(inode);
     62		spin_lock_irq(&ji->ag_lock);
     63		if (ji->active_ag == -1) {
     64			struct jfs_sb_info *jfs_sb = JFS_SBI(inode->i_sb);
     65			ji->active_ag = BLKTOAG(addressPXD(&ji->ixpxd), jfs_sb);
     66			atomic_inc(&jfs_sb->bmap->db_active[ji->active_ag]);
     67		}
     68		spin_unlock_irq(&ji->ag_lock);
     69	}
     70
     71	return 0;
     72}
     73static int jfs_release(struct inode *inode, struct file *file)
     74{
     75	struct jfs_inode_info *ji = JFS_IP(inode);
     76
     77	spin_lock_irq(&ji->ag_lock);
     78	if (ji->active_ag != -1) {
     79		struct bmap *bmap = JFS_SBI(inode->i_sb)->bmap;
     80		atomic_dec(&bmap->db_active[ji->active_ag]);
     81		ji->active_ag = -1;
     82	}
     83	spin_unlock_irq(&ji->ag_lock);
     84
     85	return 0;
     86}
     87
     88int jfs_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
     89		struct iattr *iattr)
     90{
     91	struct inode *inode = d_inode(dentry);
     92	int rc;
     93
     94	rc = setattr_prepare(&init_user_ns, dentry, iattr);
     95	if (rc)
     96		return rc;
     97
     98	if (is_quota_modification(inode, iattr)) {
     99		rc = dquot_initialize(inode);
    100		if (rc)
    101			return rc;
    102	}
    103	if ((iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)) ||
    104	    (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))) {
    105		rc = dquot_transfer(inode, iattr);
    106		if (rc)
    107			return rc;
    108	}
    109
    110	if ((iattr->ia_valid & ATTR_SIZE) &&
    111	    iattr->ia_size != i_size_read(inode)) {
    112		inode_dio_wait(inode);
    113
    114		rc = inode_newsize_ok(inode, iattr->ia_size);
    115		if (rc)
    116			return rc;
    117
    118		truncate_setsize(inode, iattr->ia_size);
    119		jfs_truncate(inode);
    120	}
    121
    122	setattr_copy(&init_user_ns, inode, iattr);
    123	mark_inode_dirty(inode);
    124
    125	if (iattr->ia_valid & ATTR_MODE)
    126		rc = posix_acl_chmod(&init_user_ns, inode, inode->i_mode);
    127	return rc;
    128}
    129
    130const struct inode_operations jfs_file_inode_operations = {
    131	.listxattr	= jfs_listxattr,
    132	.setattr	= jfs_setattr,
    133	.fileattr_get	= jfs_fileattr_get,
    134	.fileattr_set	= jfs_fileattr_set,
    135#ifdef CONFIG_JFS_POSIX_ACL
    136	.get_acl	= jfs_get_acl,
    137	.set_acl	= jfs_set_acl,
    138#endif
    139};
    140
    141const struct file_operations jfs_file_operations = {
    142	.open		= jfs_open,
    143	.llseek		= generic_file_llseek,
    144	.read_iter	= generic_file_read_iter,
    145	.write_iter	= generic_file_write_iter,
    146	.mmap		= generic_file_mmap,
    147	.splice_read	= generic_file_splice_read,
    148	.splice_write	= iter_file_splice_write,
    149	.fsync		= jfs_fsync,
    150	.release	= jfs_release,
    151	.unlocked_ioctl = jfs_ioctl,
    152	.compat_ioctl	= compat_ptr_ioctl,
    153};