2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "xfs_trans.h"
27 #include "xfs_alloc.h"
28 #include "xfs_quota.h"
29 #include "xfs_mount.h"
30 #include "xfs_bmap_btree.h"
31 #include "xfs_dinode.h"
32 #include "xfs_inode.h"
34 #include "xfs_rtalloc.h"
35 #include "xfs_error.h"
36 #include "xfs_itable.h"
39 #include "xfs_buf_item.h"
40 #include "xfs_utils.h"
41 #include "xfs_vnodeops.h"
42 #include "xfs_trace.h"
44 #include <linux/capability.h>
45 #include <linux/xattr.h>
46 #include <linux/namei.h>
47 #include <linux/posix_acl.h>
48 #include <linux/security.h>
49 #include <linux/falloc.h>
50 #include <linux/fiemap.h>
51 #include <linux/slab.h>
54 * Bring the timestamps in the XFS inode uptodate.
56 * Used before writing the inode to disk.
59 xfs_synchronize_times(
62 struct inode
*inode
= VFS_I(ip
);
64 ip
->i_d
.di_atime
.t_sec
= (__int32_t
)inode
->i_atime
.tv_sec
;
65 ip
->i_d
.di_atime
.t_nsec
= (__int32_t
)inode
->i_atime
.tv_nsec
;
66 ip
->i_d
.di_ctime
.t_sec
= (__int32_t
)inode
->i_ctime
.tv_sec
;
67 ip
->i_d
.di_ctime
.t_nsec
= (__int32_t
)inode
->i_ctime
.tv_nsec
;
68 ip
->i_d
.di_mtime
.t_sec
= (__int32_t
)inode
->i_mtime
.tv_sec
;
69 ip
->i_d
.di_mtime
.t_nsec
= (__int32_t
)inode
->i_mtime
.tv_nsec
;
73 * If the linux inode is valid, mark it dirty.
74 * Used when commiting a dirty inode into a transaction so that
75 * the inode will get written back by the linux code
78 xfs_mark_inode_dirty_sync(
81 struct inode
*inode
= VFS_I(ip
);
83 if (!(inode
->i_state
& (I_WILL_FREE
|I_FREEING
)))
84 mark_inode_dirty_sync(inode
);
91 struct inode
*inode
= VFS_I(ip
);
93 if (!(inode
->i_state
& (I_WILL_FREE
|I_FREEING
)))
94 mark_inode_dirty(inode
);
98 * Change the requested timestamp in the given inode.
99 * We don't lock across timestamp updates, and we don't log them but
100 * we do record the fact that there is dirty information in core.
107 struct inode
*inode
= VFS_I(ip
);
111 tv
= current_fs_time(inode
->i_sb
);
113 if ((flags
& XFS_ICHGTIME_MOD
) &&
114 !timespec_equal(&inode
->i_mtime
, &tv
)) {
118 if ((flags
& XFS_ICHGTIME_CHG
) &&
119 !timespec_equal(&inode
->i_ctime
, &tv
)) {
125 * Update complete - now make sure everyone knows that the inode
129 xfs_mark_inode_dirty_sync(ip
);
133 * Hook in SELinux. This is not quite correct yet, what we really need
134 * here (as we do for default ACLs) is a mechanism by which creation of
135 * these attrs can be journalled at inode creation time (along with the
136 * inode, of course, such that log replay can't cause these to be lost).
143 struct xfs_inode
*ip
= XFS_I(inode
);
149 error
= security_inode_init_security(inode
, dir
, (char **)&name
,
152 if (error
== -EOPNOTSUPP
)
157 error
= xfs_attr_set(ip
, name
, value
, length
, ATTR_SECURE
);
166 struct xfs_name
*namep
,
167 struct dentry
*dentry
)
169 namep
->name
= dentry
->d_name
.name
;
170 namep
->len
= dentry
->d_name
.len
;
177 struct dentry
*dentry
)
179 struct xfs_name teardown
;
182 * If we can't add the ACL or we fail in
183 * xfs_init_security we must back out.
184 * ENOSPC can hit here, among other things.
186 xfs_dentry_to_name(&teardown
, dentry
);
188 xfs_remove(XFS_I(dir
), &teardown
, XFS_I(inode
));
195 struct dentry
*dentry
,
200 struct xfs_inode
*ip
= NULL
;
201 struct posix_acl
*default_acl
= NULL
;
202 struct xfs_name name
;
206 * Irix uses Missed'em'V split, but doesn't want to see
207 * the upper 5 bits of (14bit) major.
209 if (S_ISCHR(mode
) || S_ISBLK(mode
)) {
210 if (unlikely(!sysv_valid_dev(rdev
) || MAJOR(rdev
) & ~0x1ff))
212 rdev
= sysv_encode_dev(rdev
);
217 if (IS_POSIXACL(dir
)) {
218 default_acl
= xfs_get_acl(dir
, ACL_TYPE_DEFAULT
);
219 if (IS_ERR(default_acl
))
220 return -PTR_ERR(default_acl
);
223 mode
&= ~current_umask();
226 xfs_dentry_to_name(&name
, dentry
);
227 error
= xfs_create(XFS_I(dir
), &name
, mode
, rdev
, &ip
, NULL
);
233 error
= xfs_init_security(inode
, dir
);
235 goto out_cleanup_inode
;
238 error
= -xfs_inherit_acl(inode
, default_acl
);
240 goto out_cleanup_inode
;
241 posix_acl_release(default_acl
);
245 d_instantiate(dentry
, inode
);
249 xfs_cleanup_inode(dir
, inode
, dentry
);
251 posix_acl_release(default_acl
);
258 struct dentry
*dentry
,
260 struct nameidata
*nd
)
262 return xfs_vn_mknod(dir
, dentry
, mode
, 0);
268 struct dentry
*dentry
,
271 return xfs_vn_mknod(dir
, dentry
, mode
|S_IFDIR
, 0);
274 STATIC
struct dentry
*
277 struct dentry
*dentry
,
278 struct nameidata
*nd
)
280 struct xfs_inode
*cip
;
281 struct xfs_name name
;
284 if (dentry
->d_name
.len
>= MAXNAMELEN
)
285 return ERR_PTR(-ENAMETOOLONG
);
287 xfs_dentry_to_name(&name
, dentry
);
288 error
= xfs_lookup(XFS_I(dir
), &name
, &cip
, NULL
);
289 if (unlikely(error
)) {
290 if (unlikely(error
!= ENOENT
))
291 return ERR_PTR(-error
);
296 return d_splice_alias(VFS_I(cip
), dentry
);
299 STATIC
struct dentry
*
302 struct dentry
*dentry
,
303 struct nameidata
*nd
)
305 struct xfs_inode
*ip
;
306 struct xfs_name xname
;
307 struct xfs_name ci_name
;
311 if (dentry
->d_name
.len
>= MAXNAMELEN
)
312 return ERR_PTR(-ENAMETOOLONG
);
314 xfs_dentry_to_name(&xname
, dentry
);
315 error
= xfs_lookup(XFS_I(dir
), &xname
, &ip
, &ci_name
);
316 if (unlikely(error
)) {
317 if (unlikely(error
!= ENOENT
))
318 return ERR_PTR(-error
);
320 * call d_add(dentry, NULL) here when d_drop_negative_children
321 * is called in xfs_vn_mknod (ie. allow negative dentries
322 * with CI filesystems).
327 /* if exact match, just splice and exit */
329 return d_splice_alias(VFS_I(ip
), dentry
);
331 /* else case-insensitive match... */
332 dname
.name
= ci_name
.name
;
333 dname
.len
= ci_name
.len
;
334 dentry
= d_add_ci(dentry
, VFS_I(ip
), &dname
);
335 kmem_free(ci_name
.name
);
341 struct dentry
*old_dentry
,
343 struct dentry
*dentry
)
345 struct inode
*inode
= old_dentry
->d_inode
;
346 struct xfs_name name
;
349 xfs_dentry_to_name(&name
, dentry
);
351 error
= xfs_link(XFS_I(dir
), XFS_I(inode
), &name
);
355 atomic_inc(&inode
->i_count
);
356 d_instantiate(dentry
, inode
);
363 struct dentry
*dentry
)
365 struct xfs_name name
;
368 xfs_dentry_to_name(&name
, dentry
);
370 error
= -xfs_remove(XFS_I(dir
), &name
, XFS_I(dentry
->d_inode
));
375 * With unlink, the VFS makes the dentry "negative": no inode,
376 * but still hashed. This is incompatible with case-insensitive
377 * mode, so invalidate (unhash) the dentry in CI-mode.
379 if (xfs_sb_version_hasasciici(&XFS_M(dir
->i_sb
)->m_sb
))
380 d_invalidate(dentry
);
387 struct dentry
*dentry
,
391 struct xfs_inode
*cip
= NULL
;
392 struct xfs_name name
;
397 (irix_symlink_mode
? 0777 & ~current_umask() : S_IRWXUGO
);
398 xfs_dentry_to_name(&name
, dentry
);
400 error
= xfs_symlink(XFS_I(dir
), &name
, symname
, mode
, &cip
, NULL
);
406 error
= xfs_init_security(inode
, dir
);
408 goto out_cleanup_inode
;
410 d_instantiate(dentry
, inode
);
414 xfs_cleanup_inode(dir
, inode
, dentry
);
422 struct dentry
*odentry
,
424 struct dentry
*ndentry
)
426 struct inode
*new_inode
= ndentry
->d_inode
;
427 struct xfs_name oname
;
428 struct xfs_name nname
;
430 xfs_dentry_to_name(&oname
, odentry
);
431 xfs_dentry_to_name(&nname
, ndentry
);
433 return -xfs_rename(XFS_I(odir
), &oname
, XFS_I(odentry
->d_inode
),
434 XFS_I(ndir
), &nname
, new_inode
?
435 XFS_I(new_inode
) : NULL
);
439 * careful here - this function can get called recursively, so
440 * we need to be very careful about how much stack we use.
441 * uio is kmalloced for this reason...
445 struct dentry
*dentry
,
446 struct nameidata
*nd
)
451 link
= kmalloc(MAXPATHLEN
+1, GFP_KERNEL
);
455 error
= -xfs_readlink(XFS_I(dentry
->d_inode
), link
);
459 nd_set_link(nd
, link
);
465 nd_set_link(nd
, ERR_PTR(error
));
471 struct dentry
*dentry
,
472 struct nameidata
*nd
,
475 char *s
= nd_get_link(nd
);
483 struct vfsmount
*mnt
,
484 struct dentry
*dentry
,
487 struct inode
*inode
= dentry
->d_inode
;
488 struct xfs_inode
*ip
= XFS_I(inode
);
489 struct xfs_mount
*mp
= ip
->i_mount
;
491 trace_xfs_getattr(ip
);
493 if (XFS_FORCED_SHUTDOWN(mp
))
494 return XFS_ERROR(EIO
);
496 stat
->size
= XFS_ISIZE(ip
);
497 stat
->dev
= inode
->i_sb
->s_dev
;
498 stat
->mode
= ip
->i_d
.di_mode
;
499 stat
->nlink
= ip
->i_d
.di_nlink
;
500 stat
->uid
= ip
->i_d
.di_uid
;
501 stat
->gid
= ip
->i_d
.di_gid
;
502 stat
->ino
= ip
->i_ino
;
503 stat
->atime
= inode
->i_atime
;
504 stat
->mtime
= inode
->i_mtime
;
505 stat
->ctime
= inode
->i_ctime
;
507 XFS_FSB_TO_BB(mp
, ip
->i_d
.di_nblocks
+ ip
->i_delayed_blks
);
510 switch (inode
->i_mode
& S_IFMT
) {
513 stat
->blksize
= BLKDEV_IOSIZE
;
514 stat
->rdev
= MKDEV(sysv_major(ip
->i_df
.if_u2
.if_rdev
) & 0x1ff,
515 sysv_minor(ip
->i_df
.if_u2
.if_rdev
));
518 if (XFS_IS_REALTIME_INODE(ip
)) {
520 * If the file blocks are being allocated from a
521 * realtime volume, then return the inode's realtime
522 * extent size or the realtime volume's extent size.
525 xfs_get_extsz_hint(ip
) << mp
->m_sb
.sb_blocklog
;
527 stat
->blksize
= xfs_preferred_iosize(mp
);
537 struct dentry
*dentry
,
540 return -xfs_setattr(XFS_I(dentry
->d_inode
), iattr
, 0);
553 xfs_inode_t
*ip
= XFS_I(inode
);
555 /* preallocation on directories not yet supported */
557 if (S_ISDIR(inode
->i_mode
))
564 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
566 /* check the new inode size is valid before allocating */
567 if (!(mode
& FALLOC_FL_KEEP_SIZE
) &&
568 offset
+ len
> i_size_read(inode
)) {
569 new_size
= offset
+ len
;
570 error
= inode_newsize_ok(inode
, new_size
);
575 error
= -xfs_change_file_space(ip
, XFS_IOC_RESVSP
, &bf
,
580 /* Change file size if needed */
584 iattr
.ia_valid
= ATTR_SIZE
;
585 iattr
.ia_size
= new_size
;
586 error
= -xfs_setattr(ip
, &iattr
, XFS_ATTR_NOLOCK
);
590 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
595 #define XFS_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)
598 * Call fiemap helper to fill in user data.
599 * Returns positive errors to xfs_getbmap.
604 struct getbmapx
*bmv
,
608 struct fiemap_extent_info
*fieinfo
= *arg
;
609 u32 fiemap_flags
= 0;
610 u64 logical
, physical
, length
;
612 /* Do nothing for a hole */
613 if (bmv
->bmv_block
== -1LL)
616 logical
= BBTOB(bmv
->bmv_offset
);
617 physical
= BBTOB(bmv
->bmv_block
);
618 length
= BBTOB(bmv
->bmv_length
);
620 if (bmv
->bmv_oflags
& BMV_OF_PREALLOC
)
621 fiemap_flags
|= FIEMAP_EXTENT_UNWRITTEN
;
622 else if (bmv
->bmv_oflags
& BMV_OF_DELALLOC
) {
623 fiemap_flags
|= FIEMAP_EXTENT_DELALLOC
;
624 physical
= 0; /* no block yet */
626 if (bmv
->bmv_oflags
& BMV_OF_LAST
)
627 fiemap_flags
|= FIEMAP_EXTENT_LAST
;
629 error
= fiemap_fill_next_extent(fieinfo
, logical
, physical
,
630 length
, fiemap_flags
);
633 *full
= 1; /* user array now full */
642 struct fiemap_extent_info
*fieinfo
,
646 xfs_inode_t
*ip
= XFS_I(inode
);
650 error
= fiemap_check_flags(fieinfo
, XFS_FIEMAP_FLAGS
);
654 /* Set up bmap header for xfs internal routine */
655 bm
.bmv_offset
= BTOBB(start
);
656 /* Special case for whole file */
657 if (length
== FIEMAP_MAX_OFFSET
)
658 bm
.bmv_length
= -1LL;
660 bm
.bmv_length
= BTOBB(length
);
662 /* We add one because in getbmap world count includes the header */
663 bm
.bmv_count
= !fieinfo
->fi_extents_max
? MAXEXTNUM
:
664 fieinfo
->fi_extents_max
+ 1;
665 bm
.bmv_count
= min_t(__s32
, bm
.bmv_count
,
666 (PAGE_SIZE
* 16 / sizeof(struct getbmapx
)));
667 bm
.bmv_iflags
= BMV_IF_PREALLOC
| BMV_IF_NO_HOLES
;
668 if (fieinfo
->fi_flags
& FIEMAP_FLAG_XATTR
)
669 bm
.bmv_iflags
|= BMV_IF_ATTRFORK
;
670 if (!(fieinfo
->fi_flags
& FIEMAP_FLAG_SYNC
))
671 bm
.bmv_iflags
|= BMV_IF_DELALLOC
;
673 error
= xfs_getbmap(ip
, &bm
, xfs_fiemap_format
, fieinfo
);
680 static const struct inode_operations xfs_inode_operations
= {
681 .check_acl
= xfs_check_acl
,
682 .getattr
= xfs_vn_getattr
,
683 .setattr
= xfs_vn_setattr
,
684 .setxattr
= generic_setxattr
,
685 .getxattr
= generic_getxattr
,
686 .removexattr
= generic_removexattr
,
687 .listxattr
= xfs_vn_listxattr
,
688 .fallocate
= xfs_vn_fallocate
,
689 .fiemap
= xfs_vn_fiemap
,
692 static const struct inode_operations xfs_dir_inode_operations
= {
693 .create
= xfs_vn_create
,
694 .lookup
= xfs_vn_lookup
,
696 .unlink
= xfs_vn_unlink
,
697 .symlink
= xfs_vn_symlink
,
698 .mkdir
= xfs_vn_mkdir
,
700 * Yes, XFS uses the same method for rmdir and unlink.
702 * There are some subtile differences deeper in the code,
703 * but we use S_ISDIR to check for those.
705 .rmdir
= xfs_vn_unlink
,
706 .mknod
= xfs_vn_mknod
,
707 .rename
= xfs_vn_rename
,
708 .check_acl
= xfs_check_acl
,
709 .getattr
= xfs_vn_getattr
,
710 .setattr
= xfs_vn_setattr
,
711 .setxattr
= generic_setxattr
,
712 .getxattr
= generic_getxattr
,
713 .removexattr
= generic_removexattr
,
714 .listxattr
= xfs_vn_listxattr
,
717 static const struct inode_operations xfs_dir_ci_inode_operations
= {
718 .create
= xfs_vn_create
,
719 .lookup
= xfs_vn_ci_lookup
,
721 .unlink
= xfs_vn_unlink
,
722 .symlink
= xfs_vn_symlink
,
723 .mkdir
= xfs_vn_mkdir
,
725 * Yes, XFS uses the same method for rmdir and unlink.
727 * There are some subtile differences deeper in the code,
728 * but we use S_ISDIR to check for those.
730 .rmdir
= xfs_vn_unlink
,
731 .mknod
= xfs_vn_mknod
,
732 .rename
= xfs_vn_rename
,
733 .check_acl
= xfs_check_acl
,
734 .getattr
= xfs_vn_getattr
,
735 .setattr
= xfs_vn_setattr
,
736 .setxattr
= generic_setxattr
,
737 .getxattr
= generic_getxattr
,
738 .removexattr
= generic_removexattr
,
739 .listxattr
= xfs_vn_listxattr
,
742 static const struct inode_operations xfs_symlink_inode_operations
= {
743 .readlink
= generic_readlink
,
744 .follow_link
= xfs_vn_follow_link
,
745 .put_link
= xfs_vn_put_link
,
746 .check_acl
= xfs_check_acl
,
747 .getattr
= xfs_vn_getattr
,
748 .setattr
= xfs_vn_setattr
,
749 .setxattr
= generic_setxattr
,
750 .getxattr
= generic_getxattr
,
751 .removexattr
= generic_removexattr
,
752 .listxattr
= xfs_vn_listxattr
,
756 xfs_diflags_to_iflags(
758 struct xfs_inode
*ip
)
760 if (ip
->i_d
.di_flags
& XFS_DIFLAG_IMMUTABLE
)
761 inode
->i_flags
|= S_IMMUTABLE
;
763 inode
->i_flags
&= ~S_IMMUTABLE
;
764 if (ip
->i_d
.di_flags
& XFS_DIFLAG_APPEND
)
765 inode
->i_flags
|= S_APPEND
;
767 inode
->i_flags
&= ~S_APPEND
;
768 if (ip
->i_d
.di_flags
& XFS_DIFLAG_SYNC
)
769 inode
->i_flags
|= S_SYNC
;
771 inode
->i_flags
&= ~S_SYNC
;
772 if (ip
->i_d
.di_flags
& XFS_DIFLAG_NOATIME
)
773 inode
->i_flags
|= S_NOATIME
;
775 inode
->i_flags
&= ~S_NOATIME
;
779 * Initialize the Linux inode, set up the operation vectors and
782 * When reading existing inodes from disk this is called directly
783 * from xfs_iget, when creating a new inode it is called from
784 * xfs_ialloc after setting up the inode.
786 * We are always called with an uninitialised linux inode here.
787 * We need to initialise the necessary fields and take a reference
792 struct xfs_inode
*ip
)
794 struct inode
*inode
= &ip
->i_vnode
;
796 inode
->i_ino
= ip
->i_ino
;
797 inode
->i_state
= I_NEW
;
798 inode_add_to_lists(ip
->i_mount
->m_super
, inode
);
800 inode
->i_mode
= ip
->i_d
.di_mode
;
801 inode
->i_nlink
= ip
->i_d
.di_nlink
;
802 inode
->i_uid
= ip
->i_d
.di_uid
;
803 inode
->i_gid
= ip
->i_d
.di_gid
;
805 switch (inode
->i_mode
& S_IFMT
) {
809 MKDEV(sysv_major(ip
->i_df
.if_u2
.if_rdev
) & 0x1ff,
810 sysv_minor(ip
->i_df
.if_u2
.if_rdev
));
817 inode
->i_generation
= ip
->i_d
.di_gen
;
818 i_size_write(inode
, ip
->i_d
.di_size
);
819 inode
->i_atime
.tv_sec
= ip
->i_d
.di_atime
.t_sec
;
820 inode
->i_atime
.tv_nsec
= ip
->i_d
.di_atime
.t_nsec
;
821 inode
->i_mtime
.tv_sec
= ip
->i_d
.di_mtime
.t_sec
;
822 inode
->i_mtime
.tv_nsec
= ip
->i_d
.di_mtime
.t_nsec
;
823 inode
->i_ctime
.tv_sec
= ip
->i_d
.di_ctime
.t_sec
;
824 inode
->i_ctime
.tv_nsec
= ip
->i_d
.di_ctime
.t_nsec
;
825 xfs_diflags_to_iflags(inode
, ip
);
827 switch (inode
->i_mode
& S_IFMT
) {
829 inode
->i_op
= &xfs_inode_operations
;
830 inode
->i_fop
= &xfs_file_operations
;
831 inode
->i_mapping
->a_ops
= &xfs_address_space_operations
;
834 if (xfs_sb_version_hasasciici(&XFS_M(inode
->i_sb
)->m_sb
))
835 inode
->i_op
= &xfs_dir_ci_inode_operations
;
837 inode
->i_op
= &xfs_dir_inode_operations
;
838 inode
->i_fop
= &xfs_dir_file_operations
;
841 inode
->i_op
= &xfs_symlink_inode_operations
;
842 if (!(ip
->i_df
.if_flags
& XFS_IFINLINE
))
843 inode
->i_mapping
->a_ops
= &xfs_address_space_operations
;
846 inode
->i_op
= &xfs_inode_operations
;
847 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
851 xfs_iflags_clear(ip
, XFS_INEW
);
854 unlock_new_inode(inode
);