xref: /openbmc/linux/fs/gfs2/inode.c (revision 24b1944f)
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);
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 	error = gfs2_dir_check(&dip->i_inode, name, NULL);
350 	switch (error) {
351 	case -ENOENT:
352 		error = 0;
353 		break;
354 	case 0:
355 		return -EEXIST;
356 	default:
357 		return error;
358 	}
359 
360 	if (dip->i_entries == (u32)-1)
361 		return -EFBIG;
362 	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
363 		return -EMLINK;
364 
365 	return 0;
366 }
367 
368 static void munge_mode_uid_gid(const struct gfs2_inode *dip,
369 			       struct inode *inode)
370 {
371 	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
372 	    (dip->i_inode.i_mode & S_ISUID) &&
373 	    !uid_eq(dip->i_inode.i_uid, GLOBAL_ROOT_UID)) {
374 		if (S_ISDIR(inode->i_mode))
375 			inode->i_mode |= S_ISUID;
376 		else if (!uid_eq(dip->i_inode.i_uid, current_fsuid()))
377 			inode->i_mode &= ~07111;
378 		inode->i_uid = dip->i_inode.i_uid;
379 	} else
380 		inode->i_uid = current_fsuid();
381 
382 	if (dip->i_inode.i_mode & S_ISGID) {
383 		if (S_ISDIR(inode->i_mode))
384 			inode->i_mode |= S_ISGID;
385 		inode->i_gid = dip->i_inode.i_gid;
386 	} else
387 		inode->i_gid = current_fsgid();
388 }
389 
390 static int alloc_dinode(struct gfs2_inode *ip, u32 flags)
391 {
392 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
393 	int error;
394 	int dblocks = 1;
395 
396 	error = gfs2_quota_lock_check(ip);
397 	if (error)
398 		goto out;
399 
400 	error = gfs2_inplace_reserve(ip, RES_DINODE, flags);
401 	if (error)
402 		goto out_quota;
403 
404 	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 0);
405 	if (error)
406 		goto out_ipreserv;
407 
408 	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, &dblocks, 1, &ip->i_generation);
409 	ip->i_no_formal_ino = ip->i_generation;
410 	ip->i_inode.i_ino = ip->i_no_addr;
411 	ip->i_goal = ip->i_no_addr;
412 
413 	gfs2_trans_end(sdp);
414 
415 out_ipreserv:
416 	gfs2_inplace_release(ip);
417 out_quota:
418 	gfs2_quota_unlock(ip);
419 out:
420 	return error;
421 }
422 
423 static void gfs2_init_dir(struct buffer_head *dibh,
424 			  const struct gfs2_inode *parent)
425 {
426 	struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
427 	struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
428 
429 	gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
430 	dent->de_inum = di->di_num; /* already GFS2 endian */
431 	dent->de_type = cpu_to_be16(DT_DIR);
432 
433 	dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
434 	gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
435 	gfs2_inum_out(parent, dent);
436 	dent->de_type = cpu_to_be16(DT_DIR);
437 
438 }
439 
440 /**
441  * init_dinode - Fill in a new dinode structure
442  * @dip: The directory this inode is being created in
443  * @ip: The inode
444  * @symname: The symlink destination (if a symlink)
445  * @bhp: The buffer head (returned to caller)
446  *
447  */
448 
449 static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
450 			const char *symname)
451 {
452 	struct gfs2_dinode *di;
453 	struct buffer_head *dibh;
454 
455 	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
456 	gfs2_trans_add_meta(ip->i_gl, dibh);
457 	di = (struct gfs2_dinode *)dibh->b_data;
458 	gfs2_dinode_out(ip, di);
459 
460 	di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev));
461 	di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev));
462 	di->__pad1 = 0;
463 	di->__pad2 = 0;
464 	di->__pad3 = 0;
465 	memset(&di->__pad4, 0, sizeof(di->__pad4));
466 	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
467 	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
468 
469 	switch(ip->i_inode.i_mode & S_IFMT) {
470 	case S_IFDIR:
471 		gfs2_init_dir(dibh, dip);
472 		break;
473 	case S_IFLNK:
474 		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size);
475 		break;
476 	}
477 
478 	set_buffer_uptodate(dibh);
479 	brelse(dibh);
480 }
481 
482 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
483 		       struct gfs2_inode *ip, int arq)
484 {
485 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
486 	int error;
487 
488 	if (arq) {
489 		error = gfs2_quota_lock_check(dip);
490 		if (error)
491 			goto fail_quota_locks;
492 
493 		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres, 0);
494 		if (error)
495 			goto fail_quota_locks;
496 
497 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
498 					 dip->i_rgd->rd_length +
499 					 2 * RES_DINODE +
500 					 RES_STATFS + RES_QUOTA, 0);
501 		if (error)
502 			goto fail_ipreserv;
503 	} else {
504 		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
505 		if (error)
506 			goto fail_quota_locks;
507 	}
508 
509 	error = gfs2_dir_add(&dip->i_inode, name, ip);
510 	if (error)
511 		goto fail_end_trans;
512 
513 fail_end_trans:
514 	gfs2_trans_end(sdp);
515 fail_ipreserv:
516 	gfs2_inplace_release(dip);
517 fail_quota_locks:
518 	gfs2_quota_unlock(dip);
519 	return error;
520 }
521 
522 static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
523 		    void *fs_info)
524 {
525 	const struct xattr *xattr;
526 	int err = 0;
527 
528 	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
529 		err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
530 				       xattr->value_len, 0,
531 				       GFS2_EATYPE_SECURITY);
532 		if (err < 0)
533 			break;
534 	}
535 	return err;
536 }
537 
538 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
539 			      const struct qstr *qstr)
540 {
541 	return security_inode_init_security(&ip->i_inode, &dip->i_inode, qstr,
542 					    &gfs2_initxattrs, NULL);
543 }
544 
545 /**
546  * gfs2_create_inode - Create a new inode
547  * @dir: The parent directory
548  * @dentry: The new dentry
549  * @mode: The permissions on the new inode
550  * @dev: For device nodes, this is the device number
551  * @symname: For symlinks, this is the link destination
552  * @size: The initial size of the inode (ignored for directories)
553  *
554  * Returns: 0 on success, or error code
555  */
556 
557 static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
558 			     umode_t mode, dev_t dev, const char *symname,
559 			     unsigned int size, int excl)
560 {
561 	const struct qstr *name = &dentry->d_name;
562 	struct gfs2_holder ghs[2];
563 	struct inode *inode = NULL;
564 	struct gfs2_inode *dip = GFS2_I(dir), *ip;
565 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
566 	struct gfs2_glock *io_gl;
567 	int error;
568 	u32 aflags = 0;
569 	int arq;
570 
571 	if (!name->len || name->len > GFS2_FNAMESIZE)
572 		return -ENAMETOOLONG;
573 
574 	error = gfs2_rs_alloc(dip);
575 	if (error)
576 		return error;
577 
578 	error = gfs2_rindex_update(sdp);
579 	if (error)
580 		return error;
581 
582 	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
583 	if (error)
584 		goto fail;
585 
586 	error = create_ok(dip, name, mode);
587 	if ((error == -EEXIST) && S_ISREG(mode) && !excl) {
588 		inode = gfs2_lookupi(dir, &dentry->d_name, 0);
589 		gfs2_glock_dq_uninit(ghs);
590 		d_instantiate(dentry, inode);
591 		return IS_ERR(inode) ? PTR_ERR(inode) : 0;
592 	}
593 	if (error)
594 		goto fail_gunlock;
595 
596 	arq = error = gfs2_diradd_alloc_required(dir, name);
597 	if (error < 0)
598 		goto fail_gunlock;
599 
600 	inode = new_inode(sdp->sd_vfs);
601 	error = -ENOMEM;
602 	if (!inode)
603 		goto fail_gunlock;
604 
605 	ip = GFS2_I(inode);
606 	error = gfs2_rs_alloc(ip);
607 	if (error)
608 		goto fail_free_inode;
609 
610 	inode->i_mode = mode;
611 	set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
612 	inode->i_rdev = dev;
613 	inode->i_size = size;
614 	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
615 	gfs2_set_inode_blocks(inode, 1);
616 	munge_mode_uid_gid(dip, inode);
617 	ip->i_goal = dip->i_goal;
618 	ip->i_diskflags = 0;
619 	ip->i_eattr = 0;
620 	ip->i_height = 0;
621 	ip->i_depth = 0;
622 	ip->i_entries = 0;
623 
624 	switch(mode & S_IFMT) {
625 	case S_IFREG:
626 		if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
627 		    gfs2_tune_get(sdp, gt_new_files_jdata))
628 			ip->i_diskflags |= GFS2_DIF_JDATA;
629 		gfs2_set_aops(inode);
630 		break;
631 	case S_IFDIR:
632 		ip->i_diskflags |= (dip->i_diskflags & GFS2_DIF_INHERIT_JDATA);
633 		ip->i_diskflags |= GFS2_DIF_JDATA;
634 		ip->i_entries = 2;
635 		break;
636 	}
637 	gfs2_set_inode_flags(inode);
638 
639 	if ((GFS2_I(sdp->sd_root_dir->d_inode) == dip) ||
640 	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
641 		aflags |= GFS2_AF_ORLOV;
642 
643 	error = alloc_dinode(ip, aflags);
644 	if (error)
645 		goto fail_free_inode;
646 
647 	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
648 	if (error)
649 		goto fail_free_inode;
650 
651 	ip->i_gl->gl_object = ip;
652 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
653 	if (error)
654 		goto fail_free_inode;
655 
656 	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
657 	if (error)
658 		goto fail_gunlock2;
659 
660 	init_dinode(dip, ip, symname);
661 	gfs2_trans_end(sdp);
662 
663 	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
664 	if (error)
665 		goto fail_gunlock2;
666 
667 	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
668 	if (error)
669 		goto fail_gunlock2;
670 
671 	ip->i_iopen_gh.gh_gl->gl_object = ip;
672 	gfs2_glock_put(io_gl);
673 	gfs2_set_iop(inode);
674 	insert_inode_hash(inode);
675 
676 	error = gfs2_acl_create(dip, inode);
677 	if (error)
678 		goto fail_gunlock3;
679 
680 	error = gfs2_security_init(dip, ip, name);
681 	if (error)
682 		goto fail_gunlock3;
683 
684 	error = link_dinode(dip, name, ip, arq);
685 	if (error)
686 		goto fail_gunlock3;
687 
688 	mark_inode_dirty(inode);
689 	gfs2_glock_dq_uninit(ghs);
690 	gfs2_glock_dq_uninit(ghs + 1);
691 	d_instantiate(dentry, inode);
692 	return 0;
693 
694 fail_gunlock3:
695 	gfs2_glock_dq_uninit(ghs + 1);
696 	if (ip->i_gl)
697 		gfs2_glock_put(ip->i_gl);
698 	goto fail_gunlock;
699 
700 fail_gunlock2:
701 	gfs2_glock_dq_uninit(ghs + 1);
702 fail_free_inode:
703 	if (ip->i_gl)
704 		gfs2_glock_put(ip->i_gl);
705 	gfs2_rs_delete(ip);
706 	free_inode_nonrcu(inode);
707 	inode = NULL;
708 fail_gunlock:
709 	gfs2_glock_dq_uninit(ghs);
710 	if (inode && !IS_ERR(inode)) {
711 		clear_nlink(inode);
712 		mark_inode_dirty(inode);
713 		set_bit(GIF_ALLOC_FAILED, &GFS2_I(inode)->i_flags);
714 		iput(inode);
715 	}
716 fail:
717 	return error;
718 }
719 
720 /**
721  * gfs2_create - Create a file
722  * @dir: The directory in which to create the file
723  * @dentry: The dentry of the new file
724  * @mode: The mode of the new file
725  *
726  * Returns: errno
727  */
728 
729 static int gfs2_create(struct inode *dir, struct dentry *dentry,
730 		       umode_t mode, bool excl)
731 {
732 	return gfs2_create_inode(dir, dentry, S_IFREG | mode, 0, NULL, 0, excl);
733 }
734 
735 /**
736  * gfs2_lookup - Look up a filename in a directory and return its inode
737  * @dir: The directory inode
738  * @dentry: The dentry of the new inode
739  * @nd: passed from Linux VFS, ignored by us
740  *
741  * Called by the VFS layer. Lock dir and call gfs2_lookupi()
742  *
743  * Returns: errno
744  */
745 
746 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
747 				  unsigned int flags)
748 {
749 	struct inode *inode = gfs2_lookupi(dir, &dentry->d_name, 0);
750 	if (inode && !IS_ERR(inode)) {
751 		struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
752 		struct gfs2_holder gh;
753 		int error;
754 		error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
755 		if (error) {
756 			iput(inode);
757 			return ERR_PTR(error);
758 		}
759 		gfs2_glock_dq_uninit(&gh);
760 	}
761 	return d_splice_alias(inode, dentry);
762 }
763 
764 /**
765  * gfs2_link - Link to a file
766  * @old_dentry: The inode to link
767  * @dir: Add link to this directory
768  * @dentry: The name of the link
769  *
770  * Link the inode in "old_dentry" into the directory "dir" with the
771  * name in "dentry".
772  *
773  * Returns: errno
774  */
775 
776 static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
777 		     struct dentry *dentry)
778 {
779 	struct gfs2_inode *dip = GFS2_I(dir);
780 	struct gfs2_sbd *sdp = GFS2_SB(dir);
781 	struct inode *inode = old_dentry->d_inode;
782 	struct gfs2_inode *ip = GFS2_I(inode);
783 	struct gfs2_holder ghs[2];
784 	struct buffer_head *dibh;
785 	int alloc_required;
786 	int error;
787 
788 	if (S_ISDIR(inode->i_mode))
789 		return -EPERM;
790 
791 	error = gfs2_rs_alloc(dip);
792 	if (error)
793 		return error;
794 
795 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
796 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
797 
798 	error = gfs2_glock_nq(ghs); /* parent */
799 	if (error)
800 		goto out_parent;
801 
802 	error = gfs2_glock_nq(ghs + 1); /* child */
803 	if (error)
804 		goto out_child;
805 
806 	error = -ENOENT;
807 	if (inode->i_nlink == 0)
808 		goto out_gunlock;
809 
810 	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
811 	if (error)
812 		goto out_gunlock;
813 
814 	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
815 	switch (error) {
816 	case -ENOENT:
817 		break;
818 	case 0:
819 		error = -EEXIST;
820 	default:
821 		goto out_gunlock;
822 	}
823 
824 	error = -EINVAL;
825 	if (!dip->i_inode.i_nlink)
826 		goto out_gunlock;
827 	error = -EFBIG;
828 	if (dip->i_entries == (u32)-1)
829 		goto out_gunlock;
830 	error = -EPERM;
831 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
832 		goto out_gunlock;
833 	error = -EINVAL;
834 	if (!ip->i_inode.i_nlink)
835 		goto out_gunlock;
836 	error = -EMLINK;
837 	if (ip->i_inode.i_nlink == (u32)-1)
838 		goto out_gunlock;
839 
840 	alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
841 	if (error < 0)
842 		goto out_gunlock;
843 	error = 0;
844 
845 	if (alloc_required) {
846 		error = gfs2_quota_lock_check(dip);
847 		if (error)
848 			goto out_gunlock;
849 
850 		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres, 0);
851 		if (error)
852 			goto out_gunlock_q;
853 
854 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
855 					 gfs2_rg_blocks(dip, sdp->sd_max_dirres) +
856 					 2 * RES_DINODE + RES_STATFS +
857 					 RES_QUOTA, 0);
858 		if (error)
859 			goto out_ipres;
860 	} else {
861 		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
862 		if (error)
863 			goto out_ipres;
864 	}
865 
866 	error = gfs2_meta_inode_buffer(ip, &dibh);
867 	if (error)
868 		goto out_end_trans;
869 
870 	error = gfs2_dir_add(dir, &dentry->d_name, ip);
871 	if (error)
872 		goto out_brelse;
873 
874 	gfs2_trans_add_meta(ip->i_gl, dibh);
875 	inc_nlink(&ip->i_inode);
876 	ip->i_inode.i_ctime = CURRENT_TIME;
877 	ihold(inode);
878 	d_instantiate(dentry, inode);
879 	mark_inode_dirty(inode);
880 
881 out_brelse:
882 	brelse(dibh);
883 out_end_trans:
884 	gfs2_trans_end(sdp);
885 out_ipres:
886 	if (alloc_required)
887 		gfs2_inplace_release(dip);
888 out_gunlock_q:
889 	if (alloc_required)
890 		gfs2_quota_unlock(dip);
891 out_gunlock:
892 	gfs2_glock_dq(ghs + 1);
893 out_child:
894 	gfs2_glock_dq(ghs);
895 out_parent:
896 	gfs2_holder_uninit(ghs);
897 	gfs2_holder_uninit(ghs + 1);
898 	return error;
899 }
900 
901 /*
902  * gfs2_unlink_ok - check to see that a inode is still in a directory
903  * @dip: the directory
904  * @name: the name of the file
905  * @ip: the inode
906  *
907  * Assumes that the lock on (at least) @dip is held.
908  *
909  * Returns: 0 if the parent/child relationship is correct, errno if it isn't
910  */
911 
912 static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
913 			  const struct gfs2_inode *ip)
914 {
915 	int error;
916 
917 	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
918 		return -EPERM;
919 
920 	if ((dip->i_inode.i_mode & S_ISVTX) &&
921 	    !uid_eq(dip->i_inode.i_uid, current_fsuid()) &&
922 	    !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER))
923 		return -EPERM;
924 
925 	if (IS_APPEND(&dip->i_inode))
926 		return -EPERM;
927 
928 	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
929 	if (error)
930 		return error;
931 
932 	error = gfs2_dir_check(&dip->i_inode, name, ip);
933 	if (error)
934 		return error;
935 
936 	return 0;
937 }
938 
939 /**
940  * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
941  * @dip: The parent directory
942  * @name: The name of the entry in the parent directory
943  * @inode: The inode to be removed
944  *
945  * Called with all the locks and in a transaction. This will only be
946  * called for a directory after it has been checked to ensure it is empty.
947  *
948  * Returns: 0 on success, or an error
949  */
950 
951 static int gfs2_unlink_inode(struct gfs2_inode *dip,
952 			     const struct dentry *dentry)
953 {
954 	struct inode *inode = dentry->d_inode;
955 	struct gfs2_inode *ip = GFS2_I(inode);
956 	int error;
957 
958 	error = gfs2_dir_del(dip, dentry);
959 	if (error)
960 		return error;
961 
962 	ip->i_entries = 0;
963 	inode->i_ctime = CURRENT_TIME;
964 	if (S_ISDIR(inode->i_mode))
965 		clear_nlink(inode);
966 	else
967 		drop_nlink(inode);
968 	mark_inode_dirty(inode);
969 	if (inode->i_nlink == 0)
970 		gfs2_unlink_di(inode);
971 	return 0;
972 }
973 
974 
975 /**
976  * gfs2_unlink - Unlink an inode (this does rmdir as well)
977  * @dir: The inode of the directory containing the inode to unlink
978  * @dentry: The file itself
979  *
980  * This routine uses the type of the inode as a flag to figure out
981  * whether this is an unlink or an rmdir.
982  *
983  * Returns: errno
984  */
985 
986 static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
987 {
988 	struct gfs2_inode *dip = GFS2_I(dir);
989 	struct gfs2_sbd *sdp = GFS2_SB(dir);
990 	struct inode *inode = dentry->d_inode;
991 	struct gfs2_inode *ip = GFS2_I(inode);
992 	struct gfs2_holder ghs[3];
993 	struct gfs2_rgrpd *rgd;
994 	int error;
995 
996 	error = gfs2_rindex_update(sdp);
997 	if (error)
998 		return error;
999 
1000 	error = -EROFS;
1001 
1002 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1003 	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
1004 
1005 	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1006 	if (!rgd)
1007 		goto out_inodes;
1008 
1009 	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
1010 
1011 
1012 	error = gfs2_glock_nq(ghs); /* parent */
1013 	if (error)
1014 		goto out_parent;
1015 
1016 	error = gfs2_glock_nq(ghs + 1); /* child */
1017 	if (error)
1018 		goto out_child;
1019 
1020 	error = -ENOENT;
1021 	if (inode->i_nlink == 0)
1022 		goto out_rgrp;
1023 
1024 	if (S_ISDIR(inode->i_mode)) {
1025 		error = -ENOTEMPTY;
1026 		if (ip->i_entries > 2 || inode->i_nlink > 2)
1027 			goto out_rgrp;
1028 	}
1029 
1030 	error = gfs2_glock_nq(ghs + 2); /* rgrp */
1031 	if (error)
1032 		goto out_rgrp;
1033 
1034 	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
1035 	if (error)
1036 		goto out_gunlock;
1037 
1038 	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
1039 	if (error)
1040 		goto out_end_trans;
1041 
1042 	error = gfs2_unlink_inode(dip, dentry);
1043 
1044 out_end_trans:
1045 	gfs2_trans_end(sdp);
1046 out_gunlock:
1047 	gfs2_glock_dq(ghs + 2);
1048 out_rgrp:
1049 	gfs2_glock_dq(ghs + 1);
1050 out_child:
1051 	gfs2_glock_dq(ghs);
1052 out_parent:
1053 	gfs2_holder_uninit(ghs + 2);
1054 out_inodes:
1055 	gfs2_holder_uninit(ghs + 1);
1056 	gfs2_holder_uninit(ghs);
1057 	return error;
1058 }
1059 
1060 /**
1061  * gfs2_symlink - Create a symlink
1062  * @dir: The directory to create the symlink in
1063  * @dentry: The dentry to put the symlink in
1064  * @symname: The thing which the link points to
1065  *
1066  * Returns: errno
1067  */
1068 
1069 static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
1070 			const char *symname)
1071 {
1072 	struct gfs2_sbd *sdp = GFS2_SB(dir);
1073 	unsigned int size;
1074 
1075 	size = strlen(symname);
1076 	if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
1077 		return -ENAMETOOLONG;
1078 
1079 	return gfs2_create_inode(dir, dentry, S_IFLNK | S_IRWXUGO, 0, symname, size, 0);
1080 }
1081 
1082 /**
1083  * gfs2_mkdir - Make a directory
1084  * @dir: The parent directory of the new one
1085  * @dentry: The dentry of the new directory
1086  * @mode: The mode of the new directory
1087  *
1088  * Returns: errno
1089  */
1090 
1091 static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1092 {
1093 	struct gfs2_sbd *sdp = GFS2_SB(dir);
1094 	unsigned dsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
1095 	return gfs2_create_inode(dir, dentry, S_IFDIR | mode, 0, NULL, dsize, 0);
1096 }
1097 
1098 /**
1099  * gfs2_mknod - Make a special file
1100  * @dir: The directory in which the special file will reside
1101  * @dentry: The dentry of the special file
1102  * @mode: The mode of the special file
1103  * @dev: The device specification of the special file
1104  *
1105  */
1106 
1107 static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
1108 		      dev_t dev)
1109 {
1110 	return gfs2_create_inode(dir, dentry, mode, dev, NULL, 0, 0);
1111 }
1112 
1113 /*
1114  * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1115  * @this: move this
1116  * @to: to here
1117  *
1118  * Follow @to back to the root and make sure we don't encounter @this
1119  * Assumes we already hold the rename lock.
1120  *
1121  * Returns: errno
1122  */
1123 
1124 static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1125 {
1126 	struct inode *dir = &to->i_inode;
1127 	struct super_block *sb = dir->i_sb;
1128 	struct inode *tmp;
1129 	int error = 0;
1130 
1131 	igrab(dir);
1132 
1133 	for (;;) {
1134 		if (dir == &this->i_inode) {
1135 			error = -EINVAL;
1136 			break;
1137 		}
1138 		if (dir == sb->s_root->d_inode) {
1139 			error = 0;
1140 			break;
1141 		}
1142 
1143 		tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
1144 		if (IS_ERR(tmp)) {
1145 			error = PTR_ERR(tmp);
1146 			break;
1147 		}
1148 
1149 		iput(dir);
1150 		dir = tmp;
1151 	}
1152 
1153 	iput(dir);
1154 
1155 	return error;
1156 }
1157 
1158 /**
1159  * gfs2_rename - Rename a file
1160  * @odir: Parent directory of old file name
1161  * @odentry: The old dentry of the file
1162  * @ndir: Parent directory of new file name
1163  * @ndentry: The new dentry of the file
1164  *
1165  * Returns: errno
1166  */
1167 
1168 static int gfs2_rename(struct inode *odir, struct dentry *odentry,
1169 		       struct inode *ndir, struct dentry *ndentry)
1170 {
1171 	struct gfs2_inode *odip = GFS2_I(odir);
1172 	struct gfs2_inode *ndip = GFS2_I(ndir);
1173 	struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
1174 	struct gfs2_inode *nip = NULL;
1175 	struct gfs2_sbd *sdp = GFS2_SB(odir);
1176 	struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
1177 	struct gfs2_rgrpd *nrgd;
1178 	unsigned int num_gh;
1179 	int dir_rename = 0;
1180 	int alloc_required = 0;
1181 	unsigned int x;
1182 	int error;
1183 
1184 	if (ndentry->d_inode) {
1185 		nip = GFS2_I(ndentry->d_inode);
1186 		if (ip == nip)
1187 			return 0;
1188 	}
1189 
1190 	error = gfs2_rindex_update(sdp);
1191 	if (error)
1192 		return error;
1193 
1194 	error = gfs2_rs_alloc(ndip);
1195 	if (error)
1196 		return error;
1197 
1198 	if (odip != ndip) {
1199 		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1200 					   0, &r_gh);
1201 		if (error)
1202 			goto out;
1203 
1204 		if (S_ISDIR(ip->i_inode.i_mode)) {
1205 			dir_rename = 1;
1206 			/* don't move a dirctory into it's subdir */
1207 			error = gfs2_ok_to_move(ip, ndip);
1208 			if (error)
1209 				goto out_gunlock_r;
1210 		}
1211 	}
1212 
1213 	num_gh = 1;
1214 	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1215 	if (odip != ndip) {
1216 		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1217 		num_gh++;
1218 	}
1219 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1220 	num_gh++;
1221 
1222 	if (nip) {
1223 		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1224 		num_gh++;
1225 		/* grab the resource lock for unlink flag twiddling
1226 		 * this is the case of the target file already existing
1227 		 * so we unlink before doing the rename
1228 		 */
1229 		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
1230 		if (nrgd)
1231 			gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
1232 	}
1233 
1234 	for (x = 0; x < num_gh; x++) {
1235 		error = gfs2_glock_nq(ghs + x);
1236 		if (error)
1237 			goto out_gunlock;
1238 	}
1239 
1240 	error = -ENOENT;
1241 	if (ip->i_inode.i_nlink == 0)
1242 		goto out_gunlock;
1243 
1244 	/* Check out the old directory */
1245 
1246 	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
1247 	if (error)
1248 		goto out_gunlock;
1249 
1250 	/* Check out the new directory */
1251 
1252 	if (nip) {
1253 		error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1254 		if (error)
1255 			goto out_gunlock;
1256 
1257 		if (nip->i_inode.i_nlink == 0) {
1258 			error = -EAGAIN;
1259 			goto out_gunlock;
1260 		}
1261 
1262 		if (S_ISDIR(nip->i_inode.i_mode)) {
1263 			if (nip->i_entries < 2) {
1264 				gfs2_consist_inode(nip);
1265 				error = -EIO;
1266 				goto out_gunlock;
1267 			}
1268 			if (nip->i_entries > 2) {
1269 				error = -ENOTEMPTY;
1270 				goto out_gunlock;
1271 			}
1272 		}
1273 	} else {
1274 		error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
1275 		if (error)
1276 			goto out_gunlock;
1277 
1278 		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
1279 		switch (error) {
1280 		case -ENOENT:
1281 			error = 0;
1282 			break;
1283 		case 0:
1284 			error = -EEXIST;
1285 		default:
1286 			goto out_gunlock;
1287 		};
1288 
1289 		if (odip != ndip) {
1290 			if (!ndip->i_inode.i_nlink) {
1291 				error = -ENOENT;
1292 				goto out_gunlock;
1293 			}
1294 			if (ndip->i_entries == (u32)-1) {
1295 				error = -EFBIG;
1296 				goto out_gunlock;
1297 			}
1298 			if (S_ISDIR(ip->i_inode.i_mode) &&
1299 			    ndip->i_inode.i_nlink == (u32)-1) {
1300 				error = -EMLINK;
1301 				goto out_gunlock;
1302 			}
1303 		}
1304 	}
1305 
1306 	/* Check out the dir to be renamed */
1307 
1308 	if (dir_rename) {
1309 		error = gfs2_permission(odentry->d_inode, MAY_WRITE);
1310 		if (error)
1311 			goto out_gunlock;
1312 	}
1313 
1314 	if (nip == NULL)
1315 		alloc_required = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
1316 	error = alloc_required;
1317 	if (error < 0)
1318 		goto out_gunlock;
1319 
1320 	if (alloc_required) {
1321 		error = gfs2_quota_lock_check(ndip);
1322 		if (error)
1323 			goto out_gunlock;
1324 
1325 		error = gfs2_inplace_reserve(ndip, sdp->sd_max_dirres, 0);
1326 		if (error)
1327 			goto out_gunlock_q;
1328 
1329 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
1330 					 gfs2_rg_blocks(ndip, sdp->sd_max_dirres) +
1331 					 4 * RES_DINODE + 4 * RES_LEAF +
1332 					 RES_STATFS + RES_QUOTA + 4, 0);
1333 		if (error)
1334 			goto out_ipreserv;
1335 	} else {
1336 		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
1337 					 5 * RES_LEAF + 4, 0);
1338 		if (error)
1339 			goto out_gunlock;
1340 	}
1341 
1342 	/* Remove the target file, if it exists */
1343 
1344 	if (nip)
1345 		error = gfs2_unlink_inode(ndip, ndentry);
1346 
1347 	if (dir_rename) {
1348 		error = gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);
1349 		if (error)
1350 			goto out_end_trans;
1351 	} else {
1352 		struct buffer_head *dibh;
1353 		error = gfs2_meta_inode_buffer(ip, &dibh);
1354 		if (error)
1355 			goto out_end_trans;
1356 		ip->i_inode.i_ctime = CURRENT_TIME;
1357 		gfs2_trans_add_meta(ip->i_gl, dibh);
1358 		gfs2_dinode_out(ip, dibh->b_data);
1359 		brelse(dibh);
1360 	}
1361 
1362 	error = gfs2_dir_del(odip, odentry);
1363 	if (error)
1364 		goto out_end_trans;
1365 
1366 	error = gfs2_dir_add(ndir, &ndentry->d_name, ip);
1367 	if (error)
1368 		goto out_end_trans;
1369 
1370 out_end_trans:
1371 	gfs2_trans_end(sdp);
1372 out_ipreserv:
1373 	if (alloc_required)
1374 		gfs2_inplace_release(ndip);
1375 out_gunlock_q:
1376 	if (alloc_required)
1377 		gfs2_quota_unlock(ndip);
1378 out_gunlock:
1379 	while (x--) {
1380 		gfs2_glock_dq(ghs + x);
1381 		gfs2_holder_uninit(ghs + x);
1382 	}
1383 out_gunlock_r:
1384 	if (r_gh.gh_gl)
1385 		gfs2_glock_dq_uninit(&r_gh);
1386 out:
1387 	return error;
1388 }
1389 
1390 /**
1391  * gfs2_follow_link - Follow a symbolic link
1392  * @dentry: The dentry of the link
1393  * @nd: Data that we pass to vfs_follow_link()
1394  *
1395  * This can handle symlinks of any size.
1396  *
1397  * Returns: 0 on success or error code
1398  */
1399 
1400 static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
1401 {
1402 	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
1403 	struct gfs2_holder i_gh;
1404 	struct buffer_head *dibh;
1405 	unsigned int size;
1406 	char *buf;
1407 	int error;
1408 
1409 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
1410 	error = gfs2_glock_nq(&i_gh);
1411 	if (error) {
1412 		gfs2_holder_uninit(&i_gh);
1413 		nd_set_link(nd, ERR_PTR(error));
1414 		return NULL;
1415 	}
1416 
1417 	size = (unsigned int)i_size_read(&ip->i_inode);
1418 	if (size == 0) {
1419 		gfs2_consist_inode(ip);
1420 		buf = ERR_PTR(-EIO);
1421 		goto out;
1422 	}
1423 
1424 	error = gfs2_meta_inode_buffer(ip, &dibh);
1425 	if (error) {
1426 		buf = ERR_PTR(error);
1427 		goto out;
1428 	}
1429 
1430 	buf = kzalloc(size + 1, GFP_NOFS);
1431 	if (!buf)
1432 		buf = ERR_PTR(-ENOMEM);
1433 	else
1434 		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1435 	brelse(dibh);
1436 out:
1437 	gfs2_glock_dq_uninit(&i_gh);
1438 	nd_set_link(nd, buf);
1439 	return NULL;
1440 }
1441 
1442 static void gfs2_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1443 {
1444 	char *s = nd_get_link(nd);
1445 	if (!IS_ERR(s))
1446 		kfree(s);
1447 }
1448 
1449 /**
1450  * gfs2_permission -
1451  * @inode: The inode
1452  * @mask: The mask to be tested
1453  * @flags: Indicates whether this is an RCU path walk or not
1454  *
1455  * This may be called from the VFS directly, or from within GFS2 with the
1456  * inode locked, so we look to see if the glock is already locked and only
1457  * lock the glock if its not already been done.
1458  *
1459  * Returns: errno
1460  */
1461 
1462 int gfs2_permission(struct inode *inode, int mask)
1463 {
1464 	struct gfs2_inode *ip;
1465 	struct gfs2_holder i_gh;
1466 	int error;
1467 	int unlock = 0;
1468 
1469 
1470 	ip = GFS2_I(inode);
1471 	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1472 		if (mask & MAY_NOT_BLOCK)
1473 			return -ECHILD;
1474 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
1475 		if (error)
1476 			return error;
1477 		unlock = 1;
1478 	}
1479 
1480 	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
1481 		error = -EACCES;
1482 	else
1483 		error = generic_permission(inode, mask);
1484 	if (unlock)
1485 		gfs2_glock_dq_uninit(&i_gh);
1486 
1487 	return error;
1488 }
1489 
1490 static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1491 {
1492 	setattr_copy(inode, attr);
1493 	mark_inode_dirty(inode);
1494 	return 0;
1495 }
1496 
1497 /**
1498  * gfs2_setattr_simple -
1499  * @ip:
1500  * @attr:
1501  *
1502  * Returns: errno
1503  */
1504 
1505 int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1506 {
1507 	int error;
1508 
1509 	if (current->journal_info)
1510 		return __gfs2_setattr_simple(inode, attr);
1511 
1512 	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1513 	if (error)
1514 		return error;
1515 
1516 	error = __gfs2_setattr_simple(inode, attr);
1517 	gfs2_trans_end(GFS2_SB(inode));
1518 	return error;
1519 }
1520 
1521 static int setattr_chown(struct inode *inode, struct iattr *attr)
1522 {
1523 	struct gfs2_inode *ip = GFS2_I(inode);
1524 	struct gfs2_sbd *sdp = GFS2_SB(inode);
1525 	kuid_t ouid, nuid;
1526 	kgid_t ogid, ngid;
1527 	int error;
1528 
1529 	ouid = inode->i_uid;
1530 	ogid = inode->i_gid;
1531 	nuid = attr->ia_uid;
1532 	ngid = attr->ia_gid;
1533 
1534 	if (!(attr->ia_valid & ATTR_UID) || uid_eq(ouid, nuid))
1535 		ouid = nuid = NO_UID_QUOTA_CHANGE;
1536 	if (!(attr->ia_valid & ATTR_GID) || gid_eq(ogid, ngid))
1537 		ogid = ngid = NO_GID_QUOTA_CHANGE;
1538 
1539 	error = gfs2_quota_lock(ip, nuid, ngid);
1540 	if (error)
1541 		return error;
1542 
1543 	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
1544 	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1545 		error = gfs2_quota_check(ip, nuid, ngid);
1546 		if (error)
1547 			goto out_gunlock_q;
1548 	}
1549 
1550 	error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
1551 	if (error)
1552 		goto out_gunlock_q;
1553 
1554 	error = gfs2_setattr_simple(inode, attr);
1555 	if (error)
1556 		goto out_end_trans;
1557 
1558 	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
1559 	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1560 		u64 blocks = gfs2_get_inode_blocks(&ip->i_inode);
1561 		gfs2_quota_change(ip, -blocks, ouid, ogid);
1562 		gfs2_quota_change(ip, blocks, nuid, ngid);
1563 	}
1564 
1565 out_end_trans:
1566 	gfs2_trans_end(sdp);
1567 out_gunlock_q:
1568 	gfs2_quota_unlock(ip);
1569 	return error;
1570 }
1571 
1572 /**
1573  * gfs2_setattr - Change attributes on an inode
1574  * @dentry: The dentry which is changing
1575  * @attr: The structure describing the change
1576  *
1577  * The VFS layer wants to change one or more of an inodes attributes.  Write
1578  * that change out to disk.
1579  *
1580  * Returns: errno
1581  */
1582 
1583 static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
1584 {
1585 	struct inode *inode = dentry->d_inode;
1586 	struct gfs2_inode *ip = GFS2_I(inode);
1587 	struct gfs2_holder i_gh;
1588 	int error;
1589 
1590 	error = gfs2_rs_alloc(ip);
1591 	if (error)
1592 		return error;
1593 
1594 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1595 	if (error)
1596 		return error;
1597 
1598 	error = -EPERM;
1599 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1600 		goto out;
1601 
1602 	error = inode_change_ok(inode, attr);
1603 	if (error)
1604 		goto out;
1605 
1606 	if (attr->ia_valid & ATTR_SIZE)
1607 		error = gfs2_setattr_size(inode, attr->ia_size);
1608 	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
1609 		error = setattr_chown(inode, attr);
1610 	else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode))
1611 		error = gfs2_acl_chmod(ip, attr);
1612 	else
1613 		error = gfs2_setattr_simple(inode, attr);
1614 
1615 out:
1616 	if (!error)
1617 		mark_inode_dirty(inode);
1618 	gfs2_glock_dq_uninit(&i_gh);
1619 	return error;
1620 }
1621 
1622 /**
1623  * gfs2_getattr - Read out an inode's attributes
1624  * @mnt: The vfsmount the inode is being accessed from
1625  * @dentry: The dentry to stat
1626  * @stat: The inode's stats
1627  *
1628  * This may be called from the VFS directly, or from within GFS2 with the
1629  * inode locked, so we look to see if the glock is already locked and only
1630  * lock the glock if its not already been done. Note that its the NFS
1631  * readdirplus operation which causes this to be called (from filldir)
1632  * with the glock already held.
1633  *
1634  * Returns: errno
1635  */
1636 
1637 static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
1638 			struct kstat *stat)
1639 {
1640 	struct inode *inode = dentry->d_inode;
1641 	struct gfs2_inode *ip = GFS2_I(inode);
1642 	struct gfs2_holder gh;
1643 	int error;
1644 	int unlock = 0;
1645 
1646 	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1647 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1648 		if (error)
1649 			return error;
1650 		unlock = 1;
1651 	}
1652 
1653 	generic_fillattr(inode, stat);
1654 	if (unlock)
1655 		gfs2_glock_dq_uninit(&gh);
1656 
1657 	return 0;
1658 }
1659 
1660 static int gfs2_setxattr(struct dentry *dentry, const char *name,
1661 			 const void *data, size_t size, int flags)
1662 {
1663 	struct inode *inode = dentry->d_inode;
1664 	struct gfs2_inode *ip = GFS2_I(inode);
1665 	struct gfs2_holder gh;
1666 	int ret;
1667 
1668 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1669 	ret = gfs2_glock_nq(&gh);
1670 	if (ret == 0) {
1671 		ret = gfs2_rs_alloc(ip);
1672 		if (ret == 0)
1673 			ret = generic_setxattr(dentry, name, data, size, flags);
1674 		gfs2_glock_dq(&gh);
1675 	}
1676 	gfs2_holder_uninit(&gh);
1677 	return ret;
1678 }
1679 
1680 static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
1681 			     void *data, size_t size)
1682 {
1683 	struct inode *inode = dentry->d_inode;
1684 	struct gfs2_inode *ip = GFS2_I(inode);
1685 	struct gfs2_holder gh;
1686 	int ret;
1687 
1688 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1689 	ret = gfs2_glock_nq(&gh);
1690 	if (ret == 0) {
1691 		ret = generic_getxattr(dentry, name, data, size);
1692 		gfs2_glock_dq(&gh);
1693 	}
1694 	gfs2_holder_uninit(&gh);
1695 	return ret;
1696 }
1697 
1698 static int gfs2_removexattr(struct dentry *dentry, const char *name)
1699 {
1700 	struct inode *inode = dentry->d_inode;
1701 	struct gfs2_inode *ip = GFS2_I(inode);
1702 	struct gfs2_holder gh;
1703 	int ret;
1704 
1705 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1706 	ret = gfs2_glock_nq(&gh);
1707 	if (ret == 0) {
1708 		ret = gfs2_rs_alloc(ip);
1709 		if (ret == 0)
1710 			ret = generic_removexattr(dentry, name);
1711 		gfs2_glock_dq(&gh);
1712 	}
1713 	gfs2_holder_uninit(&gh);
1714 	return ret;
1715 }
1716 
1717 static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
1718 		       u64 start, u64 len)
1719 {
1720 	struct gfs2_inode *ip = GFS2_I(inode);
1721 	struct gfs2_holder gh;
1722 	int ret;
1723 
1724 	ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
1725 	if (ret)
1726 		return ret;
1727 
1728 	mutex_lock(&inode->i_mutex);
1729 
1730 	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
1731 	if (ret)
1732 		goto out;
1733 
1734 	if (gfs2_is_stuffed(ip)) {
1735 		u64 phys = ip->i_no_addr << inode->i_blkbits;
1736 		u64 size = i_size_read(inode);
1737 		u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
1738 			    FIEMAP_EXTENT_DATA_INLINE;
1739 		phys += sizeof(struct gfs2_dinode);
1740 		phys += start;
1741 		if (start + len > size)
1742 			len = size - start;
1743 		if (start < size)
1744 			ret = fiemap_fill_next_extent(fieinfo, start, phys,
1745 						      len, flags);
1746 		if (ret == 1)
1747 			ret = 0;
1748 	} else {
1749 		ret = __generic_block_fiemap(inode, fieinfo, start, len,
1750 					     gfs2_block_map);
1751 	}
1752 
1753 	gfs2_glock_dq_uninit(&gh);
1754 out:
1755 	mutex_unlock(&inode->i_mutex);
1756 	return ret;
1757 }
1758 
1759 const struct inode_operations gfs2_file_iops = {
1760 	.permission = gfs2_permission,
1761 	.setattr = gfs2_setattr,
1762 	.getattr = gfs2_getattr,
1763 	.setxattr = gfs2_setxattr,
1764 	.getxattr = gfs2_getxattr,
1765 	.listxattr = gfs2_listxattr,
1766 	.removexattr = gfs2_removexattr,
1767 	.fiemap = gfs2_fiemap,
1768 	.get_acl = gfs2_get_acl,
1769 };
1770 
1771 const struct inode_operations gfs2_dir_iops = {
1772 	.create = gfs2_create,
1773 	.lookup = gfs2_lookup,
1774 	.link = gfs2_link,
1775 	.unlink = gfs2_unlink,
1776 	.symlink = gfs2_symlink,
1777 	.mkdir = gfs2_mkdir,
1778 	.rmdir = gfs2_unlink,
1779 	.mknod = gfs2_mknod,
1780 	.rename = gfs2_rename,
1781 	.permission = gfs2_permission,
1782 	.setattr = gfs2_setattr,
1783 	.getattr = gfs2_getattr,
1784 	.setxattr = gfs2_setxattr,
1785 	.getxattr = gfs2_getxattr,
1786 	.listxattr = gfs2_listxattr,
1787 	.removexattr = gfs2_removexattr,
1788 	.fiemap = gfs2_fiemap,
1789 	.get_acl = gfs2_get_acl,
1790 };
1791 
1792 const struct inode_operations gfs2_symlink_iops = {
1793 	.readlink = generic_readlink,
1794 	.follow_link = gfs2_follow_link,
1795 	.put_link = gfs2_put_link,
1796 	.permission = gfs2_permission,
1797 	.setattr = gfs2_setattr,
1798 	.getattr = gfs2_getattr,
1799 	.setxattr = gfs2_setxattr,
1800 	.getxattr = gfs2_getxattr,
1801 	.listxattr = gfs2_listxattr,
1802 	.removexattr = gfs2_removexattr,
1803 	.fiemap = gfs2_fiemap,
1804 	.get_acl = gfs2_get_acl,
1805 };
1806 
1807