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"
28 #include "xfs_alloc.h"
29 #include "xfs_dmapi.h"
30 #include "xfs_quota.h"
31 #include "xfs_mount.h"
32 #include "xfs_bmap_btree.h"
33 #include "xfs_alloc_btree.h"
34 #include "xfs_ialloc_btree.h"
35 #include "xfs_dir2_sf.h"
36 #include "xfs_attr_sf.h"
37 #include "xfs_dinode.h"
38 #include "xfs_inode.h"
40 #include "xfs_btree.h"
41 #include "xfs_ialloc.h"
42 #include "xfs_rtalloc.h"
43 #include "xfs_error.h"
44 #include "xfs_itable.h"
47 #include "xfs_buf_item.h"
48 #include "xfs_utils.h"
49 #include "xfs_vnodeops.h"
50 #include "xfs_trace.h"
52 #include <linux/capability.h>
53 #include <linux/xattr.h>
54 #include <linux/namei.h>
55 #include <linux/posix_acl.h>
56 #include <linux/security.h>
57 #include <linux/falloc.h>
58 #include <linux/fiemap.h>
61 * Bring the timestamps in the XFS inode uptodate.
63 * Used before writing the inode to disk.
66 xfs_synchronize_times(
69 struct inode
*inode
= VFS_I(ip
);
71 ip
->i_d
.di_atime
.t_sec
= (__int32_t
)inode
->i_atime
.tv_sec
;
72 ip
->i_d
.di_atime
.t_nsec
= (__int32_t
)inode
->i_atime
.tv_nsec
;
73 ip
->i_d
.di_ctime
.t_sec
= (__int32_t
)inode
->i_ctime
.tv_sec
;
74 ip
->i_d
.di_ctime
.t_nsec
= (__int32_t
)inode
->i_ctime
.tv_nsec
;
75 ip
->i_d
.di_mtime
.t_sec
= (__int32_t
)inode
->i_mtime
.tv_sec
;
76 ip
->i_d
.di_mtime
.t_nsec
= (__int32_t
)inode
->i_mtime
.tv_nsec
;
80 * If the linux inode is valid, mark it dirty.
81 * Used when commiting a dirty inode into a transaction so that
82 * the inode will get written back by the linux code
85 xfs_mark_inode_dirty_sync(
88 struct inode
*inode
= VFS_I(ip
);
90 if (!(inode
->i_state
& (I_WILL_FREE
|I_FREEING
|I_CLEAR
)))
91 mark_inode_dirty_sync(inode
);
98 struct inode
*inode
= VFS_I(ip
);
100 if (!(inode
->i_state
& (I_WILL_FREE
|I_FREEING
|I_CLEAR
)))
101 mark_inode_dirty(inode
);
105 * Change the requested timestamp in the given inode.
106 * We don't lock across timestamp updates, and we don't log them but
107 * we do record the fact that there is dirty information in core.
114 struct inode
*inode
= VFS_I(ip
);
118 tv
= current_fs_time(inode
->i_sb
);
120 if ((flags
& XFS_ICHGTIME_MOD
) &&
121 !timespec_equal(&inode
->i_mtime
, &tv
)) {
125 if ((flags
& XFS_ICHGTIME_CHG
) &&
126 !timespec_equal(&inode
->i_ctime
, &tv
)) {
132 * Update complete - now make sure everyone knows that the inode
136 xfs_mark_inode_dirty_sync(ip
);
140 * Hook in SELinux. This is not quite correct yet, what we really need
141 * here (as we do for default ACLs) is a mechanism by which creation of
142 * these attrs can be journalled at inode creation time (along with the
143 * inode, of course, such that log replay can't cause these to be lost).
150 struct xfs_inode
*ip
= XFS_I(inode
);
156 error
= security_inode_init_security(inode
, dir
, (char **)&name
,
159 if (error
== -EOPNOTSUPP
)
164 error
= xfs_attr_set(ip
, name
, value
, length
, ATTR_SECURE
);
173 struct xfs_name
*namep
,
174 struct dentry
*dentry
)
176 namep
->name
= dentry
->d_name
.name
;
177 namep
->len
= dentry
->d_name
.len
;
184 struct dentry
*dentry
)
186 struct xfs_name teardown
;
189 * If we can't add the ACL or we fail in
190 * xfs_init_security we must back out.
191 * ENOSPC can hit here, among other things.
193 xfs_dentry_to_name(&teardown
, dentry
);
195 xfs_remove(XFS_I(dir
), &teardown
, XFS_I(inode
));
202 struct dentry
*dentry
,
207 struct xfs_inode
*ip
= NULL
;
208 struct posix_acl
*default_acl
= NULL
;
209 struct xfs_name name
;
213 * Irix uses Missed'em'V split, but doesn't want to see
214 * the upper 5 bits of (14bit) major.
216 if (S_ISCHR(mode
) || S_ISBLK(mode
)) {
217 if (unlikely(!sysv_valid_dev(rdev
) || MAJOR(rdev
) & ~0x1ff))
219 rdev
= sysv_encode_dev(rdev
);
224 if (IS_POSIXACL(dir
)) {
225 default_acl
= xfs_get_acl(dir
, ACL_TYPE_DEFAULT
);
226 if (IS_ERR(default_acl
))
227 return -PTR_ERR(default_acl
);
230 mode
&= ~current_umask();
233 xfs_dentry_to_name(&name
, dentry
);
234 error
= xfs_create(XFS_I(dir
), &name
, mode
, rdev
, &ip
, NULL
);
240 error
= xfs_init_security(inode
, dir
);
242 goto out_cleanup_inode
;
245 error
= -xfs_inherit_acl(inode
, default_acl
);
247 goto out_cleanup_inode
;
248 posix_acl_release(default_acl
);
252 d_instantiate(dentry
, inode
);
256 xfs_cleanup_inode(dir
, inode
, dentry
);
258 posix_acl_release(default_acl
);
265 struct dentry
*dentry
,
267 struct nameidata
*nd
)
269 return xfs_vn_mknod(dir
, dentry
, mode
, 0);
275 struct dentry
*dentry
,
278 return xfs_vn_mknod(dir
, dentry
, mode
|S_IFDIR
, 0);
281 STATIC
struct dentry
*
284 struct dentry
*dentry
,
285 struct nameidata
*nd
)
287 struct xfs_inode
*cip
;
288 struct xfs_name name
;
291 if (dentry
->d_name
.len
>= MAXNAMELEN
)
292 return ERR_PTR(-ENAMETOOLONG
);
294 xfs_dentry_to_name(&name
, dentry
);
295 error
= xfs_lookup(XFS_I(dir
), &name
, &cip
, NULL
);
296 if (unlikely(error
)) {
297 if (unlikely(error
!= ENOENT
))
298 return ERR_PTR(-error
);
303 return d_splice_alias(VFS_I(cip
), dentry
);
306 STATIC
struct dentry
*
309 struct dentry
*dentry
,
310 struct nameidata
*nd
)
312 struct xfs_inode
*ip
;
313 struct xfs_name xname
;
314 struct xfs_name ci_name
;
318 if (dentry
->d_name
.len
>= MAXNAMELEN
)
319 return ERR_PTR(-ENAMETOOLONG
);
321 xfs_dentry_to_name(&xname
, dentry
);
322 error
= xfs_lookup(XFS_I(dir
), &xname
, &ip
, &ci_name
);
323 if (unlikely(error
)) {
324 if (unlikely(error
!= ENOENT
))
325 return ERR_PTR(-error
);
327 * call d_add(dentry, NULL) here when d_drop_negative_children
328 * is called in xfs_vn_mknod (ie. allow negative dentries
329 * with CI filesystems).
334 /* if exact match, just splice and exit */
336 return d_splice_alias(VFS_I(ip
), dentry
);
338 /* else case-insensitive match... */
339 dname
.name
= ci_name
.name
;
340 dname
.len
= ci_name
.len
;
341 dentry
= d_add_ci(dentry
, VFS_I(ip
), &dname
);
342 kmem_free(ci_name
.name
);
348 struct dentry
*old_dentry
,
350 struct dentry
*dentry
)
352 struct inode
*inode
= old_dentry
->d_inode
;
353 struct xfs_name name
;
356 xfs_dentry_to_name(&name
, dentry
);
358 error
= xfs_link(XFS_I(dir
), XFS_I(inode
), &name
);
362 atomic_inc(&inode
->i_count
);
363 d_instantiate(dentry
, inode
);
370 struct dentry
*dentry
)
372 struct xfs_name name
;
375 xfs_dentry_to_name(&name
, dentry
);
377 error
= -xfs_remove(XFS_I(dir
), &name
, XFS_I(dentry
->d_inode
));
382 * With unlink, the VFS makes the dentry "negative": no inode,
383 * but still hashed. This is incompatible with case-insensitive
384 * mode, so invalidate (unhash) the dentry in CI-mode.
386 if (xfs_sb_version_hasasciici(&XFS_M(dir
->i_sb
)->m_sb
))
387 d_invalidate(dentry
);
394 struct dentry
*dentry
,
398 struct xfs_inode
*cip
= NULL
;
399 struct xfs_name name
;
404 (irix_symlink_mode
? 0777 & ~current_umask() : S_IRWXUGO
);
405 xfs_dentry_to_name(&name
, dentry
);
407 error
= xfs_symlink(XFS_I(dir
), &name
, symname
, mode
, &cip
, NULL
);
413 error
= xfs_init_security(inode
, dir
);
415 goto out_cleanup_inode
;
417 d_instantiate(dentry
, inode
);
421 xfs_cleanup_inode(dir
, inode
, dentry
);
429 struct dentry
*odentry
,
431 struct dentry
*ndentry
)
433 struct inode
*new_inode
= ndentry
->d_inode
;
434 struct xfs_name oname
;
435 struct xfs_name nname
;
437 xfs_dentry_to_name(&oname
, odentry
);
438 xfs_dentry_to_name(&nname
, ndentry
);
440 return -xfs_rename(XFS_I(odir
), &oname
, XFS_I(odentry
->d_inode
),
441 XFS_I(ndir
), &nname
, new_inode
?
442 XFS_I(new_inode
) : NULL
);
446 * careful here - this function can get called recursively, so
447 * we need to be very careful about how much stack we use.
448 * uio is kmalloced for this reason...
452 struct dentry
*dentry
,
453 struct nameidata
*nd
)
458 link
= kmalloc(MAXPATHLEN
+1, GFP_KERNEL
);
462 error
= -xfs_readlink(XFS_I(dentry
->d_inode
), link
);
466 nd_set_link(nd
, link
);
472 nd_set_link(nd
, ERR_PTR(error
));
478 struct dentry
*dentry
,
479 struct nameidata
*nd
,
482 char *s
= nd_get_link(nd
);
490 struct vfsmount
*mnt
,
491 struct dentry
*dentry
,
494 struct inode
*inode
= dentry
->d_inode
;
495 struct xfs_inode
*ip
= XFS_I(inode
);
496 struct xfs_mount
*mp
= ip
->i_mount
;
498 xfs_itrace_entry(ip
);
500 if (XFS_FORCED_SHUTDOWN(mp
))
501 return XFS_ERROR(EIO
);
503 stat
->size
= XFS_ISIZE(ip
);
504 stat
->dev
= inode
->i_sb
->s_dev
;
505 stat
->mode
= ip
->i_d
.di_mode
;
506 stat
->nlink
= ip
->i_d
.di_nlink
;
507 stat
->uid
= ip
->i_d
.di_uid
;
508 stat
->gid
= ip
->i_d
.di_gid
;
509 stat
->ino
= ip
->i_ino
;
510 stat
->atime
= inode
->i_atime
;
511 stat
->mtime
= inode
->i_mtime
;
512 stat
->ctime
= inode
->i_ctime
;
514 XFS_FSB_TO_BB(mp
, ip
->i_d
.di_nblocks
+ ip
->i_delayed_blks
);
517 switch (inode
->i_mode
& S_IFMT
) {
520 stat
->blksize
= BLKDEV_IOSIZE
;
521 stat
->rdev
= MKDEV(sysv_major(ip
->i_df
.if_u2
.if_rdev
) & 0x1ff,
522 sysv_minor(ip
->i_df
.if_u2
.if_rdev
));
525 if (XFS_IS_REALTIME_INODE(ip
)) {
527 * If the file blocks are being allocated from a
528 * realtime volume, then return the inode's realtime
529 * extent size or the realtime volume's extent size.
532 xfs_get_extsz_hint(ip
) << mp
->m_sb
.sb_blocklog
;
534 stat
->blksize
= xfs_preferred_iosize(mp
);
544 struct dentry
*dentry
,
547 return -xfs_setattr(XFS_I(dentry
->d_inode
), iattr
, 0);
551 * block_truncate_page can return an error, but we can't propagate it
552 * at all here. Leave a complaint + stack trace in the syslog because
553 * this could be bad. If it is bad, we need to propagate the error further.
560 error
= block_truncate_page(inode
->i_mapping
, inode
->i_size
,
575 xfs_inode_t
*ip
= XFS_I(inode
);
577 /* preallocation on directories not yet supported */
579 if (S_ISDIR(inode
->i_mode
))
586 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
587 error
= -xfs_change_file_space(ip
, XFS_IOC_RESVSP
, &bf
,
589 if (!error
&& !(mode
& FALLOC_FL_KEEP_SIZE
) &&
590 offset
+ len
> i_size_read(inode
))
591 new_size
= offset
+ len
;
593 /* Change file size if needed */
597 iattr
.ia_valid
= ATTR_SIZE
;
598 iattr
.ia_size
= new_size
;
599 error
= -xfs_setattr(ip
, &iattr
, XFS_ATTR_NOLOCK
);
602 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
607 #define XFS_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)
610 * Call fiemap helper to fill in user data.
611 * Returns positive errors to xfs_getbmap.
616 struct getbmapx
*bmv
,
620 struct fiemap_extent_info
*fieinfo
= *arg
;
621 u32 fiemap_flags
= 0;
622 u64 logical
, physical
, length
;
624 /* Do nothing for a hole */
625 if (bmv
->bmv_block
== -1LL)
628 logical
= BBTOB(bmv
->bmv_offset
);
629 physical
= BBTOB(bmv
->bmv_block
);
630 length
= BBTOB(bmv
->bmv_length
);
632 if (bmv
->bmv_oflags
& BMV_OF_PREALLOC
)
633 fiemap_flags
|= FIEMAP_EXTENT_UNWRITTEN
;
634 else if (bmv
->bmv_oflags
& BMV_OF_DELALLOC
) {
635 fiemap_flags
|= FIEMAP_EXTENT_DELALLOC
;
636 physical
= 0; /* no block yet */
638 if (bmv
->bmv_oflags
& BMV_OF_LAST
)
639 fiemap_flags
|= FIEMAP_EXTENT_LAST
;
641 error
= fiemap_fill_next_extent(fieinfo
, logical
, physical
,
642 length
, fiemap_flags
);
645 *full
= 1; /* user array now full */
654 struct fiemap_extent_info
*fieinfo
,
658 xfs_inode_t
*ip
= XFS_I(inode
);
662 error
= fiemap_check_flags(fieinfo
, XFS_FIEMAP_FLAGS
);
666 /* Set up bmap header for xfs internal routine */
667 bm
.bmv_offset
= BTOBB(start
);
668 /* Special case for whole file */
669 if (length
== FIEMAP_MAX_OFFSET
)
670 bm
.bmv_length
= -1LL;
672 bm
.bmv_length
= BTOBB(length
);
674 /* We add one because in getbmap world count includes the header */
675 bm
.bmv_count
= fieinfo
->fi_extents_max
+ 1;
676 bm
.bmv_iflags
= BMV_IF_PREALLOC
;
677 if (fieinfo
->fi_flags
& FIEMAP_FLAG_XATTR
)
678 bm
.bmv_iflags
|= BMV_IF_ATTRFORK
;
679 if (!(fieinfo
->fi_flags
& FIEMAP_FLAG_SYNC
))
680 bm
.bmv_iflags
|= BMV_IF_DELALLOC
;
682 error
= xfs_getbmap(ip
, &bm
, xfs_fiemap_format
, fieinfo
);
689 static const struct inode_operations xfs_inode_operations
= {
690 .check_acl
= xfs_check_acl
,
691 .truncate
= xfs_vn_truncate
,
692 .getattr
= xfs_vn_getattr
,
693 .setattr
= xfs_vn_setattr
,
694 .setxattr
= generic_setxattr
,
695 .getxattr
= generic_getxattr
,
696 .removexattr
= generic_removexattr
,
697 .listxattr
= xfs_vn_listxattr
,
698 .fallocate
= xfs_vn_fallocate
,
699 .fiemap
= xfs_vn_fiemap
,
702 static const struct inode_operations xfs_dir_inode_operations
= {
703 .create
= xfs_vn_create
,
704 .lookup
= xfs_vn_lookup
,
706 .unlink
= xfs_vn_unlink
,
707 .symlink
= xfs_vn_symlink
,
708 .mkdir
= xfs_vn_mkdir
,
710 * Yes, XFS uses the same method for rmdir and unlink.
712 * There are some subtile differences deeper in the code,
713 * but we use S_ISDIR to check for those.
715 .rmdir
= xfs_vn_unlink
,
716 .mknod
= xfs_vn_mknod
,
717 .rename
= xfs_vn_rename
,
718 .check_acl
= xfs_check_acl
,
719 .getattr
= xfs_vn_getattr
,
720 .setattr
= xfs_vn_setattr
,
721 .setxattr
= generic_setxattr
,
722 .getxattr
= generic_getxattr
,
723 .removexattr
= generic_removexattr
,
724 .listxattr
= xfs_vn_listxattr
,
727 static const struct inode_operations xfs_dir_ci_inode_operations
= {
728 .create
= xfs_vn_create
,
729 .lookup
= xfs_vn_ci_lookup
,
731 .unlink
= xfs_vn_unlink
,
732 .symlink
= xfs_vn_symlink
,
733 .mkdir
= xfs_vn_mkdir
,
735 * Yes, XFS uses the same method for rmdir and unlink.
737 * There are some subtile differences deeper in the code,
738 * but we use S_ISDIR to check for those.
740 .rmdir
= xfs_vn_unlink
,
741 .mknod
= xfs_vn_mknod
,
742 .rename
= xfs_vn_rename
,
743 .check_acl
= xfs_check_acl
,
744 .getattr
= xfs_vn_getattr
,
745 .setattr
= xfs_vn_setattr
,
746 .setxattr
= generic_setxattr
,
747 .getxattr
= generic_getxattr
,
748 .removexattr
= generic_removexattr
,
749 .listxattr
= xfs_vn_listxattr
,
752 static const struct inode_operations xfs_symlink_inode_operations
= {
753 .readlink
= generic_readlink
,
754 .follow_link
= xfs_vn_follow_link
,
755 .put_link
= xfs_vn_put_link
,
756 .check_acl
= xfs_check_acl
,
757 .getattr
= xfs_vn_getattr
,
758 .setattr
= xfs_vn_setattr
,
759 .setxattr
= generic_setxattr
,
760 .getxattr
= generic_getxattr
,
761 .removexattr
= generic_removexattr
,
762 .listxattr
= xfs_vn_listxattr
,
766 xfs_diflags_to_iflags(
768 struct xfs_inode
*ip
)
770 if (ip
->i_d
.di_flags
& XFS_DIFLAG_IMMUTABLE
)
771 inode
->i_flags
|= S_IMMUTABLE
;
773 inode
->i_flags
&= ~S_IMMUTABLE
;
774 if (ip
->i_d
.di_flags
& XFS_DIFLAG_APPEND
)
775 inode
->i_flags
|= S_APPEND
;
777 inode
->i_flags
&= ~S_APPEND
;
778 if (ip
->i_d
.di_flags
& XFS_DIFLAG_SYNC
)
779 inode
->i_flags
|= S_SYNC
;
781 inode
->i_flags
&= ~S_SYNC
;
782 if (ip
->i_d
.di_flags
& XFS_DIFLAG_NOATIME
)
783 inode
->i_flags
|= S_NOATIME
;
785 inode
->i_flags
&= ~S_NOATIME
;
789 * Initialize the Linux inode, set up the operation vectors and
792 * When reading existing inodes from disk this is called directly
793 * from xfs_iget, when creating a new inode it is called from
794 * xfs_ialloc after setting up the inode.
796 * We are always called with an uninitialised linux inode here.
797 * We need to initialise the necessary fields and take a reference
802 struct xfs_inode
*ip
)
804 struct inode
*inode
= &ip
->i_vnode
;
806 inode
->i_ino
= ip
->i_ino
;
807 inode
->i_state
= I_NEW
;
808 inode_add_to_lists(ip
->i_mount
->m_super
, inode
);
810 inode
->i_mode
= ip
->i_d
.di_mode
;
811 inode
->i_nlink
= ip
->i_d
.di_nlink
;
812 inode
->i_uid
= ip
->i_d
.di_uid
;
813 inode
->i_gid
= ip
->i_d
.di_gid
;
815 switch (inode
->i_mode
& S_IFMT
) {
819 MKDEV(sysv_major(ip
->i_df
.if_u2
.if_rdev
) & 0x1ff,
820 sysv_minor(ip
->i_df
.if_u2
.if_rdev
));
827 inode
->i_generation
= ip
->i_d
.di_gen
;
828 i_size_write(inode
, ip
->i_d
.di_size
);
829 inode
->i_atime
.tv_sec
= ip
->i_d
.di_atime
.t_sec
;
830 inode
->i_atime
.tv_nsec
= ip
->i_d
.di_atime
.t_nsec
;
831 inode
->i_mtime
.tv_sec
= ip
->i_d
.di_mtime
.t_sec
;
832 inode
->i_mtime
.tv_nsec
= ip
->i_d
.di_mtime
.t_nsec
;
833 inode
->i_ctime
.tv_sec
= ip
->i_d
.di_ctime
.t_sec
;
834 inode
->i_ctime
.tv_nsec
= ip
->i_d
.di_ctime
.t_nsec
;
835 xfs_diflags_to_iflags(inode
, ip
);
837 switch (inode
->i_mode
& S_IFMT
) {
839 inode
->i_op
= &xfs_inode_operations
;
840 inode
->i_fop
= &xfs_file_operations
;
841 inode
->i_mapping
->a_ops
= &xfs_address_space_operations
;
844 if (xfs_sb_version_hasasciici(&XFS_M(inode
->i_sb
)->m_sb
))
845 inode
->i_op
= &xfs_dir_ci_inode_operations
;
847 inode
->i_op
= &xfs_dir_inode_operations
;
848 inode
->i_fop
= &xfs_dir_file_operations
;
851 inode
->i_op
= &xfs_symlink_inode_operations
;
852 if (!(ip
->i_df
.if_flags
& XFS_IFINLINE
))
853 inode
->i_mapping
->a_ops
= &xfs_address_space_operations
;
856 inode
->i_op
= &xfs_inode_operations
;
857 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
861 xfs_iflags_clear(ip
, XFS_INEW
);
864 unlock_new_inode(inode
);