file.c 26.3 KB
Newer Older
David Teigland's avatar
David Teigland committed
1 2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
David Teigland's avatar
David Teigland committed
4 5 6
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
7
 * of the GNU General Public License version 2.
David Teigland's avatar
David Teigland committed
8 9 10 11 12 13 14 15 16 17
 */

#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/pagemap.h>
#include <linux/uio.h>
#include <linux/blkdev.h>
#include <linux/mm.h>
18
#include <linux/mount.h>
19
#include <linux/fs.h>
20
#include <linux/gfs2_ondisk.h>
21 22
#include <linux/falloc.h>
#include <linux/swap.h>
23
#include <linux/crc32.h>
24
#include <linux/writeback.h>
David Teigland's avatar
David Teigland committed
25
#include <asm/uaccess.h>
26 27
#include <linux/dlm.h>
#include <linux/dlm_plock.h>
David Teigland's avatar
David Teigland committed
28 29

#include "gfs2.h"
30
#include "incore.h"
David Teigland's avatar
David Teigland committed
31 32 33 34 35 36 37 38 39 40
#include "bmap.h"
#include "dir.h"
#include "glock.h"
#include "glops.h"
#include "inode.h"
#include "log.h"
#include "meta_io.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
41
#include "util.h"
David Teigland's avatar
David Teigland committed
42 43 44 45 46

/**
 * gfs2_llseek - seek to a location in a file
 * @file: the file
 * @offset: the offset
47
 * @whence: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
David Teigland's avatar
David Teigland committed
48 49 50 51 52 53 54
 *
 * SEEK_END requires the glock for the file because it references the
 * file's size.
 *
 * Returns: The new offset, or errno
 */

55
static loff_t gfs2_llseek(struct file *file, loff_t offset, int whence)
David Teigland's avatar
David Teigland committed
56
{
57
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
David Teigland's avatar
David Teigland committed
58 59 60
	struct gfs2_holder i_gh;
	loff_t error;

61
	switch (whence) {
62 63 64
	case SEEK_END: /* These reference inode->i_size */
	case SEEK_DATA:
	case SEEK_HOLE:
David Teigland's avatar
David Teigland committed
65 66 67
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
					   &i_gh);
		if (!error) {
68
			error = generic_file_llseek(file, offset, whence);
David Teigland's avatar
David Teigland committed
69 70
			gfs2_glock_dq_uninit(&i_gh);
		}
71 72 73
		break;
	case SEEK_CUR:
	case SEEK_SET:
74
		error = generic_file_llseek(file, offset, whence);
75 76 77 78
		break;
	default:
		error = -EINVAL;
	}
David Teigland's avatar
David Teigland committed
79 80 81 82 83

	return error;
}

/**
84
 * gfs2_readdir - Read directory entries from a directory
David Teigland's avatar
David Teigland committed
85 86 87 88 89 90 91
 * @file: The directory to read from
 * @dirent: Buffer for dirents
 * @filldir: Function used to do the copying
 *
 * Returns: errno
 */

92
static int gfs2_readdir(struct file *file, void *dirent, filldir_t filldir)
David Teigland's avatar
David Teigland committed
93
{
94
	struct inode *dir = file->f_mapping->host;
95
	struct gfs2_inode *dip = GFS2_I(dir);
David Teigland's avatar
David Teigland committed
96
	struct gfs2_holder d_gh;
97
	u64 offset = file->f_pos;
David Teigland's avatar
David Teigland committed
98 99
	int error;

100 101
	gfs2_holder_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
	error = gfs2_glock_nq(&d_gh);
David Teigland's avatar
David Teigland committed
102 103 104 105 106
	if (error) {
		gfs2_holder_uninit(&d_gh);
		return error;
	}

107
	error = gfs2_dir_read(dir, &offset, dirent, filldir, &file->f_ra);
David Teigland's avatar
David Teigland committed
108 109 110 111 112 113 114 115

	gfs2_glock_dq_uninit(&d_gh);

	file->f_pos = offset;

	return error;
}

116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
/**
 * fsflags_cvt
 * @table: A table of 32 u32 flags
 * @val: a 32 bit value to convert
 *
 * This function can be used to convert between fsflags values and
 * GFS2's own flags values.
 *
 * Returns: the converted flags
 */
static u32 fsflags_cvt(const u32 *table, u32 val)
{
	u32 res = 0;
	while(val) {
		if (val & 1)
			res |= *table;
		table++;
		val >>= 1;
	}
	return res;
}
David Teigland's avatar
David Teigland committed
137

138 139 140 141 142 143
static const u32 fsflags_to_gfs2[32] = {
	[3] = GFS2_DIF_SYNC,
	[4] = GFS2_DIF_IMMUTABLE,
	[5] = GFS2_DIF_APPENDONLY,
	[7] = GFS2_DIF_NOATIME,
	[12] = GFS2_DIF_EXHASH,
144
	[14] = GFS2_DIF_INHERIT_JDATA,
145
	[17] = GFS2_DIF_TOPDIR,
146 147
};

148 149 150 151 152 153
static const u32 gfs2_to_fsflags[32] = {
	[gfs2fl_Sync] = FS_SYNC_FL,
	[gfs2fl_Immutable] = FS_IMMUTABLE_FL,
	[gfs2fl_AppendOnly] = FS_APPEND_FL,
	[gfs2fl_NoAtime] = FS_NOATIME_FL,
	[gfs2fl_ExHash] = FS_INDEX_FL,
154
	[gfs2fl_TopLevel] = FS_TOPDIR_FL,
155
	[gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,
156
};
157

158
static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
159
{
160
	struct inode *inode = filp->f_path.dentry->d_inode;
161
	struct gfs2_inode *ip = GFS2_I(inode);
162 163
	struct gfs2_holder gh;
	int error;
164
	u32 fsflags;
165

166 167
	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
	error = gfs2_glock_nq(&gh);
168 169
	if (error)
		return error;
170

171 172
	fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_diskflags);
	if (!S_ISDIR(inode->i_mode) && ip->i_diskflags & GFS2_DIF_JDATA)
173
		fsflags |= FS_JOURNAL_DATA_FL;
174
	if (put_user(fsflags, ptr))
175 176
		error = -EFAULT;

177
	gfs2_glock_dq(&gh);
178 179 180 181
	gfs2_holder_uninit(&gh);
	return error;
}

182 183 184 185 186
void gfs2_set_inode_flags(struct inode *inode)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	unsigned int flags = inode->i_flags;

Steven Whitehouse's avatar
Steven Whitehouse committed
187 188 189
	flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_NOSEC);
	if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode))
		inode->i_flags |= S_NOSEC;
190
	if (ip->i_diskflags & GFS2_DIF_IMMUTABLE)
191
		flags |= S_IMMUTABLE;
192
	if (ip->i_diskflags & GFS2_DIF_APPENDONLY)
193
		flags |= S_APPEND;
194
	if (ip->i_diskflags & GFS2_DIF_NOATIME)
195
		flags |= S_NOATIME;
196
	if (ip->i_diskflags & GFS2_DIF_SYNC)
197 198 199 200
		flags |= S_SYNC;
	inode->i_flags = flags;
}

201 202 203 204 205 206 207
/* Flags that can be set by user space */
#define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA|			\
			     GFS2_DIF_IMMUTABLE|		\
			     GFS2_DIF_APPENDONLY|		\
			     GFS2_DIF_NOATIME|			\
			     GFS2_DIF_SYNC|			\
			     GFS2_DIF_SYSTEM|			\
208
			     GFS2_DIF_TOPDIR|			\
209 210 211 212 213 214 215 216 217
			     GFS2_DIF_INHERIT_JDATA)

/**
 * gfs2_set_flags - set flags on an inode
 * @inode: The inode
 * @flags: The flags to set
 * @mask: Indicates which flags are valid
 *
 */
218
static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
219
{
220
	struct inode *inode = filp->f_path.dentry->d_inode;
221 222
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
223 224 225
	struct buffer_head *bh;
	struct gfs2_holder gh;
	int error;
226
	u32 new_flags, flags;
227

228
	error = mnt_want_write_file(filp);
229
	if (error)
230 231
		return error;

232 233 234 235
	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
	if (error)
		goto out_drop_write;

236
	error = -EACCES;
237
	if (!inode_owner_or_capable(inode))
238 239 240
		goto out;

	error = 0;
241
	flags = ip->i_diskflags;
242
	new_flags = (flags & ~mask) | (reqflags & mask);
243 244 245 246 247 248 249 250 251 252 253 254
	if ((new_flags ^ flags) == 0)
		goto out;

	error = -EINVAL;
	if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)
		goto out;

	error = -EPERM;
	if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))
		goto out;
	if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))
		goto out;
255
	if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
256
	    !capable(CAP_LINUX_IMMUTABLE))
257
		goto out;
258
	if (!IS_IMMUTABLE(inode)) {
259
		error = gfs2_permission(inode, MAY_WRITE);
260 261 262
		if (error)
			goto out;
	}
263 264 265 266 267 268 269 270 271 272
	if ((flags ^ new_flags) & GFS2_DIF_JDATA) {
		if (flags & GFS2_DIF_JDATA)
			gfs2_log_flush(sdp, ip->i_gl);
		error = filemap_fdatawrite(inode->i_mapping);
		if (error)
			goto out;
		error = filemap_fdatawait(inode->i_mapping);
		if (error)
			goto out;
	}
273
	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
274 275
	if (error)
		goto out;
276 277 278
	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error)
		goto out_trans_end;
279
	gfs2_trans_add_meta(ip->i_gl, bh);
280
	ip->i_diskflags = new_flags;
281
	gfs2_dinode_out(ip, bh->b_data);
282
	brelse(bh);
283
	gfs2_set_inode_flags(inode);
284
	gfs2_set_aops(inode);
285 286
out_trans_end:
	gfs2_trans_end(sdp);
287 288
out:
	gfs2_glock_dq_uninit(&gh);
289
out_drop_write:
Al Viro's avatar
Al Viro committed
290
	mnt_drop_write_file(filp);
291 292 293
	return error;
}

294
static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
295
{
296
	struct inode *inode = filp->f_path.dentry->d_inode;
297
	u32 fsflags, gfsflags;
298

299
	if (get_user(fsflags, ptr))
300
		return -EFAULT;
301

302
	gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);
303
	if (!S_ISDIR(inode->i_mode)) {
304
		gfsflags &= ~GFS2_DIF_TOPDIR;
305 306 307 308 309
		if (gfsflags & GFS2_DIF_INHERIT_JDATA)
			gfsflags ^= (GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA);
		return do_gfs2_set_flags(filp, gfsflags, ~0);
	}
	return do_gfs2_set_flags(filp, gfsflags, ~GFS2_DIF_JDATA);
310 311
}

312
static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
313 314
{
	switch(cmd) {
315
	case FS_IOC_GETFLAGS:
316
		return gfs2_get_flags(filp, (u32 __user *)arg);
317
	case FS_IOC_SETFLAGS:
318
		return gfs2_set_flags(filp, (u32 __user *)arg);
Steven Whitehouse's avatar
Steven Whitehouse committed
319 320
	case FITRIM:
		return gfs2_fitrim(filp, (void __user *)arg);
321 322 323 324
	}
	return -ENOTTY;
}

325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
/**
 * gfs2_size_hint - Give a hint to the size of a write request
 * @file: The struct file
 * @offset: The file offset of the write
 * @size: The length of the write
 *
 * When we are about to do a write, this function records the total
 * write size in order to provide a suitable hint to the lower layers
 * about how many blocks will be required.
 *
 */

static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size)
{
	struct inode *inode = filep->f_dentry->d_inode;
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	struct gfs2_inode *ip = GFS2_I(inode);
	size_t blks = (size + sdp->sd_sb.sb_bsize - 1) >> sdp->sd_sb.sb_bsize_shift;
	int hint = min_t(size_t, INT_MAX, blks);

	atomic_set(&ip->i_res->rs_sizehint, hint);
}

348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
/**
 * gfs2_allocate_page_backing - Use bmap to allocate blocks
 * @page: The (locked) page to allocate backing for
 *
 * We try to allocate all the blocks required for the page in
 * one go. This might fail for various reasons, so we keep
 * trying until all the blocks to back this page are allocated.
 * If some of the blocks are already allocated, thats ok too.
 */

static int gfs2_allocate_page_backing(struct page *page)
{
	struct inode *inode = page->mapping->host;
	struct buffer_head bh;
	unsigned long size = PAGE_CACHE_SIZE;
	u64 lblock = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);

	do {
		bh.b_state = 0;
		bh.b_size = size;
368
		gfs2_block_map(inode, lblock, &bh, 1);
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
		if (!buffer_mapped(&bh))
			return -EIO;
		size -= bh.b_size;
		lblock += (bh.b_size >> inode->i_blkbits);
	} while(size > 0);
	return 0;
}

/**
 * gfs2_page_mkwrite - Make a shared, mmap()ed, page writable
 * @vma: The virtual memory area
 * @page: The page which is about to become writable
 *
 * When the page becomes writable, we need to ensure that we have
 * blocks allocated on disk to back that page.
 */

386
static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
387
{
388
	struct page *page = vmf->page;
389 390 391 392
	struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	unsigned long last_index;
393
	u64 pos = page->index << PAGE_CACHE_SHIFT;
394 395
	unsigned int data_blocks, ind_blocks, rblocks;
	struct gfs2_holder gh;
396
	loff_t size;
397 398
	int ret;

399
	sb_start_pagefault(inode->i_sb);
400

401 402
	/* Update file times before taking page lock */
	file_update_time(vma->vm_file);
403

404 405 406 407
	ret = gfs2_rs_alloc(ip);
	if (ret)
		return ret;

408
	gfs2_size_hint(vma->vm_file, pos, PAGE_CACHE_SIZE);
Bob Peterson's avatar
Bob Peterson committed
409

410 411
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
	ret = gfs2_glock_nq(&gh);
412 413 414
	if (ret)
		goto out;

415 416 417
	set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
	set_bit(GIF_SW_PAGED, &ip->i_flags);

418 419 420 421 422 423
	if (!gfs2_write_alloc_required(ip, pos, PAGE_CACHE_SIZE)) {
		lock_page(page);
		if (!PageUptodate(page) || page->mapping != inode->i_mapping) {
			ret = -EAGAIN;
			unlock_page(page);
		}
424
		goto out_unlock;
425 426
	}

427 428
	ret = gfs2_rindex_update(sdp);
	if (ret)
429 430
		goto out_unlock;

431
	ret = gfs2_quota_lock_check(ip);
432
	if (ret)
433
		goto out_unlock;
434
	gfs2_write_calc_reserv(ip, PAGE_CACHE_SIZE, &data_blocks, &ind_blocks);
Steven Whitehouse's avatar
Steven Whitehouse committed
435
	ret = gfs2_inplace_reserve(ip, data_blocks + ind_blocks, 0);
436 437 438 439 440 441
	if (ret)
		goto out_quota_unlock;

	rblocks = RES_DINODE + ind_blocks;
	if (gfs2_is_jdata(ip))
		rblocks += data_blocks ? data_blocks : 1;
442
	if (ind_blocks || data_blocks) {
443
		rblocks += RES_STATFS + RES_QUOTA;
444
		rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks);
445
	}
446 447 448 449 450 451
	ret = gfs2_trans_begin(sdp, rblocks, 0);
	if (ret)
		goto out_trans_fail;

	lock_page(page);
	ret = -EINVAL;
452 453 454 455 456 457 458 459 460 461 462 463 464 465
	size = i_size_read(inode);
	last_index = (size - 1) >> PAGE_CACHE_SHIFT;
	/* Check page index against inode size */
	if (size == 0 || (page->index > last_index))
		goto out_trans_end;

	ret = -EAGAIN;
	/* If truncated, we must retry the operation, we may have raced
	 * with the glock demotion code.
	 */
	if (!PageUptodate(page) || page->mapping != inode->i_mapping)
		goto out_trans_end;

	/* Unstuff, if required, and allocate backing blocks for page */
466
	ret = 0;
467
	if (gfs2_is_stuffed(ip))
468
		ret = gfs2_unstuff_dinode(ip, page);
469 470
	if (ret == 0)
		ret = gfs2_allocate_page_backing(page);
471

472 473 474
out_trans_end:
	if (ret)
		unlock_page(page);
475 476 477 478 479 480 481 482 483
	gfs2_trans_end(sdp);
out_trans_fail:
	gfs2_inplace_release(ip);
out_quota_unlock:
	gfs2_quota_unlock(ip);
out_unlock:
	gfs2_glock_dq(&gh);
out:
	gfs2_holder_uninit(&gh);
484 485
	if (ret == 0) {
		set_page_dirty(page);
486
		wait_on_page_writeback(page);
487
	}
488
	sb_end_pagefault(inode->i_sb);
489
	return block_page_mkwrite_return(ret);
490 491
}

492
static const struct vm_operations_struct gfs2_vm_ops = {
493 494
	.fault = filemap_fault,
	.page_mkwrite = gfs2_page_mkwrite,
495
	.remap_pages = generic_file_remap_pages,
496 497
};

David Teigland's avatar
David Teigland committed
498 499 500 501 502
/**
 * gfs2_mmap -
 * @file: The file to map
 * @vma: The VMA which described the mapping
 *
503 504 505 506 507
 * There is no need to get a lock here unless we should be updating
 * atime. We ignore any locking errors since the only consequence is
 * a missed atime update (which will just be deferred until later).
 *
 * Returns: 0
David Teigland's avatar
David Teigland committed
508 509 510 511
 */

static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
{
512
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
David Teigland's avatar
David Teigland committed
513

514 515
	if (!(file->f_flags & O_NOATIME) &&
	    !IS_NOATIME(&ip->i_inode)) {
516 517
		struct gfs2_holder i_gh;
		int error;
David Teigland's avatar
David Teigland committed
518

519 520
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
					   &i_gh);
521 522
		if (error)
			return error;
523 524 525
		/* grab lock to update inode */
		gfs2_glock_dq_uninit(&i_gh);
		file_accessed(file);
526
	}
527
	vma->vm_ops = &gfs2_vm_ops;
David Teigland's avatar
David Teigland committed
528

529
	return 0;
David Teigland's avatar
David Teigland committed
530 531 532 533 534 535 536 537 538 539 540 541
}

/**
 * gfs2_open - open a file
 * @inode: the inode to open
 * @file: the struct file for this opening
 *
 * Returns: errno
 */

static int gfs2_open(struct inode *inode, struct file *file)
{
542
	struct gfs2_inode *ip = GFS2_I(inode);
David Teigland's avatar
David Teigland committed
543 544 545 546 547 548 549 550
	struct gfs2_holder i_gh;
	struct gfs2_file *fp;
	int error;

	fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
	if (!fp)
		return -ENOMEM;

551
	mutex_init(&fp->f_fl_mutex);
David Teigland's avatar
David Teigland committed
552

553
	gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
554
	file->private_data = fp;
David Teigland's avatar
David Teigland committed
555

556
	if (S_ISREG(ip->i_inode.i_mode)) {
David Teigland's avatar
David Teigland committed
557 558 559 560 561 562
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
					   &i_gh);
		if (error)
			goto fail;

		if (!(file->f_flags & O_LARGEFILE) &&
Steven Whitehouse's avatar
Steven Whitehouse committed
563
		    i_size_read(inode) > MAX_NON_LFS) {
564
			error = -EOVERFLOW;
David Teigland's avatar
David Teigland committed
565 566 567 568 569 570 571 572
			goto fail_gunlock;
		}

		gfs2_glock_dq_uninit(&i_gh);
	}

	return 0;

573
fail_gunlock:
David Teigland's avatar
David Teigland committed
574
	gfs2_glock_dq_uninit(&i_gh);
575
fail:
576
	file->private_data = NULL;
David Teigland's avatar
David Teigland committed
577 578 579 580 581
	kfree(fp);
	return error;
}

/**
582
 * gfs2_release - called to close a struct file
David Teigland's avatar
David Teigland committed
583 584 585 586 587 588
 * @inode: the inode the struct file belongs to
 * @file: the struct file being closed
 *
 * Returns: errno
 */

589
static int gfs2_release(struct inode *inode, struct file *file)
David Teigland's avatar
David Teigland committed
590
{
591
	struct gfs2_inode *ip = GFS2_I(inode);
David Teigland's avatar
David Teigland committed
592

Bob Peterson's avatar
Bob Peterson committed
593
	kfree(file->private_data);
594
	file->private_data = NULL;
David Teigland's avatar
David Teigland committed
595

Bob Peterson's avatar
Bob Peterson committed
596
	if ((file->f_mode & FMODE_WRITE) &&
597 598 599
	    (atomic_read(&inode->i_writecount) == 1))
		gfs2_rs_delete(ip);

David Teigland's avatar
David Teigland committed
600 601 602 603 604
	return 0;
}

/**
 * gfs2_fsync - sync the dirty data for a file (across the cluster)
605 606 607
 * @file: the file that points to the dentry
 * @start: the start position in the file to sync
 * @end: the end position in the file to sync
Steven Whitehouse's avatar
Steven Whitehouse committed
608
 * @datasync: set if we can ignore timestamp changes
David Teigland's avatar
David Teigland committed
609
 *
610 611 612 613 614 615 616 617 618 619
 * We split the data flushing here so that we don't wait for the data
 * until after we've also sent the metadata to disk. Note that for
 * data=ordered, we will write & wait for the data at the log flush
 * stage anyway, so this is unlikely to make much of a difference
 * except in the data=writeback case.
 *
 * If the fdatawrite fails due to any reason except -EIO, we will
 * continue the remainder of the fsync, although we'll still report
 * the error at the end. This is to match filemap_write_and_wait_range()
 * behaviour.
620
 *
David Teigland's avatar
David Teigland committed
621 622 623
 * Returns: errno
 */

624 625
static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
		      int datasync)
David Teigland's avatar
David Teigland committed
626
{
627 628
	struct address_space *mapping = file->f_mapping;
	struct inode *inode = mapping->host;
629
	int sync_state = inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC);
Steven Whitehouse's avatar
Steven Whitehouse committed
630
	struct gfs2_inode *ip = GFS2_I(inode);
631
	int ret = 0, ret1 = 0;
David Teigland's avatar
David Teigland committed
632

633 634 635 636 637
	if (mapping->nrpages) {
		ret1 = filemap_fdatawrite_range(mapping, start, end);
		if (ret1 == -EIO)
			return ret1;
	}
638

Steven Whitehouse's avatar
Steven Whitehouse committed
639 640
	if (datasync)
		sync_state &= ~I_DIRTY_SYNC;
David Teigland's avatar
David Teigland committed
641

Steven Whitehouse's avatar
Steven Whitehouse committed
642 643
	if (sync_state) {
		ret = sync_inode_metadata(inode, 1);
644
		if (ret)
Steven Whitehouse's avatar
Steven Whitehouse committed
645
			return ret;
646 647
		if (gfs2_is_jdata(ip))
			filemap_write_and_wait(mapping);
648
		gfs2_ail_flush(ip->i_gl, 1);
649 650
	}

651 652 653 654
	if (mapping->nrpages)
		ret = filemap_fdatawait_range(mapping, start, end);

	return ret ? ret : ret1;
David Teigland's avatar
David Teigland committed
655 656
}

657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
/**
 * gfs2_file_aio_write - Perform a write to a file
 * @iocb: The io context
 * @iov: The data to write
 * @nr_segs: Number of @iov segments
 * @pos: The file position
 *
 * We have to do a lock/unlock here to refresh the inode size for
 * O_APPEND writes, otherwise we can land up writing at the wrong
 * offset. There is still a race, but provided the app is using its
 * own file locking, this will make O_APPEND work as expected.
 *
 */

static ssize_t gfs2_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
				   unsigned long nr_segs, loff_t pos)
{
	struct file *file = iocb->ki_filp;
Bob Peterson's avatar
Bob Peterson committed
675
	size_t writesize = iov_length(iov, nr_segs);
676 677 678 679 680 681 682
	struct dentry *dentry = file->f_dentry;
	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
	int ret;

	ret = gfs2_rs_alloc(ip);
	if (ret)
		return ret;
683

684 685
	gfs2_size_hint(file, pos, writesize);

686 687 688 689 690 691 692 693 694 695 696 697
	if (file->f_flags & O_APPEND) {
		struct gfs2_holder gh;

		ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
		if (ret)
			return ret;
		gfs2_glock_dq_uninit(&gh);
	}

	return generic_file_aio_write(iocb, iov, nr_segs, pos);
}

698 699 700 701 702 703
static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,
			   int mode)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct buffer_head *dibh;
	int error;
704
	loff_t size = len;
705 706
	unsigned int nr_blks;
	sector_t lblock = offset >> inode->i_blkbits;
707 708 709

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (unlikely(error))
710
		return error;
711

712
	gfs2_trans_add_meta(ip->i_gl, dibh);
713 714 715 716 717 718 719

	if (gfs2_is_stuffed(ip)) {
		error = gfs2_unstuff_dinode(ip, NULL);
		if (unlikely(error))
			goto out;
	}

720 721 722 723
	while (len) {
		struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
		bh_map.b_size = len;
		set_buffer_zeronew(&bh_map);
724

725 726 727 728 729 730 731 732 733 734
		error = gfs2_block_map(inode, lblock, &bh_map, 1);
		if (unlikely(error))
			goto out;
		len -= bh_map.b_size;
		nr_blks = bh_map.b_size >> inode->i_blkbits;
		lblock += nr_blks;
		if (!buffer_new(&bh_map))
			continue;
		if (unlikely(!buffer_zeronew(&bh_map))) {
			error = -EIO;
735
			goto out;
736
		}
737
	}
738 739
	if (offset + size > inode->i_size && !(mode & FALLOC_FL_KEEP_SIZE))
		i_size_write(inode, offset + size);
740 741 742 743

	mark_inode_dirty(inode);

out:
744
	brelse(dibh);
745 746 747 748 749 750 751
	return error;
}

static void calc_max_reserv(struct gfs2_inode *ip, loff_t max, loff_t *len,
			    unsigned int *data_blocks, unsigned int *ind_blocks)
{
	const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
752
	unsigned int max_blocks = ip->i_rgd->rd_free_clone;
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
	unsigned int tmp, max_data = max_blocks - 3 * (sdp->sd_max_height - 1);

	for (tmp = max_data; tmp > sdp->sd_diptrs;) {
		tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);
		max_data -= tmp;
	}
	/* This calculation isn't the exact reverse of gfs2_write_calc_reserve,
	   so it might end up with fewer data blocks */
	if (max_data <= *data_blocks)
		return;
	*data_blocks = max_data;
	*ind_blocks = max_blocks - max_data;
	*len = ((loff_t)max_data - 3) << sdp->sd_sb.sb_bsize_shift;
	if (*len > max) {
		*len = max;
		gfs2_write_calc_reserv(ip, max, data_blocks, ind_blocks);
	}
}

static long gfs2_fallocate(struct file *file, int mode, loff_t offset,
			   loff_t len)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	struct gfs2_inode *ip = GFS2_I(inode);
	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
	loff_t bytes, max_bytes;
	int error;
781 782
	const loff_t pos = offset;
	const loff_t count = len;
783
	loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1);
784
	loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift;
785
	loff_t max_chunk_size = UINT_MAX & bsize_mask;
786 787 788 789 790 791
	next = (next + 1) << sdp->sd_sb.sb_bsize_shift;

	/* We only support the FALLOC_FL_KEEP_SIZE mode */
	if (mode & ~FALLOC_FL_KEEP_SIZE)
		return -EOPNOTSUPP;

792
	offset &= bsize_mask;
793 794 795 796 797

	len = next - offset;
	bytes = sdp->sd_max_rg_data * sdp->sd_sb.sb_bsize / 2;
	if (!bytes)
		bytes = UINT_MAX;
798 799 800
	bytes &= bsize_mask;
	if (bytes == 0)
		bytes = sdp->sd_sb.sb_bsize;
801

802 803 804 805
	error = gfs2_rs_alloc(ip);
	if (error)
		return error;

806 807 808 809 810
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
	error = gfs2_glock_nq(&ip->i_gh);
	if (unlikely(error))
		goto out_uninit;

811
	gfs2_size_hint(file, offset, len);
Bob Peterson's avatar
Bob Peterson committed
812

813 814 815
	while (len > 0) {
		if (len < bytes)
			bytes = len;
816 817 818 819 820
		if (!gfs2_write_alloc_required(ip, offset, bytes)) {
			len -= bytes;
			offset += bytes;
			continue;
		}
821 822
		error = gfs2_quota_lock_check(ip);
		if (error)
823
			goto out_unlock;
824 825 826 827

retry:
		gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks);

Steven Whitehouse's avatar
Steven Whitehouse committed
828
		error = gfs2_inplace_reserve(ip, data_blocks + ind_blocks, 0);
829 830 831
		if (error) {
			if (error == -ENOSPC && bytes > sdp->sd_sb.sb_bsize) {
				bytes >>= 1;
832 833 834
				bytes &= bsize_mask;
				if (bytes == 0)
					bytes = sdp->sd_sb.sb_bsize;
835 836 837 838 839
				goto retry;
			}
			goto out_qunlock;
		}
		max_bytes = bytes;
840 841
		calc_max_reserv(ip, (len > max_chunk_size)? max_chunk_size: len,
				&max_bytes, &data_blocks, &ind_blocks);
842 843

		rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA +
844
			  RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks);
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
		if (gfs2_is_jdata(ip))
			rblocks += data_blocks ? data_blocks : 1;

		error = gfs2_trans_begin(sdp, rblocks,
					 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
		if (error)
			goto out_trans_fail;

		error = fallocate_chunk(inode, offset, max_bytes, mode);
		gfs2_trans_end(sdp);

		if (error)
			goto out_trans_fail;

		len -= max_bytes;
		offset += max_bytes;
		gfs2_inplace_release(ip);
		gfs2_quota_unlock(ip);
	}
864 865 866

	if (error == 0)
		error = generic_write_sync(file, pos, count);
867 868 869 870 871 872 873 874 875 876 877 878 879
	goto out_unlock;

out_trans_fail:
	gfs2_inplace_release(ip);
out_qunlock:
	gfs2_quota_unlock(ip);
out_unlock:
	gfs2_glock_dq(&ip->i_gh);
out_uninit:
	gfs2_holder_uninit(&ip->i_gh);
	return error;
}

880 881
#ifdef CONFIG_GFS2_FS_LOCKING_DLM

882 883 884 885 886 887
/**
 * gfs2_setlease - acquire/release a file lease
 * @file: the file pointer
 * @arg: lease type
 * @fl: file lock
 *
888 889 890 891
 * We don't currently have a way to enforce a lease across the whole
 * cluster; until we do, disable leases (by just returning -EINVAL),
 * unless the administrator has requested purely local locking.
 *
892 893
 * Locking: called under lock_flocks
 *
894 895 896 897 898
 * Returns: errno
 */

static int gfs2_setlease(struct file *file, long arg, struct file_lock **fl)
{
899
	return -EINVAL;
900 901
}

David Teigland's avatar
David Teigland committed
902 903 904 905 906 907 908 909 910 911 912
/**
 * gfs2_lock - acquire/release a posix lock on a file
 * @file: the file pointer
 * @cmd: either modify or retrieve lock state, possibly wait
 * @fl: type and range of lock
 *
 * Returns: errno
 */

static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
{
913 914
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
915
	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
David Teigland's avatar
David Teigland committed
916 917 918

	if (!(fl->fl_flags & FL_POSIX))
		return -ENOLCK;
919
	if (__mandatory_lock(&ip->i_inode) && fl->fl_type != F_UNLCK)
David Teigland's avatar
David Teigland committed
920 921
		return -ENOLCK;

Marc Eshel's avatar
Marc Eshel committed
922 923 924 925 926
	if (cmd == F_CANCELLK) {
		/* Hack: */
		cmd = F_SETLK;
		fl->fl_type = F_UNLCK;
	}
927 928
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
		return -EIO;
David Teigland's avatar
David Teigland committed
929
	if (IS_GETLK(cmd))
930
		return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl);
David Teigland's avatar
David Teigland committed
931
	else if (fl->fl_type == F_UNLCK)
932
		return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl);
David Teigland's avatar
David Teigland committed
933
	else
934
		return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl);
David Teigland's avatar
David Teigland committed
935 936 937 938
}

static int do_flock(struct file *file, int cmd, struct file_lock *fl)
{
939
	struct gfs2_file *fp = file->private_data;
David Teigland's avatar
David Teigland committed
940
	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
941
	struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);
David Teigland's avatar
David Teigland committed
942 943 944 945 946 947
	struct gfs2_glock *gl;
	unsigned int state;
	int flags;
	int error = 0;

	state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
948
	flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE;
David Teigland's avatar
David Teigland committed
949

950
	mutex_lock(&fp->f_fl_mutex);
David Teigland's avatar
David Teigland committed
951 952 953 954 955 956

	gl = fl_gh->gh_gl;
	if (gl) {
		if (fl_gh->gh_state == state)
			goto out;
		flock_lock_file_wait(file,
957
				     &(struct file_lock){.fl_type = F_UNLCK});
958 959
		gfs2_glock_dq_wait(fl_gh);
		gfs2_holder_reinit(state, flags, fl_gh);
David Teigland's avatar
David Teigland committed
960
	} else {
961 962
		error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr,
				       &gfs2_flock_glops, CREATE, &gl);
David Teigland's avatar
David Teigland committed
963 964
		if (error)
			goto out;
965 966
		gfs2_holder_init(gl, state, flags, fl_gh);
		gfs2_glock_put(gl);
David Teigland's avatar
David Teigland committed
967 968 969 970 971 972 973 974
	}
	error = gfs2_glock_nq(fl_gh);
	if (error) {
		gfs2_holder_uninit(fl_gh);
		if (error == GLR_TRYFAILED)
			error = -EAGAIN;
	} else {
		error = flock_lock_file_wait(file, fl);
975
		gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
David Teigland's avatar
David Teigland committed
976 977
	}

978
out:
979
	mutex_unlock(&fp->f_fl_mutex);
David Teigland's avatar
David Teigland committed
980 981 982 983 984
	return error;
}

static void do_unflock(struct file *file, struct file_lock *fl)
{
985
	struct gfs2_file *fp = file->private_data;
David Teigland's avatar
David Teigland committed
986 987
	struct gfs2_holder *fl_gh = &fp->f_fl_gh;

988
	mutex_lock(&fp->f_fl_mutex);
David Teigland's avatar
David Teigland committed
989
	flock_lock_file_wait(file, fl);
990 991 992 993
	if (fl_gh->gh_gl) {
		gfs2_glock_dq_wait(fl_gh);
		gfs2_holder_uninit(fl_gh);
	}
994
	mutex_unlock(&fp->f_fl_mutex);
David Teigland's avatar
David Teigland committed
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
}

/**
 * gfs2_flock - acquire/release a flock lock on a file
 * @file: the file pointer
 * @cmd: either modify or retrieve lock state, possibly wait
 * @fl: type and range of lock
 *
 * Returns: errno
 */

static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
{
	if (!(fl->fl_flags & FL_FLOCK))
		return -ENOLCK;
1010 1011
	if (fl->fl_type & LOCK_MAND)
		return -EOPNOTSUPP;
David Teigland's avatar
David Teigland committed
1012 1013 1014 1015

	if (fl->fl_type == F_UNLCK) {
		do_unflock(file, fl);
		return 0;
1016
	} else {
David Teigland's avatar
David Teigland committed
1017
		return do_flock(file, cmd, fl);
1018
	}
David Teigland's avatar
David Teigland committed
1019 1020
}

1021
const struct file_operations gfs2_file_fops = {
1022
	.llseek		= gfs2_llseek,
1023
	.read		= do_sync_read,
1024
	.aio_read	= generic_file_aio_read,
1025
	.write		= do_sync_write,
1026
	.aio_write	= gfs2_file_aio_write,
1027 1028 1029
	.unlocked_ioctl	= gfs2_ioctl,
	.mmap		= gfs2_mmap,
	.open		= gfs2_open,
1030
	.release	= gfs2_release,
1031 1032 1033 1034 1035
	.fsync		= gfs2_fsync,
	.lock		= gfs2_lock,
	.flock		= gfs2_flock,
	.splice_read	= generic_file_splice_read,
	.splice_write	= generic_file_splice_write,
1036
	.setlease	= gfs2_setlease,
1037
	.fallocate	= gfs2_fallocate,
David Teigland's avatar
David Teigland committed
1038 1039
};

1040
const struct file_operations gfs2_dir_fops = {
1041 1042 1043
	.readdir	= gfs2_readdir,
	.unlocked_ioctl	= gfs2_ioctl,
	.open		= gfs2_open,
1044
	.release	= gfs2_release