file.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   4 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
   5 */
   6
   7#include <linux/slab.h>
   8#include <linux/spinlock.h>
   9#include <linux/compat.h>
  10#include <linux/completion.h>
  11#include <linux/buffer_head.h>
  12#include <linux/pagemap.h>
  13#include <linux/uio.h>
  14#include <linux/blkdev.h>
  15#include <linux/mm.h>
  16#include <linux/mount.h>
  17#include <linux/fs.h>
  18#include <linux/filelock.h>
  19#include <linux/gfs2_ondisk.h>
  20#include <linux/falloc.h>
  21#include <linux/swap.h>
  22#include <linux/crc32.h>
  23#include <linux/writeback.h>
  24#include <linux/uaccess.h>
  25#include <linux/dlm.h>
  26#include <linux/dlm_plock.h>
  27#include <linux/delay.h>
  28#include <linux/backing-dev.h>
  29#include <linux/fileattr.h>
  30
  31#include "gfs2.h"
  32#include "incore.h"
  33#include "bmap.h"
  34#include "aops.h"
  35#include "dir.h"
  36#include "glock.h"
  37#include "glops.h"
  38#include "inode.h"
  39#include "log.h"
  40#include "meta_io.h"
  41#include "quota.h"
  42#include "rgrp.h"
  43#include "trans.h"
  44#include "util.h"
  45
  46/**
  47 * gfs2_llseek - seek to a location in a file
  48 * @file: the file
  49 * @offset: the offset
  50 * @whence: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
  51 *
  52 * SEEK_END requires the glock for the file because it references the
  53 * file's size.
  54 *
  55 * Returns: The new offset, or errno
  56 */
  57
  58static loff_t gfs2_llseek(struct file *file, loff_t offset, int whence)
  59{
  60	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
  61	struct gfs2_holder i_gh;
  62	loff_t error;
  63
  64	switch (whence) {
  65	case SEEK_END:
  66		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
  67					   &i_gh);
  68		if (!error) {
  69			error = generic_file_llseek(file, offset, whence);
  70			gfs2_glock_dq_uninit(&i_gh);
  71		}
  72		break;
  73
  74	case SEEK_DATA:
  75		error = gfs2_seek_data(file, offset);
  76		break;
  77
  78	case SEEK_HOLE:
  79		error = gfs2_seek_hole(file, offset);
  80		break;
  81
  82	case SEEK_CUR:
  83	case SEEK_SET:
  84		/*
  85		 * These don't reference inode->i_size and don't depend on the
  86		 * block mapping, so we don't need the glock.
  87		 */
  88		error = generic_file_llseek(file, offset, whence);
  89		break;
  90	default:
  91		error = -EINVAL;
  92	}
  93
  94	return error;
  95}
  96
  97/**
  98 * gfs2_readdir - Iterator for a directory
  99 * @file: The directory to read from
 100 * @ctx: What to feed directory entries to
 101 *
 102 * Returns: errno
 103 */
 104
 105static int gfs2_readdir(struct file *file, struct dir_context *ctx)
 106{
 107	struct inode *dir = file->f_mapping->host;
 108	struct gfs2_inode *dip = GFS2_I(dir);
 109	struct gfs2_holder d_gh;
 110	int error;
 111
 112	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 113	if (error)
 114		return error;
 115
 116	error = gfs2_dir_read(dir, ctx, &file->f_ra);
 117
 118	gfs2_glock_dq_uninit(&d_gh);
 119
 120	return error;
 121}
 122
 123/*
 124 * struct fsflag_gfs2flag
 125 *
 126 * The FS_JOURNAL_DATA_FL flag maps to GFS2_DIF_INHERIT_JDATA for directories,
 127 * and to GFS2_DIF_JDATA for non-directories.
 128 */
 129static struct {
 130	u32 fsflag;
 131	u32 gfsflag;
 132} fsflag_gfs2flag[] = {
 133	{FS_SYNC_FL, GFS2_DIF_SYNC},
 134	{FS_IMMUTABLE_FL, GFS2_DIF_IMMUTABLE},
 135	{FS_APPEND_FL, GFS2_DIF_APPENDONLY},
 136	{FS_NOATIME_FL, GFS2_DIF_NOATIME},
 137	{FS_INDEX_FL, GFS2_DIF_EXHASH},
 138	{FS_TOPDIR_FL, GFS2_DIF_TOPDIR},
 139	{FS_JOURNAL_DATA_FL, GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA},
 140};
 141
 142static inline u32 gfs2_gfsflags_to_fsflags(struct inode *inode, u32 gfsflags)
 143{
 144	int i;
 145	u32 fsflags = 0;
 146
 147	if (S_ISDIR(inode->i_mode))
 148		gfsflags &= ~GFS2_DIF_JDATA;
 149	else
 150		gfsflags &= ~GFS2_DIF_INHERIT_JDATA;
 151
 152	for (i = 0; i < ARRAY_SIZE(fsflag_gfs2flag); i++)
 153		if (gfsflags & fsflag_gfs2flag[i].gfsflag)
 154			fsflags |= fsflag_gfs2flag[i].fsflag;
 155	return fsflags;
 156}
 157
 158int gfs2_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
 159{
 160	struct inode *inode = d_inode(dentry);
 161	struct gfs2_inode *ip = GFS2_I(inode);
 162	struct gfs2_holder gh;
 163	int error;
 164	u32 fsflags;
 165
 166	if (d_is_special(dentry))
 167		return -ENOTTY;
 168
 169	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
 170	error = gfs2_glock_nq(&gh);
 171	if (error)
 172		goto out_uninit;
 173
 174	fsflags = gfs2_gfsflags_to_fsflags(inode, ip->i_diskflags);
 175
 176	fileattr_fill_flags(fa, fsflags);
 177
 178	gfs2_glock_dq(&gh);
 179out_uninit:
 180	gfs2_holder_uninit(&gh);
 181	return error;
 182}
 183
 184void gfs2_set_inode_flags(struct inode *inode)
 185{
 186	struct gfs2_inode *ip = GFS2_I(inode);
 187	unsigned int flags = inode->i_flags;
 188
 189	flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_NOSEC);
 190	if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode))
 191		flags |= S_NOSEC;
 192	if (ip->i_diskflags & GFS2_DIF_IMMUTABLE)
 193		flags |= S_IMMUTABLE;
 194	if (ip->i_diskflags & GFS2_DIF_APPENDONLY)
 195		flags |= S_APPEND;
 196	if (ip->i_diskflags & GFS2_DIF_NOATIME)
 197		flags |= S_NOATIME;
 198	if (ip->i_diskflags & GFS2_DIF_SYNC)
 199		flags |= S_SYNC;
 200	inode->i_flags = flags;
 201}
 202
 203/* Flags that can be set by user space */
 204#define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA|			\
 205			     GFS2_DIF_IMMUTABLE|		\
 206			     GFS2_DIF_APPENDONLY|		\
 207			     GFS2_DIF_NOATIME|			\
 208			     GFS2_DIF_SYNC|			\
 209			     GFS2_DIF_TOPDIR|			\
 210			     GFS2_DIF_INHERIT_JDATA)
 211
 212/**
 213 * do_gfs2_set_flags - set flags on an inode
 214 * @inode: The inode
 215 * @reqflags: The flags to set
 216 * @mask: Indicates which flags are valid
 217 *
 218 */
 219static int do_gfs2_set_flags(struct inode *inode, u32 reqflags, u32 mask)
 220{
 221	struct gfs2_inode *ip = GFS2_I(inode);
 222	struct gfs2_sbd *sdp = GFS2_SB(inode);
 223	struct buffer_head *bh;
 224	struct gfs2_holder gh;
 225	int error;
 226	u32 new_flags, flags;
 227
 228	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 229	if (error)
 230		return error;
 231
 232	error = 0;
 233	flags = ip->i_diskflags;
 234	new_flags = (flags & ~mask) | (reqflags & mask);
 235	if ((new_flags ^ flags) == 0)
 236		goto out;
 237
 238	if (!IS_IMMUTABLE(inode)) {
 239		error = gfs2_permission(&nop_mnt_idmap, inode, MAY_WRITE);
 240		if (error)
 241			goto out;
 242	}
 243	if ((flags ^ new_flags) & GFS2_DIF_JDATA) {
 244		if (new_flags & GFS2_DIF_JDATA)
 245			gfs2_log_flush(sdp, ip->i_gl,
 246				       GFS2_LOG_HEAD_FLUSH_NORMAL |
 247				       GFS2_LFC_SET_FLAGS);
 248		error = filemap_fdatawrite(inode->i_mapping);
 249		if (error)
 250			goto out;
 251		error = filemap_fdatawait(inode->i_mapping);
 252		if (error)
 253			goto out;
 254		truncate_inode_pages(inode->i_mapping, 0);
 255		if (new_flags & GFS2_DIF_JDATA)
 256			gfs2_ordered_del_inode(ip);
 257	}
 258	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
 259	if (error)
 260		goto out;
 261	error = gfs2_meta_inode_buffer(ip, &bh);
 262	if (error)
 263		goto out_trans_end;
 264	inode_set_ctime_current(inode);
 265	gfs2_trans_add_meta(ip->i_gl, bh);
 266	ip->i_diskflags = new_flags;
 267	gfs2_dinode_out(ip, bh->b_data);
 268	brelse(bh);
 269	gfs2_set_inode_flags(inode);
 270	gfs2_set_aops(inode);
 271out_trans_end:
 272	gfs2_trans_end(sdp);
 273out:
 274	gfs2_glock_dq_uninit(&gh);
 275	return error;
 276}
 277
 278int gfs2_fileattr_set(struct mnt_idmap *idmap,
 279		      struct dentry *dentry, struct file_kattr *fa)
 280{
 281	struct inode *inode = d_inode(dentry);
 282	u32 fsflags = fa->flags, gfsflags = 0;
 283	u32 mask;
 284	int i;
 285
 286	if (d_is_special(dentry))
 287		return -ENOTTY;
 288
 289	if (fileattr_has_fsx(fa))
 290		return -EOPNOTSUPP;
 291
 292	for (i = 0; i < ARRAY_SIZE(fsflag_gfs2flag); i++) {
 293		if (fsflags & fsflag_gfs2flag[i].fsflag) {
 294			fsflags &= ~fsflag_gfs2flag[i].fsflag;
 295			gfsflags |= fsflag_gfs2flag[i].gfsflag;
 296		}
 297	}
 298	if (fsflags || gfsflags & ~GFS2_FLAGS_USER_SET)
 299		return -EINVAL;
 300
 301	mask = GFS2_FLAGS_USER_SET;
 302	if (S_ISDIR(inode->i_mode)) {
 303		mask &= ~GFS2_DIF_JDATA;
 304	} else {
 305		/* The GFS2_DIF_TOPDIR flag is only valid for directories. */
 306		if (gfsflags & GFS2_DIF_TOPDIR)
 307			return -EINVAL;
 308		mask &= ~(GFS2_DIF_TOPDIR | GFS2_DIF_INHERIT_JDATA);
 309	}
 310
 311	return do_gfs2_set_flags(inode, gfsflags, mask);
 312}
 313
 314static int gfs2_getlabel(struct file *filp, char __user *label)
 315{
 316	struct inode *inode = file_inode(filp);
 317	struct gfs2_sbd *sdp = GFS2_SB(inode);
 318
 319	if (copy_to_user(label, sdp->sd_sb.sb_locktable, GFS2_LOCKNAME_LEN))
 320		return -EFAULT;
 321
 322	return 0;
 323}
 324
 325static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 326{
 327	switch(cmd) {
 328	case FITRIM:
 329		return gfs2_fitrim(filp, (void __user *)arg);
 330	case FS_IOC_GETFSLABEL:
 331		return gfs2_getlabel(filp, (char __user *)arg);
 332	}
 333
 334	return -ENOTTY;
 335}
 336
 337#ifdef CONFIG_COMPAT
 338static long gfs2_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 339{
 340	switch(cmd) {
 341	/* Keep this list in sync with gfs2_ioctl */
 342	case FITRIM:
 343	case FS_IOC_GETFSLABEL:
 344		break;
 345	default:
 346		return -ENOIOCTLCMD;
 347	}
 348
 349	return gfs2_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
 350}
 351#else
 352#define gfs2_compat_ioctl NULL
 353#endif
 354
 355/**
 356 * gfs2_size_hint - Give a hint to the size of a write request
 357 * @filep: The struct file
 358 * @offset: The file offset of the write
 359 * @size: The length of the write
 360 *
 361 * When we are about to do a write, this function records the total
 362 * write size in order to provide a suitable hint to the lower layers
 363 * about how many blocks will be required.
 364 *
 365 */
 366
 367static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size)
 368{
 369	struct inode *inode = file_inode(filep);
 370	struct gfs2_sbd *sdp = GFS2_SB(inode);
 371	struct gfs2_inode *ip = GFS2_I(inode);
 372	size_t blks = (size + sdp->sd_sb.sb_bsize - 1) >> sdp->sd_sb.sb_bsize_shift;
 373	int hint = min_t(size_t, INT_MAX, blks);
 374
 375	if (hint > atomic_read(&ip->i_sizehint))
 376		atomic_set(&ip->i_sizehint, hint);
 377}
 378
 379/**
 380 * gfs2_allocate_folio_backing - Allocate blocks for a write fault
 381 * @folio: The (locked) folio to allocate backing for
 382 * @length: Size of the allocation
 383 *
 384 * We try to allocate all the blocks required for the folio in one go.  This
 385 * might fail for various reasons, so we keep trying until all the blocks to
 386 * back this folio are allocated.  If some of the blocks are already allocated,
 387 * that is ok too.
 388 */
 389static int gfs2_allocate_folio_backing(struct folio *folio, size_t length)
 390{
 391	u64 pos = folio_pos(folio);
 392
 393	do {
 394		struct iomap iomap = { };
 395
 396		if (gfs2_iomap_alloc(folio->mapping->host, pos, length, &iomap))
 397			return -EIO;
 398
 399		if (length < iomap.length)
 400			iomap.length = length;
 401		length -= iomap.length;
 402		pos += iomap.length;
 403	} while (length > 0);
 404
 405	return 0;
 406}
 407
 408/**
 409 * gfs2_page_mkwrite - Make a shared, mmap()ed, page writable
 410 * @vmf: The virtual memory fault containing the page to become writable
 411 *
 412 * When the page becomes writable, we need to ensure that we have
 413 * blocks allocated on disk to back that page.
 414 */
 415
 416static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf)
 417{
 418	struct folio *folio = page_folio(vmf->page);
 419	struct inode *inode = file_inode(vmf->vma->vm_file);
 420	struct gfs2_inode *ip = GFS2_I(inode);
 421	struct gfs2_sbd *sdp = GFS2_SB(inode);
 422	struct gfs2_alloc_parms ap = {};
 423	u64 pos = folio_pos(folio);
 424	unsigned int data_blocks, ind_blocks, rblocks;
 425	vm_fault_t ret = VM_FAULT_LOCKED;
 426	struct gfs2_holder gh;
 427	size_t length;
 428	loff_t size;
 429	int err;
 430
 431	sb_start_pagefault(inode->i_sb);
 432
 433	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 434	err = gfs2_glock_nq(&gh);
 435	if (err) {
 436		ret = vmf_fs_error(err);
 437		goto out_uninit;
 438	}
 439
 440	/* Check folio index against inode size */
 441	size = i_size_read(inode);
 442	if (pos >= size) {
 443		ret = VM_FAULT_SIGBUS;
 444		goto out_unlock;
 445	}
 446
 447	/* Update file times before taking folio lock */
 448	file_update_time(vmf->vma->vm_file);
 449
 450	/* folio is wholly or partially inside EOF */
 451	if (size - pos < folio_size(folio))
 452		length = size - pos;
 453	else
 454		length = folio_size(folio);
 455
 456	gfs2_size_hint(vmf->vma->vm_file, pos, length);
 457
 458	set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
 459	set_bit(GIF_SW_PAGED, &ip->i_flags);
 460
 461	/*
 462	 * iomap_writepage / iomap_writepages currently don't support inline
 463	 * files, so always unstuff here.
 464	 */
 465
 466	if (!gfs2_is_stuffed(ip) &&
 467	    !gfs2_write_alloc_required(ip, pos, length)) {
 468		folio_lock(folio);
 469		if (!folio_test_uptodate(folio) ||
 470		    folio->mapping != inode->i_mapping) {
 471			ret = VM_FAULT_NOPAGE;
 472			folio_unlock(folio);
 473		}
 474		goto out_unlock;
 475	}
 476
 477	err = gfs2_rindex_update(sdp);
 478	if (err) {
 479		ret = vmf_fs_error(err);
 480		goto out_unlock;
 481	}
 482
 483	gfs2_write_calc_reserv(ip, length, &data_blocks, &ind_blocks);
 484	ap.target = data_blocks + ind_blocks;
 485	err = gfs2_quota_lock_check(ip, &ap);
 486	if (err) {
 487		ret = vmf_fs_error(err);
 488		goto out_unlock;
 489	}
 490	err = gfs2_inplace_reserve(ip, &ap);
 491	if (err) {
 492		ret = vmf_fs_error(err);
 493		goto out_quota_unlock;
 494	}
 495
 496	rblocks = RES_DINODE + ind_blocks;
 497	if (gfs2_is_jdata(ip))
 498		rblocks += data_blocks ? data_blocks : 1;
 499	if (ind_blocks || data_blocks) {
 500		rblocks += RES_STATFS + RES_QUOTA;
 501		rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks);
 502	}
 503	err = gfs2_trans_begin(sdp, rblocks, 0);
 504	if (err) {
 505		ret = vmf_fs_error(err);
 506		goto out_trans_fail;
 507	}
 508
 509	/* Unstuff, if required, and allocate backing blocks for folio */
 510	if (gfs2_is_stuffed(ip)) {
 511		err = gfs2_unstuff_dinode(ip);
 512		if (err) {
 513			ret = vmf_fs_error(err);
 514			goto out_trans_end;
 515		}
 516	}
 517
 518	folio_lock(folio);
 519	/* If truncated, we must retry the operation, we may have raced
 520	 * with the glock demotion code.
 521	 */
 522	if (!folio_test_uptodate(folio) || folio->mapping != inode->i_mapping) {
 523		ret = VM_FAULT_NOPAGE;
 524		goto out_page_locked;
 525	}
 526
 527	err = gfs2_allocate_folio_backing(folio, length);
 528	if (err)
 529		ret = vmf_fs_error(err);
 530
 531out_page_locked:
 532	if (ret != VM_FAULT_LOCKED)
 533		folio_unlock(folio);
 534out_trans_end:
 535	gfs2_trans_end(sdp);
 536out_trans_fail:
 537	gfs2_inplace_release(ip);
 538out_quota_unlock:
 539	gfs2_quota_unlock(ip);
 540out_unlock:
 541	gfs2_glock_dq(&gh);
 542out_uninit:
 543	gfs2_holder_uninit(&gh);
 544	if (ret == VM_FAULT_LOCKED) {
 545		folio_mark_dirty(folio);
 546		folio_wait_stable(folio);
 547	}
 548	sb_end_pagefault(inode->i_sb);
 549	return ret;
 550}
 551
 552static vm_fault_t gfs2_fault(struct vm_fault *vmf)
 553{
 554	struct inode *inode = file_inode(vmf->vma->vm_file);
 555	struct gfs2_inode *ip = GFS2_I(inode);
 556	struct gfs2_holder gh;
 557	vm_fault_t ret;
 558	int err;
 559
 560	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
 561	err = gfs2_glock_nq(&gh);
 562	if (err) {
 563		ret = vmf_fs_error(err);
 564		goto out_uninit;
 565	}
 566	ret = filemap_fault(vmf);
 567	gfs2_glock_dq(&gh);
 568out_uninit:
 569	gfs2_holder_uninit(&gh);
 570	return ret;
 571}
 572
 573static const struct vm_operations_struct gfs2_vm_ops = {
 574	.fault = gfs2_fault,
 575	.map_pages = filemap_map_pages,
 576	.page_mkwrite = gfs2_page_mkwrite,
 577};
 578
 579/**
 580 * gfs2_mmap
 581 * @file: The file to map
 582 * @vma: The VMA which described the mapping
 583 *
 584 * There is no need to get a lock here unless we should be updating
 585 * atime. We ignore any locking errors since the only consequence is
 586 * a missed atime update (which will just be deferred until later).
 587 *
 588 * Returns: 0
 589 */
 590
 591static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
 592{
 593	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
 594
 595	if (!(file->f_flags & O_NOATIME) &&
 596	    !IS_NOATIME(&ip->i_inode)) {
 597		struct gfs2_holder i_gh;
 598		int error;
 599
 600		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
 601					   &i_gh);
 602		if (error)
 603			return error;
 604		/* grab lock to update inode */
 605		gfs2_glock_dq_uninit(&i_gh);
 606		file_accessed(file);
 607	}
 608	vma->vm_ops = &gfs2_vm_ops;
 609
 610	return 0;
 611}
 612
 613/**
 614 * gfs2_open_common - This is common to open and atomic_open
 615 * @inode: The inode being opened
 616 * @file: The file being opened
 617 *
 618 * This maybe called under a glock or not depending upon how it has
 619 * been called. We must always be called under a glock for regular
 620 * files, however. For other file types, it does not matter whether
 621 * we hold the glock or not.
 622 *
 623 * Returns: Error code or 0 for success
 624 */
 625
 626int gfs2_open_common(struct inode *inode, struct file *file)
 627{
 628	struct gfs2_file *fp;
 629	int ret;
 630
 631	if (S_ISREG(inode->i_mode)) {
 632		ret = generic_file_open(inode, file);
 633		if (ret)
 634			return ret;
 635
 636		if (!gfs2_is_jdata(GFS2_I(inode)))
 637			file->f_mode |= FMODE_CAN_ODIRECT;
 638	}
 639
 640	fp = kzalloc(sizeof(struct gfs2_file), GFP_NOFS);
 641	if (!fp)
 642		return -ENOMEM;
 643
 644	mutex_init(&fp->f_fl_mutex);
 645
 646	gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
 647	file->private_data = fp;
 648	if (file->f_mode & FMODE_WRITE) {
 649		ret = gfs2_qa_get(GFS2_I(inode));
 650		if (ret)
 651			goto fail;
 652	}
 653	return 0;
 654
 655fail:
 656	kfree(file->private_data);
 657	file->private_data = NULL;
 658	return ret;
 659}
 660
 661/**
 662 * gfs2_open - open a file
 663 * @inode: the inode to open
 664 * @file: the struct file for this opening
 665 *
 666 * After atomic_open, this function is only used for opening files
 667 * which are already cached. We must still get the glock for regular
 668 * files to ensure that we have the file size uptodate for the large
 669 * file check which is in the common code. That is only an issue for
 670 * regular files though.
 671 *
 672 * Returns: errno
 673 */
 674
 675static int gfs2_open(struct inode *inode, struct file *file)
 676{
 677	struct gfs2_inode *ip = GFS2_I(inode);
 678	struct gfs2_holder i_gh;
 679	int error;
 680	bool need_unlock = false;
 681
 682	if (S_ISREG(ip->i_inode.i_mode)) {
 683		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
 684					   &i_gh);
 685		if (error)
 686			return error;
 687		need_unlock = true;
 688	}
 689
 690	error = gfs2_open_common(inode, file);
 691
 692	if (need_unlock)
 693		gfs2_glock_dq_uninit(&i_gh);
 694
 695	return error;
 696}
 697
 698/**
 699 * gfs2_release - called to close a struct file
 700 * @inode: the inode the struct file belongs to
 701 * @file: the struct file being closed
 702 *
 703 * Returns: errno
 704 */
 705
 706static int gfs2_release(struct inode *inode, struct file *file)
 707{
 708	struct gfs2_inode *ip = GFS2_I(inode);
 709
 710	kfree(file->private_data);
 711	file->private_data = NULL;
 712
 713	if (file->f_mode & FMODE_WRITE) {
 714		if (gfs2_rs_active(&ip->i_res))
 715			gfs2_rs_delete(ip);
 716		gfs2_qa_put(ip);
 717	}
 718	return 0;
 719}
 720
 721/**
 722 * gfs2_fsync - sync the dirty data for a file (across the cluster)
 723 * @file: the file that points to the dentry
 724 * @start: the start position in the file to sync
 725 * @end: the end position in the file to sync
 726 * @datasync: set if we can ignore timestamp changes
 727 *
 728 * We split the data flushing here so that we don't wait for the data
 729 * until after we've also sent the metadata to disk. Note that for
 730 * data=ordered, we will write & wait for the data at the log flush
 731 * stage anyway, so this is unlikely to make much of a difference
 732 * except in the data=writeback case.
 733 *
 734 * If the fdatawrite fails due to any reason except -EIO, we will
 735 * continue the remainder of the fsync, although we'll still report
 736 * the error at the end. This is to match filemap_write_and_wait_range()
 737 * behaviour.
 738 *
 739 * Returns: errno
 740 */
 741
 742static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
 743		      int datasync)
 744{
 745	struct address_space *mapping = file->f_mapping;
 746	struct inode *inode = mapping->host;
 747	int sync_state = inode_state_read_once(inode) & I_DIRTY;
 748	struct gfs2_inode *ip = GFS2_I(inode);
 749	int ret = 0, ret1 = 0;
 750
 751	if (mapping->nrpages) {
 752		ret1 = filemap_fdatawrite_range(mapping, start, end);
 753		if (ret1 == -EIO)
 754			return ret1;
 755	}
 756
 757	if (!gfs2_is_jdata(ip))
 758		sync_state &= ~I_DIRTY_PAGES;
 759	if (datasync)
 760		sync_state &= ~I_DIRTY_SYNC;
 761
 762	if (sync_state) {
 763		ret = sync_inode_metadata(inode, 1);
 764		if (ret)
 765			return ret;
 766		if (gfs2_is_jdata(ip))
 767			ret = file_write_and_wait(file);
 768		if (ret)
 769			return ret;
 770		gfs2_ail_flush(ip->i_gl, 1);
 771	}
 772
 773	if (mapping->nrpages)
 774		ret = file_fdatawait_range(file, start, end);
 775
 776	return ret ? ret : ret1;
 777}
 778
 779static inline bool should_fault_in_pages(struct iov_iter *i,
 780					 struct kiocb *iocb,
 781					 size_t *prev_count,
 782					 size_t *window_size)
 783{
 784	size_t count = iov_iter_count(i);
 785	size_t size, offs;
 786
 787	if (!count)
 788		return false;
 789	if (!user_backed_iter(i))
 790		return false;
 791
 792	/*
 793	 * Try to fault in multiple pages initially.  When that doesn't result
 794	 * in any progress, fall back to a single page.
 795	 */
 796	size = PAGE_SIZE;
 797	offs = offset_in_page(iocb->ki_pos);
 798	if (*prev_count != count) {
 799		size_t nr_dirtied;
 800
 801		nr_dirtied = max(current->nr_dirtied_pause -
 802				 current->nr_dirtied, 8);
 803		size = min_t(size_t, SZ_1M, nr_dirtied << PAGE_SHIFT);
 804	}
 805
 806	*prev_count = count;
 807	*window_size = size - offs;
 808	return true;
 809}
 810
 811static ssize_t gfs2_file_direct_read(struct kiocb *iocb, struct iov_iter *to,
 812				     struct gfs2_holder *gh)
 813{
 814	struct file *file = iocb->ki_filp;
 815	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
 816	size_t prev_count = 0, window_size = 0;
 817	size_t read = 0;
 818	ssize_t ret;
 819
 820	/*
 821	 * In this function, we disable page faults when we're holding the
 822	 * inode glock while doing I/O.  If a page fault occurs, we indicate
 823	 * that the inode glock should be dropped, fault in the pages manually,
 824	 * and retry.
 825	 *
 826	 * Unlike generic_file_read_iter, for reads, iomap_dio_rw can trigger
 827	 * physical as well as manual page faults, and we need to disable both
 828	 * kinds.
 829	 *
 830	 * For direct I/O, gfs2 takes the inode glock in deferred mode.  This
 831	 * locking mode is compatible with other deferred holders, so multiple
 832	 * processes and nodes can do direct I/O to a file at the same time.
 833	 * There's no guarantee that reads or writes will be atomic.  Any
 834	 * coordination among readers and writers needs to happen externally.
 835	 */
 836
 837	if (!iov_iter_count(to))
 838		return 0; /* skip atime */
 839
 840	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, gh);
 841retry:
 842	ret = gfs2_glock_nq(gh);
 843	if (ret)
 844		goto out_uninit;
 845	pagefault_disable();
 846	to->nofault = true;
 847	ret = iomap_dio_rw(iocb, to, &gfs2_iomap_ops, NULL,
 848			   IOMAP_DIO_PARTIAL, NULL, read);
 849	to->nofault = false;
 850	pagefault_enable();
 851	if (ret <= 0 && ret != -EFAULT)
 852		goto out_unlock;
 853	/* No increment (+=) because iomap_dio_rw returns a cumulative value. */
 854	if (ret > 0)
 855		read = ret;
 856
 857	if (should_fault_in_pages(to, iocb, &prev_count, &window_size)) {
 858		gfs2_glock_dq(gh);
 859		window_size -= fault_in_iov_iter_writeable(to, window_size);
 860		if (window_size)
 861			goto retry;
 862	}
 863out_unlock:
 864	if (gfs2_holder_queued(gh))
 865		gfs2_glock_dq(gh);
 866out_uninit:
 867	gfs2_holder_uninit(gh);
 868	/* User space doesn't expect partial success. */
 869	if (ret < 0)
 870		return ret;
 871	return read;
 872}
 873
 874static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from,
 875				      struct gfs2_holder *gh)
 876{
 877	struct file *file = iocb->ki_filp;
 878	struct inode *inode = file->f_mapping->host;
 879	struct gfs2_inode *ip = GFS2_I(inode);
 880	size_t prev_count = 0, window_size = 0;
 881	size_t written = 0;
 882	bool enough_retries;
 883	ssize_t ret;
 884
 885	/*
 886	 * In this function, we disable page faults when we're holding the
 887	 * inode glock while doing I/O.  If a page fault occurs, we indicate
 888	 * that the inode glock should be dropped, fault in the pages manually,
 889	 * and retry.
 890	 *
 891	 * For writes, iomap_dio_rw only triggers manual page faults, so we
 892	 * don't need to disable physical ones.
 893	 */
 894
 895	/*
 896	 * Deferred lock, even if its a write, since we do no allocation on
 897	 * this path. All we need to change is the atime, and this lock mode
 898	 * ensures that other nodes have flushed their buffered read caches
 899	 * (i.e. their page cache entries for this inode). We do not,
 900	 * unfortunately, have the option of only flushing a range like the
 901	 * VFS does.
 902	 */
 903	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, gh);
 904retry:
 905	ret = gfs2_glock_nq(gh);
 906	if (ret)
 907		goto out_uninit;
 908	/* Silently fall back to buffered I/O when writing beyond EOF */
 909	if (iocb->ki_pos + iov_iter_count(from) > i_size_read(&ip->i_inode))
 910		goto out_unlock;
 911
 912	from->nofault = true;
 913	ret = iomap_dio_rw(iocb, from, &gfs2_iomap_ops, NULL,
 914			   IOMAP_DIO_PARTIAL, NULL, written);
 915	from->nofault = false;
 916	if (ret <= 0) {
 917		if (ret == -ENOTBLK)
 918			ret = 0;
 919		if (ret != -EFAULT)
 920			goto out_unlock;
 921	}
 922	/* No increment (+=) because iomap_dio_rw returns a cumulative value. */
 923	if (ret > 0)
 924		written = ret;
 925
 926	enough_retries = prev_count == iov_iter_count(from) &&
 927			 window_size <= PAGE_SIZE;
 928	if (should_fault_in_pages(from, iocb, &prev_count, &window_size)) {
 929		gfs2_glock_dq(gh);
 930		window_size -= fault_in_iov_iter_readable(from, window_size);
 931		if (window_size) {
 932			if (!enough_retries)
 933				goto retry;
 934			/* fall back to buffered I/O */
 935			ret = 0;
 936		}
 937	}
 938out_unlock:
 939	if (gfs2_holder_queued(gh))
 940		gfs2_glock_dq(gh);
 941out_uninit:
 942	gfs2_holder_uninit(gh);
 943	/* User space doesn't expect partial success. */
 944	if (ret < 0)
 945		return ret;
 946	return written;
 947}
 948
 949static ssize_t gfs2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
 950{
 951	struct gfs2_inode *ip;
 952	struct gfs2_holder gh;
 953	size_t prev_count = 0, window_size = 0;
 954	size_t read = 0;
 955	ssize_t ret;
 956
 957	/*
 958	 * In this function, we disable page faults when we're holding the
 959	 * inode glock while doing I/O.  If a page fault occurs, we indicate
 960	 * that the inode glock should be dropped, fault in the pages manually,
 961	 * and retry.
 962	 */
 963
 964	if (iocb->ki_flags & IOCB_DIRECT)
 965		return gfs2_file_direct_read(iocb, to, &gh);
 966
 967	pagefault_disable();
 968	iocb->ki_flags |= IOCB_NOIO;
 969	ret = generic_file_read_iter(iocb, to);
 970	iocb->ki_flags &= ~IOCB_NOIO;
 971	pagefault_enable();
 972	if (ret >= 0) {
 973		if (!iov_iter_count(to))
 974			return ret;
 975		read = ret;
 976	} else if (ret != -EFAULT) {
 977		if (ret != -EAGAIN)
 978			return ret;
 979		if (iocb->ki_flags & IOCB_NOWAIT)
 980			return ret;
 981	}
 982	ip = GFS2_I(iocb->ki_filp->f_mapping->host);
 983	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
 984retry:
 985	ret = gfs2_glock_nq(&gh);
 986	if (ret)
 987		goto out_uninit;
 988	pagefault_disable();
 989	ret = generic_file_read_iter(iocb, to);
 990	pagefault_enable();
 991	if (ret <= 0 && ret != -EFAULT)
 992		goto out_unlock;
 993	if (ret > 0)
 994		read += ret;
 995
 996	if (should_fault_in_pages(to, iocb, &prev_count, &window_size)) {
 997		gfs2_glock_dq(&gh);
 998		window_size -= fault_in_iov_iter_writeable(to, window_size);
 999		if (window_size)
1000			goto retry;
1001	}
1002out_unlock:
1003	if (gfs2_holder_queued(&gh))
1004		gfs2_glock_dq(&gh);
1005out_uninit:
1006	gfs2_holder_uninit(&gh);
1007	return read ? read : ret;
1008}
1009
1010static ssize_t gfs2_file_buffered_write(struct kiocb *iocb,
1011					struct iov_iter *from,
1012					struct gfs2_holder *gh)
1013{
1014	struct file *file = iocb->ki_filp;
1015	struct inode *inode = file_inode(file);
1016	struct gfs2_inode *ip = GFS2_I(inode);
1017	struct gfs2_sbd *sdp = GFS2_SB(inode);
1018	struct gfs2_holder *statfs_gh = NULL;
1019	size_t prev_count = 0, window_size = 0;
1020	size_t orig_count = iov_iter_count(from);
1021	size_t written = 0;
1022	ssize_t ret;
1023
1024	/*
1025	 * In this function, we disable page faults when we're holding the
1026	 * inode glock while doing I/O.  If a page fault occurs, we indicate
1027	 * that the inode glock should be dropped, fault in the pages manually,
1028	 * and retry.
1029	 */
1030
1031	if (inode == sdp->sd_rindex) {
1032		statfs_gh = kmalloc(sizeof(*statfs_gh), GFP_NOFS);
1033		if (!statfs_gh)
1034			return -ENOMEM;
1035	}
1036
1037	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, gh);
1038	if (should_fault_in_pages(from, iocb, &prev_count, &window_size)) {
1039retry:
1040		window_size -= fault_in_iov_iter_readable(from, window_size);
1041		if (!window_size) {
1042			ret = -EFAULT;
1043			goto out_uninit;
1044		}
1045		from->count = min(from->count, window_size);
1046	}
1047	ret = gfs2_glock_nq(gh);
1048	if (ret)
1049		goto out_uninit;
1050
1051	if (inode == sdp->sd_rindex) {
1052		struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
1053
1054		ret = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,
1055					 GL_NOCACHE, statfs_gh);
1056		if (ret)
1057			goto out_unlock;
1058	}
1059
1060	pagefault_disable();
1061	ret = iomap_file_buffered_write(iocb, from, &gfs2_iomap_ops,
1062			&gfs2_iomap_write_ops, NULL);
1063	pagefault_enable();
1064	if (ret > 0)
1065		written += ret;
1066
1067	if (inode == sdp->sd_rindex)
1068		gfs2_glock_dq_uninit(statfs_gh);
1069
1070	if (ret <= 0 && ret != -EFAULT)
1071		goto out_unlock;
1072
1073	from->count = orig_count - written;
1074	if (should_fault_in_pages(from, iocb, &prev_count, &window_size)) {
1075		gfs2_glock_dq(gh);
1076		goto retry;
1077	}
1078out_unlock:
1079	if (gfs2_holder_queued(gh))
1080		gfs2_glock_dq(gh);
1081out_uninit:
1082	gfs2_holder_uninit(gh);
1083	kfree(statfs_gh);
1084	from->count = orig_count - written;
1085	return written ? written : ret;
1086}
1087
1088/**
1089 * gfs2_file_write_iter - Perform a write to a file
1090 * @iocb: The io context
1091 * @from: The data to write
1092 *
1093 * We have to do a lock/unlock here to refresh the inode size for
1094 * O_APPEND writes, otherwise we can land up writing at the wrong
1095 * offset. There is still a race, but provided the app is using its
1096 * own file locking, this will make O_APPEND work as expected.
1097 *
1098 */
1099
1100static ssize_t gfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
1101{
1102	struct file *file = iocb->ki_filp;
1103	struct inode *inode = file_inode(file);
1104	struct gfs2_inode *ip = GFS2_I(inode);
1105	struct gfs2_holder gh;
1106	ssize_t ret;
1107
1108	gfs2_size_hint(file, iocb->ki_pos, iov_iter_count(from));
1109
1110	if (iocb->ki_flags & IOCB_APPEND) {
1111		ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
1112		if (ret)
1113			return ret;
1114		gfs2_glock_dq_uninit(&gh);
1115	}
1116
1117	inode_lock(inode);
1118	ret = generic_write_checks(iocb, from);
1119	if (ret <= 0)
1120		goto out_unlock;
1121
1122	ret = file_remove_privs(file);
1123	if (ret)
1124		goto out_unlock;
1125
1126	if (iocb->ki_flags & IOCB_DIRECT) {
1127		struct address_space *mapping = file->f_mapping;
1128		ssize_t buffered, ret2;
1129
1130		/*
1131		 * Note that under direct I/O, we don't allow and inode
1132		 * timestamp updates, so we're not calling file_update_time()
1133		 * here.
1134		 */
1135
1136		ret = gfs2_file_direct_write(iocb, from, &gh);
1137		if (ret < 0 || !iov_iter_count(from))
1138			goto out_unlock;
1139
1140		iocb->ki_flags |= IOCB_DSYNC;
1141		buffered = gfs2_file_buffered_write(iocb, from, &gh);
1142		if (unlikely(buffered <= 0)) {
1143			if (!ret)
1144				ret = buffered;
1145			goto out_unlock;
1146		}
1147
1148		/*
1149		 * We need to ensure that the page cache pages are written to
1150		 * disk and invalidated to preserve the expected O_DIRECT
1151		 * semantics.  If the writeback or invalidate fails, only report
1152		 * the direct I/O range as we don't know if the buffered pages
1153		 * made it to disk.
1154		 */
1155		ret2 = generic_write_sync(iocb, buffered);
1156		invalidate_mapping_pages(mapping,
1157				(iocb->ki_pos - buffered) >> PAGE_SHIFT,
1158				(iocb->ki_pos - 1) >> PAGE_SHIFT);
1159		if (!ret || ret2 > 0)
1160			ret += ret2;
1161	} else {
1162		ret = file_update_time(file);
1163		if (ret)
1164			goto out_unlock;
1165
1166		ret = gfs2_file_buffered_write(iocb, from, &gh);
1167		if (likely(ret > 0))
1168			ret = generic_write_sync(iocb, ret);
1169	}
1170
1171out_unlock:
1172	inode_unlock(inode);
1173	return ret;
1174}
1175
1176static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,
1177			   int mode)
1178{
1179	struct super_block *sb = inode->i_sb;
1180	struct gfs2_inode *ip = GFS2_I(inode);
1181	loff_t end = offset + len;
1182	struct buffer_head *dibh;
1183	int error;
1184
1185	error = gfs2_meta_inode_buffer(ip, &dibh);
1186	if (unlikely(error))
1187		return error;
1188
1189	gfs2_trans_add_meta(ip->i_gl, dibh);
1190
1191	if (gfs2_is_stuffed(ip)) {
1192		error = gfs2_unstuff_dinode(ip);
1193		if (unlikely(error))
1194			goto out;
1195	}
1196
1197	while (offset < end) {
1198		struct iomap iomap = { };
1199
1200		error = gfs2_iomap_alloc(inode, offset, end - offset, &iomap);
1201		if (error)
1202			goto out;
1203		offset = iomap.offset + iomap.length;
1204		if (!(iomap.flags & IOMAP_F_NEW))
1205			continue;
1206		error = sb_issue_zeroout(sb, iomap.addr >> inode->i_blkbits,
1207					 iomap.length >> inode->i_blkbits,
1208					 GFP_NOFS);
1209		if (error) {
1210			fs_err(GFS2_SB(inode), "Failed to zero data buffers\n");
1211			goto out;
1212		}
1213	}
1214out:
1215	brelse(dibh);
1216	return error;
1217}
1218
1219/**
1220 * calc_max_reserv() - Reverse of write_calc_reserv. Given a number of
1221 *                     blocks, determine how many bytes can be written.
1222 * @ip:          The inode in question.
1223 * @len:         Max cap of bytes. What we return in *len must be <= this.
1224 * @data_blocks: Compute and return the number of data blocks needed
1225 * @ind_blocks:  Compute and return the number of indirect blocks needed
1226 * @max_blocks:  The total blocks available to work with.
1227 *
1228 * Returns: void, but @len, @data_blocks and @ind_blocks are filled in.
1229 */
1230static void calc_max_reserv(struct gfs2_inode *ip, loff_t *len,
1231			    unsigned int *data_blocks, unsigned int *ind_blocks,
1232			    unsigned int max_blocks)
1233{
1234	loff_t max = *len;
1235	const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1236	unsigned int tmp, max_data = max_blocks - 3 * (sdp->sd_max_height - 1);
1237
1238	for (tmp = max_data; tmp > sdp->sd_diptrs;) {
1239		tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);
1240		max_data -= tmp;
1241	}
1242
1243	*data_blocks = max_data;
1244	*ind_blocks = max_blocks - max_data;
1245	*len = ((loff_t)max_data - 3) << sdp->sd_sb.sb_bsize_shift;
1246	if (*len > max) {
1247		*len = max;
1248		gfs2_write_calc_reserv(ip, max, data_blocks, ind_blocks);
1249	}
1250}
1251
1252static long __gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
1253{
1254	struct inode *inode = file_inode(file);
1255	struct gfs2_sbd *sdp = GFS2_SB(inode);
1256	struct gfs2_inode *ip = GFS2_I(inode);
1257	struct gfs2_alloc_parms ap = {};
1258	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
1259	loff_t bytes, max_bytes, max_blks;
1260	int error;
1261	const loff_t pos = offset;
1262	const loff_t count = len;
1263	loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1);
1264	loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift;
1265	loff_t max_chunk_size = UINT_MAX & bsize_mask;
1266
1267	next = (next + 1) << sdp->sd_sb.sb_bsize_shift;
1268
1269	offset &= bsize_mask;
1270
1271	len = next - offset;
1272	bytes = sdp->sd_max_rg_data * sdp->sd_sb.sb_bsize / 2;
1273	if (!bytes)
1274		bytes = UINT_MAX;
1275	bytes &= bsize_mask;
1276	if (bytes == 0)
1277		bytes = sdp->sd_sb.sb_bsize;
1278
1279	gfs2_size_hint(file, offset, len);
1280
1281	gfs2_write_calc_reserv(ip, PAGE_SIZE, &data_blocks, &ind_blocks);
1282	ap.min_target = data_blocks + ind_blocks;
1283
1284	while (len > 0) {
1285		if (len < bytes)
1286			bytes = len;
1287		if (!gfs2_write_alloc_required(ip, offset, bytes)) {
1288			len -= bytes;
1289			offset += bytes;
1290			continue;
1291		}
1292
1293		/* We need to determine how many bytes we can actually
1294		 * fallocate without exceeding quota or going over the
1295		 * end of the fs. We start off optimistically by assuming
1296		 * we can write max_bytes */
1297		max_bytes = (len > max_chunk_size) ? max_chunk_size : len;
1298
1299		/* Since max_bytes is most likely a theoretical max, we
1300		 * calculate a more realistic 'bytes' to serve as a good
1301		 * starting point for the number of bytes we may be able
1302		 * to write */
1303		gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks);
1304		ap.target = data_blocks + ind_blocks;
1305
1306		error = gfs2_quota_lock_check(ip, &ap);
1307		if (error)
1308			return error;
1309		/* ap.allowed tells us how many blocks quota will allow
1310		 * us to write. Check if this reduces max_blks */
1311		max_blks = UINT_MAX;
1312		if (ap.allowed)
1313			max_blks = ap.allowed;
1314
1315		error = gfs2_inplace_reserve(ip, &ap);
1316		if (error)
1317			goto out_qunlock;
1318
1319		/* check if the selected rgrp limits our max_blks further */
1320		if (ip->i_res.rs_reserved < max_blks)
1321			max_blks = ip->i_res.rs_reserved;
1322
1323		/* Almost done. Calculate bytes that can be written using
1324		 * max_blks. We also recompute max_bytes, data_blocks and
1325		 * ind_blocks */
1326		calc_max_reserv(ip, &max_bytes, &data_blocks,
1327				&ind_blocks, max_blks);
1328
1329		rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA +
1330			  RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks);
1331		if (gfs2_is_jdata(ip))
1332			rblocks += data_blocks ? data_blocks : 1;
1333
1334		error = gfs2_trans_begin(sdp, rblocks,
1335					 PAGE_SIZE >> inode->i_blkbits);
1336		if (error)
1337			goto out_trans_fail;
1338
1339		error = fallocate_chunk(inode, offset, max_bytes, mode);
1340		gfs2_trans_end(sdp);
1341
1342		if (error)
1343			goto out_trans_fail;
1344
1345		len -= max_bytes;
1346		offset += max_bytes;
1347		gfs2_inplace_release(ip);
1348		gfs2_quota_unlock(ip);
1349	}
1350
1351	if (!(mode & FALLOC_FL_KEEP_SIZE) && (pos + count) > inode->i_size)
1352		i_size_write(inode, pos + count);
1353	file_update_time(file);
1354	mark_inode_dirty(inode);
1355
1356	if ((file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host))
1357		return vfs_fsync_range(file, pos, pos + count - 1,
1358			       (file->f_flags & __O_SYNC) ? 0 : 1);
1359	return 0;
1360
1361out_trans_fail:
1362	gfs2_inplace_release(ip);
1363out_qunlock:
1364	gfs2_quota_unlock(ip);
1365	return error;
1366}
1367
1368static long gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
1369{
1370	struct inode *inode = file_inode(file);
1371	struct gfs2_sbd *sdp = GFS2_SB(inode);
1372	struct gfs2_inode *ip = GFS2_I(inode);
1373	struct gfs2_holder gh;
1374	int ret;
1375
1376	if (mode & ~(FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE))
1377		return -EOPNOTSUPP;
1378	/* fallocate is needed by gfs2_grow to reserve space in the rindex */
1379	if (gfs2_is_jdata(ip) && inode != sdp->sd_rindex)
1380		return -EOPNOTSUPP;
1381
1382	inode_lock(inode);
1383
1384	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1385	ret = gfs2_glock_nq(&gh);
1386	if (ret)
1387		goto out_uninit;
1388
1389	if (!(mode & FALLOC_FL_KEEP_SIZE) &&
1390	    (offset + len) > inode->i_size) {
1391		ret = inode_newsize_ok(inode, offset + len);
1392		if (ret)
1393			goto out_unlock;
1394	}
1395
1396	ret = get_write_access(inode);
1397	if (ret)
1398		goto out_unlock;
1399
1400	if (mode & FALLOC_FL_PUNCH_HOLE) {
1401		ret = __gfs2_punch_hole(file, offset, len);
1402	} else {
1403		ret = __gfs2_fallocate(file, mode, offset, len);
1404		if (ret)
1405			gfs2_rs_deltree(&ip->i_res);
1406	}
1407
1408	put_write_access(inode);
1409out_unlock:
1410	gfs2_glock_dq(&gh);
1411out_uninit:
1412	gfs2_holder_uninit(&gh);
1413	inode_unlock(inode);
1414	return ret;
1415}
1416
1417static ssize_t gfs2_file_splice_write(struct pipe_inode_info *pipe,
1418				      struct file *out, loff_t *ppos,
1419				      size_t len, unsigned int flags)
1420{
1421	ssize_t ret;
1422
1423	gfs2_size_hint(out, *ppos, len);
1424
1425	ret = iter_file_splice_write(pipe, out, ppos, len, flags);
1426	return ret;
1427}
1428
1429#ifdef CONFIG_GFS2_FS_LOCKING_DLM
1430
1431/**
1432 * gfs2_lock - acquire/release a posix lock on a file
1433 * @file: the file pointer
1434 * @cmd: either modify or retrieve lock state, possibly wait
1435 * @fl: type and range of lock
1436 *
1437 * Returns: errno
1438 */
1439
1440static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
1441{
1442	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
1443	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
1444	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
1445	int ret;
1446
1447	if (!(fl->c.flc_flags & FL_POSIX))
1448		return -ENOLCK;
1449	if (gfs2_withdrawn(sdp)) {
1450		if (lock_is_unlock(fl))
1451			locks_lock_file_wait(file, fl);
1452		return -EIO;
1453	}
1454	down_read(&ls->ls_sem);
1455	ret = -ENODEV;
1456	if (likely(ls->ls_dlm != NULL)) {
1457		if (cmd == F_CANCELLK)
1458			ret = dlm_posix_cancel(ls->ls_dlm, ip->i_no_addr, file, fl);
1459		else if (IS_GETLK(cmd))
1460			ret = dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl);
1461		else if (lock_is_unlock(fl))
1462			ret = dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl);
1463		else
1464			ret = dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl);
1465	}
1466	up_read(&ls->ls_sem);
1467	return ret;
1468}
1469
1470static void __flock_holder_uninit(struct file *file, struct gfs2_holder *fl_gh)
1471{
1472	struct gfs2_glock *gl = gfs2_glock_hold(fl_gh->gh_gl);
1473
1474	/*
1475	 * Make sure gfs2_glock_put() won't sleep under the file->f_lock
1476	 * spinlock.
1477	 */
1478
1479	spin_lock(&file->f_lock);
1480	gfs2_holder_uninit(fl_gh);
1481	spin_unlock(&file->f_lock);
1482	gfs2_glock_put(gl);
1483}
1484
1485static int do_flock(struct file *file, int cmd, struct file_lock *fl)
1486{
1487	struct gfs2_file *fp = file->private_data;
1488	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
1489	struct gfs2_inode *ip = GFS2_I(file_inode(file));
1490	struct gfs2_glock *gl;
1491	unsigned int state;
1492	u16 flags;
1493	int error = 0;
1494	int sleeptime;
1495
1496	state = lock_is_write(fl) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
1497	flags = GL_EXACT | GL_NOPID;
1498	if (!IS_SETLKW(cmd))
1499		flags |= LM_FLAG_TRY_1CB;
1500
1501	mutex_lock(&fp->f_fl_mutex);
1502
1503	if (gfs2_holder_initialized(fl_gh)) {
1504		struct file_lock request;
1505		if (fl_gh->gh_state == state)
1506			goto out;
1507		locks_init_lock(&request);
1508		request.c.flc_type = F_UNLCK;
1509		request.c.flc_flags = FL_FLOCK;
1510		locks_lock_file_wait(file, &request);
1511		gfs2_glock_dq(fl_gh);
1512		gfs2_holder_reinit(state, flags, fl_gh);
1513	} else {
1514		error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr,
1515				       &gfs2_flock_glops, CREATE, &gl);
1516		if (error)
1517			goto out;
1518		spin_lock(&file->f_lock);
1519		gfs2_holder_init(gl, state, flags, fl_gh);
1520		spin_unlock(&file->f_lock);
1521		gfs2_glock_put(gl);
1522	}
1523	for (sleeptime = 1; sleeptime <= 4; sleeptime <<= 1) {
1524		error = gfs2_glock_nq(fl_gh);
1525		if (error != GLR_TRYFAILED)
1526			break;
1527		fl_gh->gh_flags &= ~LM_FLAG_TRY_1CB;
1528		fl_gh->gh_flags |= LM_FLAG_TRY;
1529		msleep(sleeptime);
1530	}
1531	if (error) {
1532		__flock_holder_uninit(file, fl_gh);
1533		if (error == GLR_TRYFAILED)
1534			error = -EAGAIN;
1535	} else {
1536		error = locks_lock_file_wait(file, fl);
1537		gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
1538	}
1539
1540out:
1541	mutex_unlock(&fp->f_fl_mutex);
1542	return error;
1543}
1544
1545static void do_unflock(struct file *file, struct file_lock *fl)
1546{
1547	struct gfs2_file *fp = file->private_data;
1548	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
1549
1550	mutex_lock(&fp->f_fl_mutex);
1551	locks_lock_file_wait(file, fl);
1552	if (gfs2_holder_initialized(fl_gh)) {
1553		gfs2_glock_dq(fl_gh);
1554		__flock_holder_uninit(file, fl_gh);
1555	}
1556	mutex_unlock(&fp->f_fl_mutex);
1557}
1558
1559/**
1560 * gfs2_flock - acquire/release a flock lock on a file
1561 * @file: the file pointer
1562 * @cmd: either modify or retrieve lock state, possibly wait
1563 * @fl: type and range of lock
1564 *
1565 * Returns: errno
1566 */
1567
1568static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
1569{
1570	if (!(fl->c.flc_flags & FL_FLOCK))
1571		return -ENOLCK;
1572
1573	if (lock_is_unlock(fl)) {
1574		do_unflock(file, fl);
1575		return 0;
1576	} else {
1577		return do_flock(file, cmd, fl);
1578	}
1579}
1580
1581const struct file_operations gfs2_file_fops = {
1582	.llseek		= gfs2_llseek,
1583	.read_iter	= gfs2_file_read_iter,
1584	.write_iter	= gfs2_file_write_iter,
1585	.iopoll		= iocb_bio_iopoll,
1586	.unlocked_ioctl	= gfs2_ioctl,
1587	.compat_ioctl	= gfs2_compat_ioctl,
1588	.mmap		= gfs2_mmap,
1589	.open		= gfs2_open,
1590	.release	= gfs2_release,
1591	.fsync		= gfs2_fsync,
1592	.lock		= gfs2_lock,
1593	.flock		= gfs2_flock,
1594	.splice_read	= copy_splice_read,
1595	.splice_write	= gfs2_file_splice_write,
1596	.setlease	= simple_nosetlease,
1597	.fallocate	= gfs2_fallocate,
1598	.fop_flags	= FOP_ASYNC_LOCK,
1599};
1600
1601const struct file_operations gfs2_dir_fops = {
1602	.iterate_shared	= gfs2_readdir,
1603	.unlocked_ioctl	= gfs2_ioctl,
1604	.compat_ioctl	= gfs2_compat_ioctl,
1605	.open		= gfs2_open,
1606	.release	= gfs2_release,
1607	.fsync		= gfs2_fsync,
1608	.lock		= gfs2_lock,
1609	.flock		= gfs2_flock,
1610	.llseek		= default_llseek,
1611	.setlease	= simple_nosetlease,
1612	.fop_flags	= FOP_ASYNC_LOCK,
1613};
1614
1615#endif /* CONFIG_GFS2_FS_LOCKING_DLM */
1616
1617const struct file_operations gfs2_file_fops_nolock = {
1618	.llseek		= gfs2_llseek,
1619	.read_iter	= gfs2_file_read_iter,
1620	.write_iter	= gfs2_file_write_iter,
1621	.iopoll		= iocb_bio_iopoll,
1622	.unlocked_ioctl	= gfs2_ioctl,
1623	.compat_ioctl	= gfs2_compat_ioctl,
1624	.mmap		= gfs2_mmap,
1625	.open		= gfs2_open,
1626	.release	= gfs2_release,
1627	.fsync		= gfs2_fsync,
1628	.splice_read	= copy_splice_read,
1629	.splice_write	= gfs2_file_splice_write,
1630	.setlease	= generic_setlease,
1631	.fallocate	= gfs2_fallocate,
1632};
1633
1634const struct file_operations gfs2_dir_fops_nolock = {
1635	.iterate_shared	= gfs2_readdir,
1636	.unlocked_ioctl	= gfs2_ioctl,
1637	.compat_ioctl	= gfs2_compat_ioctl,
1638	.open		= gfs2_open,
1639	.release	= gfs2_release,
1640	.fsync		= gfs2_fsync,
1641	.llseek		= default_llseek,
1642};
1643