2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2011 Red Hat, Inc. All rights reserved.
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.
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>
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>
40 struct gfs2_skip_data
{
46 static int iget_test(struct inode
*inode
, void *opaque
)
48 struct gfs2_inode
*ip
= GFS2_I(inode
);
49 struct gfs2_skip_data
*data
= opaque
;
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
)) {
62 static int iget_set(struct inode
*inode
, void *opaque
)
64 struct gfs2_inode
*ip
= GFS2_I(inode
);
65 struct gfs2_skip_data
*data
= opaque
;
69 inode
->i_ino
= (unsigned long)(data
->no_addr
);
70 ip
->i_no_addr
= data
->no_addr
;
74 struct inode
*gfs2_ilookup(struct super_block
*sb
, u64 no_addr
, int non_block
)
76 unsigned long hash
= (unsigned long)no_addr
;
77 struct gfs2_skip_data data
;
79 data
.no_addr
= no_addr
;
81 data
.non_block
= non_block
;
82 return ilookup5(sb
, hash
, iget_test
, &data
);
85 static struct inode
*gfs2_iget(struct super_block
*sb
, u64 no_addr
,
88 struct gfs2_skip_data data
;
89 unsigned long hash
= (unsigned long)no_addr
;
91 data
.no_addr
= no_addr
;
93 data
.non_block
= non_block
;
94 return iget5_locked(sb
, hash
, iget_test
, iget_set
, &data
);
98 * gfs2_set_iop - Sets inode operations
99 * @inode: The inode with correct i_mode filled in
101 * GFS2 lookup code fills in vfs inode contents based on info obtained
102 * from directory entry inside gfs2_inode_lookup().
105 static void gfs2_set_iop(struct inode
*inode
)
107 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
108 umode_t mode
= inode
->i_mode
;
111 inode
->i_op
= &gfs2_file_iops
;
112 if (gfs2_localflocks(sdp
))
113 inode
->i_fop
= &gfs2_file_fops_nolock
;
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
;
121 inode
->i_fop
= &gfs2_dir_fops
;
122 } else if (S_ISLNK(mode
)) {
123 inode
->i_op
= &gfs2_symlink_iops
;
125 inode
->i_op
= &gfs2_file_iops
;
126 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
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?
137 * Returns: A VFS inode, or an error
140 struct inode
*gfs2_inode_lookup(struct super_block
*sb
, unsigned int type
,
141 u64 no_addr
, u64 no_formal_ino
, int non_block
)
144 struct gfs2_inode
*ip
;
145 struct gfs2_glock
*io_gl
= NULL
;
148 inode
= gfs2_iget(sb
, no_addr
, non_block
);
152 return ERR_PTR(-ENOBUFS
);
154 if (inode
->i_state
& I_NEW
) {
155 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
156 ip
->i_no_formal_ino
= no_formal_ino
;
158 error
= gfs2_glock_get(sdp
, no_addr
, &gfs2_inode_glops
, CREATE
, &ip
->i_gl
);
161 ip
->i_gl
->gl_object
= ip
;
163 error
= gfs2_glock_get(sdp
, no_addr
, &gfs2_iopen_glops
, CREATE
, &io_gl
);
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
);
172 ip
->i_iopen_gh
.gh_gl
->gl_object
= ip
;
173 gfs2_glock_put(io_gl
);
176 if (type
== DT_UNKNOWN
) {
177 /* Inode glock must be locked already */
178 error
= gfs2_inode_refresh(GFS2_I(inode
));
182 inode
->i_mode
= DT2IF(type
);
186 unlock_new_inode(inode
);
192 ip
->i_iopen_gh
.gh_gl
->gl_object
= NULL
;
193 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
196 gfs2_glock_put(io_gl
);
198 ip
->i_gl
->gl_object
= NULL
;
199 gfs2_glock_put(ip
->i_gl
);
202 return ERR_PTR(error
);
205 struct inode
*gfs2_lookup_by_inum(struct gfs2_sbd
*sdp
, u64 no_addr
,
206 u64
*no_formal_ino
, unsigned int blktype
)
208 struct super_block
*sb
= sdp
->sd_vfs
;
209 struct gfs2_holder i_gh
;
210 struct inode
*inode
= NULL
;
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
);
217 return ERR_PTR(error
);
219 error
= gfs2_check_blk_type(sdp
, no_addr
, blktype
);
223 inode
= gfs2_inode_lookup(sb
, DT_UNKNOWN
, no_addr
, 0, 1);
227 /* Two extra checks for NFS only */
230 if (GFS2_I(inode
)->i_no_formal_ino
!= *no_formal_ino
)
234 if (GFS2_I(inode
)->i_diskflags
& GFS2_DIF_SYSTEM
)
241 gfs2_glock_dq_uninit(&i_gh
);
242 return error
? ERR_PTR(error
) : inode
;
249 struct inode
*gfs2_lookup_simple(struct inode
*dip
, const char *name
)
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.
261 return ERR_PTR(-ENOENT
);
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
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.
282 struct inode
*gfs2_lookupi(struct inode
*dir
, const struct qstr
*name
,
285 struct super_block
*sb
= dir
->i_sb
;
286 struct gfs2_inode
*dip
= GFS2_I(dir
);
287 struct gfs2_holder d_gh
;
289 struct inode
*inode
= NULL
;
292 if (!name
->len
|| name
->len
> GFS2_FNAMESIZE
)
293 return ERR_PTR(-ENAMETOOLONG
);
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
)) {
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
);
305 return ERR_PTR(error
);
310 error
= gfs2_permission(dir
, MAY_EXEC
);
315 inode
= gfs2_dir_search(dir
, name
);
317 error
= PTR_ERR(inode
);
320 gfs2_glock_dq_uninit(&d_gh
);
321 if (error
== -ENOENT
)
323 return inode
? inode
: ERR_PTR(error
);
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
335 static int create_ok(struct gfs2_inode
*dip
, const struct qstr
*name
,
340 error
= gfs2_permission(&dip
->i_inode
, MAY_WRITE
| MAY_EXEC
);
344 /* Don't create entries in an unlinked directory */
345 if (!dip
->i_inode
.i_nlink
)
348 error
= gfs2_dir_check(&dip
->i_inode
, name
, NULL
);
359 if (dip
->i_entries
== (u32
)-1)
361 if (S_ISDIR(mode
) && dip
->i_inode
.i_nlink
== (u32
)-1)
367 static void munge_mode_uid_gid(struct gfs2_inode
*dip
, umode_t
*mode
,
368 unsigned int *uid
, unsigned int *gid
)
370 if (GFS2_SB(&dip
->i_inode
)->sd_args
.ar_suiddir
&&
371 (dip
->i_inode
.i_mode
& S_ISUID
) && dip
->i_inode
.i_uid
) {
374 else if (dip
->i_inode
.i_uid
!= current_fsuid())
376 *uid
= dip
->i_inode
.i_uid
;
378 *uid
= current_fsuid();
380 if (dip
->i_inode
.i_mode
& S_ISGID
) {
383 *gid
= dip
->i_inode
.i_gid
;
385 *gid
= current_fsgid();
388 static int alloc_dinode(struct gfs2_inode
*dip
, u64
*no_addr
, u64
*generation
)
390 struct gfs2_sbd
*sdp
= GFS2_SB(&dip
->i_inode
);
394 error
= gfs2_inplace_reserve(dip
, RES_DINODE
);
398 error
= gfs2_trans_begin(sdp
, RES_RG_BIT
+ RES_STATFS
, 0);
402 error
= gfs2_alloc_blocks(dip
, no_addr
, &dblocks
, 1, generation
);
407 gfs2_inplace_release(dip
);
412 static void gfs2_init_dir(struct buffer_head
*dibh
,
413 const struct gfs2_inode
*parent
)
415 struct gfs2_dinode
*di
= (struct gfs2_dinode
*)dibh
->b_data
;
416 struct gfs2_dirent
*dent
= (struct gfs2_dirent
*)(di
+1);
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
);
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
);
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)
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
)
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
;
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
;
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
);
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
);
477 di
->di_payload_format
= cpu_to_be32(S_ISDIR(mode
) ? GFS2_FORMAT_DE
: 0);
483 memset(&di
->__pad4
, 0, sizeof(di
->__pad4
));
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
));
490 switch(mode
& S_IFMT
) {
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
);
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
);
505 memcpy(dibh
->b_data
+ sizeof(struct gfs2_dinode
), symname
, size
);
509 set_buffer_uptodate(dibh
);
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
)
519 struct gfs2_sbd
*sdp
= GFS2_SB(&dip
->i_inode
);
520 unsigned int uid
, gid
;
523 munge_mode_uid_gid(dip
, &mode
, &uid
, &gid
);
524 error
= gfs2_rindex_update(sdp
);
528 error
= gfs2_quota_lock(dip
, uid
, gid
);
532 error
= gfs2_quota_check(dip
, uid
, gid
);
536 error
= gfs2_trans_begin(sdp
, RES_DINODE
+ RES_QUOTA
, 0);
540 init_dinode(dip
, gl
, inum
, mode
, uid
, gid
, generation
, dev
, symname
, size
, bhp
);
541 gfs2_quota_change(dip
, +1, uid
, gid
);
545 gfs2_quota_unlock(dip
);
549 static int link_dinode(struct gfs2_inode
*dip
, const struct qstr
*name
,
550 struct gfs2_inode
*ip
)
552 struct gfs2_sbd
*sdp
= GFS2_SB(&dip
->i_inode
);
554 struct buffer_head
*dibh
;
557 error
= gfs2_rindex_update(sdp
);
561 error
= gfs2_quota_lock(dip
, NO_QUOTA_CHANGE
, NO_QUOTA_CHANGE
);
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
);
571 goto fail_quota_locks
;
573 error
= gfs2_inplace_reserve(dip
, sdp
->sd_max_dirres
);
575 goto fail_quota_locks
;
577 error
= gfs2_trans_begin(sdp
, sdp
->sd_max_dirres
+
578 dip
->i_rgd
->rd_length
+
580 RES_STATFS
+ RES_QUOTA
, 0);
584 error
= gfs2_trans_begin(sdp
, RES_LEAF
+ 2 * RES_DINODE
, 0);
586 goto fail_quota_locks
;
589 error
= gfs2_dir_add(&dip
->i_inode
, name
, ip
);
593 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
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
);
607 gfs2_inplace_release(dip
);
610 gfs2_quota_unlock(dip
);
616 static int gfs2_initxattrs(struct inode
*inode
, const struct xattr
*xattr_array
,
619 const struct xattr
*xattr
;
622 for (xattr
= xattr_array
; xattr
->name
!= NULL
; xattr
++) {
623 err
= __gfs2_xattr_set(inode
, xattr
->name
, xattr
->value
,
625 GFS2_EATYPE_SECURITY
);
632 static int gfs2_security_init(struct gfs2_inode
*dip
, struct gfs2_inode
*ip
,
633 const struct qstr
*qstr
)
635 return security_inode_init_security(&ip
->i_inode
, &dip
->i_inode
, qstr
,
636 &gfs2_initxattrs
, NULL
);
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)
648 * Returns: 0 on success, or error code
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
)
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 };
663 struct buffer_head
*bh
= NULL
;
665 if (!name
->len
|| name
->len
> GFS2_FNAMESIZE
)
666 return -ENAMETOOLONG
;
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
);
677 error
= gfs2_glock_nq_init(dip
->i_gl
, LM_ST_EXCLUSIVE
, 0, ghs
);
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;
691 error
= alloc_dinode(dip
, &inum
.no_addr
, &generation
);
694 inum
.no_formal_ino
= generation
;
696 error
= gfs2_glock_nq_num(sdp
, inum
.no_addr
, &gfs2_inode_glops
,
697 LM_ST_EXCLUSIVE
, GL_SKIP
, ghs
+ 1);
701 error
= make_dinode(dip
, ghs
[1].gh_gl
, mode
, &inum
, &generation
, dev
, symname
, size
, &bh
);
705 inode
= gfs2_inode_lookup(dir
->i_sb
, IF2DT(mode
), inum
.no_addr
,
706 inum
.no_formal_ino
, 0);
711 error
= gfs2_inode_refresh(ip
);
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
;
724 error
= gfs2_acl_create(dip
, inode
);
728 error
= gfs2_security_init(dip
, ip
, name
);
732 error
= link_dinode(dip
, name
, ip
);
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
);
751 gfs2_glock_dq_uninit(ghs
+ 1);
753 gfs2_glock_dq_uninit(ghs
);
754 if (inode
&& !IS_ERR(inode
)) {
755 set_bit(GIF_ALLOC_FAILED
, &GFS2_I(inode
)->i_flags
);
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
774 static int gfs2_create(struct inode
*dir
, struct dentry
*dentry
,
775 umode_t mode
, struct nameidata
*nd
)
778 if (nd
&& (nd
->flags
& LOOKUP_EXCL
))
780 return gfs2_create_inode(dir
, dentry
, S_IFREG
| mode
, 0, NULL
, 0, excl
);
784 * gfs2_lookup - Look up a filename in a directory and return its inode
785 * @dir: The directory inode
786 * @dentry: The dentry of the new inode
787 * @nd: passed from Linux VFS, ignored by us
789 * Called by the VFS layer. Lock dir and call gfs2_lookupi()
794 static struct dentry
*gfs2_lookup(struct inode
*dir
, struct dentry
*dentry
,
795 struct nameidata
*nd
)
797 struct inode
*inode
= gfs2_lookupi(dir
, &dentry
->d_name
, 0);
798 if (inode
&& !IS_ERR(inode
)) {
799 struct gfs2_glock
*gl
= GFS2_I(inode
)->i_gl
;
800 struct gfs2_holder gh
;
802 error
= gfs2_glock_nq_init(gl
, LM_ST_SHARED
, LM_FLAG_ANY
, &gh
);
805 return ERR_PTR(error
);
807 gfs2_glock_dq_uninit(&gh
);
809 return d_splice_alias(inode
, dentry
);
813 * gfs2_link - Link to a file
814 * @old_dentry: The inode to link
815 * @dir: Add link to this directory
816 * @dentry: The name of the link
818 * Link the inode in "old_dentry" into the directory "dir" with the
824 static int gfs2_link(struct dentry
*old_dentry
, struct inode
*dir
,
825 struct dentry
*dentry
)
827 struct gfs2_inode
*dip
= GFS2_I(dir
);
828 struct gfs2_sbd
*sdp
= GFS2_SB(dir
);
829 struct inode
*inode
= old_dentry
->d_inode
;
830 struct gfs2_inode
*ip
= GFS2_I(inode
);
831 struct gfs2_holder ghs
[2];
832 struct buffer_head
*dibh
;
836 if (S_ISDIR(inode
->i_mode
))
839 error
= gfs2_rs_alloc(dip
);
843 gfs2_holder_init(dip
->i_gl
, LM_ST_EXCLUSIVE
, 0, ghs
);
844 gfs2_holder_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, ghs
+ 1);
846 error
= gfs2_glock_nq(ghs
); /* parent */
850 error
= gfs2_glock_nq(ghs
+ 1); /* child */
855 if (inode
->i_nlink
== 0)
858 error
= gfs2_permission(dir
, MAY_WRITE
| MAY_EXEC
);
862 error
= gfs2_dir_check(dir
, &dentry
->d_name
, NULL
);
873 if (!dip
->i_inode
.i_nlink
)
876 if (dip
->i_entries
== (u32
)-1)
879 if (IS_IMMUTABLE(inode
) || IS_APPEND(inode
))
882 if (!ip
->i_inode
.i_nlink
)
885 if (ip
->i_inode
.i_nlink
== (u32
)-1)
888 alloc_required
= error
= gfs2_diradd_alloc_required(dir
, &dentry
->d_name
);
893 if (alloc_required
) {
894 error
= gfs2_quota_lock_check(dip
);
898 error
= gfs2_inplace_reserve(dip
, sdp
->sd_max_dirres
);
902 error
= gfs2_trans_begin(sdp
, sdp
->sd_max_dirres
+
903 gfs2_rg_blocks(dip
) +
904 2 * RES_DINODE
+ RES_STATFS
+
909 error
= gfs2_trans_begin(sdp
, 2 * RES_DINODE
+ RES_LEAF
, 0);
914 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
918 error
= gfs2_dir_add(dir
, &dentry
->d_name
, ip
);
922 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
923 inc_nlink(&ip
->i_inode
);
924 ip
->i_inode
.i_ctime
= CURRENT_TIME
;
926 d_instantiate(dentry
, inode
);
927 mark_inode_dirty(inode
);
935 gfs2_inplace_release(dip
);
938 gfs2_quota_unlock(dip
);
940 gfs2_glock_dq(ghs
+ 1);
944 gfs2_holder_uninit(ghs
);
945 gfs2_holder_uninit(ghs
+ 1);
950 * gfs2_unlink_ok - check to see that a inode is still in a directory
951 * @dip: the directory
952 * @name: the name of the file
955 * Assumes that the lock on (at least) @dip is held.
957 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
960 static int gfs2_unlink_ok(struct gfs2_inode
*dip
, const struct qstr
*name
,
961 const struct gfs2_inode
*ip
)
965 if (IS_IMMUTABLE(&ip
->i_inode
) || IS_APPEND(&ip
->i_inode
))
968 if ((dip
->i_inode
.i_mode
& S_ISVTX
) &&
969 dip
->i_inode
.i_uid
!= current_fsuid() &&
970 ip
->i_inode
.i_uid
!= current_fsuid() && !capable(CAP_FOWNER
))
973 if (IS_APPEND(&dip
->i_inode
))
976 error
= gfs2_permission(&dip
->i_inode
, MAY_WRITE
| MAY_EXEC
);
980 error
= gfs2_dir_check(&dip
->i_inode
, name
, ip
);
988 * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
989 * @dip: The parent directory
990 * @name: The name of the entry in the parent directory
991 * @bh: The inode buffer for the inode to be removed
992 * @inode: The inode to be removed
994 * Called with all the locks and in a transaction. This will only be
995 * called for a directory after it has been checked to ensure it is empty.
997 * Returns: 0 on success, or an error
1000 static int gfs2_unlink_inode(struct gfs2_inode
*dip
,
1001 const struct dentry
*dentry
,
1002 struct buffer_head
*bh
)
1004 struct inode
*inode
= dentry
->d_inode
;
1005 struct gfs2_inode
*ip
= GFS2_I(inode
);
1008 error
= gfs2_dir_del(dip
, dentry
);
1013 inode
->i_ctime
= CURRENT_TIME
;
1014 if (S_ISDIR(inode
->i_mode
))
1018 mark_inode_dirty(inode
);
1019 if (inode
->i_nlink
== 0)
1020 gfs2_unlink_di(inode
);
1026 * gfs2_unlink - Unlink an inode (this does rmdir as well)
1027 * @dir: The inode of the directory containing the inode to unlink
1028 * @dentry: The file itself
1030 * This routine uses the type of the inode as a flag to figure out
1031 * whether this is an unlink or an rmdir.
1036 static int gfs2_unlink(struct inode
*dir
, struct dentry
*dentry
)
1038 struct gfs2_inode
*dip
= GFS2_I(dir
);
1039 struct gfs2_sbd
*sdp
= GFS2_SB(dir
);
1040 struct inode
*inode
= dentry
->d_inode
;
1041 struct gfs2_inode
*ip
= GFS2_I(inode
);
1042 struct buffer_head
*bh
;
1043 struct gfs2_holder ghs
[3];
1044 struct gfs2_rgrpd
*rgd
;
1047 error
= gfs2_rindex_update(sdp
);
1053 gfs2_holder_init(dip
->i_gl
, LM_ST_EXCLUSIVE
, 0, ghs
);
1054 gfs2_holder_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, ghs
+ 1);
1056 rgd
= gfs2_blk2rgrpd(sdp
, ip
->i_no_addr
, 1);
1060 gfs2_holder_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
, 0, ghs
+ 2);
1063 error
= gfs2_glock_nq(ghs
); /* parent */
1067 error
= gfs2_glock_nq(ghs
+ 1); /* child */
1072 if (inode
->i_nlink
== 0)
1075 if (S_ISDIR(inode
->i_mode
)) {
1077 if (ip
->i_entries
> 2 || inode
->i_nlink
> 2)
1081 error
= gfs2_glock_nq(ghs
+ 2); /* rgrp */
1085 error
= gfs2_unlink_ok(dip
, &dentry
->d_name
, ip
);
1089 error
= gfs2_trans_begin(sdp
, 2*RES_DINODE
+ 3*RES_LEAF
+ RES_RG_BIT
, 0);
1093 error
= gfs2_meta_inode_buffer(ip
, &bh
);
1097 error
= gfs2_unlink_inode(dip
, dentry
, bh
);
1101 gfs2_trans_end(sdp
);
1103 gfs2_glock_dq(ghs
+ 2);
1105 gfs2_glock_dq(ghs
+ 1);
1109 gfs2_holder_uninit(ghs
+ 2);
1111 gfs2_holder_uninit(ghs
+ 1);
1112 gfs2_holder_uninit(ghs
);
1117 * gfs2_symlink - Create a symlink
1118 * @dir: The directory to create the symlink in
1119 * @dentry: The dentry to put the symlink in
1120 * @symname: The thing which the link points to
1125 static int gfs2_symlink(struct inode
*dir
, struct dentry
*dentry
,
1126 const char *symname
)
1128 struct gfs2_sbd
*sdp
= GFS2_SB(dir
);
1131 size
= strlen(symname
);
1132 if (size
> sdp
->sd_sb
.sb_bsize
- sizeof(struct gfs2_dinode
) - 1)
1133 return -ENAMETOOLONG
;
1135 return gfs2_create_inode(dir
, dentry
, S_IFLNK
| S_IRWXUGO
, 0, symname
, size
, 0);
1139 * gfs2_mkdir - Make a directory
1140 * @dir: The parent directory of the new one
1141 * @dentry: The dentry of the new directory
1142 * @mode: The mode of the new directory
1147 static int gfs2_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
1149 return gfs2_create_inode(dir
, dentry
, S_IFDIR
| mode
, 0, NULL
, 0, 0);
1153 * gfs2_mknod - Make a special file
1154 * @dir: The directory in which the special file will reside
1155 * @dentry: The dentry of the special file
1156 * @mode: The mode of the special file
1157 * @dev: The device specification of the special file
1161 static int gfs2_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
1164 return gfs2_create_inode(dir
, dentry
, mode
, dev
, NULL
, 0, 0);
1168 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1172 * Follow @to back to the root and make sure we don't encounter @this
1173 * Assumes we already hold the rename lock.
1178 static int gfs2_ok_to_move(struct gfs2_inode
*this, struct gfs2_inode
*to
)
1180 struct inode
*dir
= &to
->i_inode
;
1181 struct super_block
*sb
= dir
->i_sb
;
1188 if (dir
== &this->i_inode
) {
1192 if (dir
== sb
->s_root
->d_inode
) {
1197 tmp
= gfs2_lookupi(dir
, &gfs2_qdotdot
, 1);
1199 error
= PTR_ERR(tmp
);
1213 * gfs2_rename - Rename a file
1214 * @odir: Parent directory of old file name
1215 * @odentry: The old dentry of the file
1216 * @ndir: Parent directory of new file name
1217 * @ndentry: The new dentry of the file
1222 static int gfs2_rename(struct inode
*odir
, struct dentry
*odentry
,
1223 struct inode
*ndir
, struct dentry
*ndentry
)
1225 struct gfs2_inode
*odip
= GFS2_I(odir
);
1226 struct gfs2_inode
*ndip
= GFS2_I(ndir
);
1227 struct gfs2_inode
*ip
= GFS2_I(odentry
->d_inode
);
1228 struct gfs2_inode
*nip
= NULL
;
1229 struct gfs2_sbd
*sdp
= GFS2_SB(odir
);
1230 struct gfs2_holder ghs
[5], r_gh
= { .gh_gl
= NULL
, };
1231 struct gfs2_rgrpd
*nrgd
;
1232 unsigned int num_gh
;
1234 int alloc_required
= 0;
1238 if (ndentry
->d_inode
) {
1239 nip
= GFS2_I(ndentry
->d_inode
);
1244 error
= gfs2_rindex_update(sdp
);
1248 error
= gfs2_rs_alloc(ndip
);
1253 error
= gfs2_glock_nq_init(sdp
->sd_rename_gl
, LM_ST_EXCLUSIVE
,
1258 if (S_ISDIR(ip
->i_inode
.i_mode
)) {
1260 /* don't move a dirctory into it's subdir */
1261 error
= gfs2_ok_to_move(ip
, ndip
);
1268 gfs2_holder_init(odip
->i_gl
, LM_ST_EXCLUSIVE
, 0, ghs
);
1270 gfs2_holder_init(ndip
->i_gl
, LM_ST_EXCLUSIVE
, 0, ghs
+ num_gh
);
1273 gfs2_holder_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, ghs
+ num_gh
);
1277 gfs2_holder_init(nip
->i_gl
, LM_ST_EXCLUSIVE
, 0, ghs
+ num_gh
);
1279 /* grab the resource lock for unlink flag twiddling
1280 * this is the case of the target file already existing
1281 * so we unlink before doing the rename
1283 nrgd
= gfs2_blk2rgrpd(sdp
, nip
->i_no_addr
, 1);
1285 gfs2_holder_init(nrgd
->rd_gl
, LM_ST_EXCLUSIVE
, 0, ghs
+ num_gh
++);
1288 for (x
= 0; x
< num_gh
; x
++) {
1289 error
= gfs2_glock_nq(ghs
+ x
);
1295 if (ip
->i_inode
.i_nlink
== 0)
1298 /* Check out the old directory */
1300 error
= gfs2_unlink_ok(odip
, &odentry
->d_name
, ip
);
1304 /* Check out the new directory */
1307 error
= gfs2_unlink_ok(ndip
, &ndentry
->d_name
, nip
);
1311 if (nip
->i_inode
.i_nlink
== 0) {
1316 if (S_ISDIR(nip
->i_inode
.i_mode
)) {
1317 if (nip
->i_entries
< 2) {
1318 gfs2_consist_inode(nip
);
1322 if (nip
->i_entries
> 2) {
1328 error
= gfs2_permission(ndir
, MAY_WRITE
| MAY_EXEC
);
1332 error
= gfs2_dir_check(ndir
, &ndentry
->d_name
, NULL
);
1344 if (!ndip
->i_inode
.i_nlink
) {
1348 if (ndip
->i_entries
== (u32
)-1) {
1352 if (S_ISDIR(ip
->i_inode
.i_mode
) &&
1353 ndip
->i_inode
.i_nlink
== (u32
)-1) {
1360 /* Check out the dir to be renamed */
1363 error
= gfs2_permission(odentry
->d_inode
, MAY_WRITE
);
1369 alloc_required
= gfs2_diradd_alloc_required(ndir
, &ndentry
->d_name
);
1370 error
= alloc_required
;
1374 if (alloc_required
) {
1375 error
= gfs2_quota_lock_check(ndip
);
1379 error
= gfs2_inplace_reserve(ndip
, sdp
->sd_max_dirres
);
1383 error
= gfs2_trans_begin(sdp
, sdp
->sd_max_dirres
+
1384 gfs2_rg_blocks(ndip
) +
1385 4 * RES_DINODE
+ 4 * RES_LEAF
+
1386 RES_STATFS
+ RES_QUOTA
+ 4, 0);
1390 error
= gfs2_trans_begin(sdp
, 4 * RES_DINODE
+
1391 5 * RES_LEAF
+ 4, 0);
1396 /* Remove the target file, if it exists */
1399 struct buffer_head
*bh
;
1400 error
= gfs2_meta_inode_buffer(nip
, &bh
);
1403 error
= gfs2_unlink_inode(ndip
, ndentry
, bh
);
1408 error
= gfs2_dir_mvino(ip
, &gfs2_qdotdot
, ndip
, DT_DIR
);
1412 struct buffer_head
*dibh
;
1413 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1416 ip
->i_inode
.i_ctime
= CURRENT_TIME
;
1417 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
1418 gfs2_dinode_out(ip
, dibh
->b_data
);
1422 error
= gfs2_dir_del(odip
, odentry
);
1426 error
= gfs2_dir_add(ndir
, &ndentry
->d_name
, ip
);
1431 gfs2_trans_end(sdp
);
1434 gfs2_inplace_release(ndip
);
1437 gfs2_quota_unlock(ndip
);
1440 gfs2_glock_dq(ghs
+ x
);
1441 gfs2_holder_uninit(ghs
+ x
);
1445 gfs2_glock_dq_uninit(&r_gh
);
1451 * gfs2_follow_link - Follow a symbolic link
1452 * @dentry: The dentry of the link
1453 * @nd: Data that we pass to vfs_follow_link()
1455 * This can handle symlinks of any size.
1457 * Returns: 0 on success or error code
1460 static void *gfs2_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
1462 struct gfs2_inode
*ip
= GFS2_I(dentry
->d_inode
);
1463 struct gfs2_holder i_gh
;
1464 struct buffer_head
*dibh
;
1469 gfs2_holder_init(ip
->i_gl
, LM_ST_SHARED
, 0, &i_gh
);
1470 error
= gfs2_glock_nq(&i_gh
);
1472 gfs2_holder_uninit(&i_gh
);
1473 nd_set_link(nd
, ERR_PTR(error
));
1477 size
= (unsigned int)i_size_read(&ip
->i_inode
);
1479 gfs2_consist_inode(ip
);
1480 buf
= ERR_PTR(-EIO
);
1484 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1486 buf
= ERR_PTR(error
);
1490 buf
= kzalloc(size
+ 1, GFP_NOFS
);
1492 buf
= ERR_PTR(-ENOMEM
);
1494 memcpy(buf
, dibh
->b_data
+ sizeof(struct gfs2_dinode
), size
);
1497 gfs2_glock_dq_uninit(&i_gh
);
1498 nd_set_link(nd
, buf
);
1502 static void gfs2_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *p
)
1504 char *s
= nd_get_link(nd
);
1512 * @mask: The mask to be tested
1513 * @flags: Indicates whether this is an RCU path walk or not
1515 * This may be called from the VFS directly, or from within GFS2 with the
1516 * inode locked, so we look to see if the glock is already locked and only
1517 * lock the glock if its not already been done.
1522 int gfs2_permission(struct inode
*inode
, int mask
)
1524 struct gfs2_inode
*ip
;
1525 struct gfs2_holder i_gh
;
1531 if (gfs2_glock_is_locked_by_me(ip
->i_gl
) == NULL
) {
1532 if (mask
& MAY_NOT_BLOCK
)
1534 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
, &i_gh
);
1540 if ((mask
& MAY_WRITE
) && IS_IMMUTABLE(inode
))
1543 error
= generic_permission(inode
, mask
);
1545 gfs2_glock_dq_uninit(&i_gh
);
1550 static int __gfs2_setattr_simple(struct inode
*inode
, struct iattr
*attr
)
1552 setattr_copy(inode
, attr
);
1553 mark_inode_dirty(inode
);
1558 * gfs2_setattr_simple -
1565 int gfs2_setattr_simple(struct inode
*inode
, struct iattr
*attr
)
1569 if (current
->journal_info
)
1570 return __gfs2_setattr_simple(inode
, attr
);
1572 error
= gfs2_trans_begin(GFS2_SB(inode
), RES_DINODE
, 0);
1576 error
= __gfs2_setattr_simple(inode
, attr
);
1577 gfs2_trans_end(GFS2_SB(inode
));
1581 static int setattr_chown(struct inode
*inode
, struct iattr
*attr
)
1583 struct gfs2_inode
*ip
= GFS2_I(inode
);
1584 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
1585 u32 ouid
, ogid
, nuid
, ngid
;
1588 ouid
= inode
->i_uid
;
1589 ogid
= inode
->i_gid
;
1590 nuid
= attr
->ia_uid
;
1591 ngid
= attr
->ia_gid
;
1593 if (!(attr
->ia_valid
& ATTR_UID
) || ouid
== nuid
)
1594 ouid
= nuid
= NO_QUOTA_CHANGE
;
1595 if (!(attr
->ia_valid
& ATTR_GID
) || ogid
== ngid
)
1596 ogid
= ngid
= NO_QUOTA_CHANGE
;
1598 error
= gfs2_quota_lock(ip
, nuid
, ngid
);
1602 if (ouid
!= NO_QUOTA_CHANGE
|| ogid
!= NO_QUOTA_CHANGE
) {
1603 error
= gfs2_quota_check(ip
, nuid
, ngid
);
1608 error
= gfs2_trans_begin(sdp
, RES_DINODE
+ 2 * RES_QUOTA
, 0);
1612 error
= gfs2_setattr_simple(inode
, attr
);
1616 if (ouid
!= NO_QUOTA_CHANGE
|| ogid
!= NO_QUOTA_CHANGE
) {
1617 u64 blocks
= gfs2_get_inode_blocks(&ip
->i_inode
);
1618 gfs2_quota_change(ip
, -blocks
, ouid
, ogid
);
1619 gfs2_quota_change(ip
, blocks
, nuid
, ngid
);
1623 gfs2_trans_end(sdp
);
1625 gfs2_quota_unlock(ip
);
1630 * gfs2_setattr - Change attributes on an inode
1631 * @dentry: The dentry which is changing
1632 * @attr: The structure describing the change
1634 * The VFS layer wants to change one or more of an inodes attributes. Write
1635 * that change out to disk.
1640 static int gfs2_setattr(struct dentry
*dentry
, struct iattr
*attr
)
1642 struct inode
*inode
= dentry
->d_inode
;
1643 struct gfs2_inode
*ip
= GFS2_I(inode
);
1644 struct gfs2_holder i_gh
;
1647 error
= gfs2_rs_alloc(ip
);
1651 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &i_gh
);
1656 if (IS_IMMUTABLE(inode
) || IS_APPEND(inode
))
1659 error
= inode_change_ok(inode
, attr
);
1663 if (attr
->ia_valid
& ATTR_SIZE
)
1664 error
= gfs2_setattr_size(inode
, attr
->ia_size
);
1665 else if (attr
->ia_valid
& (ATTR_UID
| ATTR_GID
))
1666 error
= setattr_chown(inode
, attr
);
1667 else if ((attr
->ia_valid
& ATTR_MODE
) && IS_POSIXACL(inode
))
1668 error
= gfs2_acl_chmod(ip
, attr
);
1670 error
= gfs2_setattr_simple(inode
, attr
);
1674 mark_inode_dirty(inode
);
1675 gfs2_glock_dq_uninit(&i_gh
);
1680 * gfs2_getattr - Read out an inode's attributes
1681 * @mnt: The vfsmount the inode is being accessed from
1682 * @dentry: The dentry to stat
1683 * @stat: The inode's stats
1685 * This may be called from the VFS directly, or from within GFS2 with the
1686 * inode locked, so we look to see if the glock is already locked and only
1687 * lock the glock if its not already been done. Note that its the NFS
1688 * readdirplus operation which causes this to be called (from filldir)
1689 * with the glock already held.
1694 static int gfs2_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
1697 struct inode
*inode
= dentry
->d_inode
;
1698 struct gfs2_inode
*ip
= GFS2_I(inode
);
1699 struct gfs2_holder gh
;
1703 if (gfs2_glock_is_locked_by_me(ip
->i_gl
) == NULL
) {
1704 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
, &gh
);
1710 generic_fillattr(inode
, stat
);
1712 gfs2_glock_dq_uninit(&gh
);
1717 static int gfs2_setxattr(struct dentry
*dentry
, const char *name
,
1718 const void *data
, size_t size
, int flags
)
1720 struct inode
*inode
= dentry
->d_inode
;
1721 struct gfs2_inode
*ip
= GFS2_I(inode
);
1722 struct gfs2_holder gh
;
1725 gfs2_holder_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
1726 ret
= gfs2_glock_nq(&gh
);
1728 ret
= generic_setxattr(dentry
, name
, data
, size
, flags
);
1731 gfs2_holder_uninit(&gh
);
1735 static ssize_t
gfs2_getxattr(struct dentry
*dentry
, const char *name
,
1736 void *data
, size_t size
)
1738 struct inode
*inode
= dentry
->d_inode
;
1739 struct gfs2_inode
*ip
= GFS2_I(inode
);
1740 struct gfs2_holder gh
;
1743 gfs2_holder_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
, &gh
);
1744 ret
= gfs2_glock_nq(&gh
);
1746 ret
= generic_getxattr(dentry
, name
, data
, size
);
1749 gfs2_holder_uninit(&gh
);
1753 static int gfs2_removexattr(struct dentry
*dentry
, const char *name
)
1755 struct inode
*inode
= dentry
->d_inode
;
1756 struct gfs2_inode
*ip
= GFS2_I(inode
);
1757 struct gfs2_holder gh
;
1760 gfs2_holder_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
1761 ret
= gfs2_glock_nq(&gh
);
1763 ret
= generic_removexattr(dentry
, name
);
1766 gfs2_holder_uninit(&gh
);
1770 static int gfs2_fiemap(struct inode
*inode
, struct fiemap_extent_info
*fieinfo
,
1773 struct gfs2_inode
*ip
= GFS2_I(inode
);
1774 struct gfs2_holder gh
;
1777 ret
= fiemap_check_flags(fieinfo
, FIEMAP_FLAG_SYNC
);
1781 mutex_lock(&inode
->i_mutex
);
1783 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, 0, &gh
);
1787 if (gfs2_is_stuffed(ip
)) {
1788 u64 phys
= ip
->i_no_addr
<< inode
->i_blkbits
;
1789 u64 size
= i_size_read(inode
);
1790 u32 flags
= FIEMAP_EXTENT_LAST
|FIEMAP_EXTENT_NOT_ALIGNED
|
1791 FIEMAP_EXTENT_DATA_INLINE
;
1792 phys
+= sizeof(struct gfs2_dinode
);
1794 if (start
+ len
> size
)
1797 ret
= fiemap_fill_next_extent(fieinfo
, start
, phys
,
1802 ret
= __generic_block_fiemap(inode
, fieinfo
, start
, len
,
1806 gfs2_glock_dq_uninit(&gh
);
1808 mutex_unlock(&inode
->i_mutex
);
1812 const struct inode_operations gfs2_file_iops
= {
1813 .permission
= gfs2_permission
,
1814 .setattr
= gfs2_setattr
,
1815 .getattr
= gfs2_getattr
,
1816 .setxattr
= gfs2_setxattr
,
1817 .getxattr
= gfs2_getxattr
,
1818 .listxattr
= gfs2_listxattr
,
1819 .removexattr
= gfs2_removexattr
,
1820 .fiemap
= gfs2_fiemap
,
1821 .get_acl
= gfs2_get_acl
,
1824 const struct inode_operations gfs2_dir_iops
= {
1825 .create
= gfs2_create
,
1826 .lookup
= gfs2_lookup
,
1828 .unlink
= gfs2_unlink
,
1829 .symlink
= gfs2_symlink
,
1830 .mkdir
= gfs2_mkdir
,
1831 .rmdir
= gfs2_unlink
,
1832 .mknod
= gfs2_mknod
,
1833 .rename
= gfs2_rename
,
1834 .permission
= gfs2_permission
,
1835 .setattr
= gfs2_setattr
,
1836 .getattr
= gfs2_getattr
,
1837 .setxattr
= gfs2_setxattr
,
1838 .getxattr
= gfs2_getxattr
,
1839 .listxattr
= gfs2_listxattr
,
1840 .removexattr
= gfs2_removexattr
,
1841 .fiemap
= gfs2_fiemap
,
1842 .get_acl
= gfs2_get_acl
,
1845 const struct inode_operations gfs2_symlink_iops
= {
1846 .readlink
= generic_readlink
,
1847 .follow_link
= gfs2_follow_link
,
1848 .put_link
= gfs2_put_link
,
1849 .permission
= gfs2_permission
,
1850 .setattr
= gfs2_setattr
,
1851 .getattr
= gfs2_getattr
,
1852 .setxattr
= gfs2_setxattr
,
1853 .getxattr
= gfs2_getxattr
,
1854 .listxattr
= gfs2_listxattr
,
1855 .removexattr
= gfs2_removexattr
,
1856 .fiemap
= gfs2_fiemap
,
1857 .get_acl
= gfs2_get_acl
,