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