file.c 9.3 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
#include <linux/quotaops.h>
27 28
#include "ext4.h"
#include "ext4_jbd2.h"
29 30 31 32 33
#include "xattr.h"
#include "acl.h"

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

	return 0;
}

58
void ext4_unwritten_wait(struct inode *inode)
59 60 61
{
	wait_queue_head_t *wq = ext4_ioend_wq(inode);

62
	wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_unwritten) == 0));
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
}

/*
 * This tests whether the IO in question is block-aligned or not.
 * Ext4 utilizes unwritten extents when hole-filling during direct IO, and they
 * are converted to written only after the IO is complete.  Until they are
 * mapped, these blocks appear as holes, so dio_zero_block() will assume that
 * it needs to zero out portions of the start and/or end block.  If 2 AIO
 * threads are at work on the same unwritten block, they must be synchronized
 * or one thread will zero the other's data, causing corruption.
 */
static int
ext4_unaligned_aio(struct inode *inode, const struct iovec *iov,
		   unsigned long nr_segs, loff_t pos)
{
	struct super_block *sb = inode->i_sb;
	int blockmask = sb->s_blocksize - 1;
	size_t count = iov_length(iov, nr_segs);
	loff_t final_size = pos + count;

	if (pos >= inode->i_size)
		return 0;

	if ((pos & blockmask) || (final_size & blockmask))
		return 1;

	return 0;
}

92
static ssize_t
93 94
ext4_file_dio_write(struct kiocb *iocb, const struct iovec *iov,
		    unsigned long nr_segs, loff_t pos)
95
{
96 97 98
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
	struct blk_plug plug;
99
	int unaligned_aio = 0;
100
	ssize_t ret;
101 102
	int overwrite = 0;
	size_t length = iov_length(iov, nr_segs);
103

104 105
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
	    !is_sync_kiocb(iocb))
106
		unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
107

108 109 110 111 112 113 114 115 116 117 118
	/* Unaligned direct AIO must be serialized; see comment above */
	if (unaligned_aio) {
		static unsigned long unaligned_warn_time;

		/* Warn about this once per day */
		if (printk_timed_ratelimit(&unaligned_warn_time, 60*60*24*HZ))
			ext4_msg(inode->i_sb, KERN_WARNING,
				 "Unaligned AIO/DIO on inode %ld by %s; "
				 "performance will be poor.",
				 inode->i_ino, current->comm);
		mutex_lock(ext4_aio_mutex(inode));
119
		ext4_unwritten_wait(inode);
120 121
	}

122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
	BUG_ON(iocb->ki_pos != pos);

	mutex_lock(&inode->i_mutex);
	blk_start_plug(&plug);

	iocb->private = &overwrite;

	/* check whether we do a DIO overwrite or not */
	if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&
	    !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
		struct ext4_map_blocks map;
		unsigned int blkbits = inode->i_blkbits;
		int err, len;

		map.m_lblk = pos >> blkbits;
		map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits)
			- map.m_lblk;
		len = map.m_len;

		err = ext4_map_blocks(NULL, inode, &map, 0);
		/*
		 * 'err==len' means that all of blocks has been preallocated no
		 * matter they are initialized or not.  For excluding
		 * uninitialized extents, we need to check m_flags.  There are
		 * two conditions that indicate for initialized extents.
		 * 1) If we hit extent cache, EXT4_MAP_MAPPED flag is returned;
		 * 2) If we do a real lookup, non-flags are returned.
		 * So we should check these two conditions.
		 */
		if (err == len && (map.m_flags & EXT4_MAP_MAPPED))
			overwrite = 1;
	}

	ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
	mutex_unlock(&inode->i_mutex);

	if (ret > 0 || ret == -EIOCBQUEUED) {
		ssize_t err;

		err = generic_write_sync(file, pos, ret);
		if (err < 0 && ret > 0)
			ret = err;
	}
	blk_finish_plug(&plug);
166 167 168 169 170

	if (unaligned_aio)
		mutex_unlock(ext4_aio_mutex(inode));

	return ret;
171 172 173
}

static ssize_t
174
ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
175 176
		unsigned long nr_segs, loff_t pos)
{
177
	struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
178
	ssize_t ret;
179

180 181 182 183 184
	/*
	 * If we have encountered a bitmap-format file, the size limit
	 * is smaller than s_maxbytes, which is for extent-mapped files.
	 */

185
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
186 187
		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
		size_t length = iov_length(iov, nr_segs);
188

189 190
		if ((pos > sbi->s_bitmap_maxbytes ||
		    (pos == sbi->s_bitmap_maxbytes && length > 0)))
191 192 193 194 195 196 197 198
			return -EFBIG;

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

199 200 201 202
	if (unlikely(iocb->ki_filp->f_flags & O_DIRECT))
		ret = ext4_file_dio_write(iocb, iov, nr_segs, pos);
	else
		ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
203 204

	return ret;
205 206
}

207
static const struct vm_operations_struct ext4_file_vm_ops = {
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
	.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;
}

224 225 226 227
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);
228
	struct ext4_inode_info *ei = EXT4_I(inode);
229 230 231 232 233 234 235 236 237 238 239 240 241 242
	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));
243 244
		path.mnt = mnt;
		path.dentry = mnt->mnt_root;
245 246
		cp = d_path(&path, buf, sizeof(buf));
		if (!IS_ERR(cp)) {
247 248 249 250 251 252 253 254 255 256 257
			handle_t *handle;
			int err;

			handle = ext4_journal_start_sb(sb, 1);
			if (IS_ERR(handle))
				return PTR_ERR(handle);
			err = ext4_journal_get_write_access(handle, sbi->s_sbh);
			if (err) {
				ext4_journal_stop(handle);
				return err;
			}
258 259
			strlcpy(sbi->s_es->s_last_mounted, cp,
				sizeof(sbi->s_es->s_last_mounted));
260 261
			ext4_handle_dirty_super(handle, sb);
			ext4_journal_stop(handle);
262 263
		}
	}
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
	/*
	 * Set up the jbd2_inode if we are opening the inode for
	 * writing and the journal is present
	 */
	if (sbi->s_journal && !ei->jinode && (filp->f_mode & FMODE_WRITE)) {
		struct jbd2_inode *jinode = jbd2_alloc_inode(GFP_KERNEL);

		spin_lock(&inode->i_lock);
		if (!ei->jinode) {
			if (!jinode) {
				spin_unlock(&inode->i_lock);
				return -ENOMEM;
			}
			ei->jinode = jinode;
			jbd2_journal_init_jbd_inode(ei->jinode, inode);
			jinode = NULL;
		}
		spin_unlock(&inode->i_lock);
		if (unlikely(jinode != NULL))
			jbd2_free_inode(jinode);
	}
285
	return dquot_file_open(inode, filp);
286 287
}

288
/*
289 290 291
 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
 * by calling generic_file_llseek_size() with the appropriate maxbytes
 * value for each.
292 293 294 295 296 297 298 299 300 301 302
 */
loff_t ext4_llseek(struct file *file, loff_t offset, int origin)
{
	struct inode *inode = file->f_mapping->host;
	loff_t maxbytes;

	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
		maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
	else
		maxbytes = inode->i_sb->s_maxbytes;

303 304
	return generic_file_llseek_size(file, offset, origin,
					maxbytes, i_size_read(inode));
305 306
}

307
const struct file_operations ext4_file_operations = {
308
	.llseek		= ext4_llseek,
309 310 311
	.read		= do_sync_read,
	.write		= do_sync_write,
	.aio_read	= generic_file_aio_read,
312
	.aio_write	= ext4_file_write,
A
Andi Kleen 已提交
313
	.unlocked_ioctl = ext4_ioctl,
314
#ifdef CONFIG_COMPAT
315
	.compat_ioctl	= ext4_compat_ioctl,
316
#endif
317
	.mmap		= ext4_file_mmap,
318
	.open		= ext4_file_open,
319 320
	.release	= ext4_release_file,
	.fsync		= ext4_sync_file,
321 322
	.splice_read	= generic_file_splice_read,
	.splice_write	= generic_file_splice_write,
323
	.fallocate	= ext4_fallocate,
324 325
};

326
const struct inode_operations ext4_file_inode_operations = {
327
	.setattr	= ext4_setattr,
328
	.getattr	= ext4_getattr,
T
Theodore Ts'o 已提交
329
#ifdef CONFIG_EXT4_FS_XATTR
330 331
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
332
	.listxattr	= ext4_listxattr,
333 334
	.removexattr	= generic_removexattr,
#endif
335
	.get_acl	= ext4_get_acl,
336
	.fiemap		= ext4_fiemap,
337 338
};