file.c 29.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>
28
#include <linux/delay.h>
David Teigland's avatar
David Teigland committed
29 30

#include "gfs2.h"
31
#include "incore.h"
David Teigland's avatar
David Teigland committed
32 33 34 35 36 37 38 39 40 41
#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"
42
#include "util.h"
David Teigland's avatar
David Teigland committed
43 44 45 46 47

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

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

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

	return error;
}

/**
Al Viro's avatar
Al Viro committed
85
 * gfs2_readdir - Iterator for a directory
David Teigland's avatar
David Teigland committed
86
 * @file: The directory to read from
Al Viro's avatar
Al Viro committed
87
 * @ctx: What to feed directory entries to
David Teigland's avatar
David Teigland committed
88 89 90 91
 *
 * Returns: errno
 */

Al Viro's avatar
Al Viro committed
92
static int gfs2_readdir(struct file *file, struct dir_context *ctx)
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 97 98
	struct gfs2_holder d_gh;
	int error;

Al Viro's avatar
Al Viro committed
99 100
	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
	if (error)
David Teigland's avatar
David Teigland committed
101 102
		return error;

Al Viro's avatar
Al Viro committed
103
	error = gfs2_dir_read(dir, ctx, &file->f_ra);
David Teigland's avatar
David Teigland committed
104 105 106 107 108 109

	gfs2_glock_dq_uninit(&d_gh);

	return error;
}

110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
/**
 * 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
131

132 133 134 135 136 137
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,
138
	[14] = GFS2_DIF_INHERIT_JDATA,
139
	[17] = GFS2_DIF_TOPDIR,
140 141
};

142 143 144 145 146 147
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,
148
	[gfs2fl_TopLevel] = FS_TOPDIR_FL,
149
	[gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,
150
};
151

152
static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
153
{
Al Viro's avatar
Al Viro committed
154
	struct inode *inode = file_inode(filp);
155
	struct gfs2_inode *ip = GFS2_I(inode);
156 157
	struct gfs2_holder gh;
	int error;
158
	u32 fsflags;
159

160 161
	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
	error = gfs2_glock_nq(&gh);
162
	if (error)
163
		goto out_uninit;
164

165 166
	fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_diskflags);
	if (!S_ISDIR(inode->i_mode) && ip->i_diskflags & GFS2_DIF_JDATA)
167
		fsflags |= FS_JOURNAL_DATA_FL;
168
	if (put_user(fsflags, ptr))
169 170
		error = -EFAULT;

171
	gfs2_glock_dq(&gh);
172
out_uninit:
173 174 175 176
	gfs2_holder_uninit(&gh);
	return error;
}

177 178 179 180 181
void gfs2_set_inode_flags(struct inode *inode)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	unsigned int flags = inode->i_flags;

182 183
	flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_NOSEC);
	if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode))
184
		flags |= S_NOSEC;
185
	if (ip->i_diskflags & GFS2_DIF_IMMUTABLE)
186
		flags |= S_IMMUTABLE;
187
	if (ip->i_diskflags & GFS2_DIF_APPENDONLY)
188
		flags |= S_APPEND;
189
	if (ip->i_diskflags & GFS2_DIF_NOATIME)
190
		flags |= S_NOATIME;
191
	if (ip->i_diskflags & GFS2_DIF_SYNC)
192 193 194 195
		flags |= S_SYNC;
	inode->i_flags = flags;
}

196 197 198 199 200 201 202
/* 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|			\
203
			     GFS2_DIF_TOPDIR|			\
204 205 206
			     GFS2_DIF_INHERIT_JDATA)

/**
207 208 209
 * do_gfs2_set_flags - set flags on an inode
 * @filp: file pointer
 * @reqflags: The flags to set
210 211 212
 * @mask: Indicates which flags are valid
 *
 */
213
static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
214
{
Al Viro's avatar
Al Viro committed
215
	struct inode *inode = file_inode(filp);
216 217
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
218 219 220
	struct buffer_head *bh;
	struct gfs2_holder gh;
	int error;
221
	u32 new_flags, flags;
222

223
	error = mnt_want_write_file(filp);
224
	if (error)
225 226
		return error;

227 228 229 230
	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
	if (error)
		goto out_drop_write;

231
	error = -EACCES;
232
	if (!inode_owner_or_capable(inode))
233 234 235
		goto out;

	error = 0;
236
	flags = ip->i_diskflags;
237
	new_flags = (flags & ~mask) | (reqflags & mask);
238 239 240 241 242 243 244 245 246 247 248 249
	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;
250
	if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
251
	    !capable(CAP_LINUX_IMMUTABLE))
252
		goto out;
253
	if (!IS_IMMUTABLE(inode)) {
254
		error = gfs2_permission(inode, MAY_WRITE);
255 256 257
		if (error)
			goto out;
	}
258 259
	if ((flags ^ new_flags) & GFS2_DIF_JDATA) {
		if (flags & GFS2_DIF_JDATA)
260
			gfs2_log_flush(sdp, ip->i_gl, NORMAL_FLUSH);
261 262 263 264 265 266 267
		error = filemap_fdatawrite(inode->i_mapping);
		if (error)
			goto out;
		error = filemap_fdatawait(inode->i_mapping);
		if (error)
			goto out;
	}
268
	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
269 270
	if (error)
		goto out;
271 272 273
	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error)
		goto out_trans_end;
274
	gfs2_trans_add_meta(ip->i_gl, bh);
275
	ip->i_diskflags = new_flags;
276
	gfs2_dinode_out(ip, bh->b_data);
277
	brelse(bh);
278
	gfs2_set_inode_flags(inode);
279
	gfs2_set_aops(inode);
280 281
out_trans_end:
	gfs2_trans_end(sdp);
282 283
out:
	gfs2_glock_dq_uninit(&gh);
284
out_drop_write:
Al Viro's avatar
Al Viro committed
285
	mnt_drop_write_file(filp);
286 287 288
	return error;
}

289
static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
290
{
Al Viro's avatar
Al Viro committed
291
	struct inode *inode = file_inode(filp);
292
	u32 fsflags, gfsflags;
293

294
	if (get_user(fsflags, ptr))
295
		return -EFAULT;
296

297
	gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);
298
	if (!S_ISDIR(inode->i_mode)) {
299
		gfsflags &= ~GFS2_DIF_TOPDIR;
300 301
		if (gfsflags & GFS2_DIF_INHERIT_JDATA)
			gfsflags ^= (GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA);
302
		return do_gfs2_set_flags(filp, gfsflags, ~GFS2_DIF_SYSTEM);
303
	}
304
	return do_gfs2_set_flags(filp, gfsflags, ~(GFS2_DIF_SYSTEM | GFS2_DIF_JDATA));
305 306
}

307
static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
308 309
{
	switch(cmd) {
310
	case FS_IOC_GETFLAGS:
311
		return gfs2_get_flags(filp, (u32 __user *)arg);
312
	case FS_IOC_SETFLAGS:
313
		return gfs2_set_flags(filp, (u32 __user *)arg);
314 315
	case FITRIM:
		return gfs2_fitrim(filp, (void __user *)arg);
316 317 318 319
	}
	return -ENOTTY;
}

320 321
/**
 * gfs2_size_hint - Give a hint to the size of a write request
322
 * @filep: The struct file
323 324 325 326 327 328 329 330 331 332 333
 * @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)
{
Al Viro's avatar
Al Viro committed
334
	struct inode *inode = file_inode(filep);
335 336 337 338 339
	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);

340 341
	if (hint > atomic_read(&ip->i_res.rs_sizehint))
		atomic_set(&ip->i_res.rs_sizehint, hint);
342 343
}

344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
/**
 * 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;
364
		gfs2_block_map(inode, lblock, &bh, 1);
365 366 367 368 369 370 371 372 373 374 375
		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
376
 * @vmf: The virtual memory fault containing the page to become writable
377 378 379 380 381
 *
 * When the page becomes writable, we need to ensure that we have
 * blocks allocated on disk to back that page.
 */

382
static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
383
{
384
	struct page *page = vmf->page;
Al Viro's avatar
Al Viro committed
385
	struct inode *inode = file_inode(vma->vm_file);
386 387
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
388
	struct gfs2_alloc_parms ap = { .aflags = 0, };
389
	unsigned long last_index;
390
	u64 pos = page->index << PAGE_CACHE_SHIFT;
391 392
	unsigned int data_blocks, ind_blocks, rblocks;
	struct gfs2_holder gh;
393
	loff_t size;
394 395
	int ret;

396
	sb_start_pagefault(inode->i_sb);
397

398 399
	/* Update file times before taking page lock */
	file_update_time(vma->vm_file);
400

401
	ret = gfs2_rsqa_alloc(ip);
402
	if (ret)
403
		goto out;
404

405
	gfs2_size_hint(vma->vm_file, pos, PAGE_CACHE_SIZE);
406

407 408
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
	ret = gfs2_glock_nq(&gh);
409
	if (ret)
410
		goto out_uninit;
411

412 413 414
	set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
	set_bit(GIF_SW_PAGED, &ip->i_flags);

415 416 417 418 419 420
	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);
		}
421
		goto out_unlock;
422 423
	}

424 425
	ret = gfs2_rindex_update(sdp);
	if (ret)
426 427
		goto out_unlock;

428
	gfs2_write_calc_reserv(ip, PAGE_CACHE_SIZE, &data_blocks, &ind_blocks);
429
	ap.target = data_blocks + ind_blocks;
430 431 432
	ret = gfs2_quota_lock_check(ip, &ap);
	if (ret)
		goto out_unlock;
433
	ret = gfs2_inplace_reserve(ip, &ap);
434 435 436 437 438 439
	if (ret)
		goto out_quota_unlock;

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

	lock_page(page);
	ret = -EINVAL;
450 451 452 453 454 455 456 457 458 459 460 461 462 463
	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 */
464
	ret = 0;
465
	if (gfs2_is_stuffed(ip))
466
		ret = gfs2_unstuff_dinode(ip, page);
467 468
	if (ret == 0)
		ret = gfs2_allocate_page_backing(page);
469

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

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

David Teigland's avatar
David Teigland committed
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
David Teigland's avatar
David Teigland committed
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);
David Teigland's avatar
David Teigland committed
512

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

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

528
	return 0;
David Teigland's avatar
David Teigland committed
529 530 531
}

/**
532 533 534
 * gfs2_open_common - This is common to open and atomic_open
 * @inode: The inode being opened
 * @file: The file being opened
David Teigland's avatar
David Teigland committed
535
 *
536 537 538 539 540 541
 * This maybe called under a glock or not depending upon how it has
 * been called. We must always be called under a glock for regular
 * files, however. For other file types, it does not matter whether
 * we hold the glock or not.
 *
 * Returns: Error code or 0 for success
David Teigland's avatar
David Teigland committed
542 543
 */

544
int gfs2_open_common(struct inode *inode, struct file *file)
David Teigland's avatar
David Teigland committed
545 546
{
	struct gfs2_file *fp;
547 548 549 550 551 552 553
	int ret;

	if (S_ISREG(inode->i_mode)) {
		ret = generic_file_open(inode, file);
		if (ret)
			return ret;
	}
David Teigland's avatar
David Teigland committed
554

555
	fp = kzalloc(sizeof(struct gfs2_file), GFP_NOFS);
David Teigland's avatar
David Teigland committed
556 557 558
	if (!fp)
		return -ENOMEM;

559
	mutex_init(&fp->f_fl_mutex);
David Teigland's avatar
David Teigland committed
560

561
	gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
562
	file->private_data = fp;
563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
	return 0;
}

/**
 * gfs2_open - open a file
 * @inode: the inode to open
 * @file: the struct file for this opening
 *
 * After atomic_open, this function is only used for opening files
 * which are already cached. We must still get the glock for regular
 * files to ensure that we have the file size uptodate for the large
 * file check which is in the common code. That is only an issue for
 * regular files though.
 *
 * Returns: errno
 */

static int gfs2_open(struct inode *inode, struct file *file)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder i_gh;
	int error;
	bool need_unlock = false;
David Teigland's avatar
David Teigland committed
586

587
	if (S_ISREG(ip->i_inode.i_mode)) {
David Teigland's avatar
David Teigland committed
588 589 590
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
					   &i_gh);
		if (error)
591 592 593
			return error;
		need_unlock = true;
	}
David Teigland's avatar
David Teigland committed
594

595
	error = gfs2_open_common(inode, file);
David Teigland's avatar
David Teigland committed
596

597
	if (need_unlock)
David Teigland's avatar
David Teigland committed
598 599 600 601 602 603
		gfs2_glock_dq_uninit(&i_gh);

	return error;
}

/**
604
 * gfs2_release - called to close a struct file
David Teigland's avatar
David Teigland committed
605 606 607 608 609 610
 * @inode: the inode the struct file belongs to
 * @file: the struct file being closed
 *
 * Returns: errno
 */

611
static int gfs2_release(struct inode *inode, struct file *file)
David Teigland's avatar
David Teigland committed
612
{
613
	struct gfs2_inode *ip = GFS2_I(inode);
David Teigland's avatar
David Teigland committed
614

615
	kfree(file->private_data);
616
	file->private_data = NULL;
David Teigland's avatar
David Teigland committed
617

618 619
	if (!(file->f_mode & FMODE_WRITE))
		return 0;
620

621
	gfs2_rsqa_delete(ip, &inode->i_writecount);
David Teigland's avatar
David Teigland committed
622 623 624 625 626
	return 0;
}

/**
 * gfs2_fsync - sync the dirty data for a file (across the cluster)
627 628 629
 * @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
630
 * @datasync: set if we can ignore timestamp changes
David Teigland's avatar
David Teigland committed
631
 *
632 633 634 635 636 637 638 639 640 641
 * 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.
642
 *
David Teigland's avatar
David Teigland committed
643 644 645
 * Returns: errno
 */

646 647
static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
		      int datasync)
David Teigland's avatar
David Teigland committed
648
{
649 650
	struct address_space *mapping = file->f_mapping;
	struct inode *inode = mapping->host;
651
	int sync_state = inode->i_state & I_DIRTY_ALL;
Steven Whitehouse's avatar
Steven Whitehouse committed
652
	struct gfs2_inode *ip = GFS2_I(inode);
653
	int ret = 0, ret1 = 0;
David Teigland's avatar
David Teigland committed
654

655 656 657 658 659
	if (mapping->nrpages) {
		ret1 = filemap_fdatawrite_range(mapping, start, end);
		if (ret1 == -EIO)
			return ret1;
	}
660

661 662
	if (!gfs2_is_jdata(ip))
		sync_state &= ~I_DIRTY_PAGES;
Steven Whitehouse's avatar
Steven Whitehouse committed
663
	if (datasync)
664
		sync_state &= ~(I_DIRTY_SYNC | I_DIRTY_TIME);
David Teigland's avatar
David Teigland committed
665

Steven Whitehouse's avatar
Steven Whitehouse committed
666 667
	if (sync_state) {
		ret = sync_inode_metadata(inode, 1);
668
		if (ret)
Steven Whitehouse's avatar
Steven Whitehouse committed
669
			return ret;
670 671
		if (gfs2_is_jdata(ip))
			filemap_write_and_wait(mapping);
672
		gfs2_ail_flush(ip->i_gl, 1);
673 674
	}

675 676 677 678
	if (mapping->nrpages)
		ret = filemap_fdatawait_range(mapping, start, end);

	return ret ? ret : ret1;
David Teigland's avatar
David Teigland committed
679 680
}

681
/**
Al Viro's avatar
Al Viro committed
682
 * gfs2_file_write_iter - Perform a write to a file
683 684 685 686 687 688 689 690 691 692 693 694
 * @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.
 *
 */

Al Viro's avatar
Al Viro committed
695
static ssize_t gfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
696 697
{
	struct file *file = iocb->ki_filp;
Al Viro's avatar
Al Viro committed
698
	struct gfs2_inode *ip = GFS2_I(file_inode(file));
699 700
	int ret;

701
	ret = gfs2_rsqa_alloc(ip);
702 703
	if (ret)
		return ret;
704

Al Viro's avatar
Al Viro committed
705
	gfs2_size_hint(file, iocb->ki_pos, iov_iter_count(from));
706

707
	if (iocb->ki_flags & IOCB_APPEND) {
708 709 710 711 712 713 714 715
		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);
	}

Al Viro's avatar
Al Viro committed
716
	return generic_file_write_iter(iocb, from);
717 718
}

719 720 721 722 723 724
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;
725 726
	unsigned int nr_blks;
	sector_t lblock = offset >> inode->i_blkbits;
727 728 729

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (unlikely(error))
730
		return error;
731

732
	gfs2_trans_add_meta(ip->i_gl, dibh);
733 734 735 736 737 738 739

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

740 741 742 743
	while (len) {
		struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
		bh_map.b_size = len;
		set_buffer_zeronew(&bh_map);
744

745 746 747 748 749 750 751 752 753 754
		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;
755
			goto out;
756
		}
757 758
	}
out:
759
	brelse(dibh);
760 761
	return error;
}
762 763 764 765 766 767 768 769 770 771 772 773 774 775
/**
 * calc_max_reserv() - Reverse of write_calc_reserv. Given a number of
 *                     blocks, determine how many bytes can be written.
 * @ip:          The inode in question.
 * @len:         Max cap of bytes. What we return in *len must be <= this.
 * @data_blocks: Compute and return the number of data blocks needed
 * @ind_blocks:  Compute and return the number of indirect blocks needed
 * @max_blocks:  The total blocks available to work with.
 *
 * Returns: void, but @len, @data_blocks and @ind_blocks are filled in.
 */
static void calc_max_reserv(struct gfs2_inode *ip, loff_t *len,
			    unsigned int *data_blocks, unsigned int *ind_blocks,
			    unsigned int max_blocks)
776
{
777
	loff_t max = *len;
778 779 780 781 782 783 784
	const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	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;
	}
785

786 787 788 789 790 791 792 793 794
	*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);
	}
}

795
static long __gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
796
{
Al Viro's avatar
Al Viro committed
797
	struct inode *inode = file_inode(file);
798 799
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	struct gfs2_inode *ip = GFS2_I(inode);
800
	struct gfs2_alloc_parms ap = { .aflags = 0, };
801
	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
802
	loff_t bytes, max_bytes, max_blks = UINT_MAX;
803
	int error;
804 805
	const loff_t pos = offset;
	const loff_t count = len;
806
	loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1);
807
	loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift;
808
	loff_t max_chunk_size = UINT_MAX & bsize_mask;
809

810 811
	next = (next + 1) << sdp->sd_sb.sb_bsize_shift;

812
	offset &= bsize_mask;
813 814 815 816 817

	len = next - offset;
	bytes = sdp->sd_max_rg_data * sdp->sd_sb.sb_bsize / 2;
	if (!bytes)
		bytes = UINT_MAX;
818 819 820
	bytes &= bsize_mask;
	if (bytes == 0)
		bytes = sdp->sd_sb.sb_bsize;
821

822
	gfs2_size_hint(file, offset, len);
823

824 825 826
	gfs2_write_calc_reserv(ip, PAGE_SIZE, &data_blocks, &ind_blocks);
	ap.min_target = data_blocks + ind_blocks;

827 828 829
	while (len > 0) {
		if (len < bytes)
			bytes = len;
830 831 832 833 834
		if (!gfs2_write_alloc_required(ip, offset, bytes)) {
			len -= bytes;
			offset += bytes;
			continue;
		}
835 836 837 838 839 840 841 842 843 844 845

		/* We need to determine how many bytes we can actually
		 * fallocate without exceeding quota or going over the
		 * end of the fs. We start off optimistically by assuming
		 * we can write max_bytes */
		max_bytes = (len > max_chunk_size) ? max_chunk_size : len;

		/* Since max_bytes is most likely a theoretical max, we
		 * calculate a more realistic 'bytes' to serve as a good
		 * starting point for the number of bytes we may be able
		 * to write */
846
		gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks);
847
		ap.target = data_blocks + ind_blocks;
848 849

		error = gfs2_quota_lock_check(ip, &ap);
850
		if (error)
851
			return error;
852 853 854 855
		/* ap.allowed tells us how many blocks quota will allow
		 * us to write. Check if this reduces max_blks */
		if (ap.allowed && ap.allowed < max_blks)
			max_blks = ap.allowed;
856

857
		error = gfs2_inplace_reserve(ip, &ap);
858
		if (error)
859
			goto out_qunlock;
860 861 862 863 864 865 866 867 868 869

		/* check if the selected rgrp limits our max_blks further */
		if (ap.allowed && ap.allowed < max_blks)
			max_blks = ap.allowed;

		/* Almost done. Calculate bytes that can be written using
		 * max_blks. We also recompute max_bytes, data_blocks and
		 * ind_blocks */
		calc_max_reserv(ip, &max_bytes, &data_blocks,
				&ind_blocks, max_blks);
870 871

		rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA +
872
			  RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks);
873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891
		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);
	}
892

893 894
	if (!(mode & FALLOC_FL_KEEP_SIZE) && (pos + count) > inode->i_size) {
		i_size_write(inode, pos + count);
895
		file_update_time(file);
896
		mark_inode_dirty(inode);
897 898 899
	}

	return generic_write_sync(file, pos, count);
900 901 902 903 904

out_trans_fail:
	gfs2_inplace_release(ip);
out_qunlock:
	gfs2_quota_unlock(ip);
905 906 907 908 909 910 911 912 913 914
	return error;
}

static long gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
{
	struct inode *inode = file_inode(file);
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder gh;
	int ret;

915
	if ((mode & ~FALLOC_FL_KEEP_SIZE) || gfs2_is_jdata(ip))
916 917
		return -EOPNOTSUPP;

Al Viro's avatar
Al Viro committed
918
	inode_lock(inode);
919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935

	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
	ret = gfs2_glock_nq(&gh);
	if (ret)
		goto out_uninit;

	if (!(mode & FALLOC_FL_KEEP_SIZE) &&
	    (offset + len) > inode->i_size) {
		ret = inode_newsize_ok(inode, offset + len);
		if (ret)
			goto out_unlock;
	}

	ret = get_write_access(inode);
	if (ret)
		goto out_unlock;

936
	ret = gfs2_rsqa_alloc(ip);
937 938 939 940 941
	if (ret)
		goto out_putw;

	ret = __gfs2_fallocate(file, mode, offset, len);
	if (ret)
942 943
		gfs2_rs_deltree(&ip->i_res);

944 945
out_putw:
	put_write_access(inode);
946
out_unlock:
947
	gfs2_glock_dq(&gh);
948
out_uninit:
949
	gfs2_holder_uninit(&gh);
Al Viro's avatar
Al Viro committed
950
	inode_unlock(inode);
951
	return ret;
952 953
}

954 955 956 957 958 959 960 961 962
static ssize_t gfs2_file_splice_read(struct file *in, loff_t *ppos,
				     struct pipe_inode_info *pipe, size_t len,
				     unsigned int flags)
{
	struct inode *inode = in->f_mapping->host;
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder gh;
	int ret;

963
	inode_lock(inode);
964 965 966

	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
	if (ret) {
967
		inode_unlock(inode);
968 969 970 971
		return ret;
	}

	gfs2_glock_dq_uninit(&gh);
972
	inode_unlock(inode);
973 974 975 976 977

	return generic_file_splice_read(in, ppos, pipe, len, flags);
}


978 979 980 981 982 983 984
static ssize_t gfs2_file_splice_write(struct pipe_inode_info *pipe,
				      struct file *out, loff_t *ppos,
				      size_t len, unsigned int flags)
{
	int error;
	struct gfs2_inode *ip = GFS2_I(out->f_mapping->host);

985
	error = gfs2_rsqa_alloc(ip);
986 987 988 989 990 991 992 993
	if (error)
		return (ssize_t)error;

	gfs2_size_hint(out, *ppos, len);

	return iter_file_splice_write(pipe, out, ppos, len, flags);
}

994 995
#ifdef CONFIG_GFS2_FS_LOCKING_DLM

David Teigland's avatar
David Teigland committed
996 997 998 999 1000 1001 1002 1003 1004 1005 1006
/**
 * 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)
{
1007 1008
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
1009
	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
David Teigland's avatar
David Teigland committed
1010 1011 1012

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

Marc Eshel's avatar
Marc Eshel committed
1016 1017 1018 1019 1020
	if (cmd == F_CANCELLK) {
		/* Hack: */
		cmd = F_SETLK;
		fl->fl_type = F_UNLCK;
	}
1021 1022
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) {
		if (fl->fl_type == F_UNLCK)
1023
			locks_lock_file_wait(file, fl);
1024
		return -EIO;
1025
	}
David Teigland's avatar
David Teigland committed
1026
	if (IS_GETLK(cmd))
1027
		return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl);
David Teigland's avatar
David Teigland committed
1028
	else if (fl->fl_type == F_UNLCK)
1029
		return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl);
David Teigland's avatar
David Teigland committed
1030
	else
1031
		return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl);
David Teigland's avatar
David Teigland committed
1032 1033 1034 1035
}

static int do_flock(struct file *file, int cmd, struct file_lock *fl)
{
1036
	struct gfs2_file *fp = file->private_data;
David Teigland's avatar
David Teigland committed
1037
	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
Al Viro's avatar
Al Viro committed
1038
	struct gfs2_inode *ip = GFS2_I(file_inode(file));
David Teigland's avatar
David Teigland committed
1039 1040
	struct gfs2_glock *gl;
	unsigned int state;
1041
	u16 flags;
David Teigland's avatar
David Teigland committed
1042
	int error = 0;
1043
	int sleeptime;
David Teigland's avatar
David Teigland committed
1044 1045

	state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
1046
	flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY_1CB) | GL_EXACT;
David Teigland's avatar
David Teigland committed
1047

1048
	mutex_lock(&fp->f_fl_mutex);
David Teigland's avatar
David Teigland committed
1049 1050 1051 1052 1053

	gl = fl_gh->gh_gl;
	if (gl) {
		if (fl_gh->gh_state == state)
			goto out;
1054
		locks_lock_file_wait(file,
Junxiao Bi's avatar
Junxiao Bi committed
1055 1056 1057 1058
				     &(struct file_lock) {
					     .fl_type = F_UNLCK,
					     .fl_flags = FL_FLOCK
				     });
1059
		gfs2_glock_dq(fl_gh);
1060
		gfs2_holder_reinit(state, flags, fl_gh);
David Teigland's avatar
David Teigland committed
1061
	} else {
1062 1063
		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
1064 1065
		if (error)
			goto out;
1066 1067
		gfs2_holder_init(gl, state, flags, fl_gh);
		gfs2_glock_put(gl);
David Teigland's avatar
David Teigland committed
1068
	}
1069 1070 1071 1072 1073 1074 1075 1076
	for (sleeptime = 1; sleeptime <= 4; sleeptime <<= 1) {
		error = gfs2_glock_nq(fl_gh