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 * Hook in SELinux. This is not quite correct yet, what we really need
99 * here (as we do for default ACLs) is a mechanism by which creation of
100 * these attrs can be journalled at inode creation time (along with the
101 * inode, of course, such that log replay can't cause these to be lost).
107 const struct qstr
*qstr
)
109 struct xfs_inode
*ip
= XFS_I(inode
);
115 error
= security_inode_init_security(inode
, dir
, qstr
, (char **)&name
,
118 if (error
== -EOPNOTSUPP
)
123 error
= xfs_attr_set(ip
, name
, value
, length
, ATTR_SECURE
);
132 struct xfs_name
*namep
,
133 struct dentry
*dentry
)
135 namep
->name
= dentry
->d_name
.name
;
136 namep
->len
= dentry
->d_name
.len
;
143 struct dentry
*dentry
)
145 struct xfs_name teardown
;
148 * If we can't add the ACL or we fail in
149 * xfs_init_security we must back out.
150 * ENOSPC can hit here, among other things.
152 xfs_dentry_to_name(&teardown
, dentry
);
154 xfs_remove(XFS_I(dir
), &teardown
, XFS_I(inode
));
161 struct dentry
*dentry
,
166 struct xfs_inode
*ip
= NULL
;
167 struct posix_acl
*default_acl
= NULL
;
168 struct xfs_name name
;
172 * Irix uses Missed'em'V split, but doesn't want to see
173 * the upper 5 bits of (14bit) major.
175 if (S_ISCHR(mode
) || S_ISBLK(mode
)) {
176 if (unlikely(!sysv_valid_dev(rdev
) || MAJOR(rdev
) & ~0x1ff))
178 rdev
= sysv_encode_dev(rdev
);
183 if (IS_POSIXACL(dir
)) {
184 default_acl
= xfs_get_acl(dir
, ACL_TYPE_DEFAULT
);
185 if (IS_ERR(default_acl
))
186 return -PTR_ERR(default_acl
);
189 mode
&= ~current_umask();
192 xfs_dentry_to_name(&name
, dentry
);
193 error
= xfs_create(XFS_I(dir
), &name
, mode
, rdev
, &ip
);
199 error
= xfs_init_security(inode
, dir
, &dentry
->d_name
);
201 goto out_cleanup_inode
;
204 error
= -xfs_inherit_acl(inode
, default_acl
);
206 goto out_cleanup_inode
;
207 posix_acl_release(default_acl
);
211 d_instantiate(dentry
, inode
);
215 xfs_cleanup_inode(dir
, inode
, dentry
);
217 posix_acl_release(default_acl
);
224 struct dentry
*dentry
,
226 struct nameidata
*nd
)
228 return xfs_vn_mknod(dir
, dentry
, mode
, 0);
234 struct dentry
*dentry
,
237 return xfs_vn_mknod(dir
, dentry
, mode
|S_IFDIR
, 0);
240 STATIC
struct dentry
*
243 struct dentry
*dentry
,
244 struct nameidata
*nd
)
246 struct xfs_inode
*cip
;
247 struct xfs_name name
;
250 if (dentry
->d_name
.len
>= MAXNAMELEN
)
251 return ERR_PTR(-ENAMETOOLONG
);
253 xfs_dentry_to_name(&name
, dentry
);
254 error
= xfs_lookup(XFS_I(dir
), &name
, &cip
, NULL
);
255 if (unlikely(error
)) {
256 if (unlikely(error
!= ENOENT
))
257 return ERR_PTR(-error
);
262 return d_splice_alias(VFS_I(cip
), dentry
);
265 STATIC
struct dentry
*
268 struct dentry
*dentry
,
269 struct nameidata
*nd
)
271 struct xfs_inode
*ip
;
272 struct xfs_name xname
;
273 struct xfs_name ci_name
;
277 if (dentry
->d_name
.len
>= MAXNAMELEN
)
278 return ERR_PTR(-ENAMETOOLONG
);
280 xfs_dentry_to_name(&xname
, dentry
);
281 error
= xfs_lookup(XFS_I(dir
), &xname
, &ip
, &ci_name
);
282 if (unlikely(error
)) {
283 if (unlikely(error
!= ENOENT
))
284 return ERR_PTR(-error
);
286 * call d_add(dentry, NULL) here when d_drop_negative_children
287 * is called in xfs_vn_mknod (ie. allow negative dentries
288 * with CI filesystems).
293 /* if exact match, just splice and exit */
295 return d_splice_alias(VFS_I(ip
), dentry
);
297 /* else case-insensitive match... */
298 dname
.name
= ci_name
.name
;
299 dname
.len
= ci_name
.len
;
300 dentry
= d_add_ci(dentry
, VFS_I(ip
), &dname
);
301 kmem_free(ci_name
.name
);
307 struct dentry
*old_dentry
,
309 struct dentry
*dentry
)
311 struct inode
*inode
= old_dentry
->d_inode
;
312 struct xfs_name name
;
315 xfs_dentry_to_name(&name
, dentry
);
317 error
= xfs_link(XFS_I(dir
), XFS_I(inode
), &name
);
322 d_instantiate(dentry
, inode
);
329 struct dentry
*dentry
)
331 struct xfs_name name
;
334 xfs_dentry_to_name(&name
, dentry
);
336 error
= -xfs_remove(XFS_I(dir
), &name
, XFS_I(dentry
->d_inode
));
341 * With unlink, the VFS makes the dentry "negative": no inode,
342 * but still hashed. This is incompatible with case-insensitive
343 * mode, so invalidate (unhash) the dentry in CI-mode.
345 if (xfs_sb_version_hasasciici(&XFS_M(dir
->i_sb
)->m_sb
))
346 d_invalidate(dentry
);
353 struct dentry
*dentry
,
357 struct xfs_inode
*cip
= NULL
;
358 struct xfs_name name
;
363 (irix_symlink_mode
? 0777 & ~current_umask() : S_IRWXUGO
);
364 xfs_dentry_to_name(&name
, dentry
);
366 error
= xfs_symlink(XFS_I(dir
), &name
, symname
, mode
, &cip
);
372 error
= xfs_init_security(inode
, dir
, &dentry
->d_name
);
374 goto out_cleanup_inode
;
376 d_instantiate(dentry
, inode
);
380 xfs_cleanup_inode(dir
, inode
, dentry
);
388 struct dentry
*odentry
,
390 struct dentry
*ndentry
)
392 struct inode
*new_inode
= ndentry
->d_inode
;
393 struct xfs_name oname
;
394 struct xfs_name nname
;
396 xfs_dentry_to_name(&oname
, odentry
);
397 xfs_dentry_to_name(&nname
, ndentry
);
399 return -xfs_rename(XFS_I(odir
), &oname
, XFS_I(odentry
->d_inode
),
400 XFS_I(ndir
), &nname
, new_inode
?
401 XFS_I(new_inode
) : NULL
);
405 * careful here - this function can get called recursively, so
406 * we need to be very careful about how much stack we use.
407 * uio is kmalloced for this reason...
411 struct dentry
*dentry
,
412 struct nameidata
*nd
)
417 link
= kmalloc(MAXPATHLEN
+1, GFP_KERNEL
);
421 error
= -xfs_readlink(XFS_I(dentry
->d_inode
), link
);
425 nd_set_link(nd
, link
);
431 nd_set_link(nd
, ERR_PTR(error
));
437 struct dentry
*dentry
,
438 struct nameidata
*nd
,
441 char *s
= nd_get_link(nd
);
449 struct vfsmount
*mnt
,
450 struct dentry
*dentry
,
453 struct inode
*inode
= dentry
->d_inode
;
454 struct xfs_inode
*ip
= XFS_I(inode
);
455 struct xfs_mount
*mp
= ip
->i_mount
;
457 trace_xfs_getattr(ip
);
459 if (XFS_FORCED_SHUTDOWN(mp
))
460 return XFS_ERROR(EIO
);
462 stat
->size
= XFS_ISIZE(ip
);
463 stat
->dev
= inode
->i_sb
->s_dev
;
464 stat
->mode
= ip
->i_d
.di_mode
;
465 stat
->nlink
= ip
->i_d
.di_nlink
;
466 stat
->uid
= ip
->i_d
.di_uid
;
467 stat
->gid
= ip
->i_d
.di_gid
;
468 stat
->ino
= ip
->i_ino
;
469 stat
->atime
= inode
->i_atime
;
470 stat
->mtime
= inode
->i_mtime
;
471 stat
->ctime
= inode
->i_ctime
;
473 XFS_FSB_TO_BB(mp
, ip
->i_d
.di_nblocks
+ ip
->i_delayed_blks
);
476 switch (inode
->i_mode
& S_IFMT
) {
479 stat
->blksize
= BLKDEV_IOSIZE
;
480 stat
->rdev
= MKDEV(sysv_major(ip
->i_df
.if_u2
.if_rdev
) & 0x1ff,
481 sysv_minor(ip
->i_df
.if_u2
.if_rdev
));
484 if (XFS_IS_REALTIME_INODE(ip
)) {
486 * If the file blocks are being allocated from a
487 * realtime volume, then return the inode's realtime
488 * extent size or the realtime volume's extent size.
491 xfs_get_extsz_hint(ip
) << mp
->m_sb
.sb_blocklog
;
493 stat
->blksize
= xfs_preferred_iosize(mp
);
503 struct dentry
*dentry
,
506 return -xfs_setattr(XFS_I(dentry
->d_inode
), iattr
, 0);
519 xfs_inode_t
*ip
= XFS_I(inode
);
521 /* preallocation on directories not yet supported */
523 if (S_ISDIR(inode
->i_mode
))
530 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
532 /* check the new inode size is valid before allocating */
533 if (!(mode
& FALLOC_FL_KEEP_SIZE
) &&
534 offset
+ len
> i_size_read(inode
)) {
535 new_size
= offset
+ len
;
536 error
= inode_newsize_ok(inode
, new_size
);
541 error
= -xfs_change_file_space(ip
, XFS_IOC_RESVSP
, &bf
,
546 /* Change file size if needed */
550 iattr
.ia_valid
= ATTR_SIZE
;
551 iattr
.ia_size
= new_size
;
552 error
= -xfs_setattr(ip
, &iattr
, XFS_ATTR_NOLOCK
);
556 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
561 #define XFS_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)
564 * Call fiemap helper to fill in user data.
565 * Returns positive errors to xfs_getbmap.
570 struct getbmapx
*bmv
,
574 struct fiemap_extent_info
*fieinfo
= *arg
;
575 u32 fiemap_flags
= 0;
576 u64 logical
, physical
, length
;
578 /* Do nothing for a hole */
579 if (bmv
->bmv_block
== -1LL)
582 logical
= BBTOB(bmv
->bmv_offset
);
583 physical
= BBTOB(bmv
->bmv_block
);
584 length
= BBTOB(bmv
->bmv_length
);
586 if (bmv
->bmv_oflags
& BMV_OF_PREALLOC
)
587 fiemap_flags
|= FIEMAP_EXTENT_UNWRITTEN
;
588 else if (bmv
->bmv_oflags
& BMV_OF_DELALLOC
) {
589 fiemap_flags
|= FIEMAP_EXTENT_DELALLOC
;
590 physical
= 0; /* no block yet */
592 if (bmv
->bmv_oflags
& BMV_OF_LAST
)
593 fiemap_flags
|= FIEMAP_EXTENT_LAST
;
595 error
= fiemap_fill_next_extent(fieinfo
, logical
, physical
,
596 length
, fiemap_flags
);
599 *full
= 1; /* user array now full */
608 struct fiemap_extent_info
*fieinfo
,
612 xfs_inode_t
*ip
= XFS_I(inode
);
616 error
= fiemap_check_flags(fieinfo
, XFS_FIEMAP_FLAGS
);
620 /* Set up bmap header for xfs internal routine */
621 bm
.bmv_offset
= BTOBB(start
);
622 /* Special case for whole file */
623 if (length
== FIEMAP_MAX_OFFSET
)
624 bm
.bmv_length
= -1LL;
626 bm
.bmv_length
= BTOBB(length
);
628 /* We add one because in getbmap world count includes the header */
629 bm
.bmv_count
= !fieinfo
->fi_extents_max
? MAXEXTNUM
:
630 fieinfo
->fi_extents_max
+ 1;
631 bm
.bmv_count
= min_t(__s32
, bm
.bmv_count
,
632 (PAGE_SIZE
* 16 / sizeof(struct getbmapx
)));
633 bm
.bmv_iflags
= BMV_IF_PREALLOC
| BMV_IF_NO_HOLES
;
634 if (fieinfo
->fi_flags
& FIEMAP_FLAG_XATTR
)
635 bm
.bmv_iflags
|= BMV_IF_ATTRFORK
;
636 if (!(fieinfo
->fi_flags
& FIEMAP_FLAG_SYNC
))
637 bm
.bmv_iflags
|= BMV_IF_DELALLOC
;
639 error
= xfs_getbmap(ip
, &bm
, xfs_fiemap_format
, fieinfo
);
646 static const struct inode_operations xfs_inode_operations
= {
647 .check_acl
= xfs_check_acl
,
648 .getattr
= xfs_vn_getattr
,
649 .setattr
= xfs_vn_setattr
,
650 .setxattr
= generic_setxattr
,
651 .getxattr
= generic_getxattr
,
652 .removexattr
= generic_removexattr
,
653 .listxattr
= xfs_vn_listxattr
,
654 .fallocate
= xfs_vn_fallocate
,
655 .fiemap
= xfs_vn_fiemap
,
658 static const struct inode_operations xfs_dir_inode_operations
= {
659 .create
= xfs_vn_create
,
660 .lookup
= xfs_vn_lookup
,
662 .unlink
= xfs_vn_unlink
,
663 .symlink
= xfs_vn_symlink
,
664 .mkdir
= xfs_vn_mkdir
,
666 * Yes, XFS uses the same method for rmdir and unlink.
668 * There are some subtile differences deeper in the code,
669 * but we use S_ISDIR to check for those.
671 .rmdir
= xfs_vn_unlink
,
672 .mknod
= xfs_vn_mknod
,
673 .rename
= xfs_vn_rename
,
674 .check_acl
= xfs_check_acl
,
675 .getattr
= xfs_vn_getattr
,
676 .setattr
= xfs_vn_setattr
,
677 .setxattr
= generic_setxattr
,
678 .getxattr
= generic_getxattr
,
679 .removexattr
= generic_removexattr
,
680 .listxattr
= xfs_vn_listxattr
,
683 static const struct inode_operations xfs_dir_ci_inode_operations
= {
684 .create
= xfs_vn_create
,
685 .lookup
= xfs_vn_ci_lookup
,
687 .unlink
= xfs_vn_unlink
,
688 .symlink
= xfs_vn_symlink
,
689 .mkdir
= xfs_vn_mkdir
,
691 * Yes, XFS uses the same method for rmdir and unlink.
693 * There are some subtile differences deeper in the code,
694 * but we use S_ISDIR to check for those.
696 .rmdir
= xfs_vn_unlink
,
697 .mknod
= xfs_vn_mknod
,
698 .rename
= xfs_vn_rename
,
699 .check_acl
= xfs_check_acl
,
700 .getattr
= xfs_vn_getattr
,
701 .setattr
= xfs_vn_setattr
,
702 .setxattr
= generic_setxattr
,
703 .getxattr
= generic_getxattr
,
704 .removexattr
= generic_removexattr
,
705 .listxattr
= xfs_vn_listxattr
,
708 static const struct inode_operations xfs_symlink_inode_operations
= {
709 .readlink
= generic_readlink
,
710 .follow_link
= xfs_vn_follow_link
,
711 .put_link
= xfs_vn_put_link
,
712 .check_acl
= xfs_check_acl
,
713 .getattr
= xfs_vn_getattr
,
714 .setattr
= xfs_vn_setattr
,
715 .setxattr
= generic_setxattr
,
716 .getxattr
= generic_getxattr
,
717 .removexattr
= generic_removexattr
,
718 .listxattr
= xfs_vn_listxattr
,
722 xfs_diflags_to_iflags(
724 struct xfs_inode
*ip
)
726 if (ip
->i_d
.di_flags
& XFS_DIFLAG_IMMUTABLE
)
727 inode
->i_flags
|= S_IMMUTABLE
;
729 inode
->i_flags
&= ~S_IMMUTABLE
;
730 if (ip
->i_d
.di_flags
& XFS_DIFLAG_APPEND
)
731 inode
->i_flags
|= S_APPEND
;
733 inode
->i_flags
&= ~S_APPEND
;
734 if (ip
->i_d
.di_flags
& XFS_DIFLAG_SYNC
)
735 inode
->i_flags
|= S_SYNC
;
737 inode
->i_flags
&= ~S_SYNC
;
738 if (ip
->i_d
.di_flags
& XFS_DIFLAG_NOATIME
)
739 inode
->i_flags
|= S_NOATIME
;
741 inode
->i_flags
&= ~S_NOATIME
;
745 * Initialize the Linux inode, set up the operation vectors and
748 * When reading existing inodes from disk this is called directly
749 * from xfs_iget, when creating a new inode it is called from
750 * xfs_ialloc after setting up the inode.
752 * We are always called with an uninitialised linux inode here.
753 * We need to initialise the necessary fields and take a reference
758 struct xfs_inode
*ip
)
760 struct inode
*inode
= &ip
->i_vnode
;
762 inode
->i_ino
= ip
->i_ino
;
763 inode
->i_state
= I_NEW
;
765 inode_sb_list_add(inode
);
766 /* make the inode look hashed for the writeback code */
767 hlist_add_fake(&inode
->i_hash
);
769 inode
->i_mode
= ip
->i_d
.di_mode
;
770 inode
->i_nlink
= ip
->i_d
.di_nlink
;
771 inode
->i_uid
= ip
->i_d
.di_uid
;
772 inode
->i_gid
= ip
->i_d
.di_gid
;
774 switch (inode
->i_mode
& S_IFMT
) {
778 MKDEV(sysv_major(ip
->i_df
.if_u2
.if_rdev
) & 0x1ff,
779 sysv_minor(ip
->i_df
.if_u2
.if_rdev
));
786 inode
->i_generation
= ip
->i_d
.di_gen
;
787 i_size_write(inode
, ip
->i_d
.di_size
);
788 inode
->i_atime
.tv_sec
= ip
->i_d
.di_atime
.t_sec
;
789 inode
->i_atime
.tv_nsec
= ip
->i_d
.di_atime
.t_nsec
;
790 inode
->i_mtime
.tv_sec
= ip
->i_d
.di_mtime
.t_sec
;
791 inode
->i_mtime
.tv_nsec
= ip
->i_d
.di_mtime
.t_nsec
;
792 inode
->i_ctime
.tv_sec
= ip
->i_d
.di_ctime
.t_sec
;
793 inode
->i_ctime
.tv_nsec
= ip
->i_d
.di_ctime
.t_nsec
;
794 xfs_diflags_to_iflags(inode
, ip
);
796 switch (inode
->i_mode
& S_IFMT
) {
798 inode
->i_op
= &xfs_inode_operations
;
799 inode
->i_fop
= &xfs_file_operations
;
800 inode
->i_mapping
->a_ops
= &xfs_address_space_operations
;
803 if (xfs_sb_version_hasasciici(&XFS_M(inode
->i_sb
)->m_sb
))
804 inode
->i_op
= &xfs_dir_ci_inode_operations
;
806 inode
->i_op
= &xfs_dir_inode_operations
;
807 inode
->i_fop
= &xfs_dir_file_operations
;
810 inode
->i_op
= &xfs_symlink_inode_operations
;
811 if (!(ip
->i_df
.if_flags
& XFS_IFINLINE
))
812 inode
->i_mapping
->a_ops
= &xfs_address_space_operations
;
815 inode
->i_op
= &xfs_inode_operations
;
816 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
820 xfs_iflags_clear(ip
, XFS_INEW
);
823 unlock_new_inode(inode
);