file.c 4.4 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
		unsigned long nr_segs, loff_t pos)
{
61
	struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
62

63 64 65 66 67 68 69 70
	/*
	 * 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);
71

72 73 74 75 76 77 78 79 80
		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);
		}
	}

81
	return generic_file_aio_write(iocb, iov, nr_segs, pos);
82 83
}

84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
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;
}

101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
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);
}

133
const struct file_operations ext4_file_operations = {
134 135 136 137
	.llseek		= generic_file_llseek,
	.read		= do_sync_read,
	.write		= do_sync_write,
	.aio_read	= generic_file_aio_read,
138
	.aio_write	= ext4_file_write,
A
Andi Kleen 已提交
139
	.unlocked_ioctl = ext4_ioctl,
140
#ifdef CONFIG_COMPAT
141
	.compat_ioctl	= ext4_compat_ioctl,
142
#endif
143
	.mmap		= ext4_file_mmap,
144
	.open		= ext4_file_open,
145 146
	.release	= ext4_release_file,
	.fsync		= ext4_sync_file,
147 148 149 150
	.splice_read	= generic_file_splice_read,
	.splice_write	= generic_file_splice_write,
};

151
const struct inode_operations ext4_file_inode_operations = {
152 153
	.truncate	= ext4_truncate,
	.setattr	= ext4_setattr,
154
	.getattr	= ext4_getattr,
T
Theodore Ts'o 已提交
155
#ifdef CONFIG_EXT4_FS_XATTR
156 157
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
158
	.listxattr	= ext4_listxattr,
159 160
	.removexattr	= generic_removexattr,
#endif
161
	.check_acl	= ext4_check_acl,
A
Amit Arora 已提交
162
	.fallocate	= ext4_fallocate,
163
	.fiemap		= ext4_fiemap,
164 165
};