xref: /openbmc/linux/fs/gfs2/inode.c (revision e23feb16)
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9 
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #include <linux/buffer_head.h>
14 #include <linux/namei.h>
15 #include <linux/mm.h>
16 #include <linux/xattr.h>
17 #include <linux/posix_acl.h>
18 #include <linux/gfs2_ondisk.h>
19 #include <linux/crc32.h>
20 #include <linux/fiemap.h>
21 #include <linux/security.h>
22 #include <asm/uaccess.h>
23 
24 #include "gfs2.h"
25 #include "incore.h"
26 #include "acl.h"
27 #include "bmap.h"
28 #include "dir.h"
29 #include "xattr.h"
30 #include "glock.h"
31 #include "inode.h"
32 #include "meta_io.h"
33 #include "quota.h"
34 #include "rgrp.h"
35 #include "trans.h"
36 #include "util.h"
37 #include "super.h"
38 #include "glops.h"
39 
40 struct gfs2_skip_data {
41 	u64 no_addr;
42 	int skipped;
43 	int non_block;
44 };
45 
46 static int iget_test(struct inode *inode, void *opaque)
47 {
48 	struct gfs2_inode *ip = GFS2_I(inode);
49 	struct gfs2_skip_data *data = opaque;
50 
51 	if (ip->i_no_addr == data->no_addr) {
52 		if (data->non_block &&
53 		    inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
54 			data->skipped = 1;
55 			return 0;
56 		}
57 		return 1;
58 	}
59 	return 0;
60 }
61 
62 static int iget_set(struct inode *inode, void *opaque)
63 {
64 	struct gfs2_inode *ip = GFS2_I(inode);
65 	struct gfs2_skip_data *data = opaque;
66 
67 	if (data->skipped)
68 		return -ENOENT;
69 	inode->i_ino = (unsigned long)(data->no_addr);
70 	ip->i_no_addr = data->no_addr;
71 	return 0;
72 }
73 
74 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr, int non_block)
75 {
76 	unsigned long hash = (unsigned long)no_addr;
77 	struct gfs2_skip_data data;
78 
79 	data.no_addr = no_addr;
80 	data.skipped = 0;
81 	data.non_block = non_block;
82 	return ilookup5(sb, hash, iget_test, &data);
83 }
84 
85 static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr,
86 			       int non_block)
87 {
88 	struct gfs2_skip_data data;
89 	unsigned long hash = (unsigned long)no_addr;
90 
91 	data.no_addr = no_addr;
92 	data.skipped = 0;
93 	data.non_block = non_block;
94 	return iget5_locked(sb, hash, iget_test, iget_set, &data);
95 }
96 
97 /**
98  * gfs2_set_iop - Sets inode operations
99  * @inode: The inode with correct i_mode filled in
100  *
101  * GFS2 lookup code fills in vfs inode contents based on info obtained
102  * from directory entry inside gfs2_inode_lookup().
103  */
104 
105 static void gfs2_set_iop(struct inode *inode)
106 {
107 	struct gfs2_sbd *sdp = GFS2_SB(inode);
108 	umode_t mode = inode->i_mode;
109 
110 	if (S_ISREG(mode)) {
111 		inode->i_op = &gfs2_file_iops;
112 		if (gfs2_localflocks(sdp))
113 			inode->i_fop = &gfs2_file_fops_nolock;
114 		else
115 			inode->i_fop = &gfs2_file_fops;
116 	} else if (S_ISDIR(mode)) {
117 		inode->i_op = &gfs2_dir_iops;
118 		if (gfs2_localflocks(sdp))
119 			inode->i_fop = &gfs2_dir_fops_nolock;
120 		else
121 			inode->i_fop = &gfs2_dir_fops;
122 	} else if (S_ISLNK(mode)) {
123 		inode->i_op = &gfs2_symlink_iops;
124 	} else {
125 		inode->i_op = &gfs2_file_iops;
126 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
127 	}
128 }
129 
130 /**
131  * gfs2_inode_lookup - Lookup an inode
132  * @sb: The super block
133  * @no_addr: The inode number
134  * @type: The type of the inode
135  * non_block: Can we block on inodes that are being freed?
136  *
137  * Returns: A VFS inode, or an error
138  */
139 
140 struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
141 				u64 no_addr, u64 no_formal_ino, int non_block)
142 {
143 	struct inode *inode;
144 	struct gfs2_inode *ip;
145 	struct gfs2_glock *io_gl = NULL;
146 	int error;
147 
148 	inode = gfs2_iget(sb, no_addr, non_block);
149 	ip = GFS2_I(inode);
150 
151 	if (!inode)
152 		return ERR_PTR(-ENOBUFS);
153 
154 	if (inode->i_state & I_NEW) {
155 		struct gfs2_sbd *sdp = GFS2_SB(inode);
156 		ip->i_no_formal_ino = no_formal_ino;
157 
158 		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
159 		if (unlikely(error))
160 			goto fail;
161 		ip->i_gl->gl_object = ip;
162 
163 		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
164 		if (unlikely(error))
165 			goto fail_put;
166 
167 		set_bit(GIF_INVALID, &ip->i_flags);
168 		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
169 		if (unlikely(error))
170 			goto fail_iopen;
171 
172 		ip->i_iopen_gh.gh_gl->gl_object = ip;
173 		gfs2_glock_put(io_gl);
174 		io_gl = NULL;
175 
176 		if (type == DT_UNKNOWN) {
177 			/* Inode glock must be locked already */
178 			error = gfs2_inode_refresh(GFS2_I(inode));
179 			if (error)
180 				goto fail_refresh;
181 		} else {
182 			inode->i_mode = DT2IF(type);
183 		}
184 
185 		gfs2_set_iop(inode);
186 		unlock_new_inode(inode);
187 	}
188 
189 	return inode;
190 
191 fail_refresh:
192 	ip->i_iopen_gh.gh_flags |= GL_NOCACHE;
193 	ip->i_iopen_gh.gh_gl->gl_object = NULL;
194 	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
195 fail_iopen:
196 	if (io_gl)
197 		gfs2_glock_put(io_gl);
198 fail_put:
199 	ip->i_gl->gl_object = NULL;
200 	gfs2_glock_put(ip->i_gl);
201 fail:
202 	iget_failed(inode);
203 	return ERR_PTR(error);
204 }
205 
206 struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
207 				  u64 *no_formal_ino, unsigned int blktype)
208 {
209 	struct super_block *sb = sdp->sd_vfs;
210 	struct gfs2_holder i_gh;
211 	struct inode *inode = NULL;
212 	int error;
213 
214 	/* Must not read in block until block type is verified */
215 	error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops,
216 				  LM_ST_EXCLUSIVE, GL_SKIP, &i_gh);
217 	if (error)
218 		return ERR_PTR(error);
219 
220 	error = gfs2_check_blk_type(sdp, no_addr, blktype);
221 	if (error)
222 		goto fail;
223 
224 	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, 1);
225 	if (IS_ERR(inode))
226 		goto fail;
227 
228 	/* Two extra checks for NFS only */
229 	if (no_formal_ino) {
230 		error = -ESTALE;
231 		if (GFS2_I(inode)->i_no_formal_ino != *no_formal_ino)
232 			goto fail_iput;
233 
234 		error = -EIO;
235 		if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM)
236 			goto fail_iput;
237 
238 		error = 0;
239 	}
240 
241 fail:
242 	gfs2_glock_dq_uninit(&i_gh);
243 	return error ? ERR_PTR(error) : inode;
244 fail_iput:
245 	iput(inode);
246 	goto fail;
247 }
248 
249 
250 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
251 {
252 	struct qstr qstr;
253 	struct inode *inode;
254 	gfs2_str2qstr(&qstr, name);
255 	inode = gfs2_lookupi(dip, &qstr, 1);
256 	/* gfs2_lookupi has inconsistent callers: vfs
257 	 * related routines expect NULL for no entry found,
258 	 * gfs2_lookup_simple callers expect ENOENT
259 	 * and do not check for NULL.
260 	 */
261 	if (inode == NULL)
262 		return ERR_PTR(-ENOENT);
263 	else
264 		return inode;
265 }
266 
267 
268 /**
269  * gfs2_lookupi - Look up a filename in a directory and return its inode
270  * @d_gh: An initialized holder for the directory glock
271  * @name: The name of the inode to look for
272  * @is_root: If 1, ignore the caller's permissions
273  * @i_gh: An uninitialized holder for the new inode glock
274  *
275  * This can be called via the VFS filldir function when NFS is doing
276  * a readdirplus and the inode which its intending to stat isn't
277  * already in cache. In this case we must not take the directory glock
278  * again, since the readdir call will have already taken that lock.
279  *
280  * Returns: errno
281  */
282 
283 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
284 			   int is_root)
285 {
286 	struct super_block *sb = dir->i_sb;
287 	struct gfs2_inode *dip = GFS2_I(dir);
288 	struct gfs2_holder d_gh;
289 	int error = 0;
290 	struct inode *inode = NULL;
291 	int unlock = 0;
292 
293 	if (!name->len || name->len > GFS2_FNAMESIZE)
294 		return ERR_PTR(-ENAMETOOLONG);
295 
296 	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
297 	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
298 	     dir == sb->s_root->d_inode)) {
299 		igrab(dir);
300 		return dir;
301 	}
302 
303 	if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
304 		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
305 		if (error)
306 			return ERR_PTR(error);
307 		unlock = 1;
308 	}
309 
310 	if (!is_root) {
311 		error = gfs2_permission(dir, MAY_EXEC);
312 		if (error)
313 			goto out;
314 	}
315 
316 	inode = gfs2_dir_search(dir, name, false);
317 	if (IS_ERR(inode))
318 		error = PTR_ERR(inode);
319 out:
320 	if (unlock)
321 		gfs2_glock_dq_uninit(&d_gh);
322 	if (error == -ENOENT)
323 		return NULL;
324 	return inode ? inode : ERR_PTR(error);
325 }
326 
327 /**
328  * create_ok - OK to create a new on-disk inode here?
329  * @dip:  Directory in which dinode is to be created
330  * @name:  Name of new dinode
331  * @mode:
332  *
333  * Returns: errno
334  */
335 
336 static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
337 		     umode_t mode)
338 {
339 	int error;
340 
341 	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
342 	if (error)
343 		return error;
344 
345 	/*  Don't create entries in an unlinked directory  */
346 	if (!dip->i_inode.i_nlink)
347 		return -ENOENT;
348 
349 	if (dip->i_entries == (u32)-1)
350 		return -EFBIG;
351 	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
352 		return -EMLINK;
353 
354 	return 0;
355 }
356 
357 static void munge_mode_uid_gid(const struct gfs2_inode *dip,
358 			       struct inode *inode)
359 {
360 	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
361 	    (dip->i_inode.i_mode & S_ISUID) &&
362 	    !uid_eq(dip->i_inode.i_uid, GLOBAL_ROOT_UID)) {
363 		if (S_ISDIR(inode->i_mode))
364 			inode->i_mode |= S_ISUID;
365 		else if (!uid_eq(dip->i_inode.i_uid, current_fsuid()))
366 			inode->i_mode &= ~07111;
367 		inode->i_uid = dip->i_inode.i_uid;
368 	} else
369 		inode->i_uid = current_fsuid();
370 
371 	if (dip->i_inode.i_mode & S_ISGID) {
372 		if (S_ISDIR(inode->i_mode))
373 			inode->i_mode |= S_ISGID;
374 		inode->i_gid = dip->i_inode.i_gid;
375 	} else
376 		inode->i_gid = current_fsgid();
377 }
378 
379 static int alloc_dinode(struct gfs2_inode *ip, u32 flags)
380 {
381 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
382 	int error;
383 	int dblocks = 1;
384 
385 	error = gfs2_quota_lock_check(ip);
386 	if (error)
387 		goto out;
388 
389 	error = gfs2_inplace_reserve(ip, RES_DINODE, flags);
390 	if (error)
391 		goto out_quota;
392 
393 	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 0);
394 	if (error)
395 		goto out_ipreserv;
396 
397 	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, &dblocks, 1, &ip->i_generation);
398 	ip->i_no_formal_ino = ip->i_generation;
399 	ip->i_inode.i_ino = ip->i_no_addr;
400 	ip->i_goal = ip->i_no_addr;
401 
402 	gfs2_trans_end(sdp);
403 
404 out_ipreserv:
405 	gfs2_inplace_release(ip);
406 out_quota:
407 	gfs2_quota_unlock(ip);
408 out:
409 	return error;
410 }
411 
412 static void gfs2_init_dir(struct buffer_head *dibh,
413 			  const struct gfs2_inode *parent)
414 {
415 	struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
416 	struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
417 
418 	gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
419 	dent->de_inum = di->di_num; /* already GFS2 endian */
420 	dent->de_type = cpu_to_be16(DT_DIR);
421 
422 	dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
423 	gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
424 	gfs2_inum_out(parent, dent);
425 	dent->de_type = cpu_to_be16(DT_DIR);
426 
427 }
428 
429 /**
430  * init_dinode - Fill in a new dinode structure
431  * @dip: The directory this inode is being created in
432  * @ip: The inode
433  * @symname: The symlink destination (if a symlink)
434  * @bhp: The buffer head (returned to caller)
435  *
436  */
437 
438 static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
439 			const char *symname)
440 {
441 	struct gfs2_dinode *di;
442 	struct buffer_head *dibh;
443 
444 	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
445 	gfs2_trans_add_meta(ip->i_gl, dibh);
446 	di = (struct gfs2_dinode *)dibh->b_data;
447 	gfs2_dinode_out(ip, di);
448 
449 	di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev));
450 	di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev));
451 	di->__pad1 = 0;
452 	di->__pad2 = 0;
453 	di->__pad3 = 0;
454 	memset(&di->__pad4, 0, sizeof(di->__pad4));
455 	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
456 	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
457 
458 	switch(ip->i_inode.i_mode & S_IFMT) {
459 	case S_IFDIR:
460 		gfs2_init_dir(dibh, dip);
461 		break;
462 	case S_IFLNK:
463 		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size);
464 		break;
465 	}
466 
467 	set_buffer_uptodate(dibh);
468 	brelse(dibh);
469 }
470 
471 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
472 		       struct gfs2_inode *ip, int arq)
473 {
474 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
475 	int error;
476 
477 	if (arq) {
478 		error = gfs2_quota_lock_check(dip);
479 		if (error)
480 			goto fail_quota_locks;
481 
482 		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres, 0);
483 		if (error)
484 			goto fail_quota_locks;
485 
486 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
487 					 dip->i_rgd->rd_length +
488 					 2 * RES_DINODE +
489 					 RES_STATFS + RES_QUOTA, 0);
490 		if (error)
491 			goto fail_ipreserv;
492 	} else {
493 		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
494 		if (error)
495 			goto fail_quota_locks;
496 	}
497 
498 	error = gfs2_dir_add(&dip->i_inode, name, ip);
499 	if (error)
500 		goto fail_end_trans;
501 
502 fail_end_trans:
503 	gfs2_trans_end(sdp);
504 fail_ipreserv:
505 	gfs2_inplace_release(dip);
506 fail_quota_locks:
507 	gfs2_quota_unlock(dip);
508 	return error;
509 }
510 
511 static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
512 		    void *fs_info)
513 {
514 	const struct xattr *xattr;
515 	int err = 0;
516 
517 	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
518 		err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
519 				       xattr->value_len, 0,
520 				       GFS2_EATYPE_SECURITY);
521 		if (err < 0)
522 			break;
523 	}
524 	return err;
525 }
526 
527 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
528 			      const struct qstr *qstr)
529 {
530 	return security_inode_init_security(&ip->i_inode, &dip->i_inode, qstr,
531 					    &gfs2_initxattrs, NULL);
532 }
533 
534 /**
535  * gfs2_create_inode - Create a new inode
536  * @dir: The parent directory
537  * @dentry: The new dentry
538  * @file: If non-NULL, the file which is being opened
539  * @mode: The permissions on the new inode
540  * @dev: For device nodes, this is the device number
541  * @symname: For symlinks, this is the link destination
542  * @size: The initial size of the inode (ignored for directories)
543  *
544  * Returns: 0 on success, or error code
545  */
546 
547 static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
548 			     struct file *file,
549 			     umode_t mode, dev_t dev, const char *symname,
550 			     unsigned int size, int excl, int *opened)
551 {
552 	const struct qstr *name = &dentry->d_name;
553 	struct gfs2_holder ghs[2];
554 	struct inode *inode = NULL;
555 	struct gfs2_inode *dip = GFS2_I(dir), *ip;
556 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
557 	struct gfs2_glock *io_gl;
558 	struct dentry *d;
559 	int error;
560 	u32 aflags = 0;
561 	int arq;
562 
563 	if (!name->len || name->len > GFS2_FNAMESIZE)
564 		return -ENAMETOOLONG;
565 
566 	error = gfs2_rs_alloc(dip);
567 	if (error)
568 		return error;
569 
570 	error = gfs2_rindex_update(sdp);
571 	if (error)
572 		return error;
573 
574 	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
575 	if (error)
576 		goto fail;
577 
578 	error = create_ok(dip, name, mode);
579 	if (error)
580 		goto fail_gunlock;
581 
582 	inode = gfs2_dir_search(dir, &dentry->d_name, !S_ISREG(mode) || excl);
583 	error = PTR_ERR(inode);
584 	if (!IS_ERR(inode)) {
585 		d = d_splice_alias(inode, dentry);
586 		error = 0;
587 		if (file && !IS_ERR(d)) {
588 			if (d == NULL)
589 				d = dentry;
590 			if (S_ISREG(inode->i_mode))
591 				error = finish_open(file, d, gfs2_open_common, opened);
592 			else
593 				error = finish_no_open(file, d);
594 		}
595 		gfs2_glock_dq_uninit(ghs);
596 		if (IS_ERR(d))
597 			return PTR_ERR(d);
598 		return error;
599 	} else if (error != -ENOENT) {
600 		goto fail_gunlock;
601 	}
602 
603 	arq = error = gfs2_diradd_alloc_required(dir, name);
604 	if (error < 0)
605 		goto fail_gunlock;
606 
607 	inode = new_inode(sdp->sd_vfs);
608 	error = -ENOMEM;
609 	if (!inode)
610 		goto fail_gunlock;
611 
612 	ip = GFS2_I(inode);
613 	error = gfs2_rs_alloc(ip);
614 	if (error)
615 		goto fail_free_inode;
616 
617 	inode->i_mode = mode;
618 	set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
619 	inode->i_rdev = dev;
620 	inode->i_size = size;
621 	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
622 	gfs2_set_inode_blocks(inode, 1);
623 	munge_mode_uid_gid(dip, inode);
624 	ip->i_goal = dip->i_goal;
625 	ip->i_diskflags = 0;
626 	ip->i_eattr = 0;
627 	ip->i_height = 0;
628 	ip->i_depth = 0;
629 	ip->i_entries = 0;
630 
631 	switch(mode & S_IFMT) {
632 	case S_IFREG:
633 		if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
634 		    gfs2_tune_get(sdp, gt_new_files_jdata))
635 			ip->i_diskflags |= GFS2_DIF_JDATA;
636 		gfs2_set_aops(inode);
637 		break;
638 	case S_IFDIR:
639 		ip->i_diskflags |= (dip->i_diskflags & GFS2_DIF_INHERIT_JDATA);
640 		ip->i_diskflags |= GFS2_DIF_JDATA;
641 		ip->i_entries = 2;
642 		break;
643 	}
644 	gfs2_set_inode_flags(inode);
645 
646 	if ((GFS2_I(sdp->sd_root_dir->d_inode) == dip) ||
647 	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
648 		aflags |= GFS2_AF_ORLOV;
649 
650 	error = alloc_dinode(ip, aflags);
651 	if (error)
652 		goto fail_free_inode;
653 
654 	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
655 	if (error)
656 		goto fail_free_inode;
657 
658 	ip->i_gl->gl_object = ip;
659 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
660 	if (error)
661 		goto fail_free_inode;
662 
663 	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
664 	if (error)
665 		goto fail_gunlock2;
666 
667 	init_dinode(dip, ip, symname);
668 	gfs2_trans_end(sdp);
669 
670 	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
671 	if (error)
672 		goto fail_gunlock2;
673 
674 	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
675 	if (error)
676 		goto fail_gunlock2;
677 
678 	ip->i_iopen_gh.gh_gl->gl_object = ip;
679 	gfs2_glock_put(io_gl);
680 	gfs2_set_iop(inode);
681 	insert_inode_hash(inode);
682 
683 	error = gfs2_acl_create(dip, inode);
684 	if (error)
685 		goto fail_gunlock3;
686 
687 	error = gfs2_security_init(dip, ip, name);
688 	if (error)
689 		goto fail_gunlock3;
690 
691 	error = link_dinode(dip, name, ip, arq);
692 	if (error)
693 		goto fail_gunlock3;
694 
695 	mark_inode_dirty(inode);
696 	d_instantiate(dentry, inode);
697 	if (file) {
698 		*opened |= FILE_CREATED;
699 		error = finish_open(file, dentry, gfs2_open_common, opened);
700 	}
701 	gfs2_glock_dq_uninit(ghs);
702 	gfs2_glock_dq_uninit(ghs + 1);
703 	return error;
704 
705 fail_gunlock3:
706 	gfs2_glock_dq_uninit(ghs + 1);
707 	if (ip->i_gl)
708 		gfs2_glock_put(ip->i_gl);
709 	goto fail_gunlock;
710 
711 fail_gunlock2:
712 	gfs2_glock_dq_uninit(ghs + 1);
713 fail_free_inode:
714 	if (ip->i_gl)
715 		gfs2_glock_put(ip->i_gl);
716 	gfs2_rs_delete(ip);
717 	free_inode_nonrcu(inode);
718 	inode = NULL;
719 fail_gunlock:
720 	gfs2_glock_dq_uninit(ghs);
721 	if (inode && !IS_ERR(inode)) {
722 		clear_nlink(inode);
723 		mark_inode_dirty(inode);
724 		set_bit(GIF_ALLOC_FAILED, &GFS2_I(inode)->i_flags);
725 		iput(inode);
726 	}
727 fail:
728 	return error;
729 }
730 
731 /**
732  * gfs2_create - Create a file
733  * @dir: The directory in which to create the file
734  * @dentry: The dentry of the new file
735  * @mode: The mode of the new file
736  *
737  * Returns: errno
738  */
739 
740 static int gfs2_create(struct inode *dir, struct dentry *dentry,
741 		       umode_t mode, bool excl)
742 {
743 	return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl, NULL);
744 }
745 
746 /**
747  * __gfs2_lookup - Look up a filename in a directory and return its inode
748  * @dir: The directory inode
749  * @dentry: The dentry of the new inode
750  * @file: File to be opened
751  * @opened: atomic_open flags
752  *
753  *
754  * Returns: errno
755  */
756 
757 static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
758 				    struct file *file, int *opened)
759 {
760 	struct inode *inode;
761 	struct dentry *d;
762 	struct gfs2_holder gh;
763 	struct gfs2_glock *gl;
764 	int error;
765 
766 	inode = gfs2_lookupi(dir, &dentry->d_name, 0);
767 	if (!inode)
768 		return NULL;
769 	if (IS_ERR(inode))
770 		return ERR_CAST(inode);
771 
772 	gl = GFS2_I(inode)->i_gl;
773 	error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
774 	if (error) {
775 		iput(inode);
776 		return ERR_PTR(error);
777 	}
778 
779 	d = d_splice_alias(inode, dentry);
780 	if (file && S_ISREG(inode->i_mode))
781 		error = finish_open(file, dentry, gfs2_open_common, opened);
782 
783 	gfs2_glock_dq_uninit(&gh);
784 	if (error)
785 		return ERR_PTR(error);
786 	return d;
787 }
788 
789 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
790 				  unsigned flags)
791 {
792 	return __gfs2_lookup(dir, dentry, NULL, NULL);
793 }
794 
795 /**
796  * gfs2_link - Link to a file
797  * @old_dentry: The inode to link
798  * @dir: Add link to this directory
799  * @dentry: The name of the link
800  *
801  * Link the inode in "old_dentry" into the directory "dir" with the
802  * name in "dentry".
803  *
804  * Returns: errno
805  */
806 
807 static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
808 		     struct dentry *dentry)
809 {
810 	struct gfs2_inode *dip = GFS2_I(dir);
811 	struct gfs2_sbd *sdp = GFS2_SB(dir);
812 	struct inode *inode = old_dentry->d_inode;
813 	struct gfs2_inode *ip = GFS2_I(inode);
814 	struct gfs2_holder ghs[2];
815 	struct buffer_head *dibh;
816 	int alloc_required;
817 	int error;
818 
819 	if (S_ISDIR(inode->i_mode))
820 		return -EPERM;
821 
822 	error = gfs2_rs_alloc(dip);
823 	if (error)
824 		return error;
825 
826 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
827 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
828 
829 	error = gfs2_glock_nq(ghs); /* parent */
830 	if (error)
831 		goto out_parent;
832 
833 	error = gfs2_glock_nq(ghs + 1); /* child */
834 	if (error)
835 		goto out_child;
836 
837 	error = -ENOENT;
838 	if (inode->i_nlink == 0)
839 		goto out_gunlock;
840 
841 	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
842 	if (error)
843 		goto out_gunlock;
844 
845 	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
846 	switch (error) {
847 	case -ENOENT:
848 		break;
849 	case 0:
850 		error = -EEXIST;
851 	default:
852 		goto out_gunlock;
853 	}
854 
855 	error = -EINVAL;
856 	if (!dip->i_inode.i_nlink)
857 		goto out_gunlock;
858 	error = -EFBIG;
859 	if (dip->i_entries == (u32)-1)
860 		goto out_gunlock;
861 	error = -EPERM;
862 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
863 		goto out_gunlock;
864 	error = -EINVAL;
865 	if (!ip->i_inode.i_nlink)
866 		goto out_gunlock;
867 	error = -EMLINK;
868 	if (ip->i_inode.i_nlink == (u32)-1)
869 		goto out_gunlock;
870 
871 	alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
872 	if (error < 0)
873 		goto out_gunlock;
874 	error = 0;
875 
876 	if (alloc_required) {
877 		error = gfs2_quota_lock_check(dip);
878 		if (error)
879 			goto out_gunlock;
880 
881 		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres, 0);
882 		if (error)
883 			goto out_gunlock_q;
884 
885 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
886 					 gfs2_rg_blocks(dip, sdp->sd_max_dirres) +
887 					 2 * RES_DINODE + RES_STATFS +
888 					 RES_QUOTA, 0);
889 		if (error)
890 			goto out_ipres;
891 	} else {
892 		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
893 		if (error)
894 			goto out_ipres;
895 	}
896 
897 	error = gfs2_meta_inode_buffer(ip, &dibh);
898 	if (error)
899 		goto out_end_trans;
900 
901 	error = gfs2_dir_add(dir, &dentry->d_name, ip);
902 	if (error)
903 		goto out_brelse;
904 
905 	gfs2_trans_add_meta(ip->i_gl, dibh);
906 	inc_nlink(&ip->i_inode);
907 	ip->i_inode.i_ctime = CURRENT_TIME;
908 	ihold(inode);
909 	d_instantiate(dentry, inode);
910 	mark_inode_dirty(inode);
911 
912 out_brelse:
913 	brelse(dibh);
914 out_end_trans:
915 	gfs2_trans_end(sdp);
916 out_ipres:
917 	if (alloc_required)
918 		gfs2_inplace_release(dip);
919 out_gunlock_q:
920 	if (alloc_required)
921 		gfs2_quota_unlock(dip);
922 out_gunlock:
923 	gfs2_glock_dq(ghs + 1);
924 out_child:
925 	gfs2_glock_dq(ghs);
926 out_parent:
927 	gfs2_holder_uninit(ghs);
928 	gfs2_holder_uninit(ghs + 1);
929 	return error;
930 }
931 
932 /*
933  * gfs2_unlink_ok - check to see that a inode is still in a directory
934  * @dip: the directory
935  * @name: the name of the file
936  * @ip: the inode
937  *
938  * Assumes that the lock on (at least) @dip is held.
939  *
940  * Returns: 0 if the parent/child relationship is correct, errno if it isn't
941  */
942 
943 static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
944 			  const struct gfs2_inode *ip)
945 {
946 	int error;
947 
948 	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
949 		return -EPERM;
950 
951 	if ((dip->i_inode.i_mode & S_ISVTX) &&
952 	    !uid_eq(dip->i_inode.i_uid, current_fsuid()) &&
953 	    !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER))
954 		return -EPERM;
955 
956 	if (IS_APPEND(&dip->i_inode))
957 		return -EPERM;
958 
959 	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
960 	if (error)
961 		return error;
962 
963 	error = gfs2_dir_check(&dip->i_inode, name, ip);
964 	if (error)
965 		return error;
966 
967 	return 0;
968 }
969 
970 /**
971  * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
972  * @dip: The parent directory
973  * @name: The name of the entry in the parent directory
974  * @inode: The inode to be removed
975  *
976  * Called with all the locks and in a transaction. This will only be
977  * called for a directory after it has been checked to ensure it is empty.
978  *
979  * Returns: 0 on success, or an error
980  */
981 
982 static int gfs2_unlink_inode(struct gfs2_inode *dip,
983 			     const struct dentry *dentry)
984 {
985 	struct inode *inode = dentry->d_inode;
986 	struct gfs2_inode *ip = GFS2_I(inode);
987 	int error;
988 
989 	error = gfs2_dir_del(dip, dentry);
990 	if (error)
991 		return error;
992 
993 	ip->i_entries = 0;
994 	inode->i_ctime = CURRENT_TIME;
995 	if (S_ISDIR(inode->i_mode))
996 		clear_nlink(inode);
997 	else
998 		drop_nlink(inode);
999 	mark_inode_dirty(inode);
1000 	if (inode->i_nlink == 0)
1001 		gfs2_unlink_di(inode);
1002 	return 0;
1003 }
1004 
1005 
1006 /**
1007  * gfs2_unlink - Unlink an inode (this does rmdir as well)
1008  * @dir: The inode of the directory containing the inode to unlink
1009  * @dentry: The file itself
1010  *
1011  * This routine uses the type of the inode as a flag to figure out
1012  * whether this is an unlink or an rmdir.
1013  *
1014  * Returns: errno
1015  */
1016 
1017 static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
1018 {
1019 	struct gfs2_inode *dip = GFS2_I(dir);
1020 	struct gfs2_sbd *sdp = GFS2_SB(dir);
1021 	struct inode *inode = dentry->d_inode;
1022 	struct gfs2_inode *ip = GFS2_I(inode);
1023 	struct gfs2_holder ghs[3];
1024 	struct gfs2_rgrpd *rgd;
1025 	int error;
1026 
1027 	error = gfs2_rindex_update(sdp);
1028 	if (error)
1029 		return error;
1030 
1031 	error = -EROFS;
1032 
1033 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1034 	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
1035 
1036 	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1037 	if (!rgd)
1038 		goto out_inodes;
1039 
1040 	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
1041 
1042 
1043 	error = gfs2_glock_nq(ghs); /* parent */
1044 	if (error)
1045 		goto out_parent;
1046 
1047 	error = gfs2_glock_nq(ghs + 1); /* child */
1048 	if (error)
1049 		goto out_child;
1050 
1051 	error = -ENOENT;
1052 	if (inode->i_nlink == 0)
1053 		goto out_rgrp;
1054 
1055 	if (S_ISDIR(inode->i_mode)) {
1056 		error = -ENOTEMPTY;
1057 		if (ip->i_entries > 2 || inode->i_nlink > 2)
1058 			goto out_rgrp;
1059 	}
1060 
1061 	error = gfs2_glock_nq(ghs + 2); /* rgrp */
1062 	if (error)
1063 		goto out_rgrp;
1064 
1065 	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
1066 	if (error)
1067 		goto out_gunlock;
1068 
1069 	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
1070 	if (error)
1071 		goto out_end_trans;
1072 
1073 	error = gfs2_unlink_inode(dip, dentry);
1074 
1075 out_end_trans:
1076 	gfs2_trans_end(sdp);
1077 out_gunlock:
1078 	gfs2_glock_dq(ghs + 2);
1079 out_rgrp:
1080 	gfs2_glock_dq(ghs + 1);
1081 out_child:
1082 	gfs2_glock_dq(ghs);
1083 out_parent:
1084 	gfs2_holder_uninit(ghs + 2);
1085 out_inodes:
1086 	gfs2_holder_uninit(ghs + 1);
1087 	gfs2_holder_uninit(ghs);
1088 	return error;
1089 }
1090 
1091 /**
1092  * gfs2_symlink - Create a symlink
1093  * @dir: The directory to create the symlink in
1094  * @dentry: The dentry to put the symlink in
1095  * @symname: The thing which the link points to
1096  *
1097  * Returns: errno
1098  */
1099 
1100 static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
1101 			const char *symname)
1102 {
1103 	struct gfs2_sbd *sdp = GFS2_SB(dir);
1104 	unsigned int size;
1105 
1106 	size = strlen(symname);
1107 	if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
1108 		return -ENAMETOOLONG;
1109 
1110 	return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0, NULL);
1111 }
1112 
1113 /**
1114  * gfs2_mkdir - Make a directory
1115  * @dir: The parent directory of the new one
1116  * @dentry: The dentry of the new directory
1117  * @mode: The mode of the new directory
1118  *
1119  * Returns: errno
1120  */
1121 
1122 static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1123 {
1124 	struct gfs2_sbd *sdp = GFS2_SB(dir);
1125 	unsigned dsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
1126 	return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0, NULL);
1127 }
1128 
1129 /**
1130  * gfs2_mknod - Make a special file
1131  * @dir: The directory in which the special file will reside
1132  * @dentry: The dentry of the special file
1133  * @mode: The mode of the special file
1134  * @dev: The device specification of the special file
1135  *
1136  */
1137 
1138 static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
1139 		      dev_t dev)
1140 {
1141 	return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, 0, 0, NULL);
1142 }
1143 
1144 /**
1145  * gfs2_atomic_open - Atomically open a file
1146  * @dir: The directory
1147  * @dentry: The proposed new entry
1148  * @file: The proposed new struct file
1149  * @flags: open flags
1150  * @mode: File mode
1151  * @opened: Flag to say whether the file has been opened or not
1152  *
1153  * Returns: error code or 0 for success
1154  */
1155 
1156 static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
1157                             struct file *file, unsigned flags,
1158                             umode_t mode, int *opened)
1159 {
1160 	struct dentry *d;
1161 	bool excl = !!(flags & O_EXCL);
1162 
1163 	d = __gfs2_lookup(dir, dentry, file, opened);
1164 	if (IS_ERR(d))
1165 		return PTR_ERR(d);
1166 	if (d == NULL)
1167 		d = dentry;
1168 	if (d->d_inode) {
1169 		if (!(*opened & FILE_OPENED))
1170 			return finish_no_open(file, d);
1171 		return 0;
1172 	}
1173 
1174 	if (!(flags & O_CREAT))
1175 		return -ENOENT;
1176 
1177 	return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, 0, NULL, 0, excl, opened);
1178 }
1179 
1180 /*
1181  * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1182  * @this: move this
1183  * @to: to here
1184  *
1185  * Follow @to back to the root and make sure we don't encounter @this
1186  * Assumes we already hold the rename lock.
1187  *
1188  * Returns: errno
1189  */
1190 
1191 static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1192 {
1193 	struct inode *dir = &to->i_inode;
1194 	struct super_block *sb = dir->i_sb;
1195 	struct inode *tmp;
1196 	int error = 0;
1197 
1198 	igrab(dir);
1199 
1200 	for (;;) {
1201 		if (dir == &this->i_inode) {
1202 			error = -EINVAL;
1203 			break;
1204 		}
1205 		if (dir == sb->s_root->d_inode) {
1206 			error = 0;
1207 			break;
1208 		}
1209 
1210 		tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
1211 		if (IS_ERR(tmp)) {
1212 			error = PTR_ERR(tmp);
1213 			break;
1214 		}
1215 
1216 		iput(dir);
1217 		dir = tmp;
1218 	}
1219 
1220 	iput(dir);
1221 
1222 	return error;
1223 }
1224 
1225 /**
1226  * gfs2_rename - Rename a file
1227  * @odir: Parent directory of old file name
1228  * @odentry: The old dentry of the file
1229  * @ndir: Parent directory of new file name
1230  * @ndentry: The new dentry of the file
1231  *
1232  * Returns: errno
1233  */
1234 
1235 static int gfs2_rename(struct inode *odir, struct dentry *odentry,
1236 		       struct inode *ndir, struct dentry *ndentry)
1237 {
1238 	struct gfs2_inode *odip = GFS2_I(odir);
1239 	struct gfs2_inode *ndip = GFS2_I(ndir);
1240 	struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
1241 	struct gfs2_inode *nip = NULL;
1242 	struct gfs2_sbd *sdp = GFS2_SB(odir);
1243 	struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
1244 	struct gfs2_rgrpd *nrgd;
1245 	unsigned int num_gh;
1246 	int dir_rename = 0;
1247 	int alloc_required = 0;
1248 	unsigned int x;
1249 	int error;
1250 
1251 	if (ndentry->d_inode) {
1252 		nip = GFS2_I(ndentry->d_inode);
1253 		if (ip == nip)
1254 			return 0;
1255 	}
1256 
1257 	error = gfs2_rindex_update(sdp);
1258 	if (error)
1259 		return error;
1260 
1261 	error = gfs2_rs_alloc(ndip);
1262 	if (error)
1263 		return error;
1264 
1265 	if (odip != ndip) {
1266 		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1267 					   0, &r_gh);
1268 		if (error)
1269 			goto out;
1270 
1271 		if (S_ISDIR(ip->i_inode.i_mode)) {
1272 			dir_rename = 1;
1273 			/* don't move a dirctory into it's subdir */
1274 			error = gfs2_ok_to_move(ip, ndip);
1275 			if (error)
1276 				goto out_gunlock_r;
1277 		}
1278 	}
1279 
1280 	num_gh = 1;
1281 	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1282 	if (odip != ndip) {
1283 		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1284 		num_gh++;
1285 	}
1286 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1287 	num_gh++;
1288 
1289 	if (nip) {
1290 		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1291 		num_gh++;
1292 		/* grab the resource lock for unlink flag twiddling
1293 		 * this is the case of the target file already existing
1294 		 * so we unlink before doing the rename
1295 		 */
1296 		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
1297 		if (nrgd)
1298 			gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
1299 	}
1300 
1301 	for (x = 0; x < num_gh; x++) {
1302 		error = gfs2_glock_nq(ghs + x);
1303 		if (error)
1304 			goto out_gunlock;
1305 	}
1306 
1307 	error = -ENOENT;
1308 	if (ip->i_inode.i_nlink == 0)
1309 		goto out_gunlock;
1310 
1311 	/* Check out the old directory */
1312 
1313 	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
1314 	if (error)
1315 		goto out_gunlock;
1316 
1317 	/* Check out the new directory */
1318 
1319 	if (nip) {
1320 		error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1321 		if (error)
1322 			goto out_gunlock;
1323 
1324 		if (nip->i_inode.i_nlink == 0) {
1325 			error = -EAGAIN;
1326 			goto out_gunlock;
1327 		}
1328 
1329 		if (S_ISDIR(nip->i_inode.i_mode)) {
1330 			if (nip->i_entries < 2) {
1331 				gfs2_consist_inode(nip);
1332 				error = -EIO;
1333 				goto out_gunlock;
1334 			}
1335 			if (nip->i_entries > 2) {
1336 				error = -ENOTEMPTY;
1337 				goto out_gunlock;
1338 			}
1339 		}
1340 	} else {
1341 		error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
1342 		if (error)
1343 			goto out_gunlock;
1344 
1345 		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
1346 		switch (error) {
1347 		case -ENOENT:
1348 			error = 0;
1349 			break;
1350 		case 0:
1351 			error = -EEXIST;
1352 		default:
1353 			goto out_gunlock;
1354 		};
1355 
1356 		if (odip != ndip) {
1357 			if (!ndip->i_inode.i_nlink) {
1358 				error = -ENOENT;
1359 				goto out_gunlock;
1360 			}
1361 			if (ndip->i_entries == (u32)-1) {
1362 				error = -EFBIG;
1363 				goto out_gunlock;
1364 			}
1365 			if (S_ISDIR(ip->i_inode.i_mode) &&
1366 			    ndip->i_inode.i_nlink == (u32)-1) {
1367 				error = -EMLINK;
1368 				goto out_gunlock;
1369 			}
1370 		}
1371 	}
1372 
1373 	/* Check out the dir to be renamed */
1374 
1375 	if (dir_rename) {
1376 		error = gfs2_permission(odentry->d_inode, MAY_WRITE);
1377 		if (error)
1378 			goto out_gunlock;
1379 	}
1380 
1381 	if (nip == NULL)
1382 		alloc_required = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
1383 	error = alloc_required;
1384 	if (error < 0)
1385 		goto out_gunlock;
1386 
1387 	if (alloc_required) {
1388 		error = gfs2_quota_lock_check(ndip);
1389 		if (error)
1390 			goto out_gunlock;
1391 
1392 		error = gfs2_inplace_reserve(ndip, sdp->sd_max_dirres, 0);
1393 		if (error)
1394 			goto out_gunlock_q;
1395 
1396 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
1397 					 gfs2_rg_blocks(ndip, sdp->sd_max_dirres) +
1398 					 4 * RES_DINODE + 4 * RES_LEAF +
1399 					 RES_STATFS + RES_QUOTA + 4, 0);
1400 		if (error)
1401 			goto out_ipreserv;
1402 	} else {
1403 		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
1404 					 5 * RES_LEAF + 4, 0);
1405 		if (error)
1406 			goto out_gunlock;
1407 	}
1408 
1409 	/* Remove the target file, if it exists */
1410 
1411 	if (nip)
1412 		error = gfs2_unlink_inode(ndip, ndentry);
1413 
1414 	if (dir_rename) {
1415 		error = gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);
1416 		if (error)
1417 			goto out_end_trans;
1418 	} else {
1419 		struct buffer_head *dibh;
1420 		error = gfs2_meta_inode_buffer(ip, &dibh);
1421 		if (error)
1422 			goto out_end_trans;
1423 		ip->i_inode.i_ctime = CURRENT_TIME;
1424 		gfs2_trans_add_meta(ip->i_gl, dibh);
1425 		gfs2_dinode_out(ip, dibh->b_data);
1426 		brelse(dibh);
1427 	}
1428 
1429 	error = gfs2_dir_del(odip, odentry);
1430 	if (error)
1431 		goto out_end_trans;
1432 
1433 	error = gfs2_dir_add(ndir, &ndentry->d_name, ip);
1434 	if (error)
1435 		goto out_end_trans;
1436 
1437 out_end_trans:
1438 	gfs2_trans_end(sdp);
1439 out_ipreserv:
1440 	if (alloc_required)
1441 		gfs2_inplace_release(ndip);
1442 out_gunlock_q:
1443 	if (alloc_required)
1444 		gfs2_quota_unlock(ndip);
1445 out_gunlock:
1446 	while (x--) {
1447 		gfs2_glock_dq(ghs + x);
1448 		gfs2_holder_uninit(ghs + x);
1449 	}
1450 out_gunlock_r:
1451 	if (r_gh.gh_gl)
1452 		gfs2_glock_dq_uninit(&r_gh);
1453 out:
1454 	return error;
1455 }
1456 
1457 /**
1458  * gfs2_follow_link - Follow a symbolic link
1459  * @dentry: The dentry of the link
1460  * @nd: Data that we pass to vfs_follow_link()
1461  *
1462  * This can handle symlinks of any size.
1463  *
1464  * Returns: 0 on success or error code
1465  */
1466 
1467 static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
1468 {
1469 	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
1470 	struct gfs2_holder i_gh;
1471 	struct buffer_head *dibh;
1472 	unsigned int size;
1473 	char *buf;
1474 	int error;
1475 
1476 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
1477 	error = gfs2_glock_nq(&i_gh);
1478 	if (error) {
1479 		gfs2_holder_uninit(&i_gh);
1480 		nd_set_link(nd, ERR_PTR(error));
1481 		return NULL;
1482 	}
1483 
1484 	size = (unsigned int)i_size_read(&ip->i_inode);
1485 	if (size == 0) {
1486 		gfs2_consist_inode(ip);
1487 		buf = ERR_PTR(-EIO);
1488 		goto out;
1489 	}
1490 
1491 	error = gfs2_meta_inode_buffer(ip, &dibh);
1492 	if (error) {
1493 		buf = ERR_PTR(error);
1494 		goto out;
1495 	}
1496 
1497 	buf = kzalloc(size + 1, GFP_NOFS);
1498 	if (!buf)
1499 		buf = ERR_PTR(-ENOMEM);
1500 	else
1501 		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1502 	brelse(dibh);
1503 out:
1504 	gfs2_glock_dq_uninit(&i_gh);
1505 	nd_set_link(nd, buf);
1506 	return NULL;
1507 }
1508 
1509 static void gfs2_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1510 {
1511 	char *s = nd_get_link(nd);
1512 	if (!IS_ERR(s))
1513 		kfree(s);
1514 }
1515 
1516 /**
1517  * gfs2_permission -
1518  * @inode: The inode
1519  * @mask: The mask to be tested
1520  * @flags: Indicates whether this is an RCU path walk or not
1521  *
1522  * This may be called from the VFS directly, or from within GFS2 with the
1523  * inode locked, so we look to see if the glock is already locked and only
1524  * lock the glock if its not already been done.
1525  *
1526  * Returns: errno
1527  */
1528 
1529 int gfs2_permission(struct inode *inode, int mask)
1530 {
1531 	struct gfs2_inode *ip;
1532 	struct gfs2_holder i_gh;
1533 	int error;
1534 	int unlock = 0;
1535 
1536 
1537 	ip = GFS2_I(inode);
1538 	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1539 		if (mask & MAY_NOT_BLOCK)
1540 			return -ECHILD;
1541 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
1542 		if (error)
1543 			return error;
1544 		unlock = 1;
1545 	}
1546 
1547 	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
1548 		error = -EACCES;
1549 	else
1550 		error = generic_permission(inode, mask);
1551 	if (unlock)
1552 		gfs2_glock_dq_uninit(&i_gh);
1553 
1554 	return error;
1555 }
1556 
1557 static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1558 {
1559 	setattr_copy(inode, attr);
1560 	mark_inode_dirty(inode);
1561 	return 0;
1562 }
1563 
1564 /**
1565  * gfs2_setattr_simple -
1566  * @ip:
1567  * @attr:
1568  *
1569  * Returns: errno
1570  */
1571 
1572 int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1573 {
1574 	int error;
1575 
1576 	if (current->journal_info)
1577 		return __gfs2_setattr_simple(inode, attr);
1578 
1579 	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1580 	if (error)
1581 		return error;
1582 
1583 	error = __gfs2_setattr_simple(inode, attr);
1584 	gfs2_trans_end(GFS2_SB(inode));
1585 	return error;
1586 }
1587 
1588 static int setattr_chown(struct inode *inode, struct iattr *attr)
1589 {
1590 	struct gfs2_inode *ip = GFS2_I(inode);
1591 	struct gfs2_sbd *sdp = GFS2_SB(inode);
1592 	kuid_t ouid, nuid;
1593 	kgid_t ogid, ngid;
1594 	int error;
1595 
1596 	ouid = inode->i_uid;
1597 	ogid = inode->i_gid;
1598 	nuid = attr->ia_uid;
1599 	ngid = attr->ia_gid;
1600 
1601 	if (!(attr->ia_valid & ATTR_UID) || uid_eq(ouid, nuid))
1602 		ouid = nuid = NO_UID_QUOTA_CHANGE;
1603 	if (!(attr->ia_valid & ATTR_GID) || gid_eq(ogid, ngid))
1604 		ogid = ngid = NO_GID_QUOTA_CHANGE;
1605 
1606 	error = gfs2_quota_lock(ip, nuid, ngid);
1607 	if (error)
1608 		return error;
1609 
1610 	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
1611 	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1612 		error = gfs2_quota_check(ip, nuid, ngid);
1613 		if (error)
1614 			goto out_gunlock_q;
1615 	}
1616 
1617 	error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
1618 	if (error)
1619 		goto out_gunlock_q;
1620 
1621 	error = gfs2_setattr_simple(inode, attr);
1622 	if (error)
1623 		goto out_end_trans;
1624 
1625 	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
1626 	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1627 		u64 blocks = gfs2_get_inode_blocks(&ip->i_inode);
1628 		gfs2_quota_change(ip, -blocks, ouid, ogid);
1629 		gfs2_quota_change(ip, blocks, nuid, ngid);
1630 	}
1631 
1632 out_end_trans:
1633 	gfs2_trans_end(sdp);
1634 out_gunlock_q:
1635 	gfs2_quota_unlock(ip);
1636 	return error;
1637 }
1638 
1639 /**
1640  * gfs2_setattr - Change attributes on an inode
1641  * @dentry: The dentry which is changing
1642  * @attr: The structure describing the change
1643  *
1644  * The VFS layer wants to change one or more of an inodes attributes.  Write
1645  * that change out to disk.
1646  *
1647  * Returns: errno
1648  */
1649 
1650 static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
1651 {
1652 	struct inode *inode = dentry->d_inode;
1653 	struct gfs2_inode *ip = GFS2_I(inode);
1654 	struct gfs2_holder i_gh;
1655 	int error;
1656 
1657 	error = gfs2_rs_alloc(ip);
1658 	if (error)
1659 		return error;
1660 
1661 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1662 	if (error)
1663 		return error;
1664 
1665 	error = -EPERM;
1666 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1667 		goto out;
1668 
1669 	error = inode_change_ok(inode, attr);
1670 	if (error)
1671 		goto out;
1672 
1673 	if (attr->ia_valid & ATTR_SIZE)
1674 		error = gfs2_setattr_size(inode, attr->ia_size);
1675 	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
1676 		error = setattr_chown(inode, attr);
1677 	else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode))
1678 		error = gfs2_acl_chmod(ip, attr);
1679 	else
1680 		error = gfs2_setattr_simple(inode, attr);
1681 
1682 out:
1683 	if (!error)
1684 		mark_inode_dirty(inode);
1685 	gfs2_glock_dq_uninit(&i_gh);
1686 	return error;
1687 }
1688 
1689 /**
1690  * gfs2_getattr - Read out an inode's attributes
1691  * @mnt: The vfsmount the inode is being accessed from
1692  * @dentry: The dentry to stat
1693  * @stat: The inode's stats
1694  *
1695  * This may be called from the VFS directly, or from within GFS2 with the
1696  * inode locked, so we look to see if the glock is already locked and only
1697  * lock the glock if its not already been done. Note that its the NFS
1698  * readdirplus operation which causes this to be called (from filldir)
1699  * with the glock already held.
1700  *
1701  * Returns: errno
1702  */
1703 
1704 static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
1705 			struct kstat *stat)
1706 {
1707 	struct inode *inode = dentry->d_inode;
1708 	struct gfs2_inode *ip = GFS2_I(inode);
1709 	struct gfs2_holder gh;
1710 	int error;
1711 	int unlock = 0;
1712 
1713 	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1714 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1715 		if (error)
1716 			return error;
1717 		unlock = 1;
1718 	}
1719 
1720 	generic_fillattr(inode, stat);
1721 	if (unlock)
1722 		gfs2_glock_dq_uninit(&gh);
1723 
1724 	return 0;
1725 }
1726 
1727 static int gfs2_setxattr(struct dentry *dentry, const char *name,
1728 			 const void *data, size_t size, int flags)
1729 {
1730 	struct inode *inode = dentry->d_inode;
1731 	struct gfs2_inode *ip = GFS2_I(inode);
1732 	struct gfs2_holder gh;
1733 	int ret;
1734 
1735 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1736 	ret = gfs2_glock_nq(&gh);
1737 	if (ret == 0) {
1738 		ret = gfs2_rs_alloc(ip);
1739 		if (ret == 0)
1740 			ret = generic_setxattr(dentry, name, data, size, flags);
1741 		gfs2_glock_dq(&gh);
1742 	}
1743 	gfs2_holder_uninit(&gh);
1744 	return ret;
1745 }
1746 
1747 static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
1748 			     void *data, size_t size)
1749 {
1750 	struct inode *inode = dentry->d_inode;
1751 	struct gfs2_inode *ip = GFS2_I(inode);
1752 	struct gfs2_holder gh;
1753 	int ret;
1754 
1755 	/* For selinux during lookup */
1756 	if (gfs2_glock_is_locked_by_me(ip->i_gl))
1757 		return generic_getxattr(dentry, name, data, size);
1758 
1759 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1760 	ret = gfs2_glock_nq(&gh);
1761 	if (ret == 0) {
1762 		ret = generic_getxattr(dentry, name, data, size);
1763 		gfs2_glock_dq(&gh);
1764 	}
1765 	gfs2_holder_uninit(&gh);
1766 	return ret;
1767 }
1768 
1769 static int gfs2_removexattr(struct dentry *dentry, const char *name)
1770 {
1771 	struct inode *inode = dentry->d_inode;
1772 	struct gfs2_inode *ip = GFS2_I(inode);
1773 	struct gfs2_holder gh;
1774 	int ret;
1775 
1776 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1777 	ret = gfs2_glock_nq(&gh);
1778 	if (ret == 0) {
1779 		ret = gfs2_rs_alloc(ip);
1780 		if (ret == 0)
1781 			ret = generic_removexattr(dentry, name);
1782 		gfs2_glock_dq(&gh);
1783 	}
1784 	gfs2_holder_uninit(&gh);
1785 	return ret;
1786 }
1787 
1788 static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
1789 		       u64 start, u64 len)
1790 {
1791 	struct gfs2_inode *ip = GFS2_I(inode);
1792 	struct gfs2_holder gh;
1793 	int ret;
1794 
1795 	ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
1796 	if (ret)
1797 		return ret;
1798 
1799 	mutex_lock(&inode->i_mutex);
1800 
1801 	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
1802 	if (ret)
1803 		goto out;
1804 
1805 	if (gfs2_is_stuffed(ip)) {
1806 		u64 phys = ip->i_no_addr << inode->i_blkbits;
1807 		u64 size = i_size_read(inode);
1808 		u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
1809 			    FIEMAP_EXTENT_DATA_INLINE;
1810 		phys += sizeof(struct gfs2_dinode);
1811 		phys += start;
1812 		if (start + len > size)
1813 			len = size - start;
1814 		if (start < size)
1815 			ret = fiemap_fill_next_extent(fieinfo, start, phys,
1816 						      len, flags);
1817 		if (ret == 1)
1818 			ret = 0;
1819 	} else {
1820 		ret = __generic_block_fiemap(inode, fieinfo, start, len,
1821 					     gfs2_block_map);
1822 	}
1823 
1824 	gfs2_glock_dq_uninit(&gh);
1825 out:
1826 	mutex_unlock(&inode->i_mutex);
1827 	return ret;
1828 }
1829 
1830 const struct inode_operations gfs2_file_iops = {
1831 	.permission = gfs2_permission,
1832 	.setattr = gfs2_setattr,
1833 	.getattr = gfs2_getattr,
1834 	.setxattr = gfs2_setxattr,
1835 	.getxattr = gfs2_getxattr,
1836 	.listxattr = gfs2_listxattr,
1837 	.removexattr = gfs2_removexattr,
1838 	.fiemap = gfs2_fiemap,
1839 	.get_acl = gfs2_get_acl,
1840 };
1841 
1842 const struct inode_operations gfs2_dir_iops = {
1843 	.create = gfs2_create,
1844 	.lookup = gfs2_lookup,
1845 	.link = gfs2_link,
1846 	.unlink = gfs2_unlink,
1847 	.symlink = gfs2_symlink,
1848 	.mkdir = gfs2_mkdir,
1849 	.rmdir = gfs2_unlink,
1850 	.mknod = gfs2_mknod,
1851 	.rename = gfs2_rename,
1852 	.permission = gfs2_permission,
1853 	.setattr = gfs2_setattr,
1854 	.getattr = gfs2_getattr,
1855 	.setxattr = gfs2_setxattr,
1856 	.getxattr = gfs2_getxattr,
1857 	.listxattr = gfs2_listxattr,
1858 	.removexattr = gfs2_removexattr,
1859 	.fiemap = gfs2_fiemap,
1860 	.get_acl = gfs2_get_acl,
1861 	.atomic_open = gfs2_atomic_open,
1862 };
1863 
1864 const struct inode_operations gfs2_symlink_iops = {
1865 	.readlink = generic_readlink,
1866 	.follow_link = gfs2_follow_link,
1867 	.put_link = gfs2_put_link,
1868 	.permission = gfs2_permission,
1869 	.setattr = gfs2_setattr,
1870 	.getattr = gfs2_getattr,
1871 	.setxattr = gfs2_setxattr,
1872 	.getxattr = gfs2_getxattr,
1873 	.listxattr = gfs2_listxattr,
1874 	.removexattr = gfs2_removexattr,
1875 	.fiemap = gfs2_fiemap,
1876 	.get_acl = gfs2_get_acl,
1877 };
1878 
1879