file.c 5.7 KB
Newer Older
1
/*
2
 *  linux/fs/ext4/file.c
3 4 5 6 7 8 9 10 11 12 13 14
 *
 * Copyright (C) 1992, 1993, 1994, 1995
 * Remy Card (card@masi.ibp.fr)
 * Laboratoire MASI - Institut Blaise Pascal
 * Universite Pierre et Marie Curie (Paris VI)
 *
 *  from
 *
 *  linux/fs/minix/file.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
15
 *  ext4 fs regular file handling primitives
16 17 18 19 20 21 22
 *
 *  64-bit file support on 64-bit platforms by Jakub Jelinek
 *	(jj@sunsite.ms.mff.cuni.cz)
 */

#include <linux/time.h>
#include <linux/fs.h>
23
#include <linux/jbd2.h>
24 25
#include <linux/mount.h>
#include <linux/path.h>
26 27
#include "ext4.h"
#include "ext4_jbd2.h"
28 29 30 31 32
#include "xattr.h"
#include "acl.h"

/*
 * Called when an inode is released. Note that this is different
33
 * from ext4_file_open: open gets called at every open, but release
34 35
 * gets called only when /all/ the files are closed.
 */
36
static int ext4_release_file(struct inode *inode, struct file *filp)
37
{
38 39 40 41
	if (EXT4_I(inode)->i_state & EXT4_STATE_DA_ALLOC_CLOSE) {
		ext4_alloc_da_blocks(inode);
		EXT4_I(inode)->i_state &= ~EXT4_STATE_DA_ALLOC_CLOSE;
	}
42 43
	/* if we are the last writer on the inode, drop the block reservation */
	if ((filp->f_mode & FMODE_WRITE) &&
44 45
			(atomic_read(&inode->i_writecount) == 1) &&
		        !EXT4_I(inode)->i_reserved_data_blocks)
46
	{
47
		down_write(&EXT4_I(inode)->i_data_sem);
48
		ext4_discard_preallocations(inode);
49
		up_write(&EXT4_I(inode)->i_data_sem);
50 51
	}
	if (is_dx(inode) && filp->private_data)
52
		ext4_htree_free_dir_info(filp->private_data);
53 54 55 56 57

	return 0;
}

static ssize_t
58
ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
59 60 61
		unsigned long nr_segs, loff_t pos)
{
	struct file *file = iocb->ki_filp;
62
	struct inode *inode = file->f_path.dentry->d_inode;
63 64 65
	ssize_t ret;
	int err;

66 67 68 69 70 71 72 73
	/*
	 * If we have encountered a bitmap-format file, the size limit
	 * is smaller than s_maxbytes, which is for extent-mapped files.
	 */

	if (!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)) {
		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
		size_t length = iov_length(iov, nr_segs);
74

75 76 77 78 79 80 81 82 83 84
		if (pos > sbi->s_bitmap_maxbytes)
			return -EFBIG;

		if (pos + length > sbi->s_bitmap_maxbytes) {
			nr_segs = iov_shorten((struct iovec *)iov, nr_segs,
					      sbi->s_bitmap_maxbytes - pos);
		}
	}

	ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
	/*
	 * Skip flushing if there was an error, or if nothing was written.
	 */
	if (ret <= 0)
		return ret;

	/*
	 * If the inode is IS_SYNC, or is O_SYNC and we are doing data
	 * journalling then we need to make sure that we force the transaction
	 * to disk to keep all metadata uptodate synchronously.
	 */
	if (file->f_flags & O_SYNC) {
		/*
		 * If we are non-data-journaled, then the dirty data has
		 * already been flushed to backing store by generic_osync_inode,
		 * and the inode has been flushed too if there have been any
		 * modifications other than mere timestamp updates.
		 *
		 * Open question --- do we care about flushing timestamps too
		 * if the inode is IS_SYNC?
		 */
106
		if (!ext4_should_journal_data(inode))
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
			return ret;

		goto force_commit;
	}

	/*
	 * So we know that there has been no forced data flush.  If the inode
	 * is marked IS_SYNC, we need to force one ourselves.
	 */
	if (!IS_SYNC(inode))
		return ret;

	/*
	 * Open question #2 --- should we force data to disk here too?  If we
	 * don't, the only impact is that data=writeback filesystems won't
	 * flush data to disk automatically on IS_SYNC, only metadata (but
	 * historically, that is what ext2 has done.)
	 */

force_commit:
127
	err = ext4_force_commit(inode->i_sb);
128 129 130 131 132
	if (err)
		return err;
	return ret;
}

133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
static struct vm_operations_struct ext4_file_vm_ops = {
	.fault		= filemap_fault,
	.page_mkwrite   = ext4_page_mkwrite,
};

static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct address_space *mapping = file->f_mapping;

	if (!mapping->a_ops->readpage)
		return -ENOEXEC;
	file_accessed(file);
	vma->vm_ops = &ext4_file_vm_ops;
	vma->vm_flags |= VM_CAN_NONLINEAR;
	return 0;
}

150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
static int ext4_file_open(struct inode * inode, struct file * filp)
{
	struct super_block *sb = inode->i_sb;
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	struct vfsmount *mnt = filp->f_path.mnt;
	struct path path;
	char buf[64], *cp;

	if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) &&
		     !(sb->s_flags & MS_RDONLY))) {
		sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;
		/*
		 * Sample where the filesystem has been mounted and
		 * store it in the superblock for sysadmin convenience
		 * when trying to sort through large numbers of block
		 * devices or filesystem images.
		 */
		memset(buf, 0, sizeof(buf));
		path.mnt = mnt->mnt_parent;
		path.dentry = mnt->mnt_mountpoint;
		path_get(&path);
		cp = d_path(&path, buf, sizeof(buf));
		path_put(&path);
		if (!IS_ERR(cp)) {
			memcpy(sbi->s_es->s_last_mounted, cp,
			       sizeof(sbi->s_es->s_last_mounted));
			sb->s_dirt = 1;
		}
	}
	return generic_file_open(inode, filp);
}

182
const struct file_operations ext4_file_operations = {
183 184 185 186
	.llseek		= generic_file_llseek,
	.read		= do_sync_read,
	.write		= do_sync_write,
	.aio_read	= generic_file_aio_read,
187
	.aio_write	= ext4_file_write,
A
Andi Kleen 已提交
188
	.unlocked_ioctl = ext4_ioctl,
189
#ifdef CONFIG_COMPAT
190
	.compat_ioctl	= ext4_compat_ioctl,
191
#endif
192
	.mmap		= ext4_file_mmap,
193
	.open		= ext4_file_open,
194 195
	.release	= ext4_release_file,
	.fsync		= ext4_sync_file,
196 197 198 199
	.splice_read	= generic_file_splice_read,
	.splice_write	= generic_file_splice_write,
};

200
const struct inode_operations ext4_file_inode_operations = {
201 202
	.truncate	= ext4_truncate,
	.setattr	= ext4_setattr,
203
	.getattr	= ext4_getattr,
T
Theodore Ts'o 已提交
204
#ifdef CONFIG_EXT4_FS_XATTR
205 206
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
207
	.listxattr	= ext4_listxattr,
208 209
	.removexattr	= generic_removexattr,
#endif
210
	.check_acl	= ext4_check_acl,
A
Amit Arora 已提交
211
	.fallocate	= ext4_fallocate,
212
	.fiemap		= ext4_fiemap,
213 214
};