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

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

	return 0;
}

60
void ext4_unwritten_wait(struct inode *inode)
61 62 63
{
	wait_queue_head_t *wq = ext4_ioend_wq(inode);

64
	wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_unwritten) == 0));
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 92 93
}

/*
 * 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;
}

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

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

110 111 112
	/* Unaligned direct AIO must be serialized; see comment above */
	if (unaligned_aio) {
		mutex_lock(ext4_aio_mutex(inode));
113
		ext4_unwritten_wait(inode);
114 115
	}

116 117 118 119 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
	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);

152
	if (ret > 0) {
153 154 155 156 157 158 159
		ssize_t err;

		err = generic_write_sync(file, pos, ret);
		if (err < 0 && ret > 0)
			ret = err;
	}
	blk_finish_plug(&plug);
160 161 162 163 164

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

	return ret;
165 166 167
}

static ssize_t
168
ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
169 170
		unsigned long nr_segs, loff_t pos)
{
A
Al Viro 已提交
171
	struct inode *inode = file_inode(iocb->ki_filp);
172
	ssize_t ret;
173

174 175 176 177 178
	/*
	 * If we have encountered a bitmap-format file, the size limit
	 * is smaller than s_maxbytes, which is for extent-mapped files.
	 */

179
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
180 181
		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
		size_t length = iov_length(iov, nr_segs);
182

183 184
		if ((pos > sbi->s_bitmap_maxbytes ||
		    (pos == sbi->s_bitmap_maxbytes && length > 0)))
185 186 187 188 189 190 191 192
			return -EFBIG;

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

193 194 195 196
	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);
197 198

	return ret;
199 200
}

201
static const struct vm_operations_struct ext4_file_vm_ops = {
202 203
	.fault		= filemap_fault,
	.page_mkwrite   = ext4_page_mkwrite,
204
	.remap_pages	= generic_file_remap_pages,
205 206 207 208 209 210 211 212 213 214 215 216 217
};

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;
	return 0;
}

218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
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));
236 237
		path.mnt = mnt;
		path.dentry = mnt->mnt_root;
238 239
		cp = d_path(&path, buf, sizeof(buf));
		if (!IS_ERR(cp)) {
240 241 242
			handle_t *handle;
			int err;

243
			handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
244 245 246 247 248 249 250
			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;
			}
251 252
			strlcpy(sbi->s_es->s_last_mounted, cp,
				sizeof(sbi->s_es->s_last_mounted));
253 254
			ext4_handle_dirty_super(handle, sb);
			ext4_journal_stop(handle);
255 256
		}
	}
257 258 259 260
	/*
	 * Set up the jbd2_inode if we are opening the inode for
	 * writing and the journal is present
	 */
261 262 263 264
	if (filp->f_mode & FMODE_WRITE) {
		int ret = ext4_inode_attach_jinode(inode);
		if (ret < 0)
			return ret;
265
	}
266
	return dquot_file_open(inode, filp);
267 268
}

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
/*
 * Here we use ext4_map_blocks() to get a block mapping for a extent-based
 * file rather than ext4_ext_walk_space() because we can introduce
 * SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same
 * function.  When extent status tree has been fully implemented, it will
 * track all extent status for a file and we can directly use it to
 * retrieve the offset for SEEK_DATA/SEEK_HOLE.
 */

/*
 * When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to
 * lookup page cache to check whether or not there has some data between
 * [startoff, endoff] because, if this range contains an unwritten extent,
 * we determine this extent as a data or a hole according to whether the
 * page cache has data or not.
 */
static int ext4_find_unwritten_pgoff(struct inode *inode,
286
				     int whence,
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
				     struct ext4_map_blocks *map,
				     loff_t *offset)
{
	struct pagevec pvec;
	unsigned int blkbits;
	pgoff_t index;
	pgoff_t end;
	loff_t endoff;
	loff_t startoff;
	loff_t lastoff;
	int found = 0;

	blkbits = inode->i_sb->s_blocksize_bits;
	startoff = *offset;
	lastoff = startoff;
302
	endoff = (loff_t)(map->m_lblk + map->m_len) << blkbits;
303 304 305 306 307 308 309 310 311 312 313 314 315

	index = startoff >> PAGE_CACHE_SHIFT;
	end = endoff >> PAGE_CACHE_SHIFT;

	pagevec_init(&pvec, 0);
	do {
		int i, num;
		unsigned long nr_pages;

		num = min_t(pgoff_t, end - index, PAGEVEC_SIZE);
		nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
					  (pgoff_t)num);
		if (nr_pages == 0) {
316
			if (whence == SEEK_DATA)
317 318
				break;

319
			BUG_ON(whence != SEEK_HOLE);
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
			/*
			 * If this is the first time to go into the loop and
			 * offset is not beyond the end offset, it will be a
			 * hole at this offset
			 */
			if (lastoff == startoff || lastoff < endoff)
				found = 1;
			break;
		}

		/*
		 * If this is the first time to go into the loop and
		 * offset is smaller than the first page offset, it will be a
		 * hole at this offset.
		 */
335
		if (lastoff == startoff && whence == SEEK_HOLE &&
336 337 338 339 340 341 342 343 344 345 346 347 348
		    lastoff < page_offset(pvec.pages[0])) {
			found = 1;
			break;
		}

		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];
			struct buffer_head *bh, *head;

			/*
			 * If the current offset is not beyond the end of given
			 * range, it will be a hole.
			 */
349
			if (lastoff < endoff && whence == SEEK_HOLE &&
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
			    page->index > end) {
				found = 1;
				*offset = lastoff;
				goto out;
			}

			lock_page(page);

			if (unlikely(page->mapping != inode->i_mapping)) {
				unlock_page(page);
				continue;
			}

			if (!page_has_buffers(page)) {
				unlock_page(page);
				continue;
			}

			if (page_has_buffers(page)) {
				lastoff = page_offset(page);
				bh = head = page_buffers(page);
				do {
					if (buffer_uptodate(bh) ||
					    buffer_unwritten(bh)) {
374
						if (whence == SEEK_DATA)
375 376
							found = 1;
					} else {
377
						if (whence == SEEK_HOLE)
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
							found = 1;
					}
					if (found) {
						*offset = max_t(loff_t,
							startoff, lastoff);
						unlock_page(page);
						goto out;
					}
					lastoff += bh->b_size;
					bh = bh->b_this_page;
				} while (bh != head);
			}

			lastoff = page_offset(page) + PAGE_SIZE;
			unlock_page(page);
		}

		/*
		 * The no. of pages is less than our desired, that would be a
		 * hole in there.
		 */
399
		if (nr_pages < num && whence == SEEK_HOLE) {
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
			found = 1;
			*offset = lastoff;
			break;
		}

		index = pvec.pages[i - 1]->index + 1;
		pagevec_release(&pvec);
	} while (index <= end);

out:
	pagevec_release(&pvec);
	return found;
}

/*
 * ext4_seek_data() retrieves the offset for SEEK_DATA.
 */
static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize)
{
	struct inode *inode = file->f_mapping->host;
	struct ext4_map_blocks map;
	struct extent_status es;
	ext4_lblk_t start, last, end;
	loff_t dataoff, isize;
	int blkbits;
	int ret = 0;

	mutex_lock(&inode->i_mutex);

	isize = i_size_read(inode);
	if (offset >= isize) {
		mutex_unlock(&inode->i_mutex);
		return -ENXIO;
	}

	blkbits = inode->i_sb->s_blocksize_bits;
	start = offset >> blkbits;
	last = start;
	end = isize >> blkbits;
	dataoff = offset;

	do {
		map.m_lblk = last;
		map.m_len = end - last + 1;
		ret = ext4_map_blocks(NULL, inode, &map, 0);
		if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
			if (last != start)
447
				dataoff = (loff_t)last << blkbits;
448 449 450 451 452 453 454
			break;
		}

		/*
		 * If there is a delay extent at this offset,
		 * it will be as a data.
		 */
Y
Yan, Zheng 已提交
455
		ext4_es_find_delayed_extent_range(inode, last, last, &es);
Z
Zheng Liu 已提交
456
		if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
457
			if (last != start)
458
				dataoff = (loff_t)last << blkbits;
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
			break;
		}

		/*
		 * If there is a unwritten extent at this offset,
		 * it will be as a data or a hole according to page
		 * cache that has data or not.
		 */
		if (map.m_flags & EXT4_MAP_UNWRITTEN) {
			int unwritten;
			unwritten = ext4_find_unwritten_pgoff(inode, SEEK_DATA,
							      &map, &dataoff);
			if (unwritten)
				break;
		}

		last++;
476
		dataoff = (loff_t)last << blkbits;
477 478 479 480 481 482 483
	} while (last <= end);

	mutex_unlock(&inode->i_mutex);

	if (dataoff > isize)
		return -ENXIO;

J
Jie Liu 已提交
484
	return vfs_setpos(file, dataoff, maxsize);
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
}

/*
 * ext4_seek_hole() retrieves the offset for SEEK_HOLE.
 */
static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
{
	struct inode *inode = file->f_mapping->host;
	struct ext4_map_blocks map;
	struct extent_status es;
	ext4_lblk_t start, last, end;
	loff_t holeoff, isize;
	int blkbits;
	int ret = 0;

	mutex_lock(&inode->i_mutex);

	isize = i_size_read(inode);
	if (offset >= isize) {
		mutex_unlock(&inode->i_mutex);
		return -ENXIO;
	}

	blkbits = inode->i_sb->s_blocksize_bits;
	start = offset >> blkbits;
	last = start;
	end = isize >> blkbits;
	holeoff = offset;

	do {
		map.m_lblk = last;
		map.m_len = end - last + 1;
		ret = ext4_map_blocks(NULL, inode, &map, 0);
		if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
			last += ret;
520
			holeoff = (loff_t)last << blkbits;
521 522 523 524 525 526 527
			continue;
		}

		/*
		 * If there is a delay extent at this offset,
		 * we will skip this extent.
		 */
Y
Yan, Zheng 已提交
528
		ext4_es_find_delayed_extent_range(inode, last, last, &es);
Z
Zheng Liu 已提交
529 530
		if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
			last = es.es_lblk + es.es_len;
531
			holeoff = (loff_t)last << blkbits;
532 533 534 535 536 537 538 539 540 541 542 543 544 545
			continue;
		}

		/*
		 * If there is a unwritten extent at this offset,
		 * it will be as a data or a hole according to page
		 * cache that has data or not.
		 */
		if (map.m_flags & EXT4_MAP_UNWRITTEN) {
			int unwritten;
			unwritten = ext4_find_unwritten_pgoff(inode, SEEK_HOLE,
							      &map, &holeoff);
			if (!unwritten) {
				last += ret;
546
				holeoff = (loff_t)last << blkbits;
547 548 549 550 551 552 553 554 555 556 557 558 559
				continue;
			}
		}

		/* find a hole */
		break;
	} while (last <= end);

	mutex_unlock(&inode->i_mutex);

	if (holeoff > isize)
		holeoff = isize;

J
Jie Liu 已提交
560
	return vfs_setpos(file, holeoff, maxsize);
561 562
}

563
/*
564 565 566
 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
 * by calling generic_file_llseek_size() with the appropriate maxbytes
 * value for each.
567
 */
568
loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
569 570 571 572 573 574 575 576 577
{
	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;

578
	switch (whence) {
579 580 581
	case SEEK_SET:
	case SEEK_CUR:
	case SEEK_END:
582
		return generic_file_llseek_size(file, offset, whence,
583 584 585 586 587 588 589 590
						maxbytes, i_size_read(inode));
	case SEEK_DATA:
		return ext4_seek_data(file, offset, maxbytes);
	case SEEK_HOLE:
		return ext4_seek_hole(file, offset, maxbytes);
	}

	return -EINVAL;
591 592
}

593
const struct file_operations ext4_file_operations = {
594
	.llseek		= ext4_llseek,
595 596 597
	.read		= do_sync_read,
	.write		= do_sync_write,
	.aio_read	= generic_file_aio_read,
598
	.aio_write	= ext4_file_write,
A
Andi Kleen 已提交
599
	.unlocked_ioctl = ext4_ioctl,
600
#ifdef CONFIG_COMPAT
601
	.compat_ioctl	= ext4_compat_ioctl,
602
#endif
603
	.mmap		= ext4_file_mmap,
604
	.open		= ext4_file_open,
605 606
	.release	= ext4_release_file,
	.fsync		= ext4_sync_file,
607 608
	.splice_read	= generic_file_splice_read,
	.splice_write	= generic_file_splice_write,
609
	.fallocate	= ext4_fallocate,
610 611
};

612
const struct inode_operations ext4_file_inode_operations = {
613
	.setattr	= ext4_setattr,
614
	.getattr	= ext4_getattr,
615 616
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
617
	.listxattr	= ext4_listxattr,
618
	.removexattr	= generic_removexattr,
619
	.get_acl	= ext4_get_acl,
620
	.fiemap		= ext4_fiemap,
621 622
};