file.c 26.4 KB
Newer Older
D
David Teigland 已提交
1 2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
D
David Teigland 已提交
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.
D
David Teigland 已提交
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>
M
Miklos Szeredi 已提交
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>
D
David Teigland 已提交
25
#include <asm/uaccess.h>
26 27
#include <linux/dlm.h>
#include <linux/dlm_plock.h>
D
David Teigland 已提交
28 29

#include "gfs2.h"
30
#include "incore.h"
D
David Teigland 已提交
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"
D
David Teigland 已提交
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

/**
 * gfs2_llseek - seek to a location in a file
 * @file: the file
 * @offset: the offset
 * @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
 *
 * SEEK_END requires the glock for the file because it references the
 * file's size.
 *
 * Returns: The new offset, or errno
 */

static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
{
57
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
D
David Teigland 已提交
58 59 60
	struct gfs2_holder i_gh;
	loff_t error;

61 62 63 64
	switch (origin) {
	case SEEK_END: /* These reference inode->i_size */
	case SEEK_DATA:
	case SEEK_HOLE:
D
David Teigland 已提交
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, origin);
D
David Teigland 已提交
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, origin);
75 76 77 78
		break;
	default:
		error = -EINVAL;
	}
D
David Teigland 已提交
79 80 81 82 83

	return error;
}

/**
84
 * gfs2_readdir - Read directory entries from a directory
D
David Teigland 已提交
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)
D
David Teigland 已提交
93
{
94
	struct inode *dir = file->f_mapping->host;
95
	struct gfs2_inode *dip = GFS2_I(dir);
D
David Teigland 已提交
96
	struct gfs2_holder d_gh;
97
	u64 offset = file->f_pos;
D
David Teigland 已提交
98 99
	int error;

100 101
	gfs2_holder_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
	error = gfs2_glock_nq(&d_gh);
D
David Teigland 已提交
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);
D
David Teigland 已提交
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;
}
D
David Teigland 已提交
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
{
J
Josef Sipek 已提交
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;

S
Steven Whitehouse 已提交
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
{
J
Josef Sipek 已提交
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;

M
Miklos Szeredi 已提交
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_bh(ip->i_gl, bh, 1);
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);
M
Miklos Szeredi 已提交
289
out_drop_write:
A
Al Viro 已提交
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);
S
Steven Whitehouse 已提交
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;
S
Steven Whitehouse 已提交
396
	loff_t size;
397 398
	int ret;

399
	sb_start_pagefault(inode->i_sb);
S
Steven Whitehouse 已提交
400

401 402
	/* Update file times before taking page lock */
	file_update_time(vma->vm_file);
S
Steven Whitehouse 已提交
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);
B
Bob Peterson 已提交
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);

S
Steven Whitehouse 已提交
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;
S
Steven Whitehouse 已提交
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);
435
	ret = gfs2_inplace_reserve(ip, data_blocks + ind_blocks);
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;
S
Steven Whitehouse 已提交
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;
S
Steven Whitehouse 已提交
467
	if (gfs2_is_stuffed(ip))
468
		ret = gfs2_unstuff_dinode(ip, page);
S
Steven Whitehouse 已提交
469 470
	if (ret == 0)
		ret = gfs2_allocate_page_backing(page);
471

S
Steven Whitehouse 已提交
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);
S
Steven Whitehouse 已提交
484 485
	if (ret == 0) {
		set_page_dirty(page);
486
		wait_on_page_writeback(page);
S
Steven Whitehouse 已提交
487
	}
488
	sb_end_pagefault(inode->i_sb);
S
Steven Whitehouse 已提交
489
	return block_page_mkwrite_return(ret);
490 491
}

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

D
David Teigland 已提交
497 498 499 500 501
/**
 * gfs2_mmap -
 * @file: The file to map
 * @vma: The VMA which described the mapping
 *
502 503 504 505 506
 * 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
D
David Teigland 已提交
507 508 509 510
 */

static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
{
511
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
D
David Teigland 已提交
512

513 514
	if (!(file->f_flags & O_NOATIME) &&
	    !IS_NOATIME(&ip->i_inode)) {
515 516
		struct gfs2_holder i_gh;
		int error;
D
David Teigland 已提交
517

518
		gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
519
		error = gfs2_glock_nq(&i_gh);
520 521 522 523 524 525 526
		if (error == 0) {
			file_accessed(file);
			gfs2_glock_dq(&i_gh);
		}
		gfs2_holder_uninit(&i_gh);
		if (error)
			return error;
527
	}
528
	vma->vm_ops = &gfs2_vm_ops;
529
	vma->vm_flags |= VM_CAN_NONLINEAR;
D
David Teigland 已提交
530

531
	return 0;
D
David Teigland 已提交
532 533 534 535 536 537 538 539 540 541 542 543
}

/**
 * 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)
{
544
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
545 546 547 548 549 550 551 552
	struct gfs2_holder i_gh;
	struct gfs2_file *fp;
	int error;

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

553
	mutex_init(&fp->f_fl_mutex);
D
David Teigland 已提交
554

555
	gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
556
	file->private_data = fp;
D
David Teigland 已提交
557

558
	if (S_ISREG(ip->i_inode.i_mode)) {
D
David Teigland 已提交
559 560 561 562 563 564
		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) &&
S
Steven Whitehouse 已提交
565
		    i_size_read(inode) > MAX_NON_LFS) {
566
			error = -EOVERFLOW;
D
David Teigland 已提交
567 568 569 570 571 572 573 574
			goto fail_gunlock;
		}

		gfs2_glock_dq_uninit(&i_gh);
	}

	return 0;

575
fail_gunlock:
D
David Teigland 已提交
576
	gfs2_glock_dq_uninit(&i_gh);
577
fail:
578
	file->private_data = NULL;
D
David Teigland 已提交
579 580 581 582 583
	kfree(fp);
	return error;
}

/**
584
 * gfs2_release - called to close a struct file
D
David Teigland 已提交
585 586 587 588 589 590
 * @inode: the inode the struct file belongs to
 * @file: the struct file being closed
 *
 * Returns: errno
 */

591
static int gfs2_release(struct inode *inode, struct file *file)
D
David Teigland 已提交
592
{
593
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
594

B
Bob Peterson 已提交
595
	kfree(file->private_data);
596
	file->private_data = NULL;
D
David Teigland 已提交
597

B
Bob Peterson 已提交
598
	if ((file->f_mode & FMODE_WRITE) &&
599 600 601
	    (atomic_read(&inode->i_writecount) == 1))
		gfs2_rs_delete(ip);

D
David Teigland 已提交
602 603 604 605 606
	return 0;
}

/**
 * gfs2_fsync - sync the dirty data for a file (across the cluster)
607 608 609
 * @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
S
Steven Whitehouse 已提交
610
 * @datasync: set if we can ignore timestamp changes
D
David Teigland 已提交
611
 *
612 613 614 615 616 617 618 619 620 621
 * 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.
622
 *
D
David Teigland 已提交
623 624 625
 * Returns: errno
 */

626 627
static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
		      int datasync)
D
David Teigland 已提交
628
{
629 630
	struct address_space *mapping = file->f_mapping;
	struct inode *inode = mapping->host;
631
	int sync_state = inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC);
S
Steven Whitehouse 已提交
632
	struct gfs2_inode *ip = GFS2_I(inode);
633
	int ret = 0, ret1 = 0;
D
David Teigland 已提交
634

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

S
Steven Whitehouse 已提交
641 642
	if (datasync)
		sync_state &= ~I_DIRTY_SYNC;
D
David Teigland 已提交
643

S
Steven Whitehouse 已提交
644 645
	if (sync_state) {
		ret = sync_inode_metadata(inode, 1);
646
		if (ret)
S
Steven Whitehouse 已提交
647
			return ret;
648 649
		if (gfs2_is_jdata(ip))
			filemap_write_and_wait(mapping);
650
		gfs2_ail_flush(ip->i_gl, 1);
651 652
	}

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

	return ret ? ret : ret1;
D
David Teigland 已提交
657 658
}

659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
/**
 * 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;
B
Bob Peterson 已提交
677
	size_t writesize = iov_length(iov, nr_segs);
678 679
	struct dentry *dentry = file->f_dentry;
	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
B
Bob Peterson 已提交
680
	struct gfs2_sbd *sdp;
681 682
	int ret;

B
Bob Peterson 已提交
683
	sdp = GFS2_SB(file->f_mapping->host);
684 685 686
	ret = gfs2_rs_alloc(ip);
	if (ret)
		return ret;
687

688 689
	gfs2_size_hint(file, pos, writesize);

690 691 692 693 694 695 696 697 698 699 700 701
	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);
}

702 703 704 705 706 707
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;
708
	loff_t size = len;
709 710
	unsigned int nr_blks;
	sector_t lblock = offset >> inode->i_blkbits;
711 712 713

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (unlikely(error))
714
		return error;
715 716 717 718 719 720 721 722 723

	gfs2_trans_add_bh(ip->i_gl, dibh, 1);

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

724 725 726 727
	while (len) {
		struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
		bh_map.b_size = len;
		set_buffer_zeronew(&bh_map);
728

729 730 731 732 733 734 735 736 737 738
		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;
739
			goto out;
740
		}
741
	}
742 743
	if (offset + size > inode->i_size && !(mode & FALLOC_FL_KEEP_SIZE))
		i_size_write(inode, offset + size);
744 745 746 747

	mark_inode_dirty(inode);

out:
748
	brelse(dibh);
749 750 751 752 753 754 755
	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);
756
	unsigned int max_blocks = ip->i_rgd->rd_free_clone;
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784
	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;
785 786
	const loff_t pos = offset;
	const loff_t count = len;
787
	loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1);
788
	loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift;
789
	loff_t max_chunk_size = UINT_MAX & bsize_mask;
790 791 792 793 794 795
	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;

796
	offset &= bsize_mask;
797 798 799 800 801

	len = next - offset;
	bytes = sdp->sd_max_rg_data * sdp->sd_sb.sb_bsize / 2;
	if (!bytes)
		bytes = UINT_MAX;
802 803 804
	bytes &= bsize_mask;
	if (bytes == 0)
		bytes = sdp->sd_sb.sb_bsize;
805

806 807 808 809
	error = gfs2_rs_alloc(ip);
	if (error)
		return error;

810 811 812 813 814
	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;

815
	gfs2_size_hint(file, offset, len);
B
Bob Peterson 已提交
816

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

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

832
		error = gfs2_inplace_reserve(ip, data_blocks + ind_blocks);
833 834 835
		if (error) {
			if (error == -ENOSPC && bytes > sdp->sd_sb.sb_bsize) {
				bytes >>= 1;
836 837 838
				bytes &= bsize_mask;
				if (bytes == 0)
					bytes = sdp->sd_sb.sb_bsize;
839 840 841 842 843
				goto retry;
			}
			goto out_qunlock;
		}
		max_bytes = bytes;
844 845
		calc_max_reserv(ip, (len > max_chunk_size)? max_chunk_size: len,
				&max_bytes, &data_blocks, &ind_blocks);
846 847

		rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA +
848
			  RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks);
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
		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);
	}
868 869 870

	if (error == 0)
		error = generic_write_sync(file, pos, count);
871 872 873 874 875 876 877 878 879 880 881 882 883
	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;
}

884 885
#ifdef CONFIG_GFS2_FS_LOCKING_DLM

886 887 888 889 890 891
/**
 * gfs2_setlease - acquire/release a file lease
 * @file: the file pointer
 * @arg: lease type
 * @fl: file lock
 *
892 893 894 895
 * 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.
 *
896 897
 * Locking: called under lock_flocks
 *
898 899 900 901 902
 * Returns: errno
 */

static int gfs2_setlease(struct file *file, long arg, struct file_lock **fl)
{
903
	return -EINVAL;
904 905
}

D
David Teigland 已提交
906 907 908 909 910 911 912 913 914 915 916
/**
 * 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)
{
917 918
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
919
	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
D
David Teigland 已提交
920 921 922

	if (!(fl->fl_flags & FL_POSIX))
		return -ENOLCK;
923
	if (__mandatory_lock(&ip->i_inode) && fl->fl_type != F_UNLCK)
D
David Teigland 已提交
924 925
		return -ENOLCK;

M
Marc Eshel 已提交
926 927 928 929 930
	if (cmd == F_CANCELLK) {
		/* Hack: */
		cmd = F_SETLK;
		fl->fl_type = F_UNLCK;
	}
931 932
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
		return -EIO;
D
David Teigland 已提交
933
	if (IS_GETLK(cmd))
934
		return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl);
D
David Teigland 已提交
935
	else if (fl->fl_type == F_UNLCK)
936
		return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl);
D
David Teigland 已提交
937
	else
938
		return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl);
D
David Teigland 已提交
939 940 941 942
}

static int do_flock(struct file *file, int cmd, struct file_lock *fl)
{
943
	struct gfs2_file *fp = file->private_data;
D
David Teigland 已提交
944
	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
J
Josef Sipek 已提交
945
	struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);
D
David Teigland 已提交
946 947 948 949 950 951
	struct gfs2_glock *gl;
	unsigned int state;
	int flags;
	int error = 0;

	state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
952
	flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE;
D
David Teigland 已提交
953

954
	mutex_lock(&fp->f_fl_mutex);
D
David Teigland 已提交
955 956 957 958 959 960

	gl = fl_gh->gh_gl;
	if (gl) {
		if (fl_gh->gh_state == state)
			goto out;
		flock_lock_file_wait(file,
961
				     &(struct file_lock){.fl_type = F_UNLCK});
962 963
		gfs2_glock_dq_wait(fl_gh);
		gfs2_holder_reinit(state, flags, fl_gh);
D
David Teigland 已提交
964
	} else {
965 966
		error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr,
				       &gfs2_flock_glops, CREATE, &gl);
D
David Teigland 已提交
967 968
		if (error)
			goto out;
969 970
		gfs2_holder_init(gl, state, flags, fl_gh);
		gfs2_glock_put(gl);
D
David Teigland 已提交
971 972 973 974 975 976 977 978
	}
	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);
979
		gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
D
David Teigland 已提交
980 981
	}

982
out:
983
	mutex_unlock(&fp->f_fl_mutex);
D
David Teigland 已提交
984 985 986 987 988
	return error;
}

static void do_unflock(struct file *file, struct file_lock *fl)
{
989
	struct gfs2_file *fp = file->private_data;
D
David Teigland 已提交
990 991
	struct gfs2_holder *fl_gh = &fp->f_fl_gh;

992
	mutex_lock(&fp->f_fl_mutex);
D
David Teigland 已提交
993
	flock_lock_file_wait(file, fl);
994 995 996 997
	if (fl_gh->gh_gl) {
		gfs2_glock_dq_wait(fl_gh);
		gfs2_holder_uninit(fl_gh);
	}
998
	mutex_unlock(&fp->f_fl_mutex);
D
David Teigland 已提交
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
}

/**
 * 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;
1014 1015
	if (fl->fl_type & LOCK_MAND)
		return -EOPNOTSUPP;
D
David Teigland 已提交
1016 1017 1018 1019

	if (fl->fl_type == F_UNLCK) {
		do_unflock(file, fl);
		return 0;
1020
	} else {
D
David Teigland 已提交
1021
		return do_flock(file, cmd, fl);
1022
	}
D
David Teigland 已提交
1023 1024
}

1025
const struct file_operations gfs2_file_fops = {
1026
	.llseek		= gfs2_llseek,
1027
	.read		= do_sync_read,
1028
	.aio_read	= generic_file_aio_read,
1029
	.write		= do_sync_write,
1030
	.aio_write	= gfs2_file_aio_write,
1031 1032 1033
	.unlocked_ioctl	= gfs2_ioctl,
	.mmap		= gfs2_mmap,
	.open		= gfs2_open,
1034
	.release	= gfs2_release,
1035 1036 1037 1038 1039
	.fsync		= gfs2_fsync,
	.lock		= gfs2_lock,
	.flock		= gfs2_flock,
	.splice_read	= generic_file_splice_read,
	.splice_write	= generic_file_splice_write,
1040
	.setlease	= gfs2_setlease,
1041
	.fallocate	= gfs2_fallocate,
D
David Teigland 已提交
1042 1043
};

1044
const struct file_operations gfs2_dir_fops = {
1045 1046 1047
	.readdir	= gfs2_readdir,
	.unlocked_ioctl	= gfs2_ioctl,
	.open		= gfs2_open,
1048
	.release	= gfs2_release,
1049 1050 1051
	.fsync		= gfs2_fsync,
	.lock		= gfs2_lock,
	.flock		= gfs2_flock,
1052
	.llseek		= default_llseek,
D
David Teigland 已提交
1053 1054
};

1055 1056
#endif /* CONFIG_GFS2_FS_LOCKING_DLM */

1057
const struct file_operations gfs2_file_fops_nolock = {
1058 1059 1060 1061
	.llseek		= gfs2_llseek,
	.read		= do_sync_read,
	.aio_read	= generic_file_aio_read,
	.write		= do_sync_write,
1062
	.aio_write	= gfs2_file_aio_write,
1063 1064 1065
	.unlocked_ioctl	= gfs2_ioctl,
	.mmap		= gfs2_mmap,
	.open		= gfs2_open,
1066
	.release	= gfs2_release,
1067 1068 1069
	.fsync		= gfs2_fsync,
	.splice_read	= generic_file_splice_read,
	.splice_write	= generic_file_splice_write,
1070
	.setlease	= generic_setlease,
1071
	.fallocate	= gfs2_fallocate,
1072 1073
};

1074
const struct file_operations gfs2_dir_fops_nolock = {
1075 1076 1077
	.readdir	= gfs2_readdir,
	.unlocked_ioctl	= gfs2_ioctl,
	.open		= gfs2_open,
1078
	.release	= gfs2_release,
1079
	.fsync		= gfs2_fsync,
1080
	.llseek		= default_llseek,
1081 1082
};