file.c 15.6 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
static 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
}

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

85
	if (pos >= i_size_read(inode))
86 87 88 89 90 91 92 93
		return 0;

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

	return 0;
}

94
static ssize_t
95 96
ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
		unsigned long nr_segs, loff_t pos)
97
{
98
	struct file *file = iocb->ki_filp;
99
	struct inode *inode = file_inode(iocb->ki_filp);
100
	struct mutex *aio_mutex = NULL;
101
	struct blk_plug plug;
102
	int o_direct = file->f_flags & O_DIRECT;
103 104
	int overwrite = 0;
	size_t length = iov_length(iov, nr_segs);
105
	ssize_t ret;
106

107 108
	BUG_ON(iocb->ki_pos != pos);

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
	/*
	 * Unaligned direct AIO must be serialized; see comment above
	 * In the case of O_APPEND, assume that we must always serialize
	 */
	if (o_direct &&
	    ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
	    !is_sync_kiocb(iocb) &&
	    (file->f_flags & O_APPEND ||
	     ext4_unaligned_aio(inode, iov, nr_segs, pos))) {
		aio_mutex = ext4_aio_mutex(inode);
		mutex_lock(aio_mutex);
		ext4_unwritten_wait(inode);
	}

	mutex_lock(&inode->i_mutex);
	if (file->f_flags & O_APPEND)
		iocb->ki_pos = pos = i_size_read(inode);

127 128 129 130
	/*
	 * If we have encountered a bitmap-format file, the size limit
	 * is smaller than s_maxbytes, which is for extent-mapped files.
	 */
131
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
132
		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
133

134 135 136 137 138 139
		if ((pos > sbi->s_bitmap_maxbytes) ||
		    (pos == sbi->s_bitmap_maxbytes && length > 0)) {
			mutex_unlock(&inode->i_mutex);
			ret = -EFBIG;
			goto errout;
		}
140 141 142 143 144 145 146

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

147
	if (o_direct) {
148 149 150 151 152
		blk_start_plug(&plug);

		iocb->private = &overwrite;

		/* check whether we do a DIO overwrite or not */
153
		if (ext4_should_dioread_nolock(inode) && !aio_mutex &&
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
		    !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
			 * unwritten 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;
		}
180
	}
181

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

185 186 187 188 189 190
	if (ret > 0) {
		ssize_t err;

		err = generic_write_sync(file, iocb->ki_pos - ret, ret);
		if (err < 0)
			ret = err;
191
	}
192 193
	if (o_direct)
		blk_finish_plug(&plug);
194

195
errout:
196 197
	if (aio_mutex)
		mutex_unlock(aio_mutex);
198
	return ret;
199 200
}

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

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

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

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

270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
/*
 * 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,
287
				     int whence,
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
				     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;
303
	endoff = (loff_t)(map->m_lblk + map->m_len) << blkbits;
304 305 306 307 308 309 310 311 312 313 314 315 316

	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) {
317
			if (whence == SEEK_DATA)
318 319
				break;

320
			BUG_ON(whence != SEEK_HOLE);
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
			/*
			 * 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.
		 */
336
		if (lastoff == startoff && whence == SEEK_HOLE &&
337 338 339 340 341 342 343 344 345 346 347 348 349
		    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.
			 */
350
			if (lastoff < endoff && whence == SEEK_HOLE &&
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
			    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)) {
375
						if (whence == SEEK_DATA)
376 377
							found = 1;
					} else {
378
						if (whence == SEEK_HOLE)
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
							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.
		 */
400
		if (nr_pages < num && whence == SEEK_HOLE) {
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 447
			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)
448
				dataoff = (loff_t)last << blkbits;
449 450 451 452 453 454 455
			break;
		}

		/*
		 * If there is a delay extent at this offset,
		 * it will be as a data.
		 */
Y
Yan, Zheng 已提交
456
		ext4_es_find_delayed_extent_range(inode, last, last, &es);
Z
Zheng Liu 已提交
457
		if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
458
			if (last != start)
459
				dataoff = (loff_t)last << blkbits;
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
			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++;
477
		dataoff = (loff_t)last << blkbits;
478 479 480 481 482 483 484
	} while (last <= end);

	mutex_unlock(&inode->i_mutex);

	if (dataoff > isize)
		return -ENXIO;

J
Jie Liu 已提交
485
	return vfs_setpos(file, dataoff, maxsize);
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 520
}

/*
 * 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;
521
			holeoff = (loff_t)last << blkbits;
522 523 524 525 526 527 528
			continue;
		}

		/*
		 * If there is a delay extent at this offset,
		 * we will skip this extent.
		 */
Y
Yan, Zheng 已提交
529
		ext4_es_find_delayed_extent_range(inode, last, last, &es);
Z
Zheng Liu 已提交
530 531
		if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
			last = es.es_lblk + es.es_len;
532
			holeoff = (loff_t)last << blkbits;
533 534 535 536 537 538 539 540 541 542 543 544 545 546
			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;
547
				holeoff = (loff_t)last << blkbits;
548 549 550 551 552 553 554 555 556 557 558 559 560
				continue;
			}
		}

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

	mutex_unlock(&inode->i_mutex);

	if (holeoff > isize)
		holeoff = isize;

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

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

579
	switch (whence) {
580 581 582
	case SEEK_SET:
	case SEEK_CUR:
	case SEEK_END:
583
		return generic_file_llseek_size(file, offset, whence,
584 585 586 587 588 589 590 591
						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;
592 593
}

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

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