xref: /openbmc/linux/fs/gfs2/file.c (revision cd5d5810)
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9 
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #include <linux/buffer_head.h>
14 #include <linux/pagemap.h>
15 #include <linux/uio.h>
16 #include <linux/blkdev.h>
17 #include <linux/mm.h>
18 #include <linux/mount.h>
19 #include <linux/fs.h>
20 #include <linux/gfs2_ondisk.h>
21 #include <linux/falloc.h>
22 #include <linux/swap.h>
23 #include <linux/crc32.h>
24 #include <linux/writeback.h>
25 #include <asm/uaccess.h>
26 #include <linux/dlm.h>
27 #include <linux/dlm_plock.h>
28 #include <linux/aio.h>
29 
30 #include "gfs2.h"
31 #include "incore.h"
32 #include "bmap.h"
33 #include "dir.h"
34 #include "glock.h"
35 #include "glops.h"
36 #include "inode.h"
37 #include "log.h"
38 #include "meta_io.h"
39 #include "quota.h"
40 #include "rgrp.h"
41 #include "trans.h"
42 #include "util.h"
43 
44 /**
45  * gfs2_llseek - seek to a location in a file
46  * @file: the file
47  * @offset: the offset
48  * @whence: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
49  *
50  * SEEK_END requires the glock for the file because it references the
51  * file's size.
52  *
53  * Returns: The new offset, or errno
54  */
55 
56 static loff_t gfs2_llseek(struct file *file, loff_t offset, int whence)
57 {
58 	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
59 	struct gfs2_holder i_gh;
60 	loff_t error;
61 
62 	switch (whence) {
63 	case SEEK_END: /* These reference inode->i_size */
64 	case SEEK_DATA:
65 	case SEEK_HOLE:
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 	case SEEK_CUR:
74 	case SEEK_SET:
75 		error = generic_file_llseek(file, offset, whence);
76 		break;
77 	default:
78 		error = -EINVAL;
79 	}
80 
81 	return error;
82 }
83 
84 /**
85  * gfs2_readdir - Iterator for a directory
86  * @file: The directory to read from
87  * @ctx: What to feed directory entries to
88  *
89  * Returns: errno
90  */
91 
92 static int gfs2_readdir(struct file *file, struct dir_context *ctx)
93 {
94 	struct inode *dir = file->f_mapping->host;
95 	struct gfs2_inode *dip = GFS2_I(dir);
96 	struct gfs2_holder d_gh;
97 	int error;
98 
99 	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
100 	if (error)
101 		return error;
102 
103 	error = gfs2_dir_read(dir, ctx, &file->f_ra);
104 
105 	gfs2_glock_dq_uninit(&d_gh);
106 
107 	return error;
108 }
109 
110 /**
111  * fsflags_cvt
112  * @table: A table of 32 u32 flags
113  * @val: a 32 bit value to convert
114  *
115  * This function can be used to convert between fsflags values and
116  * GFS2's own flags values.
117  *
118  * Returns: the converted flags
119  */
120 static u32 fsflags_cvt(const u32 *table, u32 val)
121 {
122 	u32 res = 0;
123 	while(val) {
124 		if (val & 1)
125 			res |= *table;
126 		table++;
127 		val >>= 1;
128 	}
129 	return res;
130 }
131 
132 static const u32 fsflags_to_gfs2[32] = {
133 	[3] = GFS2_DIF_SYNC,
134 	[4] = GFS2_DIF_IMMUTABLE,
135 	[5] = GFS2_DIF_APPENDONLY,
136 	[7] = GFS2_DIF_NOATIME,
137 	[12] = GFS2_DIF_EXHASH,
138 	[14] = GFS2_DIF_INHERIT_JDATA,
139 	[17] = GFS2_DIF_TOPDIR,
140 };
141 
142 static const u32 gfs2_to_fsflags[32] = {
143 	[gfs2fl_Sync] = FS_SYNC_FL,
144 	[gfs2fl_Immutable] = FS_IMMUTABLE_FL,
145 	[gfs2fl_AppendOnly] = FS_APPEND_FL,
146 	[gfs2fl_NoAtime] = FS_NOATIME_FL,
147 	[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 {
154 	struct inode *inode = file_inode(filp);
155 	struct gfs2_inode *ip = GFS2_I(inode);
156 	struct gfs2_holder gh;
157 	int error;
158 	u32 fsflags;
159 
160 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
161 	error = gfs2_glock_nq(&gh);
162 	if (error)
163 		return error;
164 
165 	fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_diskflags);
166 	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 		error = -EFAULT;
170 
171 	gfs2_glock_dq(&gh);
172 	gfs2_holder_uninit(&gh);
173 	return error;
174 }
175 
176 void gfs2_set_inode_flags(struct inode *inode)
177 {
178 	struct gfs2_inode *ip = GFS2_I(inode);
179 	unsigned int flags = inode->i_flags;
180 
181 	flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_NOSEC);
182 	if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode))
183 		inode->i_flags |= S_NOSEC;
184 	if (ip->i_diskflags & GFS2_DIF_IMMUTABLE)
185 		flags |= S_IMMUTABLE;
186 	if (ip->i_diskflags & GFS2_DIF_APPENDONLY)
187 		flags |= S_APPEND;
188 	if (ip->i_diskflags & GFS2_DIF_NOATIME)
189 		flags |= S_NOATIME;
190 	if (ip->i_diskflags & GFS2_DIF_SYNC)
191 		flags |= S_SYNC;
192 	inode->i_flags = flags;
193 }
194 
195 /* Flags that can be set by user space */
196 #define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA|			\
197 			     GFS2_DIF_IMMUTABLE|		\
198 			     GFS2_DIF_APPENDONLY|		\
199 			     GFS2_DIF_NOATIME|			\
200 			     GFS2_DIF_SYNC|			\
201 			     GFS2_DIF_SYSTEM|			\
202 			     GFS2_DIF_TOPDIR|			\
203 			     GFS2_DIF_INHERIT_JDATA)
204 
205 /**
206  * gfs2_set_flags - set flags on an inode
207  * @inode: The inode
208  * @flags: The flags to set
209  * @mask: Indicates which flags are valid
210  *
211  */
212 static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
213 {
214 	struct inode *inode = file_inode(filp);
215 	struct gfs2_inode *ip = GFS2_I(inode);
216 	struct gfs2_sbd *sdp = GFS2_SB(inode);
217 	struct buffer_head *bh;
218 	struct gfs2_holder gh;
219 	int error;
220 	u32 new_flags, flags;
221 
222 	error = mnt_want_write_file(filp);
223 	if (error)
224 		return error;
225 
226 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
227 	if (error)
228 		goto out_drop_write;
229 
230 	error = -EACCES;
231 	if (!inode_owner_or_capable(inode))
232 		goto out;
233 
234 	error = 0;
235 	flags = ip->i_diskflags;
236 	new_flags = (flags & ~mask) | (reqflags & mask);
237 	if ((new_flags ^ flags) == 0)
238 		goto out;
239 
240 	error = -EINVAL;
241 	if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)
242 		goto out;
243 
244 	error = -EPERM;
245 	if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))
246 		goto out;
247 	if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))
248 		goto out;
249 	if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
250 	    !capable(CAP_LINUX_IMMUTABLE))
251 		goto out;
252 	if (!IS_IMMUTABLE(inode)) {
253 		error = gfs2_permission(inode, MAY_WRITE);
254 		if (error)
255 			goto out;
256 	}
257 	if ((flags ^ new_flags) & GFS2_DIF_JDATA) {
258 		if (flags & GFS2_DIF_JDATA)
259 			gfs2_log_flush(sdp, ip->i_gl);
260 		error = filemap_fdatawrite(inode->i_mapping);
261 		if (error)
262 			goto out;
263 		error = filemap_fdatawait(inode->i_mapping);
264 		if (error)
265 			goto out;
266 	}
267 	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
268 	if (error)
269 		goto out;
270 	error = gfs2_meta_inode_buffer(ip, &bh);
271 	if (error)
272 		goto out_trans_end;
273 	gfs2_trans_add_meta(ip->i_gl, bh);
274 	ip->i_diskflags = new_flags;
275 	gfs2_dinode_out(ip, bh->b_data);
276 	brelse(bh);
277 	gfs2_set_inode_flags(inode);
278 	gfs2_set_aops(inode);
279 out_trans_end:
280 	gfs2_trans_end(sdp);
281 out:
282 	gfs2_glock_dq_uninit(&gh);
283 out_drop_write:
284 	mnt_drop_write_file(filp);
285 	return error;
286 }
287 
288 static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
289 {
290 	struct inode *inode = file_inode(filp);
291 	u32 fsflags, gfsflags;
292 
293 	if (get_user(fsflags, ptr))
294 		return -EFAULT;
295 
296 	gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);
297 	if (!S_ISDIR(inode->i_mode)) {
298 		gfsflags &= ~GFS2_DIF_TOPDIR;
299 		if (gfsflags & GFS2_DIF_INHERIT_JDATA)
300 			gfsflags ^= (GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA);
301 		return do_gfs2_set_flags(filp, gfsflags, ~0);
302 	}
303 	return do_gfs2_set_flags(filp, gfsflags, ~GFS2_DIF_JDATA);
304 }
305 
306 static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
307 {
308 	switch(cmd) {
309 	case FS_IOC_GETFLAGS:
310 		return gfs2_get_flags(filp, (u32 __user *)arg);
311 	case FS_IOC_SETFLAGS:
312 		return gfs2_set_flags(filp, (u32 __user *)arg);
313 	case FITRIM:
314 		return gfs2_fitrim(filp, (void __user *)arg);
315 	}
316 	return -ENOTTY;
317 }
318 
319 /**
320  * gfs2_size_hint - Give a hint to the size of a write request
321  * @file: The struct file
322  * @offset: The file offset of the write
323  * @size: The length of the write
324  *
325  * When we are about to do a write, this function records the total
326  * write size in order to provide a suitable hint to the lower layers
327  * about how many blocks will be required.
328  *
329  */
330 
331 static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size)
332 {
333 	struct inode *inode = file_inode(filep);
334 	struct gfs2_sbd *sdp = GFS2_SB(inode);
335 	struct gfs2_inode *ip = GFS2_I(inode);
336 	size_t blks = (size + sdp->sd_sb.sb_bsize - 1) >> sdp->sd_sb.sb_bsize_shift;
337 	int hint = min_t(size_t, INT_MAX, blks);
338 
339 	atomic_set(&ip->i_res->rs_sizehint, hint);
340 }
341 
342 /**
343  * gfs2_allocate_page_backing - Use bmap to allocate blocks
344  * @page: The (locked) page to allocate backing for
345  *
346  * We try to allocate all the blocks required for the page in
347  * one go. This might fail for various reasons, so we keep
348  * trying until all the blocks to back this page are allocated.
349  * If some of the blocks are already allocated, thats ok too.
350  */
351 
352 static int gfs2_allocate_page_backing(struct page *page)
353 {
354 	struct inode *inode = page->mapping->host;
355 	struct buffer_head bh;
356 	unsigned long size = PAGE_CACHE_SIZE;
357 	u64 lblock = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
358 
359 	do {
360 		bh.b_state = 0;
361 		bh.b_size = size;
362 		gfs2_block_map(inode, lblock, &bh, 1);
363 		if (!buffer_mapped(&bh))
364 			return -EIO;
365 		size -= bh.b_size;
366 		lblock += (bh.b_size >> inode->i_blkbits);
367 	} while(size > 0);
368 	return 0;
369 }
370 
371 /**
372  * gfs2_page_mkwrite - Make a shared, mmap()ed, page writable
373  * @vma: The virtual memory area
374  * @page: The page which is about to become writable
375  *
376  * When the page becomes writable, we need to ensure that we have
377  * blocks allocated on disk to back that page.
378  */
379 
380 static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
381 {
382 	struct page *page = vmf->page;
383 	struct inode *inode = file_inode(vma->vm_file);
384 	struct gfs2_inode *ip = GFS2_I(inode);
385 	struct gfs2_sbd *sdp = GFS2_SB(inode);
386 	unsigned long last_index;
387 	u64 pos = page->index << PAGE_CACHE_SHIFT;
388 	unsigned int data_blocks, ind_blocks, rblocks;
389 	struct gfs2_holder gh;
390 	loff_t size;
391 	int ret;
392 
393 	sb_start_pagefault(inode->i_sb);
394 
395 	/* Update file times before taking page lock */
396 	file_update_time(vma->vm_file);
397 
398 	ret = get_write_access(inode);
399 	if (ret)
400 		goto out;
401 
402 	ret = gfs2_rs_alloc(ip);
403 	if (ret)
404 		goto out_write_access;
405 
406 	gfs2_size_hint(vma->vm_file, pos, PAGE_CACHE_SIZE);
407 
408 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
409 	ret = gfs2_glock_nq(&gh);
410 	if (ret)
411 		goto out_uninit;
412 
413 	set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
414 	set_bit(GIF_SW_PAGED, &ip->i_flags);
415 
416 	if (!gfs2_write_alloc_required(ip, pos, PAGE_CACHE_SIZE)) {
417 		lock_page(page);
418 		if (!PageUptodate(page) || page->mapping != inode->i_mapping) {
419 			ret = -EAGAIN;
420 			unlock_page(page);
421 		}
422 		goto out_unlock;
423 	}
424 
425 	ret = gfs2_rindex_update(sdp);
426 	if (ret)
427 		goto out_unlock;
428 
429 	ret = gfs2_quota_lock_check(ip);
430 	if (ret)
431 		goto out_unlock;
432 	gfs2_write_calc_reserv(ip, PAGE_CACHE_SIZE, &data_blocks, &ind_blocks);
433 	ret = gfs2_inplace_reserve(ip, data_blocks + ind_blocks, 0);
434 	if (ret)
435 		goto out_quota_unlock;
436 
437 	rblocks = RES_DINODE + ind_blocks;
438 	if (gfs2_is_jdata(ip))
439 		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 	ret = gfs2_trans_begin(sdp, rblocks, 0);
445 	if (ret)
446 		goto out_trans_fail;
447 
448 	lock_page(page);
449 	ret = -EINVAL;
450 	size = i_size_read(inode);
451 	last_index = (size - 1) >> PAGE_CACHE_SHIFT;
452 	/* Check page index against inode size */
453 	if (size == 0 || (page->index > last_index))
454 		goto out_trans_end;
455 
456 	ret = -EAGAIN;
457 	/* If truncated, we must retry the operation, we may have raced
458 	 * with the glock demotion code.
459 	 */
460 	if (!PageUptodate(page) || page->mapping != inode->i_mapping)
461 		goto out_trans_end;
462 
463 	/* 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 	if (ret == 0)
468 		ret = gfs2_allocate_page_backing(page);
469 
470 out_trans_end:
471 	if (ret)
472 		unlock_page(page);
473 	gfs2_trans_end(sdp);
474 out_trans_fail:
475 	gfs2_inplace_release(ip);
476 out_quota_unlock:
477 	gfs2_quota_unlock(ip);
478 out_unlock:
479 	gfs2_glock_dq(&gh);
480 out_uninit:
481 	gfs2_holder_uninit(&gh);
482 	if (ret == 0) {
483 		set_page_dirty(page);
484 		wait_for_stable_page(page);
485 	}
486 out_write_access:
487 	put_write_access(inode);
488 out:
489 	sb_end_pagefault(inode->i_sb);
490 	return block_page_mkwrite_return(ret);
491 }
492 
493 static const struct vm_operations_struct gfs2_vm_ops = {
494 	.fault = filemap_fault,
495 	.page_mkwrite = gfs2_page_mkwrite,
496 	.remap_pages = generic_file_remap_pages,
497 };
498 
499 /**
500  * gfs2_mmap -
501  * @file: The file to map
502  * @vma: The VMA which described the mapping
503  *
504  * There is no need to get a lock here unless we should be updating
505  * atime. We ignore any locking errors since the only consequence is
506  * a missed atime update (which will just be deferred until later).
507  *
508  * Returns: 0
509  */
510 
511 static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
512 {
513 	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
514 
515 	if (!(file->f_flags & O_NOATIME) &&
516 	    !IS_NOATIME(&ip->i_inode)) {
517 		struct gfs2_holder i_gh;
518 		int error;
519 
520 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
521 					   &i_gh);
522 		if (error)
523 			return error;
524 		/* grab lock to update inode */
525 		gfs2_glock_dq_uninit(&i_gh);
526 		file_accessed(file);
527 	}
528 	vma->vm_ops = &gfs2_vm_ops;
529 
530 	return 0;
531 }
532 
533 /**
534  * gfs2_open_common - This is common to open and atomic_open
535  * @inode: The inode being opened
536  * @file: The file being opened
537  *
538  * This maybe called under a glock or not depending upon how it has
539  * been called. We must always be called under a glock for regular
540  * files, however. For other file types, it does not matter whether
541  * we hold the glock or not.
542  *
543  * Returns: Error code or 0 for success
544  */
545 
546 int gfs2_open_common(struct inode *inode, struct file *file)
547 {
548 	struct gfs2_file *fp;
549 	int ret;
550 
551 	if (S_ISREG(inode->i_mode)) {
552 		ret = generic_file_open(inode, file);
553 		if (ret)
554 			return ret;
555 	}
556 
557 	fp = kzalloc(sizeof(struct gfs2_file), GFP_NOFS);
558 	if (!fp)
559 		return -ENOMEM;
560 
561 	mutex_init(&fp->f_fl_mutex);
562 
563 	gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
564 	file->private_data = fp;
565 	return 0;
566 }
567 
568 /**
569  * gfs2_open - open a file
570  * @inode: the inode to open
571  * @file: the struct file for this opening
572  *
573  * After atomic_open, this function is only used for opening files
574  * which are already cached. We must still get the glock for regular
575  * files to ensure that we have the file size uptodate for the large
576  * file check which is in the common code. That is only an issue for
577  * regular files though.
578  *
579  * Returns: errno
580  */
581 
582 static int gfs2_open(struct inode *inode, struct file *file)
583 {
584 	struct gfs2_inode *ip = GFS2_I(inode);
585 	struct gfs2_holder i_gh;
586 	int error;
587 	bool need_unlock = false;
588 
589 	if (S_ISREG(ip->i_inode.i_mode)) {
590 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
591 					   &i_gh);
592 		if (error)
593 			return error;
594 		need_unlock = true;
595 	}
596 
597 	error = gfs2_open_common(inode, file);
598 
599 	if (need_unlock)
600 		gfs2_glock_dq_uninit(&i_gh);
601 
602 	return error;
603 }
604 
605 /**
606  * gfs2_release - called to close a struct file
607  * @inode: the inode the struct file belongs to
608  * @file: the struct file being closed
609  *
610  * Returns: errno
611  */
612 
613 static int gfs2_release(struct inode *inode, struct file *file)
614 {
615 	struct gfs2_inode *ip = GFS2_I(inode);
616 
617 	kfree(file->private_data);
618 	file->private_data = NULL;
619 
620 	if (!(file->f_mode & FMODE_WRITE))
621 		return 0;
622 
623 	gfs2_rs_delete(ip);
624 	return 0;
625 }
626 
627 /**
628  * gfs2_fsync - sync the dirty data for a file (across the cluster)
629  * @file: the file that points to the dentry
630  * @start: the start position in the file to sync
631  * @end: the end position in the file to sync
632  * @datasync: set if we can ignore timestamp changes
633  *
634  * We split the data flushing here so that we don't wait for the data
635  * until after we've also sent the metadata to disk. Note that for
636  * data=ordered, we will write & wait for the data at the log flush
637  * stage anyway, so this is unlikely to make much of a difference
638  * except in the data=writeback case.
639  *
640  * If the fdatawrite fails due to any reason except -EIO, we will
641  * continue the remainder of the fsync, although we'll still report
642  * the error at the end. This is to match filemap_write_and_wait_range()
643  * behaviour.
644  *
645  * Returns: errno
646  */
647 
648 static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
649 		      int datasync)
650 {
651 	struct address_space *mapping = file->f_mapping;
652 	struct inode *inode = mapping->host;
653 	int sync_state = inode->i_state & I_DIRTY;
654 	struct gfs2_inode *ip = GFS2_I(inode);
655 	int ret = 0, ret1 = 0;
656 
657 	if (mapping->nrpages) {
658 		ret1 = filemap_fdatawrite_range(mapping, start, end);
659 		if (ret1 == -EIO)
660 			return ret1;
661 	}
662 
663 	if (!gfs2_is_jdata(ip))
664 		sync_state &= ~I_DIRTY_PAGES;
665 	if (datasync)
666 		sync_state &= ~I_DIRTY_SYNC;
667 
668 	if (sync_state) {
669 		ret = sync_inode_metadata(inode, 1);
670 		if (ret)
671 			return ret;
672 		if (gfs2_is_jdata(ip))
673 			filemap_write_and_wait(mapping);
674 		gfs2_ail_flush(ip->i_gl, 1);
675 	}
676 
677 	if (mapping->nrpages)
678 		ret = filemap_fdatawait_range(mapping, start, end);
679 
680 	return ret ? ret : ret1;
681 }
682 
683 /**
684  * gfs2_file_aio_write - Perform a write to a file
685  * @iocb: The io context
686  * @iov: The data to write
687  * @nr_segs: Number of @iov segments
688  * @pos: The file position
689  *
690  * We have to do a lock/unlock here to refresh the inode size for
691  * O_APPEND writes, otherwise we can land up writing at the wrong
692  * offset. There is still a race, but provided the app is using its
693  * own file locking, this will make O_APPEND work as expected.
694  *
695  */
696 
697 static ssize_t gfs2_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
698 				   unsigned long nr_segs, loff_t pos)
699 {
700 	struct file *file = iocb->ki_filp;
701 	size_t writesize = iov_length(iov, nr_segs);
702 	struct gfs2_inode *ip = GFS2_I(file_inode(file));
703 	int ret;
704 
705 	ret = gfs2_rs_alloc(ip);
706 	if (ret)
707 		return ret;
708 
709 	gfs2_size_hint(file, pos, writesize);
710 
711 	if (file->f_flags & O_APPEND) {
712 		struct gfs2_holder gh;
713 
714 		ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
715 		if (ret)
716 			return ret;
717 		gfs2_glock_dq_uninit(&gh);
718 	}
719 
720 	return generic_file_aio_write(iocb, iov, nr_segs, pos);
721 }
722 
723 static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,
724 			   int mode)
725 {
726 	struct gfs2_inode *ip = GFS2_I(inode);
727 	struct buffer_head *dibh;
728 	int error;
729 	loff_t size = len;
730 	unsigned int nr_blks;
731 	sector_t lblock = offset >> inode->i_blkbits;
732 
733 	error = gfs2_meta_inode_buffer(ip, &dibh);
734 	if (unlikely(error))
735 		return error;
736 
737 	gfs2_trans_add_meta(ip->i_gl, dibh);
738 
739 	if (gfs2_is_stuffed(ip)) {
740 		error = gfs2_unstuff_dinode(ip, NULL);
741 		if (unlikely(error))
742 			goto out;
743 	}
744 
745 	while (len) {
746 		struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
747 		bh_map.b_size = len;
748 		set_buffer_zeronew(&bh_map);
749 
750 		error = gfs2_block_map(inode, lblock, &bh_map, 1);
751 		if (unlikely(error))
752 			goto out;
753 		len -= bh_map.b_size;
754 		nr_blks = bh_map.b_size >> inode->i_blkbits;
755 		lblock += nr_blks;
756 		if (!buffer_new(&bh_map))
757 			continue;
758 		if (unlikely(!buffer_zeronew(&bh_map))) {
759 			error = -EIO;
760 			goto out;
761 		}
762 	}
763 	if (offset + size > inode->i_size && !(mode & FALLOC_FL_KEEP_SIZE))
764 		i_size_write(inode, offset + size);
765 
766 	mark_inode_dirty(inode);
767 
768 out:
769 	brelse(dibh);
770 	return error;
771 }
772 
773 static void calc_max_reserv(struct gfs2_inode *ip, loff_t max, loff_t *len,
774 			    unsigned int *data_blocks, unsigned int *ind_blocks)
775 {
776 	const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
777 	unsigned int max_blocks = ip->i_rgd->rd_free_clone;
778 	unsigned int tmp, max_data = max_blocks - 3 * (sdp->sd_max_height - 1);
779 
780 	for (tmp = max_data; tmp > sdp->sd_diptrs;) {
781 		tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);
782 		max_data -= tmp;
783 	}
784 	/* This calculation isn't the exact reverse of gfs2_write_calc_reserve,
785 	   so it might end up with fewer data blocks */
786 	if (max_data <= *data_blocks)
787 		return;
788 	*data_blocks = max_data;
789 	*ind_blocks = max_blocks - max_data;
790 	*len = ((loff_t)max_data - 3) << sdp->sd_sb.sb_bsize_shift;
791 	if (*len > max) {
792 		*len = max;
793 		gfs2_write_calc_reserv(ip, max, data_blocks, ind_blocks);
794 	}
795 }
796 
797 static long gfs2_fallocate(struct file *file, int mode, loff_t offset,
798 			   loff_t len)
799 {
800 	struct inode *inode = file_inode(file);
801 	struct gfs2_sbd *sdp = GFS2_SB(inode);
802 	struct gfs2_inode *ip = GFS2_I(inode);
803 	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
804 	loff_t bytes, max_bytes;
805 	int error;
806 	const loff_t pos = offset;
807 	const loff_t count = len;
808 	loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1);
809 	loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift;
810 	loff_t max_chunk_size = UINT_MAX & bsize_mask;
811 	next = (next + 1) << sdp->sd_sb.sb_bsize_shift;
812 
813 	/* We only support the FALLOC_FL_KEEP_SIZE mode */
814 	if (mode & ~FALLOC_FL_KEEP_SIZE)
815 		return -EOPNOTSUPP;
816 
817 	offset &= bsize_mask;
818 
819 	len = next - offset;
820 	bytes = sdp->sd_max_rg_data * sdp->sd_sb.sb_bsize / 2;
821 	if (!bytes)
822 		bytes = UINT_MAX;
823 	bytes &= bsize_mask;
824 	if (bytes == 0)
825 		bytes = sdp->sd_sb.sb_bsize;
826 
827 	error = gfs2_rs_alloc(ip);
828 	if (error)
829 		return error;
830 
831 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
832 	error = gfs2_glock_nq(&ip->i_gh);
833 	if (unlikely(error))
834 		goto out_uninit;
835 
836 	gfs2_size_hint(file, offset, len);
837 
838 	while (len > 0) {
839 		if (len < bytes)
840 			bytes = len;
841 		if (!gfs2_write_alloc_required(ip, offset, bytes)) {
842 			len -= bytes;
843 			offset += bytes;
844 			continue;
845 		}
846 		error = gfs2_quota_lock_check(ip);
847 		if (error)
848 			goto out_unlock;
849 
850 retry:
851 		gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks);
852 
853 		error = gfs2_inplace_reserve(ip, data_blocks + ind_blocks, 0);
854 		if (error) {
855 			if (error == -ENOSPC && bytes > sdp->sd_sb.sb_bsize) {
856 				bytes >>= 1;
857 				bytes &= bsize_mask;
858 				if (bytes == 0)
859 					bytes = sdp->sd_sb.sb_bsize;
860 				goto retry;
861 			}
862 			goto out_qunlock;
863 		}
864 		max_bytes = bytes;
865 		calc_max_reserv(ip, (len > max_chunk_size)? max_chunk_size: len,
866 				&max_bytes, &data_blocks, &ind_blocks);
867 
868 		rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA +
869 			  RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks);
870 		if (gfs2_is_jdata(ip))
871 			rblocks += data_blocks ? data_blocks : 1;
872 
873 		error = gfs2_trans_begin(sdp, rblocks,
874 					 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
875 		if (error)
876 			goto out_trans_fail;
877 
878 		error = fallocate_chunk(inode, offset, max_bytes, mode);
879 		gfs2_trans_end(sdp);
880 
881 		if (error)
882 			goto out_trans_fail;
883 
884 		len -= max_bytes;
885 		offset += max_bytes;
886 		gfs2_inplace_release(ip);
887 		gfs2_quota_unlock(ip);
888 	}
889 
890 	if (error == 0)
891 		error = generic_write_sync(file, pos, count);
892 	goto out_unlock;
893 
894 out_trans_fail:
895 	gfs2_inplace_release(ip);
896 out_qunlock:
897 	gfs2_quota_unlock(ip);
898 out_unlock:
899 	gfs2_glock_dq(&ip->i_gh);
900 out_uninit:
901 	gfs2_holder_uninit(&ip->i_gh);
902 	return error;
903 }
904 
905 #ifdef CONFIG_GFS2_FS_LOCKING_DLM
906 
907 /**
908  * gfs2_setlease - acquire/release a file lease
909  * @file: the file pointer
910  * @arg: lease type
911  * @fl: file lock
912  *
913  * We don't currently have a way to enforce a lease across the whole
914  * cluster; until we do, disable leases (by just returning -EINVAL),
915  * unless the administrator has requested purely local locking.
916  *
917  * Locking: called under i_lock
918  *
919  * Returns: errno
920  */
921 
922 static int gfs2_setlease(struct file *file, long arg, struct file_lock **fl)
923 {
924 	return -EINVAL;
925 }
926 
927 /**
928  * gfs2_lock - acquire/release a posix lock on a file
929  * @file: the file pointer
930  * @cmd: either modify or retrieve lock state, possibly wait
931  * @fl: type and range of lock
932  *
933  * Returns: errno
934  */
935 
936 static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
937 {
938 	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
939 	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
940 	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
941 
942 	if (!(fl->fl_flags & FL_POSIX))
943 		return -ENOLCK;
944 	if (__mandatory_lock(&ip->i_inode) && fl->fl_type != F_UNLCK)
945 		return -ENOLCK;
946 
947 	if (cmd == F_CANCELLK) {
948 		/* Hack: */
949 		cmd = F_SETLK;
950 		fl->fl_type = F_UNLCK;
951 	}
952 	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) {
953 		if (fl->fl_type == F_UNLCK)
954 			posix_lock_file_wait(file, fl);
955 		return -EIO;
956 	}
957 	if (IS_GETLK(cmd))
958 		return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl);
959 	else if (fl->fl_type == F_UNLCK)
960 		return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl);
961 	else
962 		return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl);
963 }
964 
965 static int do_flock(struct file *file, int cmd, struct file_lock *fl)
966 {
967 	struct gfs2_file *fp = file->private_data;
968 	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
969 	struct gfs2_inode *ip = GFS2_I(file_inode(file));
970 	struct gfs2_glock *gl;
971 	unsigned int state;
972 	int flags;
973 	int error = 0;
974 
975 	state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
976 	flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE;
977 
978 	mutex_lock(&fp->f_fl_mutex);
979 
980 	gl = fl_gh->gh_gl;
981 	if (gl) {
982 		if (fl_gh->gh_state == state)
983 			goto out;
984 		flock_lock_file_wait(file,
985 				     &(struct file_lock){.fl_type = F_UNLCK});
986 		gfs2_glock_dq_wait(fl_gh);
987 		gfs2_holder_reinit(state, flags, fl_gh);
988 	} else {
989 		error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr,
990 				       &gfs2_flock_glops, CREATE, &gl);
991 		if (error)
992 			goto out;
993 		gfs2_holder_init(gl, state, flags, fl_gh);
994 		gfs2_glock_put(gl);
995 	}
996 	error = gfs2_glock_nq(fl_gh);
997 	if (error) {
998 		gfs2_holder_uninit(fl_gh);
999 		if (error == GLR_TRYFAILED)
1000 			error = -EAGAIN;
1001 	} else {
1002 		error = flock_lock_file_wait(file, fl);
1003 		gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
1004 	}
1005 
1006 out:
1007 	mutex_unlock(&fp->f_fl_mutex);
1008 	return error;
1009 }
1010 
1011 static void do_unflock(struct file *file, struct file_lock *fl)
1012 {
1013 	struct gfs2_file *fp = file->private_data;
1014 	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
1015 
1016 	mutex_lock(&fp->f_fl_mutex);
1017 	flock_lock_file_wait(file, fl);
1018 	if (fl_gh->gh_gl) {
1019 		gfs2_glock_dq_wait(fl_gh);
1020 		gfs2_holder_uninit(fl_gh);
1021 	}
1022 	mutex_unlock(&fp->f_fl_mutex);
1023 }
1024 
1025 /**
1026  * gfs2_flock - acquire/release a flock lock on a file
1027  * @file: the file pointer
1028  * @cmd: either modify or retrieve lock state, possibly wait
1029  * @fl: type and range of lock
1030  *
1031  * Returns: errno
1032  */
1033 
1034 static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
1035 {
1036 	if (!(fl->fl_flags & FL_FLOCK))
1037 		return -ENOLCK;
1038 	if (fl->fl_type & LOCK_MAND)
1039 		return -EOPNOTSUPP;
1040 
1041 	if (fl->fl_type == F_UNLCK) {
1042 		do_unflock(file, fl);
1043 		return 0;
1044 	} else {
1045 		return do_flock(file, cmd, fl);
1046 	}
1047 }
1048 
1049 const struct file_operations gfs2_file_fops = {
1050 	.llseek		= gfs2_llseek,
1051 	.read		= do_sync_read,
1052 	.aio_read	= generic_file_aio_read,
1053 	.write		= do_sync_write,
1054 	.aio_write	= gfs2_file_aio_write,
1055 	.unlocked_ioctl	= gfs2_ioctl,
1056 	.mmap		= gfs2_mmap,
1057 	.open		= gfs2_open,
1058 	.release	= gfs2_release,
1059 	.fsync		= gfs2_fsync,
1060 	.lock		= gfs2_lock,
1061 	.flock		= gfs2_flock,
1062 	.splice_read	= generic_file_splice_read,
1063 	.splice_write	= generic_file_splice_write,
1064 	.setlease	= gfs2_setlease,
1065 	.fallocate	= gfs2_fallocate,
1066 };
1067 
1068 const struct file_operations gfs2_dir_fops = {
1069 	.iterate	= gfs2_readdir,
1070 	.unlocked_ioctl	= gfs2_ioctl,
1071 	.open		= gfs2_open,
1072 	.release	= gfs2_release,
1073 	.fsync		= gfs2_fsync,
1074 	.lock		= gfs2_lock,
1075 	.flock		= gfs2_flock,
1076 	.llseek		= default_llseek,
1077 };
1078 
1079 #endif /* CONFIG_GFS2_FS_LOCKING_DLM */
1080 
1081 const struct file_operations gfs2_file_fops_nolock = {
1082 	.llseek		= gfs2_llseek,
1083 	.read		= do_sync_read,
1084 	.aio_read	= generic_file_aio_read,
1085 	.write		= do_sync_write,
1086 	.aio_write	= gfs2_file_aio_write,
1087 	.unlocked_ioctl	= gfs2_ioctl,
1088 	.mmap		= gfs2_mmap,
1089 	.open		= gfs2_open,
1090 	.release	= gfs2_release,
1091 	.fsync		= gfs2_fsync,
1092 	.splice_read	= generic_file_splice_read,
1093 	.splice_write	= generic_file_splice_write,
1094 	.setlease	= generic_setlease,
1095 	.fallocate	= gfs2_fallocate,
1096 };
1097 
1098 const struct file_operations gfs2_dir_fops_nolock = {
1099 	.iterate	= gfs2_readdir,
1100 	.unlocked_ioctl	= gfs2_ioctl,
1101 	.open		= gfs2_open,
1102 	.release	= gfs2_release,
1103 	.fsync		= gfs2_fsync,
1104 	.llseek		= default_llseek,
1105 };
1106 
1107