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