xref: /openbmc/linux/fs/gfs2/inode.c (revision ecfb9f40)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
4  * Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
5  */
6 
7 #include <linux/slab.h>
8 #include <linux/spinlock.h>
9 #include <linux/completion.h>
10 #include <linux/buffer_head.h>
11 #include <linux/namei.h>
12 #include <linux/mm.h>
13 #include <linux/cred.h>
14 #include <linux/xattr.h>
15 #include <linux/posix_acl.h>
16 #include <linux/gfs2_ondisk.h>
17 #include <linux/crc32.h>
18 #include <linux/iomap.h>
19 #include <linux/security.h>
20 #include <linux/fiemap.h>
21 #include <linux/uaccess.h>
22 
23 #include "gfs2.h"
24 #include "incore.h"
25 #include "acl.h"
26 #include "bmap.h"
27 #include "dir.h"
28 #include "xattr.h"
29 #include "glock.h"
30 #include "inode.h"
31 #include "meta_io.h"
32 #include "quota.h"
33 #include "rgrp.h"
34 #include "trans.h"
35 #include "util.h"
36 #include "super.h"
37 #include "glops.h"
38 
39 static const struct inode_operations gfs2_file_iops;
40 static const struct inode_operations gfs2_dir_iops;
41 static const struct inode_operations gfs2_symlink_iops;
42 
43 /**
44  * gfs2_set_iop - Sets inode operations
45  * @inode: The inode with correct i_mode filled in
46  *
47  * GFS2 lookup code fills in vfs inode contents based on info obtained
48  * from directory entry inside gfs2_inode_lookup().
49  */
50 
51 static void gfs2_set_iop(struct inode *inode)
52 {
53 	struct gfs2_sbd *sdp = GFS2_SB(inode);
54 	umode_t mode = inode->i_mode;
55 
56 	if (S_ISREG(mode)) {
57 		inode->i_op = &gfs2_file_iops;
58 		if (gfs2_localflocks(sdp))
59 			inode->i_fop = &gfs2_file_fops_nolock;
60 		else
61 			inode->i_fop = &gfs2_file_fops;
62 	} else if (S_ISDIR(mode)) {
63 		inode->i_op = &gfs2_dir_iops;
64 		if (gfs2_localflocks(sdp))
65 			inode->i_fop = &gfs2_dir_fops_nolock;
66 		else
67 			inode->i_fop = &gfs2_dir_fops;
68 	} else if (S_ISLNK(mode)) {
69 		inode->i_op = &gfs2_symlink_iops;
70 	} else {
71 		inode->i_op = &gfs2_file_iops;
72 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
73 	}
74 }
75 
76 static int iget_test(struct inode *inode, void *opaque)
77 {
78 	u64 no_addr = *(u64 *)opaque;
79 
80 	return GFS2_I(inode)->i_no_addr == no_addr;
81 }
82 
83 static int iget_set(struct inode *inode, void *opaque)
84 {
85 	u64 no_addr = *(u64 *)opaque;
86 
87 	GFS2_I(inode)->i_no_addr = no_addr;
88 	inode->i_ino = no_addr;
89 	return 0;
90 }
91 
92 /**
93  * gfs2_inode_lookup - Lookup an inode
94  * @sb: The super block
95  * @type: The type of the inode
96  * @no_addr: The inode number
97  * @no_formal_ino: The inode generation number
98  * @blktype: Requested block type (GFS2_BLKST_DINODE or GFS2_BLKST_UNLINKED;
99  *           GFS2_BLKST_FREE to indicate not to verify)
100  *
101  * If @type is DT_UNKNOWN, the inode type is fetched from disk.
102  *
103  * If @blktype is anything other than GFS2_BLKST_FREE (which is used as a
104  * placeholder because it doesn't otherwise make sense), the on-disk block type
105  * is verified to be @blktype.
106  *
107  * When @no_formal_ino is non-zero, this function will return ERR_PTR(-ESTALE)
108  * if it detects that @no_formal_ino doesn't match the actual inode generation
109  * number.  However, it doesn't always know unless @type is DT_UNKNOWN.
110  *
111  * Returns: A VFS inode, or an error
112  */
113 
114 struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
115 				u64 no_addr, u64 no_formal_ino,
116 				unsigned int blktype)
117 {
118 	struct inode *inode;
119 	struct gfs2_inode *ip;
120 	struct gfs2_holder i_gh;
121 	int error;
122 
123 	gfs2_holder_mark_uninitialized(&i_gh);
124 	inode = iget5_locked(sb, no_addr, iget_test, iget_set, &no_addr);
125 	if (!inode)
126 		return ERR_PTR(-ENOMEM);
127 
128 	ip = GFS2_I(inode);
129 
130 	if (inode->i_state & I_NEW) {
131 		struct gfs2_sbd *sdp = GFS2_SB(inode);
132 		struct gfs2_glock *io_gl;
133 		int extra_flags = 0;
134 
135 		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE,
136 				       &ip->i_gl);
137 		if (unlikely(error))
138 			goto fail;
139 
140 		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE,
141 				       &io_gl);
142 		if (unlikely(error))
143 			goto fail;
144 
145 		/*
146 		 * The only caller that sets @blktype to GFS2_BLKST_UNLINKED is
147 		 * delete_work_func().  Make sure not to cancel the delete work
148 		 * from within itself here.
149 		 */
150 		if (blktype == GFS2_BLKST_UNLINKED)
151 			extra_flags |= LM_FLAG_TRY;
152 		else
153 			gfs2_cancel_delete_work(io_gl);
154 		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED,
155 					   GL_EXACT | GL_NOPID | extra_flags,
156 					   &ip->i_iopen_gh);
157 		gfs2_glock_put(io_gl);
158 		if (unlikely(error))
159 			goto fail;
160 
161 		if (type == DT_UNKNOWN || blktype != GFS2_BLKST_FREE) {
162 			/*
163 			 * The GL_SKIP flag indicates to skip reading the inode
164 			 * block.  We read the inode when instantiating it
165 			 * after possibly checking the block type.
166 			 */
167 			error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE,
168 						   GL_SKIP, &i_gh);
169 			if (error)
170 				goto fail;
171 
172 			error = -ESTALE;
173 			if (no_formal_ino &&
174 			    gfs2_inode_already_deleted(ip->i_gl, no_formal_ino))
175 				goto fail;
176 
177 			if (blktype != GFS2_BLKST_FREE) {
178 				error = gfs2_check_blk_type(sdp, no_addr,
179 							    blktype);
180 				if (error)
181 					goto fail;
182 			}
183 		}
184 
185 		set_bit(GLF_INSTANTIATE_NEEDED, &ip->i_gl->gl_flags);
186 
187 		/* Lowest possible timestamp; will be overwritten in gfs2_dinode_in. */
188 		inode->i_atime.tv_sec = 1LL << (8 * sizeof(inode->i_atime.tv_sec) - 1);
189 		inode->i_atime.tv_nsec = 0;
190 
191 		glock_set_object(ip->i_gl, ip);
192 
193 		if (type == DT_UNKNOWN) {
194 			/* Inode glock must be locked already */
195 			error = gfs2_instantiate(&i_gh);
196 			if (error) {
197 				glock_clear_object(ip->i_gl, ip);
198 				goto fail;
199 			}
200 		} else {
201 			ip->i_no_formal_ino = no_formal_ino;
202 			inode->i_mode = DT2IF(type);
203 		}
204 
205 		if (gfs2_holder_initialized(&i_gh))
206 			gfs2_glock_dq_uninit(&i_gh);
207 		glock_set_object(ip->i_iopen_gh.gh_gl, ip);
208 
209 		gfs2_set_iop(inode);
210 		unlock_new_inode(inode);
211 	}
212 
213 	if (no_formal_ino && ip->i_no_formal_ino &&
214 	    no_formal_ino != ip->i_no_formal_ino) {
215 		iput(inode);
216 		return ERR_PTR(-ESTALE);
217 	}
218 
219 	return inode;
220 
221 fail:
222 	if (error == GLR_TRYFAILED)
223 		error = -EAGAIN;
224 	if (gfs2_holder_initialized(&ip->i_iopen_gh))
225 		gfs2_glock_dq_uninit(&ip->i_iopen_gh);
226 	if (gfs2_holder_initialized(&i_gh))
227 		gfs2_glock_dq_uninit(&i_gh);
228 	iget_failed(inode);
229 	return ERR_PTR(error);
230 }
231 
232 /**
233  * gfs2_lookup_by_inum - look up an inode by inode number
234  * @sdp: The super block
235  * @no_addr: The inode number
236  * @no_formal_ino: The inode generation number (0 for any)
237  * @blktype: Requested block type (see gfs2_inode_lookup)
238  */
239 struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
240 				  u64 no_formal_ino, unsigned int blktype)
241 {
242 	struct super_block *sb = sdp->sd_vfs;
243 	struct inode *inode;
244 	int error;
245 
246 	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, no_formal_ino,
247 				  blktype);
248 	if (IS_ERR(inode))
249 		return inode;
250 
251 	if (no_formal_ino) {
252 		error = -EIO;
253 		if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM)
254 			goto fail_iput;
255 	}
256 	return inode;
257 
258 fail_iput:
259 	iput(inode);
260 	return ERR_PTR(error);
261 }
262 
263 
264 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
265 {
266 	struct qstr qstr;
267 	struct inode *inode;
268 	gfs2_str2qstr(&qstr, name);
269 	inode = gfs2_lookupi(dip, &qstr, 1);
270 	/* gfs2_lookupi has inconsistent callers: vfs
271 	 * related routines expect NULL for no entry found,
272 	 * gfs2_lookup_simple callers expect ENOENT
273 	 * and do not check for NULL.
274 	 */
275 	if (inode == NULL)
276 		return ERR_PTR(-ENOENT);
277 	else
278 		return inode;
279 }
280 
281 
282 /**
283  * gfs2_lookupi - Look up a filename in a directory and return its inode
284  * @dir: The inode of the directory containing the inode to look-up
285  * @name: The name of the inode to look for
286  * @is_root: If 1, ignore the caller's permissions
287  *
288  * This can be called via the VFS filldir function when NFS is doing
289  * a readdirplus and the inode which its intending to stat isn't
290  * already in cache. In this case we must not take the directory glock
291  * again, since the readdir call will have already taken that lock.
292  *
293  * Returns: errno
294  */
295 
296 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
297 			   int is_root)
298 {
299 	struct super_block *sb = dir->i_sb;
300 	struct gfs2_inode *dip = GFS2_I(dir);
301 	struct gfs2_holder d_gh;
302 	int error = 0;
303 	struct inode *inode = NULL;
304 
305 	gfs2_holder_mark_uninitialized(&d_gh);
306 	if (!name->len || name->len > GFS2_FNAMESIZE)
307 		return ERR_PTR(-ENAMETOOLONG);
308 
309 	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
310 	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
311 	     dir == d_inode(sb->s_root))) {
312 		igrab(dir);
313 		return dir;
314 	}
315 
316 	if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
317 		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
318 		if (error)
319 			return ERR_PTR(error);
320 	}
321 
322 	if (!is_root) {
323 		error = gfs2_permission(&init_user_ns, dir, MAY_EXEC);
324 		if (error)
325 			goto out;
326 	}
327 
328 	inode = gfs2_dir_search(dir, name, false);
329 	if (IS_ERR(inode))
330 		error = PTR_ERR(inode);
331 out:
332 	if (gfs2_holder_initialized(&d_gh))
333 		gfs2_glock_dq_uninit(&d_gh);
334 	if (error == -ENOENT)
335 		return NULL;
336 	return inode ? inode : ERR_PTR(error);
337 }
338 
339 /**
340  * create_ok - OK to create a new on-disk inode here?
341  * @dip:  Directory in which dinode is to be created
342  * @name:  Name of new dinode
343  * @mode:
344  *
345  * Returns: errno
346  */
347 
348 static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
349 		     umode_t mode)
350 {
351 	int error;
352 
353 	error = gfs2_permission(&init_user_ns, &dip->i_inode,
354 				MAY_WRITE | MAY_EXEC);
355 	if (error)
356 		return error;
357 
358 	/*  Don't create entries in an unlinked directory  */
359 	if (!dip->i_inode.i_nlink)
360 		return -ENOENT;
361 
362 	if (dip->i_entries == (u32)-1)
363 		return -EFBIG;
364 	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
365 		return -EMLINK;
366 
367 	return 0;
368 }
369 
370 static void munge_mode_uid_gid(const struct gfs2_inode *dip,
371 			       struct inode *inode)
372 {
373 	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
374 	    (dip->i_inode.i_mode & S_ISUID) &&
375 	    !uid_eq(dip->i_inode.i_uid, GLOBAL_ROOT_UID)) {
376 		if (S_ISDIR(inode->i_mode))
377 			inode->i_mode |= S_ISUID;
378 		else if (!uid_eq(dip->i_inode.i_uid, current_fsuid()))
379 			inode->i_mode &= ~07111;
380 		inode->i_uid = dip->i_inode.i_uid;
381 	} else
382 		inode->i_uid = current_fsuid();
383 
384 	if (dip->i_inode.i_mode & S_ISGID) {
385 		if (S_ISDIR(inode->i_mode))
386 			inode->i_mode |= S_ISGID;
387 		inode->i_gid = dip->i_inode.i_gid;
388 	} else
389 		inode->i_gid = current_fsgid();
390 }
391 
392 static int alloc_dinode(struct gfs2_inode *ip, u32 flags, unsigned *dblocks)
393 {
394 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
395 	struct gfs2_alloc_parms ap = { .target = *dblocks, .aflags = flags, };
396 	int error;
397 
398 	error = gfs2_quota_lock_check(ip, &ap);
399 	if (error)
400 		goto out;
401 
402 	error = gfs2_inplace_reserve(ip, &ap);
403 	if (error)
404 		goto out_quota;
405 
406 	error = gfs2_trans_begin(sdp, (*dblocks * RES_RG_BIT) + RES_STATFS + RES_QUOTA, 0);
407 	if (error)
408 		goto out_ipreserv;
409 
410 	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, dblocks, 1, &ip->i_generation);
411 	if (error)
412 		goto out_trans_end;
413 
414 	ip->i_no_formal_ino = ip->i_generation;
415 	ip->i_inode.i_ino = ip->i_no_addr;
416 	ip->i_goal = ip->i_no_addr;
417 	if (*dblocks > 1)
418 		ip->i_eattr = ip->i_no_addr + 1;
419 
420 out_trans_end:
421 	gfs2_trans_end(sdp);
422 out_ipreserv:
423 	gfs2_inplace_release(ip);
424 out_quota:
425 	gfs2_quota_unlock(ip);
426 out:
427 	return error;
428 }
429 
430 static void gfs2_init_dir(struct buffer_head *dibh,
431 			  const struct gfs2_inode *parent)
432 {
433 	struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
434 	struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
435 
436 	gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
437 	dent->de_inum = di->di_num; /* already GFS2 endian */
438 	dent->de_type = cpu_to_be16(DT_DIR);
439 
440 	dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
441 	gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
442 	gfs2_inum_out(parent, dent);
443 	dent->de_type = cpu_to_be16(DT_DIR);
444 
445 }
446 
447 /**
448  * gfs2_init_xattr - Initialise an xattr block for a new inode
449  * @ip: The inode in question
450  *
451  * This sets up an empty xattr block for a new inode, ready to
452  * take any ACLs, LSM xattrs, etc.
453  */
454 
455 static void gfs2_init_xattr(struct gfs2_inode *ip)
456 {
457 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
458 	struct buffer_head *bh;
459 	struct gfs2_ea_header *ea;
460 
461 	bh = gfs2_meta_new(ip->i_gl, ip->i_eattr);
462 	gfs2_trans_add_meta(ip->i_gl, bh);
463 	gfs2_metatype_set(bh, GFS2_METATYPE_EA, GFS2_FORMAT_EA);
464 	gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
465 
466 	ea = GFS2_EA_BH2FIRST(bh);
467 	ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize);
468 	ea->ea_type = GFS2_EATYPE_UNUSED;
469 	ea->ea_flags = GFS2_EAFLAG_LAST;
470 
471 	brelse(bh);
472 }
473 
474 /**
475  * init_dinode - Fill in a new dinode structure
476  * @dip: The directory this inode is being created in
477  * @ip: The inode
478  * @symname: The symlink destination (if a symlink)
479  *
480  */
481 
482 static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
483 			const char *symname)
484 {
485 	struct gfs2_dinode *di;
486 	struct buffer_head *dibh;
487 
488 	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
489 	gfs2_trans_add_meta(ip->i_gl, dibh);
490 	di = (struct gfs2_dinode *)dibh->b_data;
491 	gfs2_dinode_out(ip, di);
492 
493 	di->di_major = cpu_to_be32(imajor(&ip->i_inode));
494 	di->di_minor = cpu_to_be32(iminor(&ip->i_inode));
495 	di->__pad1 = 0;
496 	di->__pad2 = 0;
497 	di->__pad3 = 0;
498 	memset(&di->__pad4, 0, sizeof(di->__pad4));
499 	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
500 	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
501 
502 	switch(ip->i_inode.i_mode & S_IFMT) {
503 	case S_IFDIR:
504 		gfs2_init_dir(dibh, dip);
505 		break;
506 	case S_IFLNK:
507 		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size);
508 		break;
509 	}
510 
511 	set_buffer_uptodate(dibh);
512 	brelse(dibh);
513 }
514 
515 /**
516  * gfs2_trans_da_blks - Calculate number of blocks to link inode
517  * @dip: The directory we are linking into
518  * @da: The dir add information
519  * @nr_inodes: The number of inodes involved
520  *
521  * This calculate the number of blocks we need to reserve in a
522  * transaction to link @nr_inodes into a directory. In most cases
523  * @nr_inodes will be 2 (the directory plus the inode being linked in)
524  * but in case of rename, 4 may be required.
525  *
526  * Returns: Number of blocks
527  */
528 
529 static unsigned gfs2_trans_da_blks(const struct gfs2_inode *dip,
530 				   const struct gfs2_diradd *da,
531 				   unsigned nr_inodes)
532 {
533 	return da->nr_blocks + gfs2_rg_blocks(dip, da->nr_blocks) +
534 	       (nr_inodes * RES_DINODE) + RES_QUOTA + RES_STATFS;
535 }
536 
537 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
538 		       struct gfs2_inode *ip, struct gfs2_diradd *da)
539 {
540 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
541 	struct gfs2_alloc_parms ap = { .target = da->nr_blocks, };
542 	int error;
543 
544 	if (da->nr_blocks) {
545 		error = gfs2_quota_lock_check(dip, &ap);
546 		if (error)
547 			goto fail_quota_locks;
548 
549 		error = gfs2_inplace_reserve(dip, &ap);
550 		if (error)
551 			goto fail_quota_locks;
552 
553 		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, da, 2), 0);
554 		if (error)
555 			goto fail_ipreserv;
556 	} else {
557 		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
558 		if (error)
559 			goto fail_quota_locks;
560 	}
561 
562 	error = gfs2_dir_add(&dip->i_inode, name, ip, da);
563 
564 	gfs2_trans_end(sdp);
565 fail_ipreserv:
566 	gfs2_inplace_release(dip);
567 fail_quota_locks:
568 	gfs2_quota_unlock(dip);
569 	return error;
570 }
571 
572 static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
573 		    void *fs_info)
574 {
575 	const struct xattr *xattr;
576 	int err = 0;
577 
578 	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
579 		err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
580 				       xattr->value_len, 0,
581 				       GFS2_EATYPE_SECURITY);
582 		if (err < 0)
583 			break;
584 	}
585 	return err;
586 }
587 
588 /**
589  * gfs2_create_inode - Create a new inode
590  * @dir: The parent directory
591  * @dentry: The new dentry
592  * @file: If non-NULL, the file which is being opened
593  * @mode: The permissions on the new inode
594  * @dev: For device nodes, this is the device number
595  * @symname: For symlinks, this is the link destination
596  * @size: The initial size of the inode (ignored for directories)
597  * @excl: Force fail if inode exists
598  *
599  * FIXME: Change to allocate the disk blocks and write them out in the same
600  * transaction.  That way, we can no longer end up in a situation in which an
601  * inode is allocated, the node crashes, and the block looks like a valid
602  * inode.  (With atomic creates in place, we will also no longer need to zero
603  * the link count and dirty the inode here on failure.)
604  *
605  * Returns: 0 on success, or error code
606  */
607 
608 static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
609 			     struct file *file,
610 			     umode_t mode, dev_t dev, const char *symname,
611 			     unsigned int size, int excl)
612 {
613 	const struct qstr *name = &dentry->d_name;
614 	struct posix_acl *default_acl, *acl;
615 	struct gfs2_holder d_gh, gh;
616 	struct inode *inode = NULL;
617 	struct gfs2_inode *dip = GFS2_I(dir), *ip;
618 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
619 	struct gfs2_glock *io_gl;
620 	int error;
621 	u32 aflags = 0;
622 	unsigned blocks = 1;
623 	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
624 
625 	if (!name->len || name->len > GFS2_FNAMESIZE)
626 		return -ENAMETOOLONG;
627 
628 	error = gfs2_qa_get(dip);
629 	if (error)
630 		return error;
631 
632 	error = gfs2_rindex_update(sdp);
633 	if (error)
634 		goto fail;
635 
636 	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, &d_gh);
637 	if (error)
638 		goto fail;
639 	gfs2_holder_mark_uninitialized(&gh);
640 
641 	error = create_ok(dip, name, mode);
642 	if (error)
643 		goto fail_gunlock;
644 
645 	inode = gfs2_dir_search(dir, &dentry->d_name, !S_ISREG(mode) || excl);
646 	error = PTR_ERR(inode);
647 	if (!IS_ERR(inode)) {
648 		if (S_ISDIR(inode->i_mode)) {
649 			iput(inode);
650 			inode = ERR_PTR(-EISDIR);
651 			goto fail_gunlock;
652 		}
653 		d_instantiate(dentry, inode);
654 		error = 0;
655 		if (file) {
656 			if (S_ISREG(inode->i_mode))
657 				error = finish_open(file, dentry, gfs2_open_common);
658 			else
659 				error = finish_no_open(file, NULL);
660 		}
661 		gfs2_glock_dq_uninit(&d_gh);
662 		goto fail;
663 	} else if (error != -ENOENT) {
664 		goto fail_gunlock;
665 	}
666 
667 	error = gfs2_diradd_alloc_required(dir, name, &da);
668 	if (error < 0)
669 		goto fail_gunlock;
670 
671 	inode = new_inode(sdp->sd_vfs);
672 	error = -ENOMEM;
673 	if (!inode)
674 		goto fail_gunlock;
675 	ip = GFS2_I(inode);
676 
677 	error = posix_acl_create(dir, &mode, &default_acl, &acl);
678 	if (error)
679 		goto fail_gunlock;
680 
681 	error = gfs2_qa_get(ip);
682 	if (error)
683 		goto fail_free_acls;
684 
685 	inode->i_mode = mode;
686 	set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
687 	inode->i_rdev = dev;
688 	inode->i_size = size;
689 	inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
690 	munge_mode_uid_gid(dip, inode);
691 	check_and_update_goal(dip);
692 	ip->i_goal = dip->i_goal;
693 	ip->i_diskflags = 0;
694 	ip->i_eattr = 0;
695 	ip->i_height = 0;
696 	ip->i_depth = 0;
697 	ip->i_entries = 0;
698 	ip->i_no_addr = 0; /* Temporarily zero until real addr is assigned */
699 
700 	switch(mode & S_IFMT) {
701 	case S_IFREG:
702 		if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
703 		    gfs2_tune_get(sdp, gt_new_files_jdata))
704 			ip->i_diskflags |= GFS2_DIF_JDATA;
705 		gfs2_set_aops(inode);
706 		break;
707 	case S_IFDIR:
708 		ip->i_diskflags |= (dip->i_diskflags & GFS2_DIF_INHERIT_JDATA);
709 		ip->i_diskflags |= GFS2_DIF_JDATA;
710 		ip->i_entries = 2;
711 		break;
712 	}
713 
714 	/* Force SYSTEM flag on all files and subdirs of a SYSTEM directory */
715 	if (dip->i_diskflags & GFS2_DIF_SYSTEM)
716 		ip->i_diskflags |= GFS2_DIF_SYSTEM;
717 
718 	gfs2_set_inode_flags(inode);
719 
720 	if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) ||
721 	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
722 		aflags |= GFS2_AF_ORLOV;
723 
724 	if (default_acl || acl)
725 		blocks++;
726 
727 	error = alloc_dinode(ip, aflags, &blocks);
728 	if (error)
729 		goto fail_free_inode;
730 
731 	gfs2_set_inode_blocks(inode, blocks);
732 
733 	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
734 	if (error)
735 		goto fail_free_inode;
736 
737 	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
738 	if (error)
739 		goto fail_free_inode;
740 	gfs2_cancel_delete_work(io_gl);
741 
742 retry:
743 	error = insert_inode_locked4(inode, ip->i_no_addr, iget_test, &ip->i_no_addr);
744 	if (error == -EBUSY)
745 		goto retry;
746 	if (error)
747 		goto fail_gunlock2;
748 
749 	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT | GL_NOPID,
750 				   &ip->i_iopen_gh);
751 	if (error)
752 		goto fail_gunlock2;
753 
754 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, &gh);
755 	if (error)
756 		goto fail_gunlock3;
757 
758 	error = gfs2_trans_begin(sdp, blocks, 0);
759 	if (error)
760 		goto fail_gunlock3;
761 
762 	if (blocks > 1)
763 		gfs2_init_xattr(ip);
764 	init_dinode(dip, ip, symname);
765 	gfs2_trans_end(sdp);
766 
767 	glock_set_object(ip->i_gl, ip);
768 	glock_set_object(io_gl, ip);
769 	gfs2_set_iop(inode);
770 
771 	if (default_acl) {
772 		error = __gfs2_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
773 		if (error)
774 			goto fail_gunlock4;
775 		posix_acl_release(default_acl);
776 		default_acl = NULL;
777 	}
778 	if (acl) {
779 		error = __gfs2_set_acl(inode, acl, ACL_TYPE_ACCESS);
780 		if (error)
781 			goto fail_gunlock4;
782 		posix_acl_release(acl);
783 		acl = NULL;
784 	}
785 
786 	error = security_inode_init_security(&ip->i_inode, &dip->i_inode, name,
787 					     &gfs2_initxattrs, NULL);
788 	if (error)
789 		goto fail_gunlock4;
790 
791 	error = link_dinode(dip, name, ip, &da);
792 	if (error)
793 		goto fail_gunlock4;
794 
795 	mark_inode_dirty(inode);
796 	d_instantiate(dentry, inode);
797 	/* After instantiate, errors should result in evict which will destroy
798 	 * both inode and iopen glocks properly. */
799 	if (file) {
800 		file->f_mode |= FMODE_CREATED;
801 		error = finish_open(file, dentry, gfs2_open_common);
802 	}
803 	gfs2_glock_dq_uninit(&d_gh);
804 	gfs2_qa_put(ip);
805 	gfs2_glock_dq_uninit(&gh);
806 	gfs2_glock_put(io_gl);
807 	gfs2_qa_put(dip);
808 	unlock_new_inode(inode);
809 	return error;
810 
811 fail_gunlock4:
812 	glock_clear_object(ip->i_gl, ip);
813 	glock_clear_object(io_gl, ip);
814 fail_gunlock3:
815 	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
816 fail_gunlock2:
817 	gfs2_glock_put(io_gl);
818 fail_free_inode:
819 	gfs2_rs_deltree(&ip->i_res);
820 	gfs2_qa_put(ip);
821 fail_free_acls:
822 	posix_acl_release(default_acl);
823 	posix_acl_release(acl);
824 fail_gunlock:
825 	gfs2_dir_no_add(&da);
826 	gfs2_glock_dq_uninit(&d_gh);
827 	if (!IS_ERR_OR_NULL(inode)) {
828 		set_bit(GIF_ALLOC_FAILED, &ip->i_flags);
829 		clear_nlink(inode);
830 		if (ip->i_no_addr)
831 			mark_inode_dirty(inode);
832 		if (inode->i_state & I_NEW)
833 			iget_failed(inode);
834 		else
835 			iput(inode);
836 	}
837 	if (gfs2_holder_initialized(&gh))
838 		gfs2_glock_dq_uninit(&gh);
839 fail:
840 	gfs2_qa_put(dip);
841 	return error;
842 }
843 
844 /**
845  * gfs2_create - Create a file
846  * @mnt_userns: User namespace of the mount the inode was found from
847  * @dir: The directory in which to create the file
848  * @dentry: The dentry of the new file
849  * @mode: The mode of the new file
850  * @excl: Force fail if inode exists
851  *
852  * Returns: errno
853  */
854 
855 static int gfs2_create(struct user_namespace *mnt_userns, struct inode *dir,
856 		       struct dentry *dentry, umode_t mode, bool excl)
857 {
858 	return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl);
859 }
860 
861 /**
862  * __gfs2_lookup - Look up a filename in a directory and return its inode
863  * @dir: The directory inode
864  * @dentry: The dentry of the new inode
865  * @file: File to be opened
866  *
867  *
868  * Returns: errno
869  */
870 
871 static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
872 				    struct file *file)
873 {
874 	struct inode *inode;
875 	struct dentry *d;
876 	struct gfs2_holder gh;
877 	struct gfs2_glock *gl;
878 	int error;
879 
880 	inode = gfs2_lookupi(dir, &dentry->d_name, 0);
881 	if (inode == NULL) {
882 		d_add(dentry, NULL);
883 		return NULL;
884 	}
885 	if (IS_ERR(inode))
886 		return ERR_CAST(inode);
887 
888 	gl = GFS2_I(inode)->i_gl;
889 	error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
890 	if (error) {
891 		iput(inode);
892 		return ERR_PTR(error);
893 	}
894 
895 	d = d_splice_alias(inode, dentry);
896 	if (IS_ERR(d)) {
897 		gfs2_glock_dq_uninit(&gh);
898 		return d;
899 	}
900 	if (file && S_ISREG(inode->i_mode))
901 		error = finish_open(file, dentry, gfs2_open_common);
902 
903 	gfs2_glock_dq_uninit(&gh);
904 	if (error) {
905 		dput(d);
906 		return ERR_PTR(error);
907 	}
908 	return d;
909 }
910 
911 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
912 				  unsigned flags)
913 {
914 	return __gfs2_lookup(dir, dentry, NULL);
915 }
916 
917 /**
918  * gfs2_link - Link to a file
919  * @old_dentry: The inode to link
920  * @dir: Add link to this directory
921  * @dentry: The name of the link
922  *
923  * Link the inode in "old_dentry" into the directory "dir" with the
924  * name in "dentry".
925  *
926  * Returns: errno
927  */
928 
929 static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
930 		     struct dentry *dentry)
931 {
932 	struct gfs2_inode *dip = GFS2_I(dir);
933 	struct gfs2_sbd *sdp = GFS2_SB(dir);
934 	struct inode *inode = d_inode(old_dentry);
935 	struct gfs2_inode *ip = GFS2_I(inode);
936 	struct gfs2_holder ghs[2];
937 	struct buffer_head *dibh;
938 	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
939 	int error;
940 
941 	if (S_ISDIR(inode->i_mode))
942 		return -EPERM;
943 
944 	error = gfs2_qa_get(dip);
945 	if (error)
946 		return error;
947 
948 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
949 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
950 
951 	error = gfs2_glock_nq(ghs); /* parent */
952 	if (error)
953 		goto out_parent;
954 
955 	error = gfs2_glock_nq(ghs + 1); /* child */
956 	if (error)
957 		goto out_child;
958 
959 	error = -ENOENT;
960 	if (inode->i_nlink == 0)
961 		goto out_gunlock;
962 
963 	error = gfs2_permission(&init_user_ns, dir, MAY_WRITE | MAY_EXEC);
964 	if (error)
965 		goto out_gunlock;
966 
967 	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
968 	switch (error) {
969 	case -ENOENT:
970 		break;
971 	case 0:
972 		error = -EEXIST;
973 		goto out_gunlock;
974 	default:
975 		goto out_gunlock;
976 	}
977 
978 	error = -EINVAL;
979 	if (!dip->i_inode.i_nlink)
980 		goto out_gunlock;
981 	error = -EFBIG;
982 	if (dip->i_entries == (u32)-1)
983 		goto out_gunlock;
984 	error = -EPERM;
985 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
986 		goto out_gunlock;
987 	error = -EINVAL;
988 	if (!ip->i_inode.i_nlink)
989 		goto out_gunlock;
990 	error = -EMLINK;
991 	if (ip->i_inode.i_nlink == (u32)-1)
992 		goto out_gunlock;
993 
994 	error = gfs2_diradd_alloc_required(dir, &dentry->d_name, &da);
995 	if (error < 0)
996 		goto out_gunlock;
997 
998 	if (da.nr_blocks) {
999 		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
1000 		error = gfs2_quota_lock_check(dip, &ap);
1001 		if (error)
1002 			goto out_gunlock;
1003 
1004 		error = gfs2_inplace_reserve(dip, &ap);
1005 		if (error)
1006 			goto out_gunlock_q;
1007 
1008 		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, &da, 2), 0);
1009 		if (error)
1010 			goto out_ipres;
1011 	} else {
1012 		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
1013 		if (error)
1014 			goto out_ipres;
1015 	}
1016 
1017 	error = gfs2_meta_inode_buffer(ip, &dibh);
1018 	if (error)
1019 		goto out_end_trans;
1020 
1021 	error = gfs2_dir_add(dir, &dentry->d_name, ip, &da);
1022 	if (error)
1023 		goto out_brelse;
1024 
1025 	gfs2_trans_add_meta(ip->i_gl, dibh);
1026 	inc_nlink(&ip->i_inode);
1027 	ip->i_inode.i_ctime = current_time(&ip->i_inode);
1028 	ihold(inode);
1029 	d_instantiate(dentry, inode);
1030 	mark_inode_dirty(inode);
1031 
1032 out_brelse:
1033 	brelse(dibh);
1034 out_end_trans:
1035 	gfs2_trans_end(sdp);
1036 out_ipres:
1037 	if (da.nr_blocks)
1038 		gfs2_inplace_release(dip);
1039 out_gunlock_q:
1040 	if (da.nr_blocks)
1041 		gfs2_quota_unlock(dip);
1042 out_gunlock:
1043 	gfs2_dir_no_add(&da);
1044 	gfs2_glock_dq(ghs + 1);
1045 out_child:
1046 	gfs2_glock_dq(ghs);
1047 out_parent:
1048 	gfs2_qa_put(dip);
1049 	gfs2_holder_uninit(ghs);
1050 	gfs2_holder_uninit(ghs + 1);
1051 	return error;
1052 }
1053 
1054 /*
1055  * gfs2_unlink_ok - check to see that a inode is still in a directory
1056  * @dip: the directory
1057  * @name: the name of the file
1058  * @ip: the inode
1059  *
1060  * Assumes that the lock on (at least) @dip is held.
1061  *
1062  * Returns: 0 if the parent/child relationship is correct, errno if it isn't
1063  */
1064 
1065 static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
1066 			  const struct gfs2_inode *ip)
1067 {
1068 	int error;
1069 
1070 	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
1071 		return -EPERM;
1072 
1073 	if ((dip->i_inode.i_mode & S_ISVTX) &&
1074 	    !uid_eq(dip->i_inode.i_uid, current_fsuid()) &&
1075 	    !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER))
1076 		return -EPERM;
1077 
1078 	if (IS_APPEND(&dip->i_inode))
1079 		return -EPERM;
1080 
1081 	error = gfs2_permission(&init_user_ns, &dip->i_inode,
1082 				MAY_WRITE | MAY_EXEC);
1083 	if (error)
1084 		return error;
1085 
1086 	return gfs2_dir_check(&dip->i_inode, name, ip);
1087 }
1088 
1089 /**
1090  * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
1091  * @dip: The parent directory
1092  * @dentry: The dentry to unlink
1093  *
1094  * Called with all the locks and in a transaction. This will only be
1095  * called for a directory after it has been checked to ensure it is empty.
1096  *
1097  * Returns: 0 on success, or an error
1098  */
1099 
1100 static int gfs2_unlink_inode(struct gfs2_inode *dip,
1101 			     const struct dentry *dentry)
1102 {
1103 	struct inode *inode = d_inode(dentry);
1104 	struct gfs2_inode *ip = GFS2_I(inode);
1105 	int error;
1106 
1107 	error = gfs2_dir_del(dip, dentry);
1108 	if (error)
1109 		return error;
1110 
1111 	ip->i_entries = 0;
1112 	inode->i_ctime = current_time(inode);
1113 	if (S_ISDIR(inode->i_mode))
1114 		clear_nlink(inode);
1115 	else
1116 		drop_nlink(inode);
1117 	mark_inode_dirty(inode);
1118 	if (inode->i_nlink == 0)
1119 		gfs2_unlink_di(inode);
1120 	return 0;
1121 }
1122 
1123 
1124 /**
1125  * gfs2_unlink - Unlink an inode (this does rmdir as well)
1126  * @dir: The inode of the directory containing the inode to unlink
1127  * @dentry: The file itself
1128  *
1129  * This routine uses the type of the inode as a flag to figure out
1130  * whether this is an unlink or an rmdir.
1131  *
1132  * Returns: errno
1133  */
1134 
1135 static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
1136 {
1137 	struct gfs2_inode *dip = GFS2_I(dir);
1138 	struct gfs2_sbd *sdp = GFS2_SB(dir);
1139 	struct inode *inode = d_inode(dentry);
1140 	struct gfs2_inode *ip = GFS2_I(inode);
1141 	struct gfs2_holder ghs[3];
1142 	struct gfs2_rgrpd *rgd;
1143 	int error;
1144 
1145 	error = gfs2_rindex_update(sdp);
1146 	if (error)
1147 		return error;
1148 
1149 	error = -EROFS;
1150 
1151 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1152 	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
1153 
1154 	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1155 	if (!rgd)
1156 		goto out_inodes;
1157 
1158 	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, LM_FLAG_NODE_SCOPE, ghs + 2);
1159 
1160 
1161 	error = gfs2_glock_nq(ghs); /* parent */
1162 	if (error)
1163 		goto out_parent;
1164 
1165 	error = gfs2_glock_nq(ghs + 1); /* child */
1166 	if (error)
1167 		goto out_child;
1168 
1169 	error = -ENOENT;
1170 	if (inode->i_nlink == 0)
1171 		goto out_rgrp;
1172 
1173 	if (S_ISDIR(inode->i_mode)) {
1174 		error = -ENOTEMPTY;
1175 		if (ip->i_entries > 2 || inode->i_nlink > 2)
1176 			goto out_rgrp;
1177 	}
1178 
1179 	error = gfs2_glock_nq(ghs + 2); /* rgrp */
1180 	if (error)
1181 		goto out_rgrp;
1182 
1183 	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
1184 	if (error)
1185 		goto out_gunlock;
1186 
1187 	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
1188 	if (error)
1189 		goto out_gunlock;
1190 
1191 	error = gfs2_unlink_inode(dip, dentry);
1192 	gfs2_trans_end(sdp);
1193 
1194 out_gunlock:
1195 	gfs2_glock_dq(ghs + 2);
1196 out_rgrp:
1197 	gfs2_glock_dq(ghs + 1);
1198 out_child:
1199 	gfs2_glock_dq(ghs);
1200 out_parent:
1201 	gfs2_holder_uninit(ghs + 2);
1202 out_inodes:
1203 	gfs2_holder_uninit(ghs + 1);
1204 	gfs2_holder_uninit(ghs);
1205 	return error;
1206 }
1207 
1208 /**
1209  * gfs2_symlink - Create a symlink
1210  * @mnt_userns: User namespace of the mount the inode was found from
1211  * @dir: The directory to create the symlink in
1212  * @dentry: The dentry to put the symlink in
1213  * @symname: The thing which the link points to
1214  *
1215  * Returns: errno
1216  */
1217 
1218 static int gfs2_symlink(struct user_namespace *mnt_userns, struct inode *dir,
1219 			struct dentry *dentry, const char *symname)
1220 {
1221 	unsigned int size;
1222 
1223 	size = strlen(symname);
1224 	if (size >= gfs2_max_stuffed_size(GFS2_I(dir)))
1225 		return -ENAMETOOLONG;
1226 
1227 	return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0);
1228 }
1229 
1230 /**
1231  * gfs2_mkdir - Make a directory
1232  * @mnt_userns: User namespace of the mount the inode was found from
1233  * @dir: The parent directory of the new one
1234  * @dentry: The dentry of the new directory
1235  * @mode: The mode of the new directory
1236  *
1237  * Returns: errno
1238  */
1239 
1240 static int gfs2_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
1241 		      struct dentry *dentry, umode_t mode)
1242 {
1243 	unsigned dsize = gfs2_max_stuffed_size(GFS2_I(dir));
1244 	return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0);
1245 }
1246 
1247 /**
1248  * gfs2_mknod - Make a special file
1249  * @mnt_userns: User namespace of the mount the inode was found from
1250  * @dir: The directory in which the special file will reside
1251  * @dentry: The dentry of the special file
1252  * @mode: The mode of the special file
1253  * @dev: The device specification of the special file
1254  *
1255  */
1256 
1257 static int gfs2_mknod(struct user_namespace *mnt_userns, struct inode *dir,
1258 		      struct dentry *dentry, umode_t mode, dev_t dev)
1259 {
1260 	return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, 0, 0);
1261 }
1262 
1263 /**
1264  * gfs2_atomic_open - Atomically open a file
1265  * @dir: The directory
1266  * @dentry: The proposed new entry
1267  * @file: The proposed new struct file
1268  * @flags: open flags
1269  * @mode: File mode
1270  *
1271  * Returns: error code or 0 for success
1272  */
1273 
1274 static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
1275 			    struct file *file, unsigned flags,
1276 			    umode_t mode)
1277 {
1278 	struct dentry *d;
1279 	bool excl = !!(flags & O_EXCL);
1280 
1281 	if (!d_in_lookup(dentry))
1282 		goto skip_lookup;
1283 
1284 	d = __gfs2_lookup(dir, dentry, file);
1285 	if (IS_ERR(d))
1286 		return PTR_ERR(d);
1287 	if (d != NULL)
1288 		dentry = d;
1289 	if (d_really_is_positive(dentry)) {
1290 		if (!(file->f_mode & FMODE_OPENED))
1291 			return finish_no_open(file, d);
1292 		dput(d);
1293 		return excl && (flags & O_CREAT) ? -EEXIST : 0;
1294 	}
1295 
1296 	BUG_ON(d != NULL);
1297 
1298 skip_lookup:
1299 	if (!(flags & O_CREAT))
1300 		return -ENOENT;
1301 
1302 	return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, 0, NULL, 0, excl);
1303 }
1304 
1305 /*
1306  * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1307  * @this: move this
1308  * @to: to here
1309  *
1310  * Follow @to back to the root and make sure we don't encounter @this
1311  * Assumes we already hold the rename lock.
1312  *
1313  * Returns: errno
1314  */
1315 
1316 static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1317 {
1318 	struct inode *dir = &to->i_inode;
1319 	struct super_block *sb = dir->i_sb;
1320 	struct inode *tmp;
1321 	int error = 0;
1322 
1323 	igrab(dir);
1324 
1325 	for (;;) {
1326 		if (dir == &this->i_inode) {
1327 			error = -EINVAL;
1328 			break;
1329 		}
1330 		if (dir == d_inode(sb->s_root)) {
1331 			error = 0;
1332 			break;
1333 		}
1334 
1335 		tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
1336 		if (!tmp) {
1337 			error = -ENOENT;
1338 			break;
1339 		}
1340 		if (IS_ERR(tmp)) {
1341 			error = PTR_ERR(tmp);
1342 			break;
1343 		}
1344 
1345 		iput(dir);
1346 		dir = tmp;
1347 	}
1348 
1349 	iput(dir);
1350 
1351 	return error;
1352 }
1353 
1354 /**
1355  * update_moved_ino - Update an inode that's being moved
1356  * @ip: The inode being moved
1357  * @ndip: The parent directory of the new filename
1358  * @dir_rename: True of ip is a directory
1359  *
1360  * Returns: errno
1361  */
1362 
1363 static int update_moved_ino(struct gfs2_inode *ip, struct gfs2_inode *ndip,
1364 			    int dir_rename)
1365 {
1366 	if (dir_rename)
1367 		return gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);
1368 
1369 	ip->i_inode.i_ctime = current_time(&ip->i_inode);
1370 	mark_inode_dirty_sync(&ip->i_inode);
1371 	return 0;
1372 }
1373 
1374 
1375 /**
1376  * gfs2_rename - Rename a file
1377  * @odir: Parent directory of old file name
1378  * @odentry: The old dentry of the file
1379  * @ndir: Parent directory of new file name
1380  * @ndentry: The new dentry of the file
1381  *
1382  * Returns: errno
1383  */
1384 
1385 static int gfs2_rename(struct inode *odir, struct dentry *odentry,
1386 		       struct inode *ndir, struct dentry *ndentry)
1387 {
1388 	struct gfs2_inode *odip = GFS2_I(odir);
1389 	struct gfs2_inode *ndip = GFS2_I(ndir);
1390 	struct gfs2_inode *ip = GFS2_I(d_inode(odentry));
1391 	struct gfs2_inode *nip = NULL;
1392 	struct gfs2_sbd *sdp = GFS2_SB(odir);
1393 	struct gfs2_holder ghs[4], r_gh, rd_gh;
1394 	struct gfs2_rgrpd *nrgd;
1395 	unsigned int num_gh;
1396 	int dir_rename = 0;
1397 	struct gfs2_diradd da = { .nr_blocks = 0, .save_loc = 0, };
1398 	unsigned int x;
1399 	int error;
1400 
1401 	gfs2_holder_mark_uninitialized(&r_gh);
1402 	gfs2_holder_mark_uninitialized(&rd_gh);
1403 	if (d_really_is_positive(ndentry)) {
1404 		nip = GFS2_I(d_inode(ndentry));
1405 		if (ip == nip)
1406 			return 0;
1407 	}
1408 
1409 	error = gfs2_rindex_update(sdp);
1410 	if (error)
1411 		return error;
1412 
1413 	error = gfs2_qa_get(ndip);
1414 	if (error)
1415 		return error;
1416 
1417 	if (odip != ndip) {
1418 		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1419 					   0, &r_gh);
1420 		if (error)
1421 			goto out;
1422 
1423 		if (S_ISDIR(ip->i_inode.i_mode)) {
1424 			dir_rename = 1;
1425 			/* don't move a directory into its subdir */
1426 			error = gfs2_ok_to_move(ip, ndip);
1427 			if (error)
1428 				goto out_gunlock_r;
1429 		}
1430 	}
1431 
1432 	num_gh = 1;
1433 	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs);
1434 	if (odip != ndip) {
1435 		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE,GL_ASYNC,
1436 				 ghs + num_gh);
1437 		num_gh++;
1438 	}
1439 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs + num_gh);
1440 	num_gh++;
1441 
1442 	if (nip) {
1443 		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC,
1444 				 ghs + num_gh);
1445 		num_gh++;
1446 	}
1447 
1448 	for (x = 0; x < num_gh; x++) {
1449 		error = gfs2_glock_nq(ghs + x);
1450 		if (error)
1451 			goto out_gunlock;
1452 	}
1453 	error = gfs2_glock_async_wait(num_gh, ghs);
1454 	if (error)
1455 		goto out_gunlock;
1456 
1457 	if (nip) {
1458 		/* Grab the resource group glock for unlink flag twiddling.
1459 		 * This is the case where the target dinode already exists
1460 		 * so we unlink before doing the rename.
1461 		 */
1462 		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
1463 		if (!nrgd) {
1464 			error = -ENOENT;
1465 			goto out_gunlock;
1466 		}
1467 		error = gfs2_glock_nq_init(nrgd->rd_gl, LM_ST_EXCLUSIVE,
1468 					   LM_FLAG_NODE_SCOPE, &rd_gh);
1469 		if (error)
1470 			goto out_gunlock;
1471 	}
1472 
1473 	error = -ENOENT;
1474 	if (ip->i_inode.i_nlink == 0)
1475 		goto out_gunlock;
1476 
1477 	/* Check out the old directory */
1478 
1479 	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
1480 	if (error)
1481 		goto out_gunlock;
1482 
1483 	/* Check out the new directory */
1484 
1485 	if (nip) {
1486 		error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1487 		if (error)
1488 			goto out_gunlock;
1489 
1490 		if (nip->i_inode.i_nlink == 0) {
1491 			error = -EAGAIN;
1492 			goto out_gunlock;
1493 		}
1494 
1495 		if (S_ISDIR(nip->i_inode.i_mode)) {
1496 			if (nip->i_entries < 2) {
1497 				gfs2_consist_inode(nip);
1498 				error = -EIO;
1499 				goto out_gunlock;
1500 			}
1501 			if (nip->i_entries > 2) {
1502 				error = -ENOTEMPTY;
1503 				goto out_gunlock;
1504 			}
1505 		}
1506 	} else {
1507 		error = gfs2_permission(&init_user_ns, ndir,
1508 					MAY_WRITE | MAY_EXEC);
1509 		if (error)
1510 			goto out_gunlock;
1511 
1512 		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
1513 		switch (error) {
1514 		case -ENOENT:
1515 			error = 0;
1516 			break;
1517 		case 0:
1518 			error = -EEXIST;
1519 			goto out_gunlock;
1520 		default:
1521 			goto out_gunlock;
1522 		}
1523 
1524 		if (odip != ndip) {
1525 			if (!ndip->i_inode.i_nlink) {
1526 				error = -ENOENT;
1527 				goto out_gunlock;
1528 			}
1529 			if (ndip->i_entries == (u32)-1) {
1530 				error = -EFBIG;
1531 				goto out_gunlock;
1532 			}
1533 			if (S_ISDIR(ip->i_inode.i_mode) &&
1534 			    ndip->i_inode.i_nlink == (u32)-1) {
1535 				error = -EMLINK;
1536 				goto out_gunlock;
1537 			}
1538 		}
1539 	}
1540 
1541 	/* Check out the dir to be renamed */
1542 
1543 	if (dir_rename) {
1544 		error = gfs2_permission(&init_user_ns, d_inode(odentry),
1545 					MAY_WRITE);
1546 		if (error)
1547 			goto out_gunlock;
1548 	}
1549 
1550 	if (nip == NULL) {
1551 		error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name, &da);
1552 		if (error)
1553 			goto out_gunlock;
1554 	}
1555 
1556 	if (da.nr_blocks) {
1557 		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
1558 		error = gfs2_quota_lock_check(ndip, &ap);
1559 		if (error)
1560 			goto out_gunlock;
1561 
1562 		error = gfs2_inplace_reserve(ndip, &ap);
1563 		if (error)
1564 			goto out_gunlock_q;
1565 
1566 		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(ndip, &da, 4) +
1567 					 4 * RES_LEAF + 4, 0);
1568 		if (error)
1569 			goto out_ipreserv;
1570 	} else {
1571 		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
1572 					 5 * RES_LEAF + 4, 0);
1573 		if (error)
1574 			goto out_gunlock;
1575 	}
1576 
1577 	/* Remove the target file, if it exists */
1578 
1579 	if (nip)
1580 		error = gfs2_unlink_inode(ndip, ndentry);
1581 
1582 	error = update_moved_ino(ip, ndip, dir_rename);
1583 	if (error)
1584 		goto out_end_trans;
1585 
1586 	error = gfs2_dir_del(odip, odentry);
1587 	if (error)
1588 		goto out_end_trans;
1589 
1590 	error = gfs2_dir_add(ndir, &ndentry->d_name, ip, &da);
1591 	if (error)
1592 		goto out_end_trans;
1593 
1594 out_end_trans:
1595 	gfs2_trans_end(sdp);
1596 out_ipreserv:
1597 	if (da.nr_blocks)
1598 		gfs2_inplace_release(ndip);
1599 out_gunlock_q:
1600 	if (da.nr_blocks)
1601 		gfs2_quota_unlock(ndip);
1602 out_gunlock:
1603 	gfs2_dir_no_add(&da);
1604 	if (gfs2_holder_initialized(&rd_gh))
1605 		gfs2_glock_dq_uninit(&rd_gh);
1606 
1607 	while (x--) {
1608 		if (gfs2_holder_queued(ghs + x))
1609 			gfs2_glock_dq(ghs + x);
1610 		gfs2_holder_uninit(ghs + x);
1611 	}
1612 out_gunlock_r:
1613 	if (gfs2_holder_initialized(&r_gh))
1614 		gfs2_glock_dq_uninit(&r_gh);
1615 out:
1616 	gfs2_qa_put(ndip);
1617 	return error;
1618 }
1619 
1620 /**
1621  * gfs2_exchange - exchange two files
1622  * @odir: Parent directory of old file name
1623  * @odentry: The old dentry of the file
1624  * @ndir: Parent directory of new file name
1625  * @ndentry: The new dentry of the file
1626  * @flags: The rename flags
1627  *
1628  * Returns: errno
1629  */
1630 
1631 static int gfs2_exchange(struct inode *odir, struct dentry *odentry,
1632 			 struct inode *ndir, struct dentry *ndentry,
1633 			 unsigned int flags)
1634 {
1635 	struct gfs2_inode *odip = GFS2_I(odir);
1636 	struct gfs2_inode *ndip = GFS2_I(ndir);
1637 	struct gfs2_inode *oip = GFS2_I(odentry->d_inode);
1638 	struct gfs2_inode *nip = GFS2_I(ndentry->d_inode);
1639 	struct gfs2_sbd *sdp = GFS2_SB(odir);
1640 	struct gfs2_holder ghs[4], r_gh;
1641 	unsigned int num_gh;
1642 	unsigned int x;
1643 	umode_t old_mode = oip->i_inode.i_mode;
1644 	umode_t new_mode = nip->i_inode.i_mode;
1645 	int error;
1646 
1647 	gfs2_holder_mark_uninitialized(&r_gh);
1648 	error = gfs2_rindex_update(sdp);
1649 	if (error)
1650 		return error;
1651 
1652 	if (odip != ndip) {
1653 		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1654 					   0, &r_gh);
1655 		if (error)
1656 			goto out;
1657 
1658 		if (S_ISDIR(old_mode)) {
1659 			/* don't move a directory into its subdir */
1660 			error = gfs2_ok_to_move(oip, ndip);
1661 			if (error)
1662 				goto out_gunlock_r;
1663 		}
1664 
1665 		if (S_ISDIR(new_mode)) {
1666 			/* don't move a directory into its subdir */
1667 			error = gfs2_ok_to_move(nip, odip);
1668 			if (error)
1669 				goto out_gunlock_r;
1670 		}
1671 	}
1672 
1673 	num_gh = 1;
1674 	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs);
1675 	if (odip != ndip) {
1676 		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC,
1677 				 ghs + num_gh);
1678 		num_gh++;
1679 	}
1680 	gfs2_holder_init(oip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs + num_gh);
1681 	num_gh++;
1682 
1683 	gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs + num_gh);
1684 	num_gh++;
1685 
1686 	for (x = 0; x < num_gh; x++) {
1687 		error = gfs2_glock_nq(ghs + x);
1688 		if (error)
1689 			goto out_gunlock;
1690 	}
1691 
1692 	error = gfs2_glock_async_wait(num_gh, ghs);
1693 	if (error)
1694 		goto out_gunlock;
1695 
1696 	error = -ENOENT;
1697 	if (oip->i_inode.i_nlink == 0 || nip->i_inode.i_nlink == 0)
1698 		goto out_gunlock;
1699 
1700 	error = gfs2_unlink_ok(odip, &odentry->d_name, oip);
1701 	if (error)
1702 		goto out_gunlock;
1703 	error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1704 	if (error)
1705 		goto out_gunlock;
1706 
1707 	if (S_ISDIR(old_mode)) {
1708 		error = gfs2_permission(&init_user_ns, odentry->d_inode,
1709 					MAY_WRITE);
1710 		if (error)
1711 			goto out_gunlock;
1712 	}
1713 	if (S_ISDIR(new_mode)) {
1714 		error = gfs2_permission(&init_user_ns, ndentry->d_inode,
1715 					MAY_WRITE);
1716 		if (error)
1717 			goto out_gunlock;
1718 	}
1719 	error = gfs2_trans_begin(sdp, 4 * RES_DINODE + 4 * RES_LEAF, 0);
1720 	if (error)
1721 		goto out_gunlock;
1722 
1723 	error = update_moved_ino(oip, ndip, S_ISDIR(old_mode));
1724 	if (error)
1725 		goto out_end_trans;
1726 
1727 	error = update_moved_ino(nip, odip, S_ISDIR(new_mode));
1728 	if (error)
1729 		goto out_end_trans;
1730 
1731 	error = gfs2_dir_mvino(ndip, &ndentry->d_name, oip,
1732 			       IF2DT(old_mode));
1733 	if (error)
1734 		goto out_end_trans;
1735 
1736 	error = gfs2_dir_mvino(odip, &odentry->d_name, nip,
1737 			       IF2DT(new_mode));
1738 	if (error)
1739 		goto out_end_trans;
1740 
1741 	if (odip != ndip) {
1742 		if (S_ISDIR(new_mode) && !S_ISDIR(old_mode)) {
1743 			inc_nlink(&odip->i_inode);
1744 			drop_nlink(&ndip->i_inode);
1745 		} else if (S_ISDIR(old_mode) && !S_ISDIR(new_mode)) {
1746 			inc_nlink(&ndip->i_inode);
1747 			drop_nlink(&odip->i_inode);
1748 		}
1749 	}
1750 	mark_inode_dirty(&ndip->i_inode);
1751 	if (odip != ndip)
1752 		mark_inode_dirty(&odip->i_inode);
1753 
1754 out_end_trans:
1755 	gfs2_trans_end(sdp);
1756 out_gunlock:
1757 	while (x--) {
1758 		if (gfs2_holder_queued(ghs + x))
1759 			gfs2_glock_dq(ghs + x);
1760 		gfs2_holder_uninit(ghs + x);
1761 	}
1762 out_gunlock_r:
1763 	if (gfs2_holder_initialized(&r_gh))
1764 		gfs2_glock_dq_uninit(&r_gh);
1765 out:
1766 	return error;
1767 }
1768 
1769 static int gfs2_rename2(struct user_namespace *mnt_userns, struct inode *odir,
1770 			struct dentry *odentry, struct inode *ndir,
1771 			struct dentry *ndentry, unsigned int flags)
1772 {
1773 	flags &= ~RENAME_NOREPLACE;
1774 
1775 	if (flags & ~RENAME_EXCHANGE)
1776 		return -EINVAL;
1777 
1778 	if (flags & RENAME_EXCHANGE)
1779 		return gfs2_exchange(odir, odentry, ndir, ndentry, flags);
1780 
1781 	return gfs2_rename(odir, odentry, ndir, ndentry);
1782 }
1783 
1784 /**
1785  * gfs2_get_link - Follow a symbolic link
1786  * @dentry: The dentry of the link
1787  * @inode: The inode of the link
1788  * @done: destructor for return value
1789  *
1790  * This can handle symlinks of any size.
1791  *
1792  * Returns: 0 on success or error code
1793  */
1794 
1795 static const char *gfs2_get_link(struct dentry *dentry,
1796 				 struct inode *inode,
1797 				 struct delayed_call *done)
1798 {
1799 	struct gfs2_inode *ip = GFS2_I(inode);
1800 	struct gfs2_holder i_gh;
1801 	struct buffer_head *dibh;
1802 	unsigned int size;
1803 	char *buf;
1804 	int error;
1805 
1806 	if (!dentry)
1807 		return ERR_PTR(-ECHILD);
1808 
1809 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
1810 	error = gfs2_glock_nq(&i_gh);
1811 	if (error) {
1812 		gfs2_holder_uninit(&i_gh);
1813 		return ERR_PTR(error);
1814 	}
1815 
1816 	size = (unsigned int)i_size_read(&ip->i_inode);
1817 	if (size == 0) {
1818 		gfs2_consist_inode(ip);
1819 		buf = ERR_PTR(-EIO);
1820 		goto out;
1821 	}
1822 
1823 	error = gfs2_meta_inode_buffer(ip, &dibh);
1824 	if (error) {
1825 		buf = ERR_PTR(error);
1826 		goto out;
1827 	}
1828 
1829 	buf = kzalloc(size + 1, GFP_NOFS);
1830 	if (!buf)
1831 		buf = ERR_PTR(-ENOMEM);
1832 	else
1833 		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1834 	brelse(dibh);
1835 out:
1836 	gfs2_glock_dq_uninit(&i_gh);
1837 	if (!IS_ERR(buf))
1838 		set_delayed_call(done, kfree_link, buf);
1839 	return buf;
1840 }
1841 
1842 /**
1843  * gfs2_permission
1844  * @mnt_userns: User namespace of the mount the inode was found from
1845  * @inode: The inode
1846  * @mask: The mask to be tested
1847  *
1848  * This may be called from the VFS directly, or from within GFS2 with the
1849  * inode locked, so we look to see if the glock is already locked and only
1850  * lock the glock if its not already been done.
1851  *
1852  * Returns: errno
1853  */
1854 
1855 int gfs2_permission(struct user_namespace *mnt_userns, struct inode *inode,
1856 		    int mask)
1857 {
1858 	struct gfs2_inode *ip;
1859 	struct gfs2_holder i_gh;
1860 	int error;
1861 
1862 	gfs2_holder_mark_uninitialized(&i_gh);
1863 	ip = GFS2_I(inode);
1864 	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1865 		if (mask & MAY_NOT_BLOCK)
1866 			return -ECHILD;
1867 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
1868 		if (error)
1869 			return error;
1870 	}
1871 
1872 	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
1873 		error = -EPERM;
1874 	else
1875 		error = generic_permission(&init_user_ns, inode, mask);
1876 	if (gfs2_holder_initialized(&i_gh))
1877 		gfs2_glock_dq_uninit(&i_gh);
1878 
1879 	return error;
1880 }
1881 
1882 static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1883 {
1884 	setattr_copy(&init_user_ns, inode, attr);
1885 	mark_inode_dirty(inode);
1886 	return 0;
1887 }
1888 
1889 static int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1890 {
1891 	int error;
1892 
1893 	if (current->journal_info)
1894 		return __gfs2_setattr_simple(inode, attr);
1895 
1896 	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1897 	if (error)
1898 		return error;
1899 
1900 	error = __gfs2_setattr_simple(inode, attr);
1901 	gfs2_trans_end(GFS2_SB(inode));
1902 	return error;
1903 }
1904 
1905 static int setattr_chown(struct inode *inode, struct iattr *attr)
1906 {
1907 	struct gfs2_inode *ip = GFS2_I(inode);
1908 	struct gfs2_sbd *sdp = GFS2_SB(inode);
1909 	kuid_t ouid, nuid;
1910 	kgid_t ogid, ngid;
1911 	int error;
1912 	struct gfs2_alloc_parms ap;
1913 
1914 	ouid = inode->i_uid;
1915 	ogid = inode->i_gid;
1916 	nuid = attr->ia_uid;
1917 	ngid = attr->ia_gid;
1918 
1919 	if (!(attr->ia_valid & ATTR_UID) || uid_eq(ouid, nuid))
1920 		ouid = nuid = NO_UID_QUOTA_CHANGE;
1921 	if (!(attr->ia_valid & ATTR_GID) || gid_eq(ogid, ngid))
1922 		ogid = ngid = NO_GID_QUOTA_CHANGE;
1923 	error = gfs2_qa_get(ip);
1924 	if (error)
1925 		return error;
1926 
1927 	error = gfs2_rindex_update(sdp);
1928 	if (error)
1929 		goto out;
1930 
1931 	error = gfs2_quota_lock(ip, nuid, ngid);
1932 	if (error)
1933 		goto out;
1934 
1935 	ap.target = gfs2_get_inode_blocks(&ip->i_inode);
1936 
1937 	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
1938 	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1939 		error = gfs2_quota_check(ip, nuid, ngid, &ap);
1940 		if (error)
1941 			goto out_gunlock_q;
1942 	}
1943 
1944 	error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
1945 	if (error)
1946 		goto out_gunlock_q;
1947 
1948 	error = gfs2_setattr_simple(inode, attr);
1949 	if (error)
1950 		goto out_end_trans;
1951 
1952 	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
1953 	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1954 		gfs2_quota_change(ip, -(s64)ap.target, ouid, ogid);
1955 		gfs2_quota_change(ip, ap.target, nuid, ngid);
1956 	}
1957 
1958 out_end_trans:
1959 	gfs2_trans_end(sdp);
1960 out_gunlock_q:
1961 	gfs2_quota_unlock(ip);
1962 out:
1963 	gfs2_qa_put(ip);
1964 	return error;
1965 }
1966 
1967 /**
1968  * gfs2_setattr - Change attributes on an inode
1969  * @mnt_userns: User namespace of the mount the inode was found from
1970  * @dentry: The dentry which is changing
1971  * @attr: The structure describing the change
1972  *
1973  * The VFS layer wants to change one or more of an inodes attributes.  Write
1974  * that change out to disk.
1975  *
1976  * Returns: errno
1977  */
1978 
1979 static int gfs2_setattr(struct user_namespace *mnt_userns,
1980 			struct dentry *dentry, struct iattr *attr)
1981 {
1982 	struct inode *inode = d_inode(dentry);
1983 	struct gfs2_inode *ip = GFS2_I(inode);
1984 	struct gfs2_holder i_gh;
1985 	int error;
1986 
1987 	error = gfs2_qa_get(ip);
1988 	if (error)
1989 		return error;
1990 
1991 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1992 	if (error)
1993 		goto out;
1994 
1995 	error = may_setattr(&init_user_ns, inode, attr->ia_valid);
1996 	if (error)
1997 		goto error;
1998 
1999 	error = setattr_prepare(&init_user_ns, dentry, attr);
2000 	if (error)
2001 		goto error;
2002 
2003 	if (attr->ia_valid & ATTR_SIZE)
2004 		error = gfs2_setattr_size(inode, attr->ia_size);
2005 	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
2006 		error = setattr_chown(inode, attr);
2007 	else {
2008 		error = gfs2_setattr_simple(inode, attr);
2009 		if (!error && attr->ia_valid & ATTR_MODE)
2010 			error = posix_acl_chmod(&init_user_ns, dentry,
2011 						inode->i_mode);
2012 	}
2013 
2014 error:
2015 	if (!error)
2016 		mark_inode_dirty(inode);
2017 	gfs2_glock_dq_uninit(&i_gh);
2018 out:
2019 	gfs2_qa_put(ip);
2020 	return error;
2021 }
2022 
2023 /**
2024  * gfs2_getattr - Read out an inode's attributes
2025  * @mnt_userns:	user namespace of the mount the inode was found from
2026  * @path: Object to query
2027  * @stat: The inode's stats
2028  * @request_mask: Mask of STATX_xxx flags indicating the caller's interests
2029  * @flags: AT_STATX_xxx setting
2030  *
2031  * This may be called from the VFS directly, or from within GFS2 with the
2032  * inode locked, so we look to see if the glock is already locked and only
2033  * lock the glock if its not already been done. Note that its the NFS
2034  * readdirplus operation which causes this to be called (from filldir)
2035  * with the glock already held.
2036  *
2037  * Returns: errno
2038  */
2039 
2040 static int gfs2_getattr(struct user_namespace *mnt_userns,
2041 			const struct path *path, struct kstat *stat,
2042 			u32 request_mask, unsigned int flags)
2043 {
2044 	struct inode *inode = d_inode(path->dentry);
2045 	struct gfs2_inode *ip = GFS2_I(inode);
2046 	struct gfs2_holder gh;
2047 	u32 gfsflags;
2048 	int error;
2049 
2050 	gfs2_holder_mark_uninitialized(&gh);
2051 	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
2052 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
2053 		if (error)
2054 			return error;
2055 	}
2056 
2057 	gfsflags = ip->i_diskflags;
2058 	if (gfsflags & GFS2_DIF_APPENDONLY)
2059 		stat->attributes |= STATX_ATTR_APPEND;
2060 	if (gfsflags & GFS2_DIF_IMMUTABLE)
2061 		stat->attributes |= STATX_ATTR_IMMUTABLE;
2062 
2063 	stat->attributes_mask |= (STATX_ATTR_APPEND |
2064 				  STATX_ATTR_COMPRESSED |
2065 				  STATX_ATTR_ENCRYPTED |
2066 				  STATX_ATTR_IMMUTABLE |
2067 				  STATX_ATTR_NODUMP);
2068 
2069 	generic_fillattr(&init_user_ns, inode, stat);
2070 
2071 	if (gfs2_holder_initialized(&gh))
2072 		gfs2_glock_dq_uninit(&gh);
2073 
2074 	return 0;
2075 }
2076 
2077 static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2078 		       u64 start, u64 len)
2079 {
2080 	struct gfs2_inode *ip = GFS2_I(inode);
2081 	struct gfs2_holder gh;
2082 	int ret;
2083 
2084 	inode_lock_shared(inode);
2085 
2086 	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
2087 	if (ret)
2088 		goto out;
2089 
2090 	ret = iomap_fiemap(inode, fieinfo, start, len, &gfs2_iomap_ops);
2091 
2092 	gfs2_glock_dq_uninit(&gh);
2093 
2094 out:
2095 	inode_unlock_shared(inode);
2096 	return ret;
2097 }
2098 
2099 loff_t gfs2_seek_data(struct file *file, loff_t offset)
2100 {
2101 	struct inode *inode = file->f_mapping->host;
2102 	struct gfs2_inode *ip = GFS2_I(inode);
2103 	struct gfs2_holder gh;
2104 	loff_t ret;
2105 
2106 	inode_lock_shared(inode);
2107 	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
2108 	if (!ret)
2109 		ret = iomap_seek_data(inode, offset, &gfs2_iomap_ops);
2110 	gfs2_glock_dq_uninit(&gh);
2111 	inode_unlock_shared(inode);
2112 
2113 	if (ret < 0)
2114 		return ret;
2115 	return vfs_setpos(file, ret, inode->i_sb->s_maxbytes);
2116 }
2117 
2118 loff_t gfs2_seek_hole(struct file *file, loff_t offset)
2119 {
2120 	struct inode *inode = file->f_mapping->host;
2121 	struct gfs2_inode *ip = GFS2_I(inode);
2122 	struct gfs2_holder gh;
2123 	loff_t ret;
2124 
2125 	inode_lock_shared(inode);
2126 	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
2127 	if (!ret)
2128 		ret = iomap_seek_hole(inode, offset, &gfs2_iomap_ops);
2129 	gfs2_glock_dq_uninit(&gh);
2130 	inode_unlock_shared(inode);
2131 
2132 	if (ret < 0)
2133 		return ret;
2134 	return vfs_setpos(file, ret, inode->i_sb->s_maxbytes);
2135 }
2136 
2137 static int gfs2_update_time(struct inode *inode, struct timespec64 *time,
2138 			    int flags)
2139 {
2140 	struct gfs2_inode *ip = GFS2_I(inode);
2141 	struct gfs2_glock *gl = ip->i_gl;
2142 	struct gfs2_holder *gh;
2143 	int error;
2144 
2145 	gh = gfs2_glock_is_locked_by_me(gl);
2146 	if (gh && !gfs2_glock_is_held_excl(gl)) {
2147 		gfs2_glock_dq(gh);
2148 		gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, gh);
2149 		error = gfs2_glock_nq(gh);
2150 		if (error)
2151 			return error;
2152 	}
2153 	return generic_update_time(inode, time, flags);
2154 }
2155 
2156 static const struct inode_operations gfs2_file_iops = {
2157 	.permission = gfs2_permission,
2158 	.setattr = gfs2_setattr,
2159 	.getattr = gfs2_getattr,
2160 	.listxattr = gfs2_listxattr,
2161 	.fiemap = gfs2_fiemap,
2162 	.get_inode_acl = gfs2_get_acl,
2163 	.set_acl = gfs2_set_acl,
2164 	.update_time = gfs2_update_time,
2165 	.fileattr_get = gfs2_fileattr_get,
2166 	.fileattr_set = gfs2_fileattr_set,
2167 };
2168 
2169 static const struct inode_operations gfs2_dir_iops = {
2170 	.create = gfs2_create,
2171 	.lookup = gfs2_lookup,
2172 	.link = gfs2_link,
2173 	.unlink = gfs2_unlink,
2174 	.symlink = gfs2_symlink,
2175 	.mkdir = gfs2_mkdir,
2176 	.rmdir = gfs2_unlink,
2177 	.mknod = gfs2_mknod,
2178 	.rename = gfs2_rename2,
2179 	.permission = gfs2_permission,
2180 	.setattr = gfs2_setattr,
2181 	.getattr = gfs2_getattr,
2182 	.listxattr = gfs2_listxattr,
2183 	.fiemap = gfs2_fiemap,
2184 	.get_inode_acl = gfs2_get_acl,
2185 	.set_acl = gfs2_set_acl,
2186 	.update_time = gfs2_update_time,
2187 	.atomic_open = gfs2_atomic_open,
2188 	.fileattr_get = gfs2_fileattr_get,
2189 	.fileattr_set = gfs2_fileattr_set,
2190 };
2191 
2192 static const struct inode_operations gfs2_symlink_iops = {
2193 	.get_link = gfs2_get_link,
2194 	.permission = gfs2_permission,
2195 	.setattr = gfs2_setattr,
2196 	.getattr = gfs2_getattr,
2197 	.listxattr = gfs2_listxattr,
2198 	.fiemap = gfs2_fiemap,
2199 };
2200 
2201