xfs: modernize the realtime volume
Subsystems (3)
PATCH 3/4 xfs: modernize the realtime volume
Hi everyone,
This third patchriver contains for the realtime modernization project. There are five main parts to this effort -- adding a metadata directory tree; sharding the realtime volume into allocation groups to reduce metadata lock contention; adding reverse mapping; adding reflink; and adding the one piece needed to make quotas work on realtime. This brings the robustness of the realtime volume up to par with the data volume.
Christoph Hellwig has recently taken an interest in getting this feature merged to better support zoned storage and garbage collection. This river is much smaller than last year's, as we've recently collaborated to get a bunch of the typedef abuses and casting problems corrected.
In theory this can also be used to support things like pmem and cxl.mem via multi-volume XFSes where the fs metadata lives on cheap(er) flash storage so that the pmem can be the exclusive backing of file data on the rt volume.
--D
PATCH 1/15 xfs: hoist inode operations to libxfs
Hi all,
This series hoists inode creation, renaming, and deletion operations to libxfs in anticipation of the metadata inode directory feature, which maintains a directory tree of metadata inodes. This will be necessary for further enhancements to the realtime feature, subvolume support.
There aren't supposed to be any functional changes in this intense refactoring -- we just split the functions into pieces that are generic and pieces that are specific to libxfs clients. As a bonus, we can remove various open-coded pieces of mkfs.xfs and xfs_repair when this series gets to xfsprogs.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=inode-refactor
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=inode-refactor
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_bmap.c | 42 + fs/xfs/libxfs/xfs_bmap.h | 3 fs/xfs/libxfs/xfs_dir2.c | 636 +++++++++++++++++ fs/xfs/libxfs/xfs_dir2.h | 48 + fs/xfs/libxfs/xfs_ialloc.c | 15 fs/xfs/libxfs/xfs_inode_util.c | 723 +++++++++++++++++++ fs/xfs/libxfs/xfs_inode_util.h | 71 ++ fs/xfs/libxfs/xfs_shared.h | 7 fs/xfs/libxfs/xfs_trans_inode.c | 2 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/tempfile.c | 20 - fs/xfs/xfs_inode.c | 1486 +++++---------------------------------- fs/xfs/xfs_inode.h | 75 +- fs/xfs/xfs_ioctl.c | 60 -- fs/xfs/xfs_iops.c | 47 + fs/xfs/xfs_linux.h | 2 fs/xfs/xfs_qm.c | 9 fs/xfs/xfs_reflink.h | 10 fs/xfs/xfs_symlink.c | 63 +- fs/xfs/xfs_trans.h | 1 21 files changed, 1830 insertions(+), 1492 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_inode_util.c create mode 100644 fs/xfs/libxfs/xfs_inode_util.h
PATCH 1/21 xfs: move inode copy-on-write predicates to xfs_inode.[ch]
From: Darrick J. Wong <[email protected]>
Move these inode predicate functions to xfs_inode.[ch] since they're not reflink functions.
--- fs/xfs/xfs_inode.c | 8 ++++++++ fs/xfs/xfs_inode.h | 7 +++++++ fs/xfs/xfs_reflink.h | 10 ---------- 3 files changed, 15 insertions(+), 10 deletions(-)
fs/xfs/xfs_inode.c +8 -0
@@ -4263,3 +4263,11 @@ xfs_inode_alloc_unitsize(return XFS_FSB_TO_B (ip->i_mount, blocks); } + +/* Should we always be using copy on write for file writes? */ +bool +xfs_is_always_cow_inode ( +struct xfs_inode *ip) +{ +return ip->i_mount->m_always_cow &&xfs_has_reflink (ip->i_mount); +}
fs/xfs/xfs_inode.h +7 -0
@@ -292,6 +292,13 @@ static inline bool xfs_is_metadata_inode(struct xfs_inode *ip)xfs_is_quota_inode (&mp->m_sb, ip->i_ino); } +bool xfs_is_always_cow_inode (struct xfs_inode *ip); + +static inline bool xfs_is_cow_inode (struct xfs_inode *ip) +{ +return xfs_is_reflink_inode (ip) ||xfs_is_always_cow_inode (ip); +} +/* * Check if an inode has any data in the COW fork. This might be often false * even for inodes with the reflink flag when there is no pending COW operation.
fs/xfs/xfs_reflink.h +0 -10
@@ -6,16 +6,6 @@#ifndef __XFS_REFLINK_H#define __XFS_REFLINK_H 1 -static inline bool xfs_is_always_cow_inode (struct xfs_inode *ip) -{ -return ip->i_mount->m_always_cow &&xfs_has_reflink (ip->i_mount); -} - -static inline bool xfs_is_cow_inode (struct xfs_inode *ip) -{ -return xfs_is_reflink_inode (ip) ||xfs_is_always_cow_inode (ip); -} -extern int xfs_reflink_trim_around_shared (struct xfs_inode *ip,struct xfs_bmbt_irec *irec,bool *shared); int xfs_bmap_trim_cow(struct xfs_inode *ip, struct xfs_bmbt_irec *imap,
PATCH 2/21 xfs: hoist extent size helpers to libxfs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move the extent size helpers to xfs_bmap.c in libxfs since they're used there already.
--- fs/xfs/libxfs/xfs_bmap.c | 41 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_bmap.h | 3 +++ fs/xfs/xfs_inode.c | 43 ------------------------------------------- fs/xfs/xfs_inode.h | 3 --- fs/xfs/xfs_iops.c | 1 + 5 files changed, 45 insertions(+), 46 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +41 -0
@@ -6363,3 +6363,44 @@ xfs_bmap_query_all(return xfs_btree_query_all (cur, xfs_bmap_query_range_helper, &query); } + +/* Helper function to extract extent size hint from inode */ +xfs_extlen_t +xfs_get_extsz_hint ( +struct xfs_inode *ip) +{ +/* +* No point in aligning allocations if we need to COW to actually +* write to them. +*/ +if (xfs_is_always_cow_inode (ip)) +return 0 ; +if ((ip->i_diflags &XFS_DIFLAG_EXTSIZE ) && ip->i_extsize) +return ip->i_extsize; +if (XFS_IS_REALTIME_INODE (ip)) +return ip->i_mount->m_sb.sb_rextsize; +return 0 ; +} + +/* +* Helper function to extract CoW extent size hint from inode. +* Between the extent size hint and the CoW extent size hint, we +* return the greater of the two. If the value is zero (automatic), +* use the default size. +*/ +xfs_extlen_t +xfs_get_cowextsz_hint ( +struct xfs_inode *ip) +{ +xfs_extlen_t a, b; + + a =0 ; +if (ip->i_diflags2 &XFS_DIFLAG2_COWEXTSIZE ) + a = ip->i_cowextsize; + b =xfs_get_extsz_hint (ip); + + a =max (a, b); +if (a ==0 ) +return XFS_DEFAULT_COWEXTSZ_HINT ; +return a; +}
fs/xfs/libxfs/xfs_bmap.h +3 -0
@@ -294,4 +294,7 @@ typedef int (*xfs_bmap_query_range_fn)(int xfs_bmap_query_all (struct xfs_btree_cur *cur,xfs_bmap_query_range_fn fn,void *priv); +xfs_extlen_t xfs_get_extsz_hint (struct xfs_inode *ip); +xfs_extlen_t xfs_get_cowextsz_hint (struct xfs_inode *ip); +#endif /* __XFS_BMAP_H__ */
fs/xfs/xfs_inode.c +0 -43
49 lines not on this page · raw message
fs/xfs/xfs_inode.h +0 -3
@@ -559,9 +559,6 @@ int xfs_iflush_cluster(struct xfs_buf *);void xfs_lock_two_inodes (struct xfs_inode *ip0,uint ip0_mode,struct xfs_inode *ip1,uint ip1_mode); -xfs_extlen_t xfs_get_extsz_hint (struct xfs_inode *ip); -xfs_extlen_t xfs_get_cowextsz_hint (struct xfs_inode *ip); - int xfs_init_new_inode(struct mnt_idmap *idmap, struct xfs_trans *tp, struct xfs_inode *pip, xfs_ino_t ino, umode_t mode, xfs_nlink_t nlink, dev_t rdev, prid_t prid, bool init_xattrs,
fs/xfs/xfs_iops.c +1 -0
@@ -26,6 +26,7 @@#include "xfs_ioctl.h" #include "xfs_xattr.h" #include "xfs_file.h" +#include "xfs_bmap.h" #include <linux/posix_acl.h> #include <linux/security.h>
PATCH 3/21 xfs: hoist inode flag conversion functions to libxfs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Hoist the inode flag conversion functions into libxfs so that we can keep them in sync. Do this by creating a new xfs_inode_util.c file in libxfs.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_bmap.c | 1 fs/xfs/libxfs/xfs_inode_util.c | 124 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_inode_util.h | 14 +++++ fs/xfs/xfs_inode.c | 49 ---------------- fs/xfs/xfs_inode.h | 2 - fs/xfs/xfs_ioctl.c | 60 ------------------- 7 files changed, 141 insertions(+), 110 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_inode_util.c create mode 100644 fs/xfs/libxfs/xfs_inode_util.h
fs/xfs/Makefile +1 -0
@@ -39,6 +39,7 @@ xfs-y += $(addprefix libxfs/, \ xfs_iext_tree.o \ xfs_inode_fork.o \ xfs_inode_buf.o \ + xfs_inode_util.o \ xfs_log_rlimit.o \ xfs_ag_resv.o \ xfs_parent.o \
fs/xfs/libxfs/xfs_bmap.c +1 -0
@@ -39,6 +39,7 @@#include "xfs_health.h" #include "xfs_bmap_item.h" #include "xfs_symlink_remote.h" +#include "xfs_inode_util.h" struct kmem_cache *xfs_bmap_intent_cache;
fs/xfs/libxfs/xfs_inode_util.c new file +124 -0
124 lines not on this page · raw message
fs/xfs/libxfs/xfs_inode_util.h new file +14 -0
@@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc. +* All Rights Reserved. +*/ +#ifndef __XFS_INODE_UTIL_H__ +#define __XFS_INODE_UTIL_H__ + +uint16_t xfs_flags2diflags (struct xfs_inode *ip,unsigned int xflags); +uint64_t xfs_flags2diflags2 (struct xfs_inode *ip,unsigned int xflags); +uint32_t xfs_dic2xflags (struct xfs_inode *ip); +uint32_t xfs_ip2xflags (struct xfs_inode *ip); + +#endif /* __XFS_INODE_UTIL_H__ */
fs/xfs/xfs_inode.c +0 -49
55 lines not on this page · raw message
fs/xfs/xfs_inode.h +1 -1
@@ -8,6 +8,7 @@#include "xfs_inode_buf.h" #include "xfs_inode_fork.h" +#include "xfs_inode_util.h" /* * Kernel only inode definitions
@@ -545,7 +546,6 @@ bool xfs_isilocked(struct xfs_inode *, uint);uint xfs_ilock_data_map_shared (struct xfs_inode *);uint xfs_ilock_attr_map_shared (struct xfs_inode *); -uint xfs_ip2xflags (struct xfs_inode *);int xfs_ifree (struct xfs_trans *,struct xfs_inode *);int xfs_itruncate_extents_flags (struct xfs_trans **,struct xfs_inode *,int ,xfs_fsize_t ,int );
fs/xfs/xfs_ioctl.c +0 -60
66 lines not on this page · raw message
PATCH 4/21 xfs: hoist project id get/set functions to libxfs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move the project id get and set functions into libxfs.
--- fs/xfs/libxfs/xfs_inode_util.c | 11 +++++++++++ fs/xfs/libxfs/xfs_inode_util.h | 2 ++ fs/xfs/xfs_inode.h | 9 --------- fs/xfs/xfs_linux.h | 2 -- 4 files changed, 13 insertions(+), 11 deletions(-)
fs/xfs/libxfs/xfs_inode_util.c +11 -0
@@ -122,3 +122,14 @@ xfs_ip2xflags( flags |=FS_XFLAG_HASATTR ;return flags; } + +#define XFS_PROJID_DEFAULT 0 + +prid_t +xfs_get_initial_prid (struct xfs_inode *dp) +{ +if (dp->i_diflags &XFS_DIFLAG_PROJINHERIT ) +return dp->i_projid; + +return XFS_PROJID_DEFAULT ; +}
fs/xfs/libxfs/xfs_inode_util.h +2 -0
@@ -11,4 +11,6 @@ uint64_t xfs_flags2diflags2(struct xfs_inode *ip, unsigned int xflags);uint32_t xfs_dic2xflags (struct xfs_inode *ip);uint32_t xfs_ip2xflags (struct xfs_inode *ip); +prid_t xfs_get_initial_prid (struct xfs_inode *dp); +#endif /* __XFS_INODE_UTIL_H__ */
fs/xfs/xfs_inode.h +0 -9
@@ -271,15 +271,6 @@ xfs_iflags_test_and_set(xfs_inode_t *ip, unsigned short flags)return ret; } -static inline prid_t -xfs_get_initial_prid (struct xfs_inode *dp) -{ -if (dp->i_diflags &XFS_DIFLAG_PROJINHERIT ) -return dp->i_projid; - -return XFS_PROJID_DEFAULT ; -} -static inline bool xfs_is_reflink_inode (struct xfs_inode *ip) {return ip->i_diflags2 &XFS_DIFLAG2_REFLINK ;
fs/xfs/xfs_linux.h +0 -2
@@ -137,8 +137,6 @@ typedef __u32 xfs_nlink_t;*/ #define __this_address ({ __label__ __here; __here: barrier(); &&__here; }) -#define XFS_PROJID_DEFAULT 0 -#define howmany (x, y) (((x)+((y)-1))/(y))static inline void delay (long ticks)
PATCH 5/21 xfs: pack icreate initialization parameters into a separate structure
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Callers that want to create an inode currently pass all possible file attribute values for the new inode into xfs_init_new_inode as ten separate parameters. This causes two code maintenance issues: first, we have large multi-line call sites which programmers must read carefully to make sure they did not accidentally invert a value. Second, all three file id parameters must be passed separately to the quota functions; any discrepancy results in quota count errors.
Clean this up by creating a new icreate_args structure to hold all this information, some helpers to initialize them properly, and make the callers pass this structure through to the creation function, whose name we shorten to xfs_icreate. This eliminates the issues, enables us to keep the inode init code in sync with userspace via libxfs, and is needed for future metadata directory tree management.
(A subsequent cleanup will also fix the quota alloc calls.)
--- fs/xfs/libxfs/xfs_inode_util.h | 32 ++++++++++++ fs/xfs/scrub/tempfile.c | 13 +++-- fs/xfs/xfs_inode.c | 106 +++++++++++++++++++++++++++++----------- fs/xfs/xfs_inode.h | 12 +++-- fs/xfs/xfs_qm.c | 9 +++ fs/xfs/xfs_symlink.c | 14 +++-- 6 files changed, 138 insertions(+), 48 deletions(-)
fs/xfs/libxfs/xfs_inode_util.h +32 -0
@@ -13,4 +13,36 @@ uint32_t xfs_ip2xflags(struct xfs_inode *ip);prid_t xfs_get_initial_prid (struct xfs_inode *dp); +/* +* Initial ids, link count, device number, and mode of a new inode. +* +* Due to our only partial reliance on the VFS to propagate uid and gid values +* according to accepted Unix behaviors, callers must initialize mnt_userns to +* the appropriate namespace, uid to fsuid_into_mnt(), and gid to +* fsgid_into_mnt() to get the correct inheritance behaviors when +* XFS_MOUNT_GRPID is set. Use the xfs_ialloc_inherit_args() helper. +* +* To override the default ids, use the FORCE flags defined below. +*/ +struct xfs_icreate_args { +struct mnt_idmap *idmap; + +struct xfs_inode *pip;/* parent inode or null */ + +kuid_t uid; +kgid_t gid; +prid_t prid; + +xfs_nlink_t nlink; +dev_t rdev; + +umode_t mode; + +#define XFS_ICREATE_ARGS_FORCE_UID (1 << 0) +#define XFS_ICREATE_ARGS_FORCE_GID (1 << 1) +#define XFS_ICREATE_ARGS_FORCE_MODE (1 << 2) +#define XFS_ICREATE_ARGS_INIT_XATTRS (1 << 3) +uint16_t flags; +}; +#endif /* __XFS_INODE_UTIL_H__ */
fs/xfs/scrub/tempfile.c +7 -6
@@ -40,6 +40,7 @@ xrep_tempfile_create( struct xfs_scrub *sc, uint16_t mode) { +struct xfs_icreate_args args = { .pip = sc->mp->m_rootip, };struct xfs_mount *mp = sc->mp;struct xfs_trans *tp =NULL ;struct xfs_dquot *udqp =NULL ;
@@ -60,12 +61,15 @@ xrep_tempfile_create(ASSERT (sc->tp ==NULL );ASSERT (sc->tempip ==NULL ); +/* Force everything to have the root ids and mode we want. */ +xfs_icreate_args_rootfile (&args, mp, mode, false); +/* * Make sure that we have allocated dquot(s) on disk. The temporary * inode should be completely root owned so that we don't fail due to * quota limits. */ - error =xfs_qm_vop_dqalloc (dp,GLOBAL_ROOT_UID ,GLOBAL_ROOT_GID ,0 , + error =xfs_qm_vop_dqalloc (dp, args.uid, args.gid, args.prid,XFS_QMOPT_QUOTALL , &udqp, &gdqp, &pdqp);if (error)return error;
@@ -87,14 +91,11 @@ xrep_tempfile_create( error =xfs_dialloc (&tp, dp->i_ino, mode, &ino);if (error) goto out_trans_cancel; - error =xfs_init_new_inode (&nop_mnt_idmap, tp, dp, ino, mode,0 ,0 , -0 , false, &sc->tempip); + error =xfs_icreate (tp, ino, &args, &sc->tempip);if (error) goto out_trans_cancel; -/* Change the ownership of the inode to root. */ -VFS_I (sc->tempip)->i_uid =GLOBAL_ROOT_UID ; -VFS_I (sc->tempip)->i_gid =GLOBAL_ROOT_GID ; +/* We don't touch file data, so drop the realtime flags. */ sc->tempip->i_diflags &= ~(XFS_DIFLAG_REALTIME |XFS_DIFLAG_RTINHERIT );xfs_trans_log_inode (tp, sc->tempip,XFS_ILOG_CORE );
fs/xfs/xfs_inode.c +77 -29
206 lines not on this page · raw message
fs/xfs/xfs_inode.h +8 -4
@@ -550,10 +550,8 @@ int xfs_iflush_cluster(struct xfs_buf *);void xfs_lock_two_inodes (struct xfs_inode *ip0,uint ip0_mode,struct xfs_inode *ip1,uint ip1_mode); -int xfs_init_new_inode (struct mnt_idmap *idmap,struct xfs_trans *tp, -struct xfs_inode *pip,xfs_ino_t ino,umode_t mode, -xfs_nlink_t nlink,dev_t rdev,prid_t prid,bool init_xattrs, -struct xfs_inode **ipp); +int xfs_icreate (struct xfs_trans *tp,xfs_ino_t ino, +const struct xfs_icreate_args *args,struct xfs_inode **ipp);static inline int xfs_itruncate_extents(
@@ -661,4 +659,10 @@ void xfs_dir_hook_del(struct xfs_mount *mp, struct xfs_dir_hook *hook);# define xfs_dir_update_hook (dp, ip, delta, name) ((void)0)#endif /* CONFIG_XFS_LIVE_HOOKS */ +void xfs_icreate_args_inherit (struct xfs_icreate_args *args, +struct xfs_inode *dp,struct mnt_idmap *idmap,umode_t mode, +bool init_xattrs); +void xfs_icreate_args_rootfile (struct xfs_icreate_args *args, +struct xfs_mount *mp,umode_t mode,bool init_xattrs); +#endif /* __XFS_INODE_H__ */
fs/xfs/xfs_qm.c +7 -2
@@ -792,12 +792,17 @@ xfs_qm_qino_alloc(return error;if (need_alloc) { +struct xfs_icreate_args args = { + .nlink =1 , + };xfs_ino_t ino; +xfs_icreate_args_rootfile (&args, mp,S_IFREG , +xfs_has_parent (mp)); + error =xfs_dialloc (&tp,0 ,S_IFREG , &ino);if (!error) - error =xfs_init_new_inode (&nop_mnt_idmap, tp,NULL , ino, -S_IFREG ,1 ,0 ,0 , false, ipp); + error =xfs_icreate (tp, ino, &args, ipp);if (error) {xfs_trans_cancel (tp);return error;
fs/xfs/xfs_symlink.c +7 -7
@@ -90,6 +90,9 @@ xfs_symlink(umode_t mode, struct xfs_inode **ipp) { + struct xfs_icreate_args args = { + .nlink =1 , + };struct xfs_mount *mp = dp->i_mount;struct xfs_trans *tp =NULL ;struct xfs_inode *ip =NULL ;
@@ -97,7 +100,6 @@ xfs_symlink(int pathlen;bool unlock_dp_on_error = false;xfs_filblks_t fs_blocks; -prid_t prid;struct xfs_dquot *udqp =NULL ;struct xfs_dquot *gdqp =NULL ;struct xfs_dquot *pdqp =NULL ;
@@ -120,13 +122,13 @@ xfs_symlink(return -ENAMETOOLONG ;ASSERT (pathlen >0 ); - prid =xfs_get_initial_prid (dp); +xfs_icreate_args_inherit (&args, dp, idmap,S_IFLNK | (mode & ~S_IFMT ), +xfs_has_parent (mp));/* * Make sure that we have allocated dquot(s) on disk. */ - error =xfs_qm_vop_dqalloc (dp,mapped_fsuid (idmap, &init_user_ns), -mapped_fsgid (idmap, &init_user_ns), prid, + error =xfs_qm_vop_dqalloc (dp, args.uid, args.gid, args.prid,XFS_QMOPT_QUOTALL |XFS_QMOPT_INHERIT , &udqp, &gdqp, &pdqp);if (error)
@@ -169,9 +171,7 @@ xfs_symlink(*/ error =xfs_dialloc (&tp, dp->i_ino,S_IFLNK , &ino);if (!error) - error =xfs_init_new_inode (idmap, tp, dp, ino, -S_IFLNK | (mode & ~S_IFMT ),1 ,0 , prid, -xfs_has_parent (mp), &ip); + error =xfs_icreate (tp, ino, &args, &ip);if (error) goto out_trans_cancel;
PATCH 6/21 xfs: implement atime updates in xfs_trans_ichgtime
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Enable xfs_trans_ichgtime to change the inode access time so that we can use this function to set inode times when allocating inodes instead of open-coding it.
--- fs/xfs/libxfs/xfs_shared.h | 1 + fs/xfs/libxfs/xfs_trans_inode.c | 2 ++ 2 files changed, 3 insertions(+)
fs/xfs/libxfs/xfs_shared.h +1 -0
@@ -136,6 +136,7 @@ void xfs_log_get_max_trans_res(struct xfs_mount *mp,#define XFS_ICHGTIME_MOD 0x1/* data fork modification timestamp */ #define XFS_ICHGTIME_CHG 0x2/* inode field change timestamp */ #define XFS_ICHGTIME_CREATE 0x4/* inode create timestamp */ +#define XFS_ICHGTIME_ACCESS 0x8/* last access timestamp */ /* Computed inode geometry for the filesystem. */ struct xfs_ino_geometry {
fs/xfs/libxfs/xfs_trans_inode.c +2 -0
@@ -68,6 +68,8 @@ xfs_trans_ichgtime(inode_set_mtime_to_ts (inode, tv);if (flags &XFS_ICHGTIME_CHG )inode_set_ctime_to_ts (inode, tv); +if (flags &XFS_ICHGTIME_ACCESS ) +inode_set_atime_to_ts (inode, tv);if (flags &XFS_ICHGTIME_CREATE ) ip->i_crtime = tv; }
PATCH 7/21 xfs: use xfs_trans_ichgtime to set times when allocating inode
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Use xfs_trans_ichgtime to set the inode times when allocating an inode, instead of open-coding them here.
--- fs/xfs/xfs_inode.c | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-)
fs/xfs/xfs_inode.c +7 -8
@@ -693,10 +693,11 @@ xfs_icreate(struct inode *dir = pip ?VFS_I (pip) :NULL ;struct xfs_mount *mp = tp->t_mountp;struct xfs_inode *ip; -unsigned int flags; -int error; -struct timespec64 tv;struct inode *inode; +unsigned int flags; +int times =XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG | +XFS_ICHGTIME_ACCESS ; +int error;/* * Protect against obviously corrupt allocation btree records. Later
@@ -759,19 +760,17 @@ xfs_icreate( ip->i_df.if_nextents =0 ;ASSERT (ip->i_nblocks ==0 ); - tv =inode_set_ctime_current (inode); -inode_set_mtime_to_ts (inode, tv); -inode_set_atime_to_ts (inode, tv); - ip->i_extsize =0 ; ip->i_diflags =0 ;if (xfs_has_v3inodes (mp)) {inode_set_iversion (inode,1 ); ip->i_cowextsize =0 ; - ip->i_crtime = tv; + times |=XFS_ICHGTIME_CREATE ; } +xfs_trans_ichgtime (tp, ip, times); + flags =XFS_ILOG_CORE ;switch (args->mode &S_IFMT ) {case S_IFIFO :
PATCH 8/21 xfs: split new inode creation into two pieces
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
There are two parts to initializing a newly allocated inode: setting up the incore structures, and initializing the new inode core based on the parent inode and the current user's environment. The initialization code is not specific to the kernel, so we would like to share that with userspace by hoisting it to libxfs. Therefore, split xfs_icreate into separate functions to prepare for the next few patches.
--- fs/xfs/libxfs/xfs_ialloc.c | 15 +++++++++ fs/xfs/xfs_inode.c | 76 ++++++++++++++++++++------------------------ 2 files changed, 50 insertions(+), 41 deletions(-)
fs/xfs/libxfs/xfs_ialloc.c +15 -0
@@ -1901,6 +1901,21 @@ xfs_dialloc( }return -ENOSPC ; } + +/* +* Protect against obviously corrupt allocation btree records. Later +* xfs_iget checks will catch re-allocation of other active in-memory +* and on-disk inodes. If we don't catch reallocating the parent inode +* here we will deadlock in xfs_iget() so we have to do these checks +* first. +*/ +if (ino == parent || !xfs_verify_dir_ino (mp, ino)) { +xfs_alert (mp,"Allocated a known in-use inode 0x%llx!" , ino); +xfs_agno_mark_sick (mp,XFS_INO_TO_AGNO (mp, ino), +XFS_SICK_AG_INOBT ); +return -EFSCORRUPTED ; + } + *new_ino = ino;return 0 ; }
fs/xfs/xfs_inode.c +35 -41
99 lines not on this page · raw message
PATCH 9/21 xfs: hoist new inode initialization functions to libxfs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move all the code that initializes a new inode's attributes from the icreate_args structure and the parent directory into libxfs.
--- fs/xfs/libxfs/xfs_inode_util.c | 202 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_inode_util.h | 12 ++ fs/xfs/libxfs/xfs_shared.h | 8 -- fs/xfs/xfs_inode.c | 198 --------------------------------------- fs/xfs/xfs_trans.h | 1 5 files changed, 215 insertions(+), 206 deletions(-)
fs/xfs/libxfs/xfs_inode_util.c +202 -0
@@ -3,6 +3,7 @@* Copyright (c) 2000-2006 Silicon Graphics, Inc. * All Rights Reserved. */ +#include <linux/iversion.h> #include "xfs.h" #include "xfs_fs.h" #include "xfs_shared.h"
@@ -13,6 +14,10 @@#include "xfs_mount.h" #include "xfs_inode.h" #include "xfs_inode_util.h" +#include "xfs_trans.h" +#include "xfs_ialloc.h" +#include "xfs_health.h" +#include "xfs_bmap.h" uint16_t xfs_flags2diflags(
@@ -133,3 +138,200 @@ xfs_get_initial_prid(struct xfs_inode *dp)return XFS_PROJID_DEFAULT ; } + +/* Propagate di_flags from a parent inode to a child inode. */ +static inline void +xfs_inode_inherit_flags ( +struct xfs_inode *ip, +const struct xfs_inode *pip) +{ +unsigned int di_flags =0 ; +xfs_failaddr_t failaddr; +umode_t mode =VFS_I (ip)->i_mode; + +if (S_ISDIR (mode)) { +if (pip->i_diflags &XFS_DIFLAG_RTINHERIT ) + di_flags |=XFS_DIFLAG_RTINHERIT ; +if (pip->i_diflags &XFS_DIFLAG_EXTSZINHERIT ) { + di_flags |=XFS_DIFLAG_EXTSZINHERIT ; + ip->i_extsize = pip->i_extsize; + } +if (pip->i_diflags &XFS_DIFLAG_PROJINHERIT ) + di_flags |=XFS_DIFLAG_PROJINHERIT ; + }else if (S_ISREG (mode)) { +if ((pip->i_diflags &XFS_DIFLAG_RTINHERIT ) && +xfs_has_realtime (ip->i_mount)) + di_flags |=XFS_DIFLAG_REALTIME ; +if (pip->i_diflags &XFS_DIFLAG_EXTSZINHERIT ) { + di_flags |=XFS_DIFLAG_EXTSIZE ; + ip->i_extsize = pip->i_extsize; + } + } +if ((pip->i_diflags &XFS_DIFLAG_NOATIME ) && + xfs_inherit_noatime) + di_flags |=XFS_DIFLAG_NOATIME ; +if ((pip->i_diflags &XFS_DIFLAG_NODUMP ) && + xfs_inherit_nodump) + di_flags |=XFS_DIFLAG_NODUMP ; +if ((pip->i_diflags &XFS_DIFLAG_SYNC ) && + xfs_inherit_sync) + di_flags |=XFS_DIFLAG_SYNC ; +if ((pip->i_diflags &XFS_DIFLAG_NOSYMLINKS ) && + xfs_inherit_nosymlinks) + di_flags |=XFS_DIFLAG_NOSYMLINKS ; +if ((pip->i_diflags &XFS_DIFLAG_NODEFRAG ) && + xfs_inherit_nodefrag) + di_flags |=XFS_DIFLAG_NODEFRAG ; +if (pip->i_diflags &XFS_DIFLAG_FILESTREAM ) + di_flags |=XFS_DIFLAG_FILESTREAM ; + + ip->i_diflags |= di_flags; + +/* +* Inode verifiers on older kernels only check that the extent size +* hint is an integer multiple of the rt extent size on realtime files. +* They did not check the hint alignment on a directory with both +* rtinherit and extszinherit flags set. If the misaligned hint is +* propagated from a directory into a new realtime file, new file +* allocations will fail due to math errors in the rt allocator and/or +* trip the verifiers. Validate the hint settings in the new file so +* that we don't let broken hints propagate. +*/ + failaddr =xfs_inode_validate_extsize (ip->i_mount, ip->i_extsize, +VFS_I (ip)->i_mode, ip->i_diflags); +if (failaddr) { + ip->i_diflags &= ~(XFS_DIFLAG_EXTSIZE | +XFS_DIFLAG_EXTSZINHERIT ); + ip->i_extsize =0 ; + } +} + +/* Propagate di_flags2 from a parent inode to a child inode. */ +static inline void +xfs_inode_inherit_flags2 ( +struct xfs_inode *ip, +const struct xfs_inode *pip) +{ +xfs_failaddr_t failaddr; + +if (pip->i_diflags2 &XFS_DIFLAG2_COWEXTSIZE ) { + ip->i_diflags2 |=XFS_DIFLAG2_COWEXTSIZE ; + ip->i_cowextsize = pip->i_cowextsize; + } +if (pip->i_diflags2 &XFS_DIFLAG2_DAX ) + ip->i_diflags2 |=XFS_DIFLAG2_DAX ; + +/* Don't let invalid cowextsize hints propagate. */ + failaddr =xfs_inode_validate_cowextsize (ip->i_mount, ip->i_cowextsize, +VFS_I (ip)->i_mode, ip->i_diflags, ip->i_diflags2); +if (failaddr) { + ip->i_diflags2 &= ~XFS_DIFLAG2_COWEXTSIZE ; + ip->i_cowextsize =0 ; + } +} + +/* Initialise an inode's attributes. */ +void +xfs_inode_init ( +struct xfs_trans *tp, +const struct xfs_icreate_args *args, +struct xfs_inode *ip) +{ +struct xfs_inode *pip = args->pip; +struct inode *dir = pip ?VFS_I (pip) :NULL ; +struct xfs_mount *mp = tp->t_mountp; +struct inode *inode =VFS_I (ip); +unsigned int flags; +int times =XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG | +XFS_ICHGTIME_ACCESS ; + +set_nlink (inode, args->nlink); + inode->i_rdev = args->rdev; + ip->i_projid = args->prid; + +if (dir && !(dir->i_mode &S_ISGID ) &&xfs_has_grpid (mp)) { +inode_fsuid_set (inode, args->idmap); + inode->i_gid = dir->i_gid; + inode->i_mode = args->mode; + }else { +inode_init_owner (args->idmap, inode, dir, args->mode); + } + +/* +* If the group ID of the new file does not match the effective group +* ID or one of the supplementary group IDs, the S_ISGID bit is cleared +* (and only if the irix_sgid_inherit compatibility variable is set). +*/ +if (irix_sgid_inherit && (inode->i_mode &S_ISGID ) && + !vfsgid_in_group_p (i_gid_into_vfsgid (args->idmap, inode))) + inode->i_mode &= ~S_ISGID ; + +/* struct copies */ +if (args->flags &XFS_ICREATE_ARGS_FORCE_UID ) + inode->i_uid = args->uid; +else +ASSERT (uid_eq (inode->i_uid, args->uid)); +if (args->flags &XFS_ICREATE_ARGS_FORCE_GID ) + inode->i_gid = args->gid; +else if (!pip || !XFS_INHERIT_GID (pip)) +ASSERT (gid_eq (inode->i_gid, args->gid)); +if (args->flags &XFS_ICREATE_ARGS_FORCE_MODE ) + inode->i_mode = args->mode; + + ip->i_disk_size =0 ; + ip->i_df.if_nextents =0 ; +ASSERT (ip->i_nblocks ==0 ); + + ip->i_extsize =0 ; + ip->i_diflags =0 ; + +if (xfs_has_v3inodes (mp)) { +inode_set_iversion (inode,1 ); + ip->i_cowextsize =0 ; + times |=XFS_ICHGTIME_CREATE ; + } + +xfs_trans_ichgtime (tp, ip, times); + + flags =XFS_ILOG_CORE ; +switch (args->mode &S_IFMT ) { +case S_IFIFO : +case S_IFCHR : +case S_IFBLK : +case S_IFSOCK : + ip->i_df.if_format =XFS_DINODE_FMT_DEV ; + flags |=XFS_ILOG_DEV ; +break ; +case S_IFREG : +case S_IFDIR : +if (pip && (pip->i_diflags &XFS_DIFLAG_ANY )) +xfs_inode_inherit_flags (ip, pip); +if (pip && (pip->i_diflags2 &XFS_DIFLAG2_ANY )) +xfs_inode_inherit_flags2 (ip, pip); + fallthrough; +case S_IFLNK : + ip->i_df.if_format =XFS_DINODE_FMT_EXTENTS ; + ip->i_df.if_bytes =0 ; + ip->i_df.if_u1.if_root =NULL ; +break ; +default : +ASSERT (0 ); + } + +/* +* If we need to create attributes immediately after allocating the +* inode, initialise an empty attribute fork right now. We use the +* default fork offset for attributes here as we don't know exactly what +* size or how many attributes we might be adding. We can do this +* safely here because we know the data fork is completely empty and +* this saves us from needing to run a separate transaction to set the +* fork offset in the immediate future. +*/ +if ((args->flags &XFS_ICREATE_ARGS_INIT_XATTRS ) && +xfs_has_attr (mp)) { + ip->i_forkoff =xfs_default_attroffset (ip) >>3 ; +xfs_ifork_init_attr (ip,XFS_DINODE_FMT_EXTENTS ,0 ); + } + +xfs_trans_log_inode (tp, ip, flags); +}
fs/xfs/libxfs/xfs_inode_util.h +12 -0
@@ -45,4 +45,16 @@ struct xfs_icreate_args { uint16_t flags; }; +/* +* Flags for xfs_trans_ichgtime(). +*/ +#define XFS_ICHGTIME_MOD 0x1/* data fork modification timestamp */ +#define XFS_ICHGTIME_CHG 0x2/* inode field change timestamp */ +#define XFS_ICHGTIME_CREATE 0x4/* inode create timestamp */ +#define XFS_ICHGTIME_ACCESS 0x8/* last access timestamp */ +void xfs_trans_ichgtime (struct xfs_trans *tp,struct xfs_inode *ip,int flags); + +void xfs_inode_init (struct xfs_trans *tp,const struct xfs_icreate_args *args, +struct xfs_inode *ip); +#endif /* __XFS_INODE_UTIL_H__ */
fs/xfs/libxfs/xfs_shared.h +0 -8
@@ -130,14 +130,6 @@ void xfs_log_get_max_trans_res(struct xfs_mount *mp,#define XFS_REFC_BTREE_REF 1#define XFS_SSB_REF 0 -/* -* Flags for xfs_trans_ichgtime(). -*/ -#define XFS_ICHGTIME_MOD 0x1/* data fork modification timestamp */ -#define XFS_ICHGTIME_CHG 0x2/* inode field change timestamp */ -#define XFS_ICHGTIME_CREATE 0x4/* inode create timestamp */ -#define XFS_ICHGTIME_ACCESS 0x8/* last access timestamp */ -/* Computed inode geometry for the filesystem. */ struct xfs_ino_geometry {/* Maximum inode count in this filesystem. */
fs/xfs/xfs_inode.c +1 -197
210 lines not on this page · raw message
fs/xfs/xfs_trans.h +0 -1
@@ -224,7 +224,6 @@ void xfs_trans_stale_inode_buf(xfs_trans_t *, struct xfs_buf *);bool xfs_trans_ordered_buf (xfs_trans_t *,struct xfs_buf *);void xfs_trans_dquot_buf (xfs_trans_t *,struct xfs_buf *,uint );void xfs_trans_inode_alloc_buf (xfs_trans_t *,struct xfs_buf *); -void xfs_trans_ichgtime (struct xfs_trans *,struct xfs_inode *,int );void xfs_trans_ijoin (struct xfs_trans *,struct xfs_inode *,uint );void xfs_trans_log_buf (struct xfs_trans *,struct xfs_buf *,uint ,uint );
PATCH 10/21 xfs: push xfs_icreate_args creation out of xfs_create*
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move the initialization of the xfs_icreate_args structure out of xfs_create and xfs_create_tempfile into their callers so that we can set the new inode's attributes in one place and pass that through instead of open coding the collection of attributes all over the code.
--- fs/xfs/xfs_inode.c | 65 ++++++++++++++++++++++++---------------------------- fs/xfs/xfs_inode.h | 9 +++---- fs/xfs/xfs_iops.c | 46 ++++++++++++++++++++++--------------- 3 files changed, 62 insertions(+), 58 deletions(-)
fs/xfs/xfs_inode.c +30 -35
@@ -784,32 +784,26 @@ xfs_dir_hook_del(int xfs_create ( -struct mnt_idmap *idmap,struct xfs_inode *dp,struct xfs_name *name, -umode_t mode, -dev_t rdev, -bool init_xattrs, -xfs_inode_t **ipp) +const struct xfs_icreate_args *args, +struct xfs_inode **ipp) { -struct xfs_icreate_args args = { - .rdev = rdev, - .nlink =S_ISDIR (mode) ?2 :1 , - }; -int is_dir =S_ISDIR (mode);struct xfs_mount *mp = dp->i_mount;struct xfs_inode *ip =NULL ;struct xfs_trans *tp =NULL ; -int error; +struct xfs_dquot *udqp =NULL ; +struct xfs_dquot *gdqp =NULL ; +struct xfs_dquot *pdqp =NULL ; +struct xfs_trans_res *tres; +struct xfs_parent_args *ppargs; +xfs_ino_t ino;bool unlock_dp_on_error = false; -struct xfs_dquot *udqp =NULL ; -struct xfs_dquot *gdqp =NULL ; -struct xfs_dquot *pdqp =NULL ; -struct xfs_trans_res *tres; +bool is_dir =S_ISDIR (args->mode);uint resblks; -xfs_ino_t ino; -struct xfs_parent_args *ppargs; +int error; +ASSERT (args->pip == dp);trace_xfs_create (dp, name);if (xfs_is_shutdown (mp))
@@ -817,12 +811,10 @@ xfs_create(if (xfs_ifork_zapped (dp,XFS_DATA_FORK ))return -EIO ; -xfs_icreate_args_inherit (&args, dp, idmap, mode, init_xattrs); -/* * Make sure that we have allocated dquot(s) on disk. */ - error =xfs_qm_vop_dqalloc (dp, args.uid, args.gid, args.prid, + error =xfs_qm_vop_dqalloc (dp, args->uid, args->gid, args->prid,XFS_QMOPT_QUOTALL |XFS_QMOPT_INHERIT , &udqp, &gdqp, &pdqp);if (error)
@@ -865,9 +857,9 @@ xfs_create(* entry pointing to them, but a directory also the "." entry * pointing to itself. */ - error =xfs_dialloc (&tp, dp->i_ino, mode, &ino); + error =xfs_dialloc (&tp, dp->i_ino, args->mode, &ino);if (!error) - error =xfs_icreate (tp, ino, &args, &ip); + error =xfs_icreate (tp, ino, args, &ip);if (error) goto out_trans_cancel;
@@ -967,33 +959,31 @@ xfs_create(int xfs_create_tmpfile ( -struct mnt_idmap *idmap,struct xfs_inode *dp, -umode_t mode, -bool init_xattrs, +const struct xfs_icreate_args *args,struct xfs_inode **ipp) { -struct xfs_icreate_args args = {NULL };struct xfs_mount *mp = dp->i_mount;struct xfs_inode *ip =NULL ;struct xfs_trans *tp =NULL ; -int error;struct xfs_dquot *udqp =NULL ;struct xfs_dquot *gdqp =NULL ;struct xfs_dquot *pdqp =NULL ;struct xfs_trans_res *tres; -uint resblks;xfs_ino_t ino; +uint resblks; +int error; + +ASSERT (args->nlink ==0 ); +ASSERT (args->pip == dp);if (xfs_is_shutdown (mp))return -EIO ; -xfs_icreate_args_inherit (&args, dp, idmap, mode, init_xattrs); -/* * Make sure that we have allocated dquot(s) on disk. */ - error =xfs_qm_vop_dqalloc (dp, args.uid, args.gid, args.prid, + error =xfs_qm_vop_dqalloc (dp, args->uid, args->gid, args->prid,XFS_QMOPT_QUOTALL |XFS_QMOPT_INHERIT , &udqp, &gdqp, &pdqp);if (error)
@@ -1007,9 +997,9 @@ xfs_create_tmpfile(if (error) goto out_release_dquots; - error =xfs_dialloc (&tp, dp->i_ino, mode, &ino); + error =xfs_dialloc (&tp, dp->i_ino, args->mode, &ino);if (!error) - error =xfs_icreate (tp, ino, &args, &ip); + error =xfs_icreate (tp, ino, args, &ip);if (error) goto out_trans_cancel;
@@ -2858,12 +2848,17 @@ xfs_rename_alloc_whiteout(struct xfs_inode *dp, struct xfs_inode **wip) { + struct xfs_icreate_args args = { + .nlink =0 , + };struct xfs_inode *tmpfile;struct qstr name;int error; - error =xfs_create_tmpfile (idmap, dp,S_IFCHR |WHITEOUT_MODE , -xfs_has_parent (dp->i_mount), &tmpfile); +xfs_icreate_args_inherit (&args, dp, idmap,S_IFCHR |WHITEOUT_MODE , +xfs_has_parent (dp->i_mount)); + + error =xfs_create_tmpfile (dp, &args, &tmpfile);if (error)return error;
fs/xfs/xfs_inode.h +4 -5
@@ -512,12 +512,11 @@ int xfs_release(struct xfs_inode *ip);int xfs_inactive (struct xfs_inode *ip);int xfs_lookup (struct xfs_inode *dp,const struct xfs_name *name,struct xfs_inode **ipp,struct xfs_name *ci_name); -int xfs_create (struct mnt_idmap *idmap, -struct xfs_inode *dp,struct xfs_name *name, -umode_t mode,dev_t rdev,bool need_xattr, +int xfs_create (struct xfs_inode *dp,struct xfs_name *name, +const struct xfs_icreate_args *iargs,struct xfs_inode **ipp); -int xfs_create_tmpfile (struct mnt_idmap *idmap, -struct xfs_inode *dp,umode_t mode,bool init_xattrs, +int xfs_create_tmpfile (struct xfs_inode *dp, +const struct xfs_icreate_args *iargs,struct xfs_inode **ipp);int xfs_remove (struct xfs_inode *dp,struct xfs_name *name,struct xfs_inode *ip);
fs/xfs/xfs_iops.c +28 -18
77 lines not on this page · raw message
PATCH 11/21 xfs: wrap inode creation dqalloc calls
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a helper that calls dqalloc to allocate and grab a reference to dquots for the user, group, and project ids listed in an icreate structure. This simplifies the creat-related dqalloc callsites scattered around the code base.
--- fs/xfs/scrub/tempfile.c | 9 ++++----- fs/xfs/xfs_inode.c | 38 ++++++++++++++++++++++++++------------ fs/xfs/xfs_inode.h | 3 +++ fs/xfs/xfs_symlink.c | 10 ++++------ 4 files changed, 37 insertions(+), 23 deletions(-)
fs/xfs/scrub/tempfile.c +4 -5
@@ -43,9 +43,9 @@ xrep_tempfile_create(struct xfs_icreate_args args = { .pip = sc->mp->m_rootip, };struct xfs_mount *mp = sc->mp;struct xfs_trans *tp =NULL ; -struct xfs_dquot *udqp =NULL ; -struct xfs_dquot *gdqp =NULL ; -struct xfs_dquot *pdqp =NULL ; +struct xfs_dquot *udqp; +struct xfs_dquot *gdqp; +struct xfs_dquot *pdqp;struct xfs_trans_res *tres;struct xfs_inode *dp = mp->m_rootip;xfs_ino_t ino;
@@ -69,8 +69,7 @@ xrep_tempfile_create(* inode should be completely root owned so that we don't fail due to * quota limits. */ - error =xfs_qm_vop_dqalloc (dp, args.uid, args.gid, args.prid, -XFS_QMOPT_QUOTALL , &udqp, &gdqp, &pdqp); + error =xfs_icreate_dqalloc (&args, &udqp, &gdqp, &pdqp);if (error)return error;
fs/xfs/xfs_inode.c +26 -12
@@ -782,6 +782,24 @@ xfs_dir_hook_del( }#endif /* CONFIG_XFS_LIVE_HOOKS */ +int +xfs_icreate_dqalloc ( +const struct xfs_icreate_args *args, +struct xfs_dquot **udqpp, +struct xfs_dquot **gdqpp, +struct xfs_dquot **pdqpp) +{ +unsigned int flags =XFS_QMOPT_QUOTALL ; + + *udqpp = *gdqpp = *pdqpp =NULL ; + +if (!(args->flags &XFS_ICREATE_ARGS_FORCE_GID )) + flags |=XFS_QMOPT_INHERIT ; + +return xfs_qm_vop_dqalloc (args->pip, args->uid, args->gid, args->prid, + flags, udqpp, gdqpp, pdqpp); +} + int xfs_create( struct xfs_inode *dp,
@@ -792,9 +810,9 @@ xfs_create(struct xfs_mount *mp = dp->i_mount;struct xfs_inode *ip =NULL ;struct xfs_trans *tp =NULL ; -struct xfs_dquot *udqp =NULL ; -struct xfs_dquot *gdqp =NULL ; -struct xfs_dquot *pdqp =NULL ; +struct xfs_dquot *udqp; +struct xfs_dquot *gdqp; +struct xfs_dquot *pdqp;struct xfs_trans_res *tres;struct xfs_parent_args *ppargs;xfs_ino_t ino;
@@ -814,9 +832,7 @@ xfs_create(/* * Make sure that we have allocated dquot(s) on disk. */ - error =xfs_qm_vop_dqalloc (dp, args->uid, args->gid, args->prid, -XFS_QMOPT_QUOTALL |XFS_QMOPT_INHERIT , - &udqp, &gdqp, &pdqp); + error =xfs_icreate_dqalloc (args, &udqp, &gdqp, &pdqp);if (error)return error;
@@ -966,9 +982,9 @@ xfs_create_tmpfile(struct xfs_mount *mp = dp->i_mount;struct xfs_inode *ip =NULL ;struct xfs_trans *tp =NULL ; -struct xfs_dquot *udqp =NULL ; -struct xfs_dquot *gdqp =NULL ; -struct xfs_dquot *pdqp =NULL ; +struct xfs_dquot *udqp; +struct xfs_dquot *gdqp; +struct xfs_dquot *pdqp;struct xfs_trans_res *tres;xfs_ino_t ino;uint resblks;
@@ -983,9 +999,7 @@ xfs_create_tmpfile(/* * Make sure that we have allocated dquot(s) on disk. */ - error =xfs_qm_vop_dqalloc (dp, args->uid, args->gid, args->prid, -XFS_QMOPT_QUOTALL |XFS_QMOPT_INHERIT , - &udqp, &gdqp, &pdqp); + error =xfs_icreate_dqalloc (args, &udqp, &gdqp, &pdqp);if (error)return error;
fs/xfs/xfs_inode.h +3 -0
@@ -663,5 +663,8 @@ void xfs_icreate_args_inherit(struct xfs_icreate_args *args, bool init_xattrs);void xfs_icreate_args_rootfile (struct xfs_icreate_args *args,struct xfs_mount *mp,umode_t mode,bool init_xattrs); +int xfs_icreate_dqalloc (const struct xfs_icreate_args *args, +struct xfs_dquot **udqpp,struct xfs_dquot **gdqpp, +struct xfs_dquot **pdqpp);#endif /* __XFS_INODE_H__ */
fs/xfs/xfs_symlink.c +4 -6
@@ -100,9 +100,9 @@ xfs_symlink(int pathlen;bool unlock_dp_on_error = false;xfs_filblks_t fs_blocks; -struct xfs_dquot *udqp =NULL ; -struct xfs_dquot *gdqp =NULL ; -struct xfs_dquot *pdqp =NULL ; +struct xfs_dquot *udqp; +struct xfs_dquot *gdqp; +struct xfs_dquot *pdqp;uint resblks;xfs_ino_t ino;struct xfs_parent_args *ppargs;
@@ -128,9 +128,7 @@ xfs_symlink(/* * Make sure that we have allocated dquot(s) on disk. */ - error =xfs_qm_vop_dqalloc (dp, args.uid, args.gid, args.prid, -XFS_QMOPT_QUOTALL |XFS_QMOPT_INHERIT , - &udqp, &gdqp, &pdqp); + error =xfs_icreate_dqalloc (&args, &udqp, &gdqp, &pdqp);if (error)return error;
PATCH 12/21 xfs: hoist xfs_iunlink to libxfs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move xfs_iunlink and xfs_iunlink_remove to libxfs.
--- fs/xfs/libxfs/xfs_inode_util.c | 282 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_inode_util.h | 4 + fs/xfs/xfs_inode.c | 280 ---------------------------------------- fs/xfs/xfs_inode.h | 5 - 4 files changed, 289 insertions(+), 282 deletions(-)
fs/xfs/libxfs/xfs_inode_util.c +282 -0
@@ -18,6 +18,10 @@#include "xfs_ialloc.h" #include "xfs_health.h" #include "xfs_bmap.h" +#include "xfs_error.h" +#include "xfs_trace.h" +#include "xfs_ag.h" +#include "xfs_iunlink_item.h" uint16_t xfs_flags2diflags(
@@ -335,3 +339,281 @@ xfs_inode_init(xfs_trans_log_inode (tp, ip, flags); } + +/* +* In-Core Unlinked List Lookups +* ============================= +* +* Every inode is supposed to be reachable from some other piece of metadata +* with the exception of the root directory. Inodes with a connection to a +* file descriptor but not linked from anywhere in the on-disk directory tree +* are collectively known as unlinked inodes, though the filesystem itself +* maintains links to these inodes so that on-disk metadata are consistent. +* +* XFS implements a per-AG on-disk hash table of unlinked inodes. The AGI +* header contains a number of buckets that point to an inode, and each inode +* record has a pointer to the next inode in the hash chain. This +* singly-linked list causes scaling problems in the iunlink remove function +* because we must walk that list to find the inode that points to the inode +* being removed from the unlinked hash bucket list. +* +* Hence we keep an in-memory double linked list to link each inode on an +* unlinked list. Because there are 64 unlinked lists per AGI, keeping pointer +* based lists would require having 64 list heads in the perag, one for each +* list. This is expensive in terms of memory (think millions of AGs) and cache +* misses on lookups. Instead, use the fact that inodes on the unlinked list +* must be referenced at the VFS level to keep them on the list and hence we +* have an existence guarantee for inodes on the unlinked list. +* +* Given we have an existence guarantee, we can use lockless inode cache lookups +* to resolve aginos to xfs inodes. This means we only need 8 bytes per inode +* for the double linked unlinked list, and we don't need any extra locking to +* keep the list safe as all manipulations are done under the AGI buffer lock. +* Keeping the list up to date does not require memory allocation, just finding +* the XFS inode and updating the next/prev unlinked list aginos. +*/ + +/* +* Update the prev pointer of the next agino. Returns -ENOLINK if the inode +* is not in cache. +*/ +static int +xfs_iunlink_update_backref ( +struct xfs_perag *pag, +xfs_agino_t prev_agino, +xfs_agino_t next_agino) +{ +struct xfs_inode *ip; + +/* No update necessary if we are at the end of the list. */ +if (next_agino ==NULLAGINO ) +return 0 ; + + ip =xfs_iunlink_lookup (pag, next_agino); +if (!ip) +return -ENOLINK ; + + ip->i_prev_unlinked = prev_agino; +return 0 ; +} + +/* +* Point the AGI unlinked bucket at an inode and log the results. The caller +* is responsible for validating the old value. +*/ +STATIC int +xfs_iunlink_update_bucket ( +struct xfs_trans *tp, +struct xfs_perag *pag, +struct xfs_buf *agibp, +unsigned int bucket_index, +xfs_agino_t new_agino) +{ +struct xfs_agi *agi = agibp->b_addr; +xfs_agino_t old_value; +int offset; + +ASSERT (xfs_verify_agino_or_null (pag, new_agino)); + + old_value =be32_to_cpu (agi->agi_unlinked[bucket_index]); +trace_xfs_iunlink_update_bucket (tp->t_mountp, pag->pag_agno, bucket_index, + old_value, new_agino); + +/* +* We should never find the head of the list already set to the value +* passed in because either we're adding or removing ourselves from the +* head of the list. +*/ +if (old_value == new_agino) { +xfs_buf_mark_corrupt (agibp); +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGI ); +return -EFSCORRUPTED ; + } + + agi->agi_unlinked[bucket_index] =cpu_to_be32 (new_agino); + offset = offsetof(struct xfs_agi , agi_unlinked) + + (sizeof (xfs_agino_t) * bucket_index); +xfs_trans_log_buf (tp, agibp, offset, offset +sizeof (xfs_agino_t) -1 ); +return 0 ; +} + +static int +xfs_iunlink_insert_inode ( +struct xfs_trans *tp, +struct xfs_perag *pag, +struct xfs_buf *agibp, +struct xfs_inode *ip) +{ +struct xfs_mount *mp = tp->t_mountp; +struct xfs_agi *agi = agibp->b_addr; +xfs_agino_t next_agino; +xfs_agino_t agino =XFS_INO_TO_AGINO (mp, ip->i_ino); +short bucket_index = agino %XFS_AGI_UNLINKED_BUCKETS ; +int error; + +/* +* Get the index into the agi hash table for the list this inode will +* go on. Make sure the pointer isn't garbage and that this inode +* isn't already on the list. +*/ + next_agino =be32_to_cpu (agi->agi_unlinked[bucket_index]); +if (next_agino == agino || + !xfs_verify_agino_or_null (pag, next_agino)) { +xfs_buf_mark_corrupt (agibp); +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGI ); +return -EFSCORRUPTED ; + } + +/* +* Update the prev pointer in the next inode to point back to this +* inode. +*/ + error =xfs_iunlink_update_backref (pag, agino, next_agino); +if (error == -ENOLINK ) + error =xfs_iunlink_reload_next (tp, agibp, agino, next_agino); +if (error) +return error; + +if (next_agino !=NULLAGINO ) { +/* +* There is already another inode in the bucket, so point this +* inode to the current head of the list. +*/ + error =xfs_iunlink_log_inode (tp, ip, pag, next_agino); +if (error) +return error; + ip->i_next_unlinked = next_agino; + } + +/* Point the head of the list to point to this inode. */ + ip->i_prev_unlinked =NULLAGINO ; +return xfs_iunlink_update_bucket (tp, pag, agibp, bucket_index, agino); +} + +/* +* This is called when the inode's link count has gone to 0 or we are creating +* a tmpfile via O_TMPFILE. The inode @ip must have nlink == 0. +* +* We place the on-disk inode on a list in the AGI. It will be pulled from this +* list when the inode is freed. +*/ +int +xfs_iunlink ( +struct xfs_trans *tp, +struct xfs_inode *ip) +{ +struct xfs_mount *mp = tp->t_mountp; +struct xfs_perag *pag; +struct xfs_buf *agibp; +int error; + +ASSERT (VFS_I (ip)->i_nlink ==0 ); +ASSERT (VFS_I (ip)->i_mode !=0 ); +trace_xfs_iunlink (ip); + + pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, ip->i_ino)); + +/* Get the agi buffer first. It ensures lock ordering on the list. */ + error =xfs_read_agi (pag, tp, &agibp); +if (error) + goto out; + + error =xfs_iunlink_insert_inode (tp, pag, agibp, ip); +out: +xfs_perag_put (pag); +return error; +} + +static int +xfs_iunlink_remove_inode ( +struct xfs_trans *tp, +struct xfs_perag *pag, +struct xfs_buf *agibp, +struct xfs_inode *ip) +{ +struct xfs_mount *mp = tp->t_mountp; +struct xfs_agi *agi = agibp->b_addr; +xfs_agino_t agino =XFS_INO_TO_AGINO (mp, ip->i_ino); +xfs_agino_t head_agino; +short bucket_index = agino %XFS_AGI_UNLINKED_BUCKETS ; +int error; + +trace_xfs_iunlink_remove (ip); + +/* +* Get the index into the agi hash table for the list this inode will +* go on. Make sure the head pointer isn't garbage. +*/ + head_agino =be32_to_cpu (agi->agi_unlinked[bucket_index]); +if (!xfs_verify_agino (pag, head_agino)) { +XFS_CORRUPTION_ERROR (__func__,XFS_ERRLEVEL_LOW , mp, + agi,sizeof (*agi)); +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGI ); +return -EFSCORRUPTED ; + } + +/* +* Set our inode's next_unlinked pointer to NULL and then return +* the old pointer value so that we can update whatever was previous +* to us in the list to point to whatever was next in the list. +*/ + error =xfs_iunlink_log_inode (tp, ip, pag,NULLAGINO ); +if (error) +return error; + +/* +* Update the prev pointer in the next inode to point back to previous +* inode in the chain. +*/ + error =xfs_iunlink_update_backref (pag, ip->i_prev_unlinked, + ip->i_next_unlinked); +if (error == -ENOLINK ) + error =xfs_iunlink_reload_next (tp, agibp, ip->i_prev_unlinked, + ip->i_next_unlinked); +if (error) +return error; + +if (head_agino != agino) { +struct xfs_inode *prev_ip; + + prev_ip =xfs_iunlink_lookup (pag, ip->i_prev_unlinked); +if (!prev_ip) { +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE ); +return -EFSCORRUPTED ; + } + + error =xfs_iunlink_log_inode (tp, prev_ip, pag, + ip->i_next_unlinked); + prev_ip->i_next_unlinked = ip->i_next_unlinked; + }else { +/* Point the head of the list to the next unlinked inode. */ + error =xfs_iunlink_update_bucket (tp, pag, agibp, bucket_index, + ip->i_next_unlinked); + } + + ip->i_next_unlinked =NULLAGINO ; + ip->i_prev_unlinked =0 ; +return error; +} + +/* +* Pull the on-disk inode from the AGI unlinked list. +*/ +int +xfs_iunlink_remove ( +struct xfs_trans *tp, +struct xfs_perag *pag, +struct xfs_inode *ip) +{ +struct xfs_buf *agibp; +int error; + +trace_xfs_iunlink_remove (ip); + +/* Get the agi buffer first. It ensures lock ordering on the list. */ + error =xfs_read_agi (pag, tp, &agibp); +if (error) +return error; + +return xfs_iunlink_remove_inode (tp, pag, agibp, ip); +}
fs/xfs/libxfs/xfs_inode_util.h +4 -0
@@ -57,4 +57,8 @@ void xfs_trans_ichgtime(struct xfs_trans *tp, struct xfs_inode *ip, int flags);void xfs_inode_init (struct xfs_trans *tp,const struct xfs_icreate_args *args,struct xfs_inode *ip); +int xfs_iunlink (struct xfs_trans *tp,struct xfs_inode *ip); +int xfs_iunlink_remove (struct xfs_trans *tp,struct xfs_perag *pag, +struct xfs_inode *ip); +#endif /* __XFS_INODE_UTIL_H__ */
fs/xfs/xfs_inode.c +1 -279
303 lines not on this page · raw message
fs/xfs/xfs_inode.h +2 -3
@@ -604,10 +604,9 @@ extern struct kmem_cache *xfs_inode_cache;bool xfs_inode_needs_inactive (struct xfs_inode *ip); -int xfs_iunlink (struct xfs_trans *tp,struct xfs_inode *ip); -int xfs_iunlink_remove (struct xfs_trans *tp,struct xfs_perag *pag, -struct xfs_inode *ip);struct xfs_inode *xfs_iunlink_lookup (struct xfs_perag *pag,xfs_agino_t agino); +int xfs_iunlink_reload_next (struct xfs_trans *tp,struct xfs_buf *agibp, +xfs_agino_t prev_agino,xfs_agino_t next_agino);void xfs_end_io (struct work_struct *work);
PATCH 13/21 xfs: hoist xfs_{bump,drop}link to libxfs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move xfs_bumplink and xfs_droplink to libxfs.
--- fs/xfs/libxfs/xfs_inode_util.c | 53 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_inode_util.h | 2 ++ fs/xfs/xfs_inode.c | 53 ---------------------------------------- fs/xfs/xfs_inode.h | 2 -- 4 files changed, 55 insertions(+), 55 deletions(-)
fs/xfs/libxfs/xfs_inode_util.c +53 -0
@@ -617,3 +617,56 @@ xfs_iunlink_remove(return xfs_iunlink_remove_inode (tp, pag, agibp, ip); } + +/* +* Decrement the link count on an inode & log the change. If this causes the +* link count to go to zero, move the inode to AGI unlinked list so that it can +* be freed when the last active reference goes away via xfs_inactive(). +*/ +int +xfs_droplink ( +struct xfs_trans *tp, +struct xfs_inode *ip) +{ +struct inode *inode =VFS_I (ip); + +xfs_trans_ichgtime (tp, ip,XFS_ICHGTIME_CHG ); + +if (inode->i_nlink ==0 ) { +xfs_info_ratelimited (tp->t_mountp, +"Inode 0x%llx link count dropped below zero. Pinning link count." , + ip->i_ino); +set_nlink (inode,XFS_NLINK_PINNED ); + } +if (inode->i_nlink !=XFS_NLINK_PINNED ) +drop_nlink (inode); + +xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); + +if (inode->i_nlink) +return 0 ; + +return xfs_iunlink (tp, ip); +} + +/* +* Increment the link count on an inode & log the change. +*/ +void +xfs_bumplink ( +struct xfs_trans *tp, +struct xfs_inode *ip) +{ +struct inode *inode =VFS_I (ip); + +xfs_trans_ichgtime (tp, ip,XFS_ICHGTIME_CHG ); + +if (inode->i_nlink ==XFS_NLINK_PINNED -1 ) +xfs_info_ratelimited (tp->t_mountp, +"Inode 0x%llx link count exceeded maximum. Pinning link count." , + ip->i_ino); +if (inode->i_nlink !=XFS_NLINK_PINNED ) +inc_nlink (inode); + +xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); +}
fs/xfs/libxfs/xfs_inode_util.h +2 -0
@@ -60,5 +60,7 @@ void xfs_inode_init(struct xfs_trans *tp, const struct xfs_icreate_args *args,int xfs_iunlink (struct xfs_trans *tp,struct xfs_inode *ip);int xfs_iunlink_remove (struct xfs_trans *tp,struct xfs_perag *pag,struct xfs_inode *ip); +int xfs_droplink (struct xfs_trans *tp,struct xfs_inode *ip); +void xfs_bumplink (struct xfs_trans *tp,struct xfs_inode *ip);#endif /* __XFS_INODE_UTIL_H__ */
fs/xfs/xfs_inode.c +0 -53
59 lines not on this page · raw message
fs/xfs/xfs_inode.h +0 -2
@@ -613,8 +613,6 @@ void xfs_end_io(struct work_struct *work);int xfs_ilock2_io_mmap (struct xfs_inode *ip1,struct xfs_inode *ip2);void xfs_iunlock2_io_mmap (struct xfs_inode *ip1,struct xfs_inode *ip2);void xfs_iunlock2_remapping (struct xfs_inode *ip1,struct xfs_inode *ip2); -int xfs_droplink (struct xfs_trans *tp,struct xfs_inode *ip); -void xfs_bumplink (struct xfs_trans *tp,struct xfs_inode *ip);void xfs_lock_inodes (struct xfs_inode **ips,int inodes,uint lock_mode);void xfs_sort_inodes (struct xfs_inode **i_tab,unsigned int num_inodes);
PATCH 14/21 xfs: create libxfs helper to link a new inode into a directory
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new libxfs function to link a newly created inode into a directory. The upcoming metadata directory feature will need this to create a metadata directory tree.
--- fs/xfs/libxfs/xfs_dir2.c | 47 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_dir2.h | 12 ++++++++++ fs/xfs/xfs_inode.c | 53 +++++++++++++++------------------------------- fs/xfs/xfs_symlink.c | 43 ++++++++++++++++--------------------- 4 files changed, 95 insertions(+), 60 deletions(-)
fs/xfs/libxfs/xfs_dir2.c +47 -0
@@ -19,6 +19,9 @@#include "xfs_error.h" #include "xfs_trace.h" #include "xfs_health.h" +#include "xfs_bmap_btree.h" +#include "xfs_trans_space.h" +#include "xfs_parent.h" const struct xfs_name xfs_name_dotdot = { .name = (const unsigned char *)".." ,
@@ -782,3 +785,47 @@ xfs_dir2_compname(return xfs_ascii_ci_compname (args, name, len);return xfs_da_compname (args, name, len); } + +/* +* Given a directory @dp, a newly allocated inode @ip, and a @name, link @ip +* into @dp under the given @name. If @ip is a directory, it will be +* initialized. Both inodes must have the ILOCK held and the transaction must +* have sufficient blocks reserved. +*/ +int +xfs_dir_create_child ( +struct xfs_trans *tp, +unsigned int resblks, +struct xfs_dir_update *du) +{ +struct xfs_inode *dp = du->dp; +const struct xfs_name *name = du->name; +struct xfs_inode *ip = du->ip; +int error; + +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (dp,XFS_ILOCK_EXCL )); + + error =xfs_dir_createname (tp, dp, name, ip->i_ino, resblks); +if (error) { +ASSERT (error != -ENOSPC ); +return error; + } + +xfs_trans_ichgtime (tp, dp,XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ); +xfs_trans_log_inode (tp, dp,XFS_ILOG_CORE ); + +if (S_ISDIR (VFS_I (ip)->i_mode)) { + error =xfs_dir_init (tp, ip, dp); +if (error) +return error; + +xfs_bumplink (tp, dp); + } + +/* +* If we have parent pointers, we need to add the attribute containing +* the parent information now. +*/ +return xfs_parent_add (tp, du->ppargs, dp, name, ip); +}
fs/xfs/libxfs/xfs_dir2.h +12 -0
@@ -293,4 +293,16 @@ static inline unsigned char xfs_ascii_ci_xfrm(unsigned char c) return c; } +struct xfs_parent_args ; + +struct xfs_dir_update { +struct xfs_inode *dp; +const struct xfs_name *name; +struct xfs_inode *ip; +struct xfs_parent_args *ppargs; +}; + +int xfs_dir_create_child (struct xfs_trans *tp,unsigned int resblks, +struct xfs_dir_update *du); +#endif /* __XFS_DIR2_H__ */
fs/xfs/xfs_inode.c +17 -36
110 lines not on this page · raw message
fs/xfs/xfs_symlink.c +19 -24
103 lines not on this page · raw message
PATCH 15/21 xfs: create libxfs helper to link an existing inode into a directory
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new libxfs function to link an existing inode into a directory. The upcoming metadata directory feature will need this to create a metadata directory tree.
--- fs/xfs/libxfs/xfs_dir2.c | 65 ++++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/libxfs/xfs_dir2.h | 4 ++- fs/xfs/xfs_inode.c | 50 +++++++---------------------------- 3 files changed, 75 insertions(+), 44 deletions(-)
fs/xfs/libxfs/xfs_dir2.c +62 -3
@@ -22,6 +22,7 @@#include "xfs_bmap_btree.h" #include "xfs_trans_space.h" #include "xfs_parent.h" +#include "xfs_ag.h" const struct xfs_name xfs_name_dotdot = { .name = (const unsigned char *)".." ,
@@ -562,9 +563,9 @@ xfs_dir_replace(*/ int xfs_dir_canenter ( -xfs_trans_t *tp, -xfs_inode_t *dp, -struct xfs_name *name)/* name of entry to add */ +struct xfs_trans *tp, +struct xfs_inode *dp, +const struct xfs_name *name)/* name of entry to add */ {return xfs_dir_createname (tp, dp, name,0 ,0 ); }
@@ -829,3 +830,61 @@ xfs_dir_create_child(*/ return xfs_parent_add (tp, du->ppargs, dp, name, ip); } + +/* +* Given a directory @dp, an existing non-directory inode @ip, and a @name, +* link @ip into @dp under the given @name. Both inodes must have the ILOCK +* held. +*/ +int +xfs_dir_add_child ( +struct xfs_trans *tp, +unsigned int resblks, +struct xfs_dir_update *du) +{ +struct xfs_inode *dp = du->dp; +const struct xfs_name *name = du->name; +struct xfs_inode *ip = du->ip; +struct xfs_mount *mp = tp->t_mountp; +int error; + +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (dp,XFS_ILOCK_EXCL )); +ASSERT (!S_ISDIR (VFS_I (ip)->i_mode)); + +if (!resblks) { + error =xfs_dir_canenter (tp, dp, name); +if (error) +return error; + } + +/* +* Handle initial link state of O_TMPFILE inode +*/ +if (VFS_I (ip)->i_nlink ==0 ) { +struct xfs_perag *pag; + + pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, ip->i_ino)); + error =xfs_iunlink_remove (tp, pag, ip); +xfs_perag_put (pag); +if (error) +return error; + } + + error =xfs_dir_createname (tp, dp, name, ip->i_ino, resblks); +if (error) +return error; + +xfs_trans_ichgtime (tp, dp,XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ); +xfs_trans_log_inode (tp, dp,XFS_ILOG_CORE ); + +xfs_bumplink (tp, ip); + +/* +* If we have parent pointers, we now need to add the parent record to +* the attribute fork of the inode. If this is the initial parent +* attribute, we need to create it correctly, otherwise we can just add +* the parent to the inode. +*/ +return xfs_parent_add (tp, du->ppargs, dp, name, ip); +}
fs/xfs/libxfs/xfs_dir2.h +3 -1
@@ -61,7 +61,7 @@ extern int xfs_dir_replace(struct xfs_trans *tp, struct xfs_inode *dp, const struct xfs_name *name, xfs_ino_t inum, xfs_extlen_t tot);extern int xfs_dir_canenter (struct xfs_trans *tp,struct xfs_inode *dp, -struct xfs_name *name); +const struct xfs_name *name);/* * Direct call from the bmap code, bypassing the generic directory layer.
@@ -304,5 +304,7 @@ struct xfs_dir_update {int xfs_dir_create_child (struct xfs_trans *tp,unsigned int resblks,struct xfs_dir_update *du); +int xfs_dir_add_child (struct xfs_trans *tp,unsigned int resblks, +struct xfs_dir_update *du);#endif /* __XFS_DIR2_H__ */
fs/xfs/xfs_inode.c +10 -40
90 lines not on this page · raw message
PATCH 16/21 xfs: hoist inode free function to libxfs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a libxfs helper function that marks an inode free on disk.
--- fs/xfs/libxfs/xfs_inode_util.c | 51 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_inode_util.h | 5 ++++ fs/xfs/xfs_inode.c | 35 +-------------------------- 3 files changed, 57 insertions(+), 34 deletions(-)
fs/xfs/libxfs/xfs_inode_util.c +51 -0
@@ -22,6 +22,7 @@#include "xfs_trace.h" #include "xfs_ag.h" #include "xfs_iunlink_item.h" +#include "xfs_inode_item.h" uint16_t xfs_flags2diflags(
@@ -670,3 +671,53 @@ xfs_bumplink(xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); } + +/* Mark an inode free on disk. */ +int +xfs_dir_ifree ( +struct xfs_trans *tp, +struct xfs_perag *pag, +struct xfs_inode *ip, +struct xfs_icluster *xic) +{ +int error; + +/* +* Free the inode first so that we guarantee that the AGI lock is going +* to be taken before we remove the inode from the unlinked list. This +* makes the AGI lock -> unlinked list modification order the same as +* used in O_TMPFILE creation. +*/ + error =xfs_difree (tp, pag, ip->i_ino, xic); +if (error) +return error; + + error =xfs_iunlink_remove (tp, pag, ip); +if (error) +return error; + +/* +* Free any local-format data sitting around before we reset the +* data fork to extents format. Note that the attr fork data has +* already been freed by xfs_attr_inactive. +*/ +if (ip->i_df.if_format ==XFS_DINODE_FMT_LOCAL ) { +kmem_free (ip->i_df.if_u1.if_data); + ip->i_df.if_u1.if_data =NULL ; + ip->i_df.if_bytes =0 ; + } + +VFS_I (ip)->i_mode =0 ;/* mark incore inode as free */ + ip->i_diflags =0 ; + ip->i_diflags2 = ip->i_mount->m_ino_geo.new_diflags2; + ip->i_forkoff =0 ;/* mark the attr fork not in use */ + ip->i_df.if_format =XFS_DINODE_FMT_EXTENTS ; + +/* +* Bump the generation count so no one will be confused +* by reincarnations of this inode. +*/ +VFS_I (ip)->i_generation++; +xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); +return 0 ; +}
fs/xfs/libxfs/xfs_inode_util.h +5 -0
@@ -6,6 +6,8 @@#ifndef __XFS_INODE_UTIL_H__#define __XFS_INODE_UTIL_H__ +struct xfs_icluster ; +uint16_t xfs_flags2diflags (struct xfs_inode *ip,unsigned int xflags);uint64_t xfs_flags2diflags2 (struct xfs_inode *ip,unsigned int xflags);uint32_t xfs_dic2xflags (struct xfs_inode *ip);
@@ -57,6 +59,9 @@ void xfs_trans_ichgtime(struct xfs_trans *tp, struct xfs_inode *ip, int flags);void xfs_inode_init (struct xfs_trans *tp,const struct xfs_icreate_args *args,struct xfs_inode *ip); +int xfs_dir_ifree (struct xfs_trans *tp,struct xfs_perag *pag, +struct xfs_inode *ip,struct xfs_icluster *xic); +int xfs_iunlink (struct xfs_trans *tp,struct xfs_inode *ip);int xfs_iunlink_remove (struct xfs_trans *tp,struct xfs_perag *pag,struct xfs_inode *ip);
fs/xfs/xfs_inode.c +1 -34
@@ -1971,36 +1971,10 @@ xfs_ifree( pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, ip->i_ino)); -/* -* Free the inode first so that we guarantee that the AGI lock is going -* to be taken before we remove the inode from the unlinked list. This -* makes the AGI lock -> unlinked list modification order the same as -* used in O_TMPFILE creation. -*/ - error =xfs_difree (tp, pag, ip->i_ino, &xic); + error =xfs_dir_ifree (tp, pag, ip, &xic);if (error) goto out; - error =xfs_iunlink_remove (tp, pag, ip); -if (error) - goto out; - -/* -* Free any local-format data sitting around before we reset the -* data fork to extents format. Note that the attr fork data has -* already been freed by xfs_attr_inactive. -*/ -if (ip->i_df.if_format ==XFS_DINODE_FMT_LOCAL ) { -kmem_free (ip->i_df.if_u1.if_data); - ip->i_df.if_u1.if_data =NULL ; - ip->i_df.if_bytes =0 ; - } - -VFS_I (ip)->i_mode =0 ;/* mark incore inode as free */ - ip->i_diflags =0 ; - ip->i_diflags2 = mp->m_ino_geo.new_diflags2; - ip->i_forkoff =0 ;/* mark the attr fork not in use */ - ip->i_df.if_format =XFS_DINODE_FMT_EXTENTS ;if (xfs_iflags_test (ip,XFS_IPRESERVE_DM_FIELDS ))xfs_iflags_clear (ip,XFS_IPRESERVE_DM_FIELDS );
@@ -2009,13 +1983,6 @@ xfs_ifree( iip->ili_fields &= ~(XFS_ILOG_AOWNER |XFS_ILOG_DOWNER );spin_unlock (&iip->ili_lock); -/* -* Bump the generation count so no one will be confused -* by reincarnations of this inode. -*/ -VFS_I (ip)->i_generation++; -xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); -if (xic.deleted) error =xfs_ifree_cluster (tp, pag, ip, &xic); out:
PATCH 17/21 xfs: create libxfs helper to remove an existing inode/name from a directory
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new libxfs function to remove a (name, inode) entry from a directory. The upcoming metadata directory feature will need this to create a metadata directory tree.
--- fs/xfs/libxfs/xfs_dir2.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_dir2.h | 2 + fs/xfs/xfs_inode.c | 72 ++++++-------------------------------------- 3 files changed, 86 insertions(+), 63 deletions(-)
fs/xfs/libxfs/xfs_dir2.c +75 -0
@@ -888,3 +888,78 @@ xfs_dir_add_child(*/ return xfs_parent_add (tp, du->ppargs, dp, name, ip); } + +/* +* Given a directory @dp, a child @ip, and a @name, remove the (@name, @ip) +* entry from the directory. Both inodes must have the ILOCK held. +*/ +int +xfs_dir_remove_child ( +struct xfs_trans *tp, +unsigned int resblks, +struct xfs_dir_update *du) +{ +struct xfs_inode *dp = du->dp; +const struct xfs_name *name = du->name; +struct xfs_inode *ip = du->ip; +int error; + +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (dp,XFS_ILOCK_EXCL )); + +/* +* If we're removing a directory perform some additional validation. +*/ +if (S_ISDIR (VFS_I (ip)->i_mode)) { +ASSERT (VFS_I (ip)->i_nlink >=2 ); +if (VFS_I (ip)->i_nlink !=2 ) +return -ENOTEMPTY ; +if (!xfs_dir_isempty (ip)) +return -ENOTEMPTY ; + +/* Drop the link from ip's "..". */ + error =xfs_droplink (tp, dp); +if (error) +return error; + +/* Drop the "." link from ip to self. */ + error =xfs_droplink (tp, ip); +if (error) +return error; + +/* +* Point the unlinked child directory's ".." entry to the root +* directory to eliminate back-references to inodes that may +* get freed before the child directory is closed. If the fs +* gets shrunk, this can lead to dirent inode validation errors. +*/ +if (dp->i_ino != tp->t_mountp->m_sb.sb_rootino) { + error =xfs_dir_replace (tp, ip, &xfs_name_dotdot, + tp->t_mountp->m_sb.sb_rootino,0 ); +if (error) +return error; + } + }else { +/* +* When removing a non-directory we need to log the parent +* inode here. For a directory this is done implicitly +* by the xfs_droplink call for the ".." entry. +*/ +xfs_trans_log_inode (tp, dp,XFS_ILOG_CORE ); + } +xfs_trans_ichgtime (tp, dp,XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ); + +/* Drop the link from dp to ip. */ + error =xfs_droplink (tp, ip); +if (error) +return error; + + error =xfs_dir_removename (tp, dp, name, ip->i_ino, resblks); +if (error) { +ASSERT (error != -ENOENT ); +return error; + } + +/* Remove parent pointer. */ +return xfs_parent_remove (tp, du->ppargs, dp, name, ip); +}
fs/xfs/libxfs/xfs_dir2.h +2 -0
@@ -306,5 +306,7 @@ int xfs_dir_create_child(struct xfs_trans *tp, unsigned int resblks, struct xfs_dir_update *du);int xfs_dir_add_child (struct xfs_trans *tp,unsigned int resblks,struct xfs_dir_update *du); +int xfs_dir_remove_child (struct xfs_trans *tp,unsigned int resblks, +struct xfs_dir_update *du);#endif /* __XFS_DIR2_H__ */
fs/xfs/xfs_inode.c +9 -63
108 lines not on this page · raw message
PATCH 18/21 xfs: create libxfs helper to exchange two directory entries
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new libxfs function to exchange two directory entries. The upcoming metadata directory feature will need this to replace a metadata inode directory entry.
--- fs/xfs/libxfs/xfs_dir2.c | 117 ++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_dir2.h | 3 + fs/xfs/xfs_inode.c | 108 ++++++------------------------------------ 3 files changed, 135 insertions(+), 93 deletions(-)
fs/xfs/libxfs/xfs_dir2.c +117 -0
@@ -963,3 +963,120 @@ xfs_dir_remove_child(/* Remove parent pointer. */ return xfs_parent_remove (tp, du->ppargs, dp, name, ip); } + +/* +* Exchange the entry (@name1, @ip1) in directory @dp1 with the entry (@name2, +* @ip2) in directory @dp2, and update '..' @ip1 and @ip2's entries as needed. +* @ip1 and @ip2 need not be of the same type. +* +* All inodes must have the ILOCK held, and both entries must already exist. +*/ +int +xfs_dir_exchange_children ( +struct xfs_trans *tp, +struct xfs_dir_update *du1, +struct xfs_dir_update *du2, +unsigned int spaceres) +{ +struct xfs_inode *dp1 = du1->dp; +const struct xfs_name *name1 = du1->name; +struct xfs_inode *ip1 = du1->ip; +struct xfs_inode *dp2 = du2->dp; +const struct xfs_name *name2 = du2->name; +struct xfs_inode *ip2 = du2->ip; +int ip1_flags =0 ; +int ip2_flags =0 ; +int dp2_flags =0 ; +int error; + +/* Swap inode number for dirent in first parent */ + error =xfs_dir_replace (tp, dp1, name1, ip2->i_ino, spaceres); +if (error) +return error; + +/* Swap inode number for dirent in second parent */ + error =xfs_dir_replace (tp, dp2, name2, ip1->i_ino, spaceres); +if (error) +return error; + +/* +* If we're renaming one or more directories across different parents, +* update the respective ".." entries (and link counts) to match the new +* parents. +*/ +if (dp1 != dp2) { + dp2_flags =XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ; + +if (S_ISDIR (VFS_I (ip2)->i_mode)) { + error =xfs_dir_replace (tp, ip2, &xfs_name_dotdot, + dp1->i_ino, spaceres); +if (error) +return error; + +/* transfer ip2 ".." reference to dp1 */ +if (!S_ISDIR (VFS_I (ip1)->i_mode)) { + error =xfs_droplink (tp, dp2); +if (error) +return error; +xfs_bumplink (tp, dp1); + } + +/* +* Although ip1 isn't changed here, userspace needs +* to be warned about the change, so that applications +* relying on it (like backup ones), will properly +* notify the change +*/ + ip1_flags |=XFS_ICHGTIME_CHG ; + ip2_flags |=XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ; + } + +if (S_ISDIR (VFS_I (ip1)->i_mode)) { + error =xfs_dir_replace (tp, ip1, &xfs_name_dotdot, + dp2->i_ino, spaceres); +if (error) +return error; + +/* transfer ip1 ".." reference to dp2 */ +if (!S_ISDIR (VFS_I (ip2)->i_mode)) { + error =xfs_droplink (tp, dp1); +if (error) +return error; +xfs_bumplink (tp, dp2); + } + +/* +* Although ip2 isn't changed here, userspace needs +* to be warned about the change, so that applications +* relying on it (like backup ones), will properly +* notify the change +*/ + ip1_flags |=XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ; + ip2_flags |=XFS_ICHGTIME_CHG ; + } + } + +if (ip1_flags) { +xfs_trans_ichgtime (tp, ip1, ip1_flags); +xfs_trans_log_inode (tp, ip1,XFS_ILOG_CORE ); + } +if (ip2_flags) { +xfs_trans_ichgtime (tp, ip2, ip2_flags); +xfs_trans_log_inode (tp, ip2,XFS_ILOG_CORE ); + } +if (dp2_flags) { +xfs_trans_ichgtime (tp, dp2, dp2_flags); +xfs_trans_log_inode (tp, dp2,XFS_ILOG_CORE ); + } +xfs_trans_ichgtime (tp, dp1,XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ); +xfs_trans_log_inode (tp, dp1,XFS_ILOG_CORE ); + +/* Schedule parent pointer replacements */ + error =xfs_parent_replace (tp, du1->ppargs, dp1, name1, dp2, name2, + ip1); +if (error) +return error; + +return xfs_parent_replace (tp, du2->ppargs, dp2, name2, dp1, name1, + ip2); +}
fs/xfs/libxfs/xfs_dir2.h +3 -0
@@ -309,4 +309,7 @@ int xfs_dir_add_child(struct xfs_trans *tp, unsigned int resblks,int xfs_dir_remove_child (struct xfs_trans *tp,unsigned int resblks,struct xfs_dir_update *du); +int xfs_dir_exchange_children (struct xfs_trans *tp,struct xfs_dir_update *du1, +struct xfs_dir_update *du2,unsigned int spaceres); +#endif /* __XFS_DIR2_H__ */
fs/xfs/xfs_inode.c +15 -93
117 lines not on this page · raw message
PATCH 19/21 xfs: create libxfs helper to rename two directory entries
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new libxfs function to rename two directory entries. The upcoming metadata directory feature will need this to replace a metadata inode directory entry.
--- fs/xfs/libxfs/xfs_dir2.c | 217 +++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_dir2.h | 3 fs/xfs/xfs_inode.c | 288 ++++++++++------------------------------------ 3 files changed, 282 insertions(+), 226 deletions(-)
fs/xfs/libxfs/xfs_dir2.c +217 -0
@@ -23,6 +23,7 @@#include "xfs_trans_space.h" #include "xfs_parent.h" #include "xfs_ag.h" +#include "xfs_ialloc.h" const struct xfs_name xfs_name_dotdot = { .name = (const unsigned char *)".." ,
@@ -1080,3 +1081,219 @@ xfs_dir_exchange_children(return xfs_parent_replace (tp, du2->ppargs, dp2, name2, dp1, name1, ip2); } + +/* +* Given an entry (@src_name, @src_ip) in directory @src_dp, make the entry +* @target_name in directory @target_dp point to @src_ip and remove the +* original entry, cleaning up everything left behind. +* +* Cleanup involves dropping a link count on @target_ip, and either removing +* the (@src_name, @src_ip) entry from @src_dp or simply replacing the entry +* with (@src_name, @wip) if a whiteout inode @wip is supplied. +* +* All inodes must have the ILOCK held. We assume that if @src_ip is a +* directory then its '..' doesn't already point to @target_dp, and that @wip +* is a freshly allocated whiteout. +*/ +int +xfs_dir_rename_children ( +struct xfs_trans *tp, +struct xfs_dir_update *du_src, +struct xfs_dir_update *du_tgt, +unsigned int spaceres, +struct xfs_dir_update *du_wip) +{ +struct xfs_mount *mp = tp->t_mountp; +struct xfs_inode *src_dp = du_src->dp; +const struct xfs_name *src_name = du_src->name; +struct xfs_inode *src_ip = du_src->ip; +struct xfs_inode *target_dp = du_tgt->dp; +const struct xfs_name *target_name = du_tgt->name; +struct xfs_inode *target_ip = du_tgt->ip; +bool new_parent = (src_dp != target_dp); +bool src_is_directory; +int error; + + src_is_directory =S_ISDIR (VFS_I (src_ip)->i_mode); + +/* +* Check for expected errors before we dirty the transaction +* so we can return an error without a transaction abort. +*/ +if (target_ip ==NULL ) { +/* +* If there's no space reservation, check the entry will +* fit before actually inserting it. +*/ +if (!spaceres) { + error =xfs_dir_canenter (tp, target_dp, target_name); +if (error) +return error; + } + }else { +/* +* If target exists and it's a directory, check that whether +* it can be destroyed. +*/ +if (S_ISDIR (VFS_I (target_ip)->i_mode) && + (!xfs_dir_isempty (target_ip) || + (VFS_I (target_ip)->i_nlink >2 ))) +return -EEXIST ; + } + +/* +* Directory entry creation below may acquire the AGF. Remove +* the whiteout from the unlinked list first to preserve correct +* AGI/AGF locking order. This dirties the transaction so failures +* after this point will abort and log recovery will clean up the +* mess. +* +* For whiteouts, we need to bump the link count on the whiteout +* inode. After this point, we have a real link, clear the tmpfile +* state flag from the inode so it doesn't accidentally get misused +* in future. +*/ +if (du_wip->ip) { +struct xfs_perag *pag; + +ASSERT (VFS_I (du_wip->ip)->i_nlink ==0 ); + + pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, du_wip->ip->i_ino)); + error =xfs_iunlink_remove (tp, pag, du_wip->ip); +xfs_perag_put (pag); +if (error) +return error; + +xfs_bumplink (tp, du_wip->ip); + } + +/* +* Set up the target. +*/ +if (target_ip ==NULL ) { +/* +* If target does not exist and the rename crosses +* directories, adjust the target directory link count +* to account for the ".." reference from the new entry. +*/ + error =xfs_dir_createname (tp, target_dp, target_name, + src_ip->i_ino, spaceres); +if (error) +return error; + +xfs_trans_ichgtime (tp, target_dp, +XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ); + +if (new_parent && src_is_directory) { +xfs_bumplink (tp, target_dp); + } + }else {/* target_ip != NULL */ +/* +* Link the source inode under the target name. +* If the source inode is a directory and we are moving +* it across directories, its ".." entry will be +* inconsistent until we replace that down below. +* +* In case there is already an entry with the same +* name at the destination directory, remove it first. +*/ + error =xfs_dir_replace (tp, target_dp, target_name, + src_ip->i_ino, spaceres); +if (error) +return error; + +xfs_trans_ichgtime (tp, target_dp, +XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ); + +/* +* Decrement the link count on the target since the target +* dir no longer points to it. +*/ + error =xfs_droplink (tp, target_ip); +if (error) +return error; + +if (src_is_directory) { +/* +* Drop the link from the old "." entry. +*/ + error =xfs_droplink (tp, target_ip); +if (error) +return error; + } + }/* target_ip != NULL */ + +/* +* Remove the source. +*/ +if (new_parent && src_is_directory) { +/* +* Rewrite the ".." entry to point to the new +* directory. +*/ + error =xfs_dir_replace (tp, src_ip, &xfs_name_dotdot, + target_dp->i_ino, spaceres); +ASSERT (error != -EEXIST ); +if (error) +return error; + } + +/* +* We always want to hit the ctime on the source inode. +* +* This isn't strictly required by the standards since the source +* inode isn't really being changed, but old unix file systems did +* it and some incremental backup programs won't work without it. +*/ +xfs_trans_ichgtime (tp, src_ip,XFS_ICHGTIME_CHG ); +xfs_trans_log_inode (tp, src_ip,XFS_ILOG_CORE ); + +/* +* Adjust the link count on src_dp. This is necessary when +* renaming a directory, either within one parent when +* the target existed, or across two parent directories. +*/ +if (src_is_directory && (new_parent || target_ip !=NULL )) { + +/* +* Decrement link count on src_directory since the +* entry that's moved no longer points to it. +*/ + error =xfs_droplink (tp, src_dp); +if (error) +return error; + } + +/* +* For whiteouts, we only need to update the source dirent with the +* inode number of the whiteout inode rather than removing it +* altogether. +*/ +if (du_wip->ip) + error =xfs_dir_replace (tp, src_dp, src_name, du_wip->ip->i_ino, + spaceres); +else + error =xfs_dir_removename (tp, src_dp, src_name, src_ip->i_ino, + spaceres); +if (error) +return error; + +xfs_trans_ichgtime (tp, src_dp,XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ); +xfs_trans_log_inode (tp, src_dp,XFS_ILOG_CORE ); +if (new_parent) +xfs_trans_log_inode (tp, target_dp,XFS_ILOG_CORE ); + +/* Schedule parent pointer updates. */ + error =xfs_parent_add (tp, du_wip->ppargs, src_dp, src_name, + du_wip->ip); +if (error) +return error; + + error =xfs_parent_replace (tp, du_src->ppargs, src_dp, src_name, + target_dp, target_name, src_ip); +if (error) +return error; + +return xfs_parent_remove (tp, du_tgt->ppargs, target_dp, target_name, + target_ip); +}
fs/xfs/libxfs/xfs_dir2.h +3 -0
@@ -311,5 +311,8 @@ int xfs_dir_remove_child(struct xfs_trans *tp, unsigned int resblks,int xfs_dir_exchange_children (struct xfs_trans *tp,struct xfs_dir_update *du1,struct xfs_dir_update *du2,unsigned int spaceres); +int xfs_dir_rename_children (struct xfs_trans *tp,struct xfs_dir_update *du_src, +struct xfs_dir_update *du_tgt,unsigned int spaceres, +struct xfs_dir_update *du_wip);#endif /* __XFS_DIR2_H__ */
fs/xfs/xfs_inode.c +62 -226
382 lines not on this page · raw message
PATCH 20/21 xfs: move dirent update hooks to xfs_dir2.c
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move the directory entry update hook code to xfs_dir2 so that it is mostly consolidated with the higher level directory functions. Retain the exports so that online fsck can still send notifications through the hooks.
--- fs/xfs/libxfs/xfs_dir2.c | 125 ++++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/libxfs/xfs_dir2.h | 24 +++++++++ fs/xfs/scrub/common.c | 1 fs/xfs/xfs_inode.c | 108 ---------------------------------------- fs/xfs/xfs_inode.h | 25 --------- fs/xfs/xfs_symlink.c | 2 - 6 files changed, 145 insertions(+), 140 deletions(-)
fs/xfs/libxfs/xfs_dir2.c +120 -5
@@ -788,6 +788,72 @@ xfs_dir2_compname(return xfs_da_compname (args, name, len); } +#ifdef CONFIG_XFS_LIVE_HOOKS +/* +* Use a static key here to reduce the overhead of directory live update hooks. +* If the compiler supports jump labels, the static branch will be replaced by +* a nop sled when there are no hook users. Online fsck is currently the only +* caller, so this is a reasonable tradeoff. +* +* Note: Patching the kernel code requires taking the cpu hotplug lock. Other +* parts of the kernel allocate memory with that lock held, which means that +* XFS callers cannot hold any locks that might be used by memory reclaim or +* writeback when calling the static_branch_{inc,dec} functions. +*/ +DEFINE_STATIC_XFS_HOOK_SWITCH (xfs_dir_hooks_switch); + +void +xfs_dir_hook_disable (void ) +{ +xfs_hooks_switch_off (&xfs_dir_hooks_switch); +} + +void +xfs_dir_hook_enable (void ) +{ +xfs_hooks_switch_on (&xfs_dir_hooks_switch); +} + +/* Call hooks for a directory update relating to a child dirent update. */ +inline void +xfs_dir_update_hook ( +struct xfs_inode *dp, +struct xfs_inode *ip, +int delta, +const struct xfs_name *name) +{ +if (xfs_hooks_switched_on (&xfs_dir_hooks_switch)) { +struct xfs_dir_update_params p = { + .dp = dp, + .ip = ip, + .delta = delta, + .name = name, + }; +struct xfs_mount *mp = ip->i_mount; + +xfs_hooks_call (&mp->m_dir_update_hooks,0 , &p); + } +} + +/* Call the specified function during a directory update. */ +int +xfs_dir_hook_add ( +struct xfs_mount *mp, +struct xfs_dir_hook *hook) +{ +return xfs_hooks_add (&mp->m_dir_update_hooks, &hook->dirent_hook); +} + +/* Stop calling the specified function during a directory update. */ +void +xfs_dir_hook_del ( +struct xfs_mount *mp, +struct xfs_dir_hook *hook) +{ +xfs_hooks_del (&mp->m_dir_update_hooks, &hook->dirent_hook); +} +#endif /* CONFIG_XFS_LIVE_HOOKS */ +/* * Given a directory @dp, a newly allocated inode @ip, and a @name, link @ip * into @dp under the given @name. If @ip is a directory, it will be
@@ -829,7 +895,12 @@ xfs_dir_create_child(* If we have parent pointers, we need to add the attribute containing * the parent information now. */ -return xfs_parent_add (tp, du->ppargs, dp, name, ip); + error =xfs_parent_add (tp, du->ppargs, dp, name, ip); +if (error) +return error; + +xfs_dir_update_hook (dp, ip,1 , name); +return 0 ; }/*
@@ -887,7 +958,12 @@ xfs_dir_add_child(* attribute, we need to create it correctly, otherwise we can just add * the parent to the inode. */ -return xfs_parent_add (tp, du->ppargs, dp, name, ip); + error =xfs_parent_add (tp, du->ppargs, dp, name, ip); +if (error) +return error; + +xfs_dir_update_hook (dp, ip,1 , name); +return 0 ; }/*
@@ -962,7 +1038,12 @@ xfs_dir_remove_child( }/* Remove parent pointer. */ -return xfs_parent_remove (tp, du->ppargs, dp, name, ip); + error =xfs_parent_remove (tp, du->ppargs, dp, name, ip); +if (error) +return error; + +xfs_dir_update_hook (dp, ip,-1 , name); +return 0 ; }/*
@@ -1078,8 +1159,24 @@ xfs_dir_exchange_children(if (error)return error; -return xfs_parent_replace (tp, du2->ppargs, dp2, name2, dp1, name1, + error =xfs_parent_replace (tp, du2->ppargs, dp2, name2, dp1, name1, ip2); +if (error) +return error; + +/* +* Inform our hook clients that we've finished an exchange operation as +* follows: removed the source and target files from their directories; +* added the target to the source directory; and added the source to +* the target directory. All inodes are locked, so it's ok to model a +* rename this way so long as we say we deleted entries before we add +* new ones. +*/ +xfs_dir_update_hook (dp1, ip1,-1 , name1); +xfs_dir_update_hook (dp2, ip2,-1 , name2); +xfs_dir_update_hook (dp1, ip2,1 , name1); +xfs_dir_update_hook (dp2, ip1,1 , name2); +return 0 ; }/*
@@ -1294,6 +1391,24 @@ xfs_dir_rename_children(if (error)return error; -return xfs_parent_remove (tp, du_tgt->ppargs, target_dp, target_name, + error =xfs_parent_remove (tp, du_tgt->ppargs, target_dp, target_name, target_ip); +if (error) +return error; + +/* +* Inform our hook clients that we've finished a rename operation as +* follows: removed the source and target files from their directories; +* that we've added the source to the target directory; and finally +* that we've added the whiteout, if there was one. All inodes are +* locked, so it's ok to model a rename this way so long as we say we +* deleted entries before we add new ones. +*/ +if (target_ip) +xfs_dir_update_hook (target_dp, target_ip,-1 , target_name); +xfs_dir_update_hook (src_dp, src_ip,-1 , src_name); +xfs_dir_update_hook (target_dp, src_ip,1 , target_name); +if (du_wip->ip) +xfs_dir_update_hook (src_dp, du_wip->ip,1 , src_name); +return 0 ; }
fs/xfs/libxfs/xfs_dir2.h +24 -0
@@ -293,6 +293,30 @@ static inline unsigned char xfs_ascii_ci_xfrm(unsigned char c)return c; } +struct xfs_dir_update_params { +const struct xfs_inode *dp; +const struct xfs_inode *ip; +const struct xfs_name *name; +int delta; +}; + +#ifdef CONFIG_XFS_LIVE_HOOKS +void xfs_dir_update_hook (struct xfs_inode *dp,struct xfs_inode *ip, +int delta,const struct xfs_name *name); + +struct xfs_dir_hook { +struct xfs_hook dirent_hook; +}; + +void xfs_dir_hook_disable (void ); +void xfs_dir_hook_enable (void ); + +int xfs_dir_hook_add (struct xfs_mount *mp,struct xfs_dir_hook *hook); +void xfs_dir_hook_del (struct xfs_mount *mp,struct xfs_dir_hook *hook); +#else +# define xfs_dir_update_hook (dp, ip, delta, name) ((void)0) +#endif /* CONFIG_XFS_LIVE_HOOKS */ +struct xfs_parent_args ;struct xfs_dir_update {
fs/xfs/scrub/common.c +1 -0
@@ -26,6 +26,7 @@#include "xfs_da_format.h" #include "xfs_da_btree.h" #include "xfs_dir2_priv.h" +#include "xfs_dir2.h" #include "xfs_attr.h" #include "xfs_reflink.h" #include "xfs_ag.h"
fs/xfs/xfs_inode.c +0 -108
144 lines not on this page · raw message
fs/xfs/xfs_inode.h +0 -25
@@ -630,31 +630,6 @@ void xfs_inode_count_blocks(struct xfs_trans *tp, struct xfs_inode *ip, xfs_filblks_t *dblocks, xfs_filblks_t *rblocks);unsigned int xfs_inode_alloc_unitsize (struct xfs_inode *ip); -struct xfs_dir_update_params { -const struct xfs_inode *dp; -const struct xfs_inode *ip; -const struct xfs_name *name; -int delta; -}; - -#ifdef CONFIG_XFS_LIVE_HOOKS -void xfs_dir_update_hook (struct xfs_inode *dp,struct xfs_inode *ip, -int delta,const struct xfs_name *name); - -struct xfs_dir_hook { -struct xfs_hook dirent_hook; -}; - -void xfs_dir_hook_disable (void ); -void xfs_dir_hook_enable (void ); - -int xfs_dir_hook_add (struct xfs_mount *mp,struct xfs_dir_hook *hook); -void xfs_dir_hook_del (struct xfs_mount *mp,struct xfs_dir_hook *hook); - -#else -# define xfs_dir_update_hook (dp, ip, delta, name) ((void)0) -#endif /* CONFIG_XFS_LIVE_HOOKS */ -void xfs_icreate_args_inherit (struct xfs_icreate_args *args,struct xfs_inode *dp,struct mnt_idmap *idmap,umode_t mode,bool init_xattrs);
fs/xfs/xfs_symlink.c +0 -2
@@ -204,8 +204,6 @@ xfs_symlink(if (error) goto out_trans_cancel; -xfs_dir_update_hook (dp, du.ip,1 , link_name); -/* * If this is a synchronous mount, make sure that the * symlink transaction goes to disk before returning to
PATCH 21/21 xfs: get rid of trivial rename helpers
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Get rid of the largely pointless xfs_cross_rename and xfs_finish_rename now that we've refactored its parent.
--- fs/xfs/xfs_inode.c | 77 +++++++++------------------------------------------- 1 file changed, 14 insertions(+), 63 deletions(-)
fs/xfs/xfs_inode.c +14 -63
@@ -2152,63 +2152,6 @@ xfs_sort_inodes( } } -static int -xfs_finish_rename ( -struct xfs_trans *tp) -{ -/* -* If this is a synchronous mount, make sure that the rename transaction -* goes to disk before returning to the user. -*/ -if (xfs_has_wsync (tp->t_mountp) ||xfs_has_dirsync (tp->t_mountp)) -xfs_trans_set_sync (tp); - -return xfs_trans_commit (tp); -} - -/* -* xfs_cross_rename() -* -* responsible for handling RENAME_EXCHANGE flag in renameat2() syscall -*/ -STATIC int -xfs_cross_rename ( -struct xfs_trans *tp, -struct xfs_inode *dp1, -struct xfs_name *name1, -struct xfs_inode *ip1, -struct xfs_parent_args *ip1_ppargs, -struct xfs_inode *dp2, -struct xfs_name *name2, -struct xfs_inode *ip2, -struct xfs_parent_args *ip2_ppargs, -int spaceres) -{ -struct xfs_dir_update du1 = { - .dp = dp1, - .name = name1, - .ip = ip1, - .ppargs = ip1_ppargs, - }; -struct xfs_dir_update du2 = { - .dp = dp2, - .name = name2, - .ip = ip2, - .ppargs = ip2_ppargs, - }; -int error; - - error =xfs_dir_exchange_children (tp, &du1, &du2, spaceres); -if (error) - goto out_trans_abort; - -return xfs_finish_rename (tp); - -out_trans_abort: -xfs_trans_cancel (tp); -return error; -} -/* * xfs_rename_alloc_whiteout() *
@@ -2402,11 +2345,11 @@ xfs_rename(/* RENAME_EXCHANGE is unique from here on. */ if (flags &RENAME_EXCHANGE ) { - error =xfs_cross_rename (tp, src_dp, src_name, src_ip, - du_src.ppargs, target_dp, target_name, - target_ip, du_tgt.ppargs, spaceres); - nospace_error =0 ; - goto out_unlock; + error =xfs_dir_exchange_children (tp, &du_src, &du_tgt, + spaceres); +if (error) + goto out_trans_cancel; + goto out_commit; }/*
@@ -2484,7 +2427,15 @@ xfs_rename(VFS_I (du_wip.ip)->i_state &= ~I_LINKABLE ; } - error =xfs_finish_rename (tp); +out_commit: +/* +* If this is a synchronous mount, make sure that the rename +* transaction goes to disk before returning to the user. +*/ +if (xfs_has_wsync (tp->t_mountp) ||xfs_has_dirsync (tp->t_mountp)) +xfs_trans_set_sync (tp); + + error =xfs_trans_commit (tp); nospace_error =0 ; goto out_unlock;
PATCH 2/15 xfs: metadata inode directories
In reply to Darrick J. WongHi all,
This series delivers a new feature -- metadata inode directories. This is a separate directory tree (rooted in the superblock) that contains only inodes that contain filesystem metadata. Different metadata objects can be looked up with regular paths.
We start by creating xfs_imeta_* functions to mediate access to metadata inode pointers. This enables the imeta code to abstract inode pointers, whether they're the classic five in the superblock, or the much more complex directory tree. All current users of metadata inodes (rt+quota) are converted to use the boilerplate code.
Next, we define the metadir on-disk format, which consists of marking inodes with a new iflag that says they're metadata. This we use to prevent bulkstat and friends from ever getting their hands on fs metadata.
Finally, we implement metadir operations so that clients can create, delete, zap, and look up metadata inodes by path. Beware that much of this code is only lightly used, because the five current users of metadata inodes don't tend to change them very often. This is likely to change if and when the subvolume and multiple-rt-volume features get written/merged/etc.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=metadir
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=metadir
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=metadir
xfsdocs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-documentation.git/log/?h=metadir
--- fs/xfs/Makefile | 3 fs/xfs/libxfs/xfs_attr.c | 5 fs/xfs/libxfs/xfs_bmap.c | 5 fs/xfs/libxfs/xfs_format.h | 72 ++- fs/xfs/libxfs/xfs_fs.h | 29 + fs/xfs/libxfs/xfs_health.h | 6 fs/xfs/libxfs/xfs_ialloc.c | 56 +- fs/xfs/libxfs/xfs_ialloc.h | 2 fs/xfs/libxfs/xfs_imeta.c | 1077 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_imeta.h | 110 ++++ fs/xfs/libxfs/xfs_inode_buf.c | 73 +++ fs/xfs/libxfs/xfs_inode_buf.h | 3 fs/xfs/libxfs/xfs_inode_util.c | 5 fs/xfs/libxfs/xfs_ondisk.h | 1 fs/xfs/libxfs/xfs_sb.c | 35 + fs/xfs/libxfs/xfs_trans_resv.c | 106 ++++ fs/xfs/libxfs/xfs_trans_resv.h | 3 fs/xfs/libxfs/xfs_types.c | 7 fs/xfs/scrub/agheader.c | 29 + fs/xfs/scrub/common.c | 23 + fs/xfs/scrub/common.h | 1 fs/xfs/scrub/dir.c | 8 fs/xfs/scrub/dir_repair.c | 8 fs/xfs/scrub/dirtree.c | 22 + fs/xfs/scrub/dirtree.h | 2 fs/xfs/scrub/findparent.c | 37 + fs/xfs/scrub/health.c | 1 fs/xfs/scrub/inode.c | 25 + fs/xfs/scrub/inode_repair.c | 18 + fs/xfs/scrub/metapath.c | 617 +++++++++++++++++++++++ fs/xfs/scrub/nlinks.c | 12 fs/xfs/scrub/nlinks_repair.c | 2 fs/xfs/scrub/orphanage.c | 2 fs/xfs/scrub/parent.c | 30 + fs/xfs/scrub/parent_repair.c | 2 fs/xfs/scrub/quotacheck.c | 7 fs/xfs/scrub/repair.c | 8 fs/xfs/scrub/repair.h | 3 fs/xfs/scrub/scrub.c | 9 fs/xfs/scrub/scrub.h | 2 fs/xfs/scrub/stats.c | 1 fs/xfs/scrub/tempfile.c | 107 ++++ fs/xfs/scrub/tempfile.h | 3 fs/xfs/scrub/trace.c | 1 fs/xfs/scrub/trace.h | 51 ++ fs/xfs/xfs_dquot.c | 1 fs/xfs/xfs_health.c | 2 fs/xfs/xfs_icache.c | 43 ++ fs/xfs/xfs_imeta_utils.c | 341 +++++++++++++ fs/xfs/xfs_imeta_utils.h | 27 + fs/xfs/xfs_inode.c | 28 + fs/xfs/xfs_inode.h | 16 + fs/xfs/xfs_ioctl.c | 7 fs/xfs/xfs_iops.c | 34 + fs/xfs/xfs_itable.c | 34 + fs/xfs/xfs_itable.h | 3 fs/xfs/xfs_mount.c | 48 ++ fs/xfs/xfs_mount.h | 3 fs/xfs/xfs_qm.c | 245 ++++++--- fs/xfs/xfs_qm_syscalls.c | 9 fs/xfs/xfs_quota.h | 5 fs/xfs/xfs_rtalloc.c | 46 +- fs/xfs/xfs_super.c | 4 fs/xfs/xfs_symlink.c | 2 fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 139 +++++ fs/xfs/xfs_trans_dquot.c | 6 67 files changed, 3466 insertions(+), 207 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_imeta.c create mode 100644 fs/xfs/libxfs/xfs_imeta.h create mode 100644 fs/xfs/scrub/metapath.c create mode 100644 fs/xfs/xfs_imeta_utils.c create mode 100644 fs/xfs/xfs_imeta_utils.h
PATCH 1/32 xfs: don't use the incore struct xfs_sb for offsets into struct xfs_dsb
From: Darrick J. Wong <[email protected]>
Currently, the XFS_SB_CRC_OFF macro uses the incore superblock struct (xfs_sb) to compute the address of sb_crc within the ondisk superblock struct (xfs_dsb). This is a landmine if we ever change the layout of the incore superblock (as we're about to do), so redefine the macro to use xfs_dsb to compute the layout of xfs_dsb.
--- fs/xfs/libxfs/xfs_format.h | 9 ++++----- fs/xfs/libxfs/xfs_ondisk.h | 1 + 2 files changed, 5 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_format.h +4 -5
@@ -90,8 +90,7 @@ struct xfs_ifork;#define XFSLABEL_MAX 12/* -* Superblock - in core version. Must match the ondisk version below. -* Must be padded to 64 bit alignment. +* Superblock - in core version. Must be padded to 64 bit alignment. */ typedef struct xfs_sb { uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */
@@ -178,10 +177,8 @@ typedef struct xfs_sb {/* must be padded to 64 bit alignment */ } xfs_sb_t; -#define XFS_SB_CRC_OFF offsetof(struct xfs_sb, sb_crc) -/* -* Superblock - on disk version. Must match the in core version above. +* Superblock - on disk version. * Must be padded to 64 bit alignment. */ struct xfs_dsb {
@@ -265,6 +262,8 @@ struct xfs_dsb {/* must be padded to 64 bit alignment */ }; +#define XFS_SB_CRC_OFF offsetof(struct xfs_dsb, sb_crc) +/* * Misc. Flags - warning - these will be cleared by xfs_repair unless * a feature bit is set when the flag is used.
fs/xfs/libxfs/xfs_ondisk.h +1 -0
@@ -85,6 +85,7 @@ xfs_check_ondisk_structs(void)XFS_CHECK_STRUCT_SIZE(xfs_attr_leaf_name_remote_t, 12); */ + XFS_CHECK_OFFSET(struct xfs_dsb, sb_crc, 224);XFS_CHECK_OFFSET (xfs_attr_leaf_name_local_t, valuelen,0 );XFS_CHECK_OFFSET (xfs_attr_leaf_name_local_t, namelen,2 );XFS_CHECK_OFFSET (xfs_attr_leaf_name_local_t, nameval,3 );
PATCH 2/32 xfs: create imeta abstractions to get and set metadata inodes
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create some helper routines to get and set metadata inode numbers instead of open-coding them throughout xfs.
--- fs/xfs/Makefile | 2 fs/xfs/libxfs/xfs_imeta.c | 411 +++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_imeta.h | 46 +++++ fs/xfs/libxfs/xfs_types.c | 5 - fs/xfs/xfs_imeta_utils.c | 198 ++++++++++++++++++++++ fs/xfs/xfs_imeta_utils.h | 24 +++ fs/xfs/xfs_mount.c | 28 +++ fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 87 +++++++++- 9 files changed, 798 insertions(+), 4 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_imeta.c create mode 100644 fs/xfs/libxfs/xfs_imeta.h create mode 100644 fs/xfs/xfs_imeta_utils.c create mode 100644 fs/xfs/xfs_imeta_utils.h
fs/xfs/Makefile +2 -0
@@ -37,6 +37,7 @@ xfs-y += $(addprefix libxfs/, \ xfs_ialloc.o \ xfs_ialloc_btree.o \ xfs_iext_tree.o \ + xfs_imeta.o \ xfs_inode_fork.o \ xfs_inode_buf.o \ xfs_inode_util.o \
@@ -80,6 +81,7 @@ xfs-y += xfs_aops.o \ xfs_globals.o \ xfs_health.o \ xfs_icache.o \ + xfs_imeta_utils.o \ xfs_ioctl.o \ xfs_iomap.o \ xfs_iops.o \
fs/xfs/libxfs/xfs_imeta.c new file +411 -0
411 lines not on this page · raw message
fs/xfs/libxfs/xfs_imeta.h new file +46 -0
46 lines not on this page · raw message
fs/xfs/libxfs/xfs_types.c +2 -3
@@ -12,6 +12,7 @@#include "xfs_bit.h" #include "xfs_mount.h" #include "xfs_ag.h" +#include "xfs_imeta.h" /*
@@ -115,9 +116,7 @@ xfs_internal_inum( struct xfs_mount *mp, xfs_ino_t ino) { -return ino == mp->m_sb.sb_rbmino || ino == mp->m_sb.sb_rsumino || - (xfs_has_quota (mp) && -xfs_is_quota_inode (&mp->m_sb, ino)); +return xfs_is_static_meta_ino (mp, ino); }/*
fs/xfs/xfs_imeta_utils.c new file +198 -0
198 lines not on this page · raw message
fs/xfs/xfs_imeta_utils.h new file +24 -0
@@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* +* Copyright (c) 2018-2024 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_IMETA_UTILS_H__ +#define __XFS_IMETA_UTILS_H__ + +int xfs_imeta_start_create (struct xfs_mount *mp, +const struct xfs_imeta_path *path, +struct xfs_imeta_update *upd); + +int xfs_imeta_start_link (struct xfs_mount *mp, +const struct xfs_imeta_path *path, +struct xfs_inode *ip,struct xfs_imeta_update *upd); + +int xfs_imeta_start_unlink (struct xfs_mount *mp, +const struct xfs_imeta_path *path, +struct xfs_inode *ip,struct xfs_imeta_update *upd); + +int xfs_imeta_commit_update (struct xfs_imeta_update *upd); +void xfs_imeta_cancel_update (struct xfs_imeta_update *upd,int error); + +#endif /* __XFS_IMETA_UTILS_H__ */
fs/xfs/xfs_mount.c +28 -0
@@ -34,6 +34,7 @@#include "xfs_health.h" #include "xfs_trace.h" #include "xfs_ag.h" +#include "xfs_imeta.h" #include "scrub/stats.h" static DEFINE_MUTEX (xfs_uuid_table_mutex);
@@ -610,6 +611,29 @@ xfs_mount_setup_inode_geom(xfs_ialloc_setup_geometry (mp); } +STATIC int +xfs_mount_setup_metadir ( +struct xfs_mount *mp) +{ +struct xfs_trans *tp; +int error; + + error =xfs_trans_alloc_empty (mp, &tp); +if (error) +return error; + + error =xfs_imeta_mount (tp); +if (error) { +xfs_warn (mp,"Failed to load metadata inodes, error %d" , + error); + goto err_cancel; + } + +err_cancel: +xfs_trans_cancel (tp); +return error; +} +/* Compute maximum possible height for per-AG btree types for this fs. */ static inline void xfs_agbtree_compute_maxlevels(
@@ -846,6 +870,10 @@ xfs_mountfs( mp->m_features |=XFS_FEAT_ATTR2 ; } + error =xfs_mount_setup_metadir (mp); +if (error) + goto out_log_dealloc; +/* * Get and sanity-check the root inode. * Save the pointer to it in the mount structure.
fs/xfs/xfs_trace.c +1 -0
@@ -43,6 +43,7 @@#include "xfs_swapext.h" #include "xfs_xchgrange.h" #include "xfs_parent.h" +#include "xfs_imeta.h" /* * We include this last to have the helpers above available for the trace
fs/xfs/xfs_trace.h +86 -1
111 lines not on this page · raw message
PATCH 3/32 xfs: create transaction reservations for metadata inode operations
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create transaction reservation types and block reservation helpers to help us calculate transaction requirements. Right now the reservations are the same as always; we're just separating the symbols for a future patch.
--- fs/xfs/libxfs/xfs_imeta.c | 4 ++++ fs/xfs/libxfs/xfs_imeta.h | 4 ++++ fs/xfs/libxfs/xfs_trans_resv.c | 5 +++++ fs/xfs/libxfs/xfs_trans_resv.h | 3 +++ fs/xfs/xfs_imeta_utils.c | 8 +++++--- 5 files changed, 21 insertions(+), 3 deletions(-)
fs/xfs/libxfs/xfs_imeta.c +4 -0
@@ -19,6 +19,10 @@#include "xfs_inode.h" #include "xfs_quota.h" #include "xfs_ialloc.h" +#include "xfs_bmap_btree.h" +#include "xfs_da_format.h" +#include "xfs_da_btree.h" +#include "xfs_trans_space.h" /* * Metadata File Management
fs/xfs/libxfs/xfs_imeta.h +4 -0
@@ -43,4 +43,8 @@ int xfs_imeta_link(struct xfs_imeta_update *upd);bool xfs_is_static_meta_ino (struct xfs_mount *mp,xfs_ino_t ino);int xfs_imeta_mount (struct xfs_trans *tp); +unsigned int xfs_imeta_create_space_res (struct xfs_mount *mp); +unsigned int xfs_imeta_link_space_res (struct xfs_mount *mp); +unsigned int xfs_imeta_unlink_space_res (struct xfs_mount *mp); +#endif /* __XFS_IMETA_H__ */
fs/xfs/libxfs/xfs_trans_resv.c +5 -0
@@ -1249,4 +1249,9 @@ xfs_trans_resv_calc( resp->tr_itruncate.tr_logcount += logcount_adj; resp->tr_write.tr_logcount += logcount_adj; resp->tr_qm_dqalloc.tr_logcount += logcount_adj; + +/* metadata inode creation and unlink */ + resp->tr_imeta_create = resp->tr_create; + resp->tr_imeta_link = resp->tr_link; + resp->tr_imeta_unlink = resp->tr_remove; }
fs/xfs/libxfs/xfs_trans_resv.h +3 -0
@@ -48,6 +48,9 @@ struct xfs_trans_resv {struct xfs_trans_res tr_qm_dqalloc;/* allocate quota on disk */ struct xfs_trans_res tr_sb;/* modify superblock */ struct xfs_trans_res tr_fsyncts;/* update timestamps on fsync */ +struct xfs_trans_res tr_imeta_create;/* create metadata inode */ +struct xfs_trans_res tr_imeta_link;/* link metadata inode */ +struct xfs_trans_res tr_imeta_unlink;/* unlink metadata inode */ };/* shorthand way of accessing reservation structure */
fs/xfs/xfs_imeta_utils.c +5 -3
@@ -78,7 +78,7 @@ xfs_imeta_start_create(* will account for them. */ - error =xfs_trans_alloc (mp, &M_RES (mp)->tr_create, + error =xfs_trans_alloc (mp, &M_RES (mp)->tr_imeta_create,xfs_create_space_res (mp,MAXNAMELEN ),0 ,0 , &upd->tp);if (error) goto out_teardown;
@@ -136,7 +136,8 @@ xfs_imeta_start_link( {int error; - error =xfs_imeta_start_dir_update (mp, path, ip, &M_RES (mp)->tr_link, + error =xfs_imeta_start_dir_update (mp, path, ip, + &M_RES (mp)->tr_imeta_link,xfs_link_space_res (mp,MAXNAMELEN ), upd);if (error)return error;
@@ -158,7 +159,8 @@ xfs_imeta_start_unlink( {int error; - error =xfs_imeta_start_dir_update (mp, path, ip, &M_RES (mp)->tr_remove, + error =xfs_imeta_start_dir_update (mp, path, ip, + &M_RES (mp)->tr_imeta_unlink,xfs_remove_space_res (mp,MAXNAMELEN ), upd);if (error)return error;
PATCH 4/32 xfs: refactor the v4 group/project inode pointer switch
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Refactor the group and project quota inode pointer switcheroo that happens only on v4 filesystems into a separate function prior to enhancing the xfs_qm_qino_alloc function.
--- fs/xfs/xfs_qm.c | 90 +++++++++++++++++++++++++++++++++---------------------- 1 file changed, 54 insertions(+), 36 deletions(-)
fs/xfs/xfs_qm.c +54 -36
@@ -732,6 +732,57 @@ xfs_qm_destroy_quotainfo( mp->m_quotainfo =NULL ; } +/* +* Switch the group and project quota in-core inode pointers if needed. +* +* On v4 superblocks that don't have separate pquotino, we share an inode +* between gquota and pquota. If the on-disk superblock has GQUOTA and the +* filesystem is now mounted with PQUOTA, just use sb_gquotino for sb_pquotino +* and vice-versa. +*/ +STATIC int +xfs_qm_qino_switch ( +struct xfs_mount *mp, +struct xfs_inode **ipp, +unsigned int flags, +bool *need_alloc) +{ +xfs_ino_t ino =NULLFSINO ; +int error; + +if (xfs_has_pquotino (mp) || + !(flags & (XFS_QMOPT_PQUOTA |XFS_QMOPT_GQUOTA ))) +return 0 ; + +if ((flags &XFS_QMOPT_PQUOTA ) && + (mp->m_sb.sb_gquotino !=NULLFSINO )) { + ino = mp->m_sb.sb_gquotino; +if (XFS_IS_CORRUPT (mp, mp->m_sb.sb_pquotino !=NULLFSINO )) { +xfs_fs_mark_sick (mp,XFS_SICK_FS_PQUOTA ); +return -EFSCORRUPTED ; + } + }else if ((flags &XFS_QMOPT_GQUOTA ) && + (mp->m_sb.sb_pquotino !=NULLFSINO )) { + ino = mp->m_sb.sb_pquotino; +if (XFS_IS_CORRUPT (mp, mp->m_sb.sb_gquotino !=NULLFSINO )) { +xfs_fs_mark_sick (mp,XFS_SICK_FS_GQUOTA ); +return -EFSCORRUPTED ; + } + } + +if (ino ==NULLFSINO ) +return 0 ; + + error =xfs_iget (mp,NULL , ino,0 ,0 , ipp); +if (error) +return error; + + mp->m_sb.sb_gquotino =NULLFSINO ; + mp->m_sb.sb_pquotino =NULLFSINO ; + *need_alloc = false; +return 0 ; +} +/* * Create an inode and return with a reference already taken, but unlocked * This is how we create quota inodes
@@ -747,43 +798,10 @@ xfs_qm_qino_alloc(bool need_alloc = true; *ipp =NULL ; -/* -* With superblock that doesn't have separate pquotino, we -* share an inode between gquota and pquota. If the on-disk -* superblock has GQUOTA and the filesystem is now mounted -* with PQUOTA, just use sb_gquotino for sb_pquotino and -* vice-versa. -*/ -if (!xfs_has_pquotino (mp) && - (flags & (XFS_QMOPT_PQUOTA |XFS_QMOPT_GQUOTA ))) { -xfs_ino_t ino =NULLFSINO ; -if ((flags &XFS_QMOPT_PQUOTA ) && - (mp->m_sb.sb_gquotino !=NULLFSINO )) { - ino = mp->m_sb.sb_gquotino; -if (XFS_IS_CORRUPT (mp, - mp->m_sb.sb_pquotino !=NULLFSINO )) { -xfs_fs_mark_sick (mp,XFS_SICK_FS_PQUOTA ); -return -EFSCORRUPTED ; - } - }else if ((flags &XFS_QMOPT_GQUOTA ) && - (mp->m_sb.sb_pquotino !=NULLFSINO )) { - ino = mp->m_sb.sb_pquotino; -if (XFS_IS_CORRUPT (mp, - mp->m_sb.sb_gquotino !=NULLFSINO )) { -xfs_fs_mark_sick (mp,XFS_SICK_FS_GQUOTA ); -return -EFSCORRUPTED ; - } - } -if (ino !=NULLFSINO ) { - error =xfs_iget (mp,NULL , ino,0 ,0 , ipp); -if (error) -return error; - mp->m_sb.sb_gquotino =NULLFSINO ; - mp->m_sb.sb_pquotino =NULLFSINO ; - need_alloc = false; - } - } + error =xfs_qm_qino_switch (mp, ipp, flags, &need_alloc); +if (error) +return error; error = xfs_trans_alloc(mp, &M_RES(mp)->tr_create, need_alloc ? XFS_QM_QINOCREATE_SPACE_RES(mp) : 0,
PATCH 5/32 xfs: convert quota file creation to use imeta methods
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Convert the quota file creation code to use xfs_imeta_create instead of open-coding a bunch of logic.
--- fs/xfs/xfs_qm.c | 91 ++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 57 insertions(+), 34 deletions(-)
fs/xfs/xfs_qm.c +57 -34
@@ -27,6 +27,8 @@#include "xfs_ialloc.h" #include "xfs_log_priv.h" #include "xfs_health.h" +#include "xfs_imeta.h" +#include "xfs_imeta_utils.h" /* * The global quota manager. There is only one of these for the entire
@@ -732,6 +734,18 @@ xfs_qm_destroy_quotainfo( mp->m_quotainfo =NULL ; } +static inline const struct xfs_imeta_path * +xfs_qflags_to_imeta_path ( +unsigned int qflags) +{ +if (qflags &XFS_QMOPT_UQUOTA ) +return &XFS_IMETA_USRQUOTA ; +else if (qflags &XFS_QMOPT_GQUOTA ) +return &XFS_IMETA_GRPQUOTA ; +else +return &XFS_IMETA_PRJQUOTA ; +} +/* * Switch the group and project quota in-core inode pointers if needed. *
@@ -739,6 +753,12 @@ xfs_qm_destroy_quotainfo(* between gquota and pquota. If the on-disk superblock has GQUOTA and the * filesystem is now mounted with PQUOTA, just use sb_gquotino for sb_pquotino * and vice-versa. +* +* We tolerate the direct manipulation of the in-core sb quota inode pointers +* here because calling xfs_imeta_ functions is only really required for +* filesystems with the metadata directory feature. That feature requires a v5 +* superblock, which always supports simultaneous group and project quotas, so +* we'll never get here. */ STATIC int xfs_qm_qino_switch(
@@ -777,8 +797,13 @@ xfs_qm_qino_switch(if (error)return error; - mp->m_sb.sb_gquotino =NULLFSINO ; - mp->m_sb.sb_pquotino =NULLFSINO ; +if (flags &XFS_QMOPT_PQUOTA ) { + mp->m_sb.sb_gquotino =NULLFSINO ; + mp->m_sb.sb_pquotino = ino; + }else if (flags &XFS_QMOPT_GQUOTA ) { + mp->m_sb.sb_gquotino = ino; + mp->m_sb.sb_pquotino =NULLFSINO ; + } *need_alloc = false;return 0 ; }
@@ -793,7 +818,8 @@ xfs_qm_qino_alloc( struct xfs_inode **ipp, unsigned int flags) { -struct xfs_trans *tp; +struct xfs_imeta_update upd = { }; +const struct xfs_imeta_path *path =xfs_qflags_to_imeta_path (flags);int error;bool need_alloc = true;
@@ -803,29 +829,14 @@ xfs_qm_qino_alloc(if (error)return error; - error =xfs_trans_alloc (mp, &M_RES (mp)->tr_create, - need_alloc ?XFS_QM_QINOCREATE_SPACE_RES (mp) :0 , -0 ,0 , &tp); -if (error) -return error; -if (need_alloc) { -struct xfs_icreate_args args = { - .nlink =1 , - }; -xfs_ino_t ino; - -xfs_icreate_args_rootfile (&args, mp,S_IFREG , -xfs_has_parent (mp)); - - error =xfs_dialloc (&tp,0 ,S_IFREG , &ino); -if (!error) - error =xfs_icreate (tp, ino, &args, ipp); -if (error) { -xfs_trans_cancel (tp); -return error; - } + error =xfs_imeta_start_create (mp, path, &upd); + }else { + error =xfs_trans_alloc (mp, &M_RES (mp)->tr_create,0 ,0 ,0 , + &upd.tp); } +if (error) + goto out_end;/* * Make the changes in the superblock, and log those too.
@@ -844,23 +855,35 @@ xfs_qm_qino_alloc(/* qflags will get updated fully _after_ quotacheck */ mp->m_sb.sb_qflags = mp->m_qflags &XFS_ALL_QUOTA_ACCT ; } -if (flags &XFS_QMOPT_UQUOTA ) - mp->m_sb.sb_uquotino = (*ipp)->i_ino; -else if (flags &XFS_QMOPT_GQUOTA ) - mp->m_sb.sb_gquotino = (*ipp)->i_ino; -else - mp->m_sb.sb_pquotino = (*ipp)->i_ino;spin_unlock (&mp->m_sb_lock); -xfs_log_sb (tp); +xfs_log_sb (upd.tp); - error =xfs_trans_commit (tp); +if (need_alloc) { + error =xfs_imeta_create (&upd,S_IFREG , ipp); +if (error) + goto out_cancel; + } + + error =xfs_imeta_commit_update (&upd);if (error) {ASSERT (xfs_is_shutdown (mp));xfs_alert (mp,"%s failed (error %d)!" , __func__, error); + goto out_end; } -if (need_alloc) { -xfs_iunlock (*ipp,XFS_ILOCK_EXCL ); + +if (need_alloc)xfs_finish_inode_setup (*ipp); + +return 0 ; + +out_cancel: +xfs_imeta_cancel_update (&upd, error); +out_end: +/* Have to finish setting up the inode to ensure it's deleted. */ +if (*ipp) { +xfs_finish_inode_setup (*ipp); +xfs_irele (*ipp); + *ipp =NULL ; }return error; }
PATCH 6/32 xfs: iget for metadata inodes
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a xfs_iget_meta function for metadata inodes to ensure that we always check that the inobt thinks a metadata inode is in use.
--- fs/xfs/libxfs/xfs_imeta.h | 5 +++++ fs/xfs/xfs_icache.c | 40 ++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_inode.c | 8 +++++++ fs/xfs/xfs_qm.c | 50 ++++++++++++++++++++++++++++++--------------- fs/xfs/xfs_qm_syscalls.c | 9 +++++++- fs/xfs/xfs_rtalloc.c | 46 +++++++++++++++++++++++------------------ 6 files changed, 120 insertions(+), 38 deletions(-)
fs/xfs/libxfs/xfs_imeta.h +5 -0
@@ -47,4 +47,9 @@ unsigned int xfs_imeta_create_space_res(struct xfs_mount *mp);unsigned int xfs_imeta_link_space_res (struct xfs_mount *mp);unsigned int xfs_imeta_unlink_space_res (struct xfs_mount *mp); +/* Must be implemented by the libxfs client */ +int xfs_imeta_iget (struct xfs_trans *tp,xfs_ino_t ino,unsigned char ftype, +struct xfs_inode **ipp); +void xfs_imeta_irele (struct xfs_inode *ip); +#endif /* __XFS_IMETA_H__ */
fs/xfs/xfs_icache.c +40 -0
@@ -25,6 +25,9 @@#include "xfs_ag.h" #include "xfs_log_priv.h" #include "xfs_health.h" +#include "xfs_da_format.h" +#include "xfs_dir2.h" +#include "xfs_imeta.h" #include <linux/iversion.h>
@@ -811,6 +814,43 @@ xfs_iget(return error; } +/* +* Get a metadata inode. The ftype must match exactly. Caller must supply +* a transaction (even if empty) to avoid livelocking if the inobt has a cycle. +*/ +int +xfs_imeta_iget ( +struct xfs_trans *tp, +xfs_ino_t ino, +unsigned char ftype, +struct xfs_inode **ipp) +{ +struct xfs_mount *mp = tp->t_mountp; +struct xfs_inode *ip; +int error; + +ASSERT (ftype !=XFS_DIR3_FT_UNKNOWN ); + + error =xfs_iget (mp, tp, ino,XFS_IGET_UNTRUSTED ,0 , &ip); +if (error == -EFSCORRUPTED ) + goto whine; +if (error) +return error; + +if (VFS_I (ip)->i_nlink ==0 ) + goto bad_rele; +if (xfs_mode_to_ftype (VFS_I (ip)->i_mode) != ftype) + goto bad_rele; + + *ipp = ip; +return 0 ; +bad_rele: +xfs_irele (ip); +whine: +xfs_err (mp,"metadata inode 0x%llx is corrupt" , ino); +return -EFSCORRUPTED ; +} +/* * Grab the inode for reclaim exclusively. *
fs/xfs/xfs_inode.c +8 -0
@@ -43,6 +43,7 @@#include "xfs_parent.h" #include "xfs_xattr.h" #include "xfs_inode_util.h" +#include "xfs_imeta.h" struct kmem_cache *xfs_inode_cache;
@@ -2741,6 +2742,13 @@ xfs_irele(iput (VFS_I (ip)); } +void +xfs_imeta_irele ( +struct xfs_inode *ip) +{ +xfs_irele (ip); +} +/* * Ensure all commited transactions touching the inode are written to the log. */
fs/xfs/xfs_qm.c +33 -17
130 lines not on this page · raw message
fs/xfs/xfs_qm_syscalls.c +8 -1
@@ -18,6 +18,8 @@#include "xfs_quota.h" #include "xfs_qm.h" #include "xfs_icache.h" +#include "xfs_imeta.h" +#include "xfs_da_format.h" int xfs_qm_scall_quotaoff(
@@ -62,7 +64,12 @@ xfs_qm_scall_trunc_qfile(if (ino ==NULLFSINO )return 0 ; - error =xfs_iget (mp,NULL , ino,0 ,0 , &ip); + error =xfs_trans_alloc_empty (mp, &tp); +if (error) +return error; + + error =xfs_imeta_iget (tp, ino,XFS_DIR3_FT_REG_FILE , &ip); +xfs_trans_cancel (tp);if (error)return error;
fs/xfs/xfs_rtalloc.c +26 -20
107 lines not on this page · raw message
PATCH 7/32 xfs: define the on-disk format for the metadir feature
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Define the on-disk layout and feature flags for the metadata inode directory feature.
--- fs/xfs/libxfs/xfs_format.h | 60 +++++++++++++++++++++++++++++++++++----- fs/xfs/libxfs/xfs_inode_util.c | 2 + fs/xfs/libxfs/xfs_sb.c | 2 + fs/xfs/xfs_inode.h | 13 +++++++++ fs/xfs/xfs_mount.h | 2 + fs/xfs/xfs_super.c | 4 +++ 6 files changed, 75 insertions(+), 8 deletions(-)
fs/xfs/libxfs/xfs_format.h +52 -8
@@ -174,6 +174,16 @@ typedef struct xfs_sb {xfs_lsn_t sb_lsn;/* last write sequence */ uuid_t sb_meta_uuid;/* metadata file system unique id */ +/* Fields beyond here do not match xfs_dsb. Be very careful! */ + +/* +* Metadata Directory Inode. On disk this lives in the sb_rbmino slot, +* but we continue to use the in-core superblock to cache the classic +* inodes (rt bitmap; rt summary; user, group, and project quotas) so +* we cache the metadir inode value here too. +*/ +xfs_ino_t sb_metadirino; +/* must be padded to 64 bit alignment */ } xfs_sb_t;
@@ -190,7 +200,14 @@ struct xfs_dsb {uuid_t sb_uuid;/* user-visible file system unique id */ __be64 sb_logstart;/* starting block of log if internal */ __be64 sb_rootino;/* root inode number */ -__be64 sb_rbmino;/* bitmap inode for realtime extents */ +/* +* bitmap inode for realtime extents. +* +* The metadata directory feature uses the sb_rbmino field to point to +* the root of the metadata directory tree. All other sb inode +* pointers are no longer used. +*/ +__be64 sb_rbmino;__be64 sb_rsumino;/* summary inode for rt bitmap */ __be32 sb_rextsize;/* realtime extent size, blocks */ __be32 sb_agblocks;/* size of an allocation group */
@@ -373,6 +390,7 @@ xfs_sb_has_ro_compat_feature(#define XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR (1 << 4)/* needs xfs_repair */ #define XFS_SB_FEAT_INCOMPAT_NREXT64 (1 << 5)/* large extent counters */ #define XFS_SB_FEAT_INCOMPAT_PARENT (1 << 6)/* parent pointers */ +#define XFS_SB_FEAT_INCOMPAT_METADIR (1U << 31)/* metadata dir tree */ #define XFS_SB_FEAT_INCOMPAT_ALL \ (XFS_SB_FEAT_INCOMPAT_FTYPE| \ XFS_SB_FEAT_INCOMPAT_SPINODES| \
@@ -1109,17 +1127,43 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)#define XFS_DIFLAG2_REFLINK_BIT 1/* file's blocks may be shared */ #define XFS_DIFLAG2_COWEXTSIZE_BIT 2/* copy on write extent size hint */ #define XFS_DIFLAG2_BIGTIME_BIT 3/* big timestamps */ -#define XFS_DIFLAG2_NREXT64_BIT 4/* large extent counters */ +#define XFS_DIFLAG2_NREXT64_BIT 4/* large extent counters */ +#define XFS_DIFLAG2_METADIR_BIT 63/* filesystem metadata */ -#define XFS_DIFLAG2_DAX (1 << XFS_DIFLAG2_DAX_BIT) -#define XFS_DIFLAG2_REFLINK (1 << XFS_DIFLAG2_REFLINK_BIT) -#define XFS_DIFLAG2_COWEXTSIZE (1 << XFS_DIFLAG2_COWEXTSIZE_BIT) -#define XFS_DIFLAG2_BIGTIME (1 << XFS_DIFLAG2_BIGTIME_BIT) -#define XFS_DIFLAG2_NREXT64 (1 << XFS_DIFLAG2_NREXT64_BIT) +#define XFS_DIFLAG2_DAX (1ULL << XFS_DIFLAG2_DAX_BIT) +#define XFS_DIFLAG2_REFLINK (1ULL << XFS_DIFLAG2_REFLINK_BIT) +#define XFS_DIFLAG2_COWEXTSIZE (1ULL << XFS_DIFLAG2_COWEXTSIZE_BIT) +#define XFS_DIFLAG2_BIGTIME (1ULL << XFS_DIFLAG2_BIGTIME_BIT) +#define XFS_DIFLAG2_NREXT64 (1ULL << XFS_DIFLAG2_NREXT64_BIT) + +/* +* The inode contains filesystem metadata and can be found through the metadata +* directory tree. Metadata inodes must satisfy the following constraints: +* +* - V5 filesystem (and ftype) are enabled; +* - The only valid modes are regular files and directories; +* - The access bits must be zero; +* - DMAPI event and state masks are zero; +* - The user, group, and project IDs must be zero; +* - The immutable, sync, noatime, nodump, nodefrag flags must be set. +* - The dax flag must not be set. +* - Directories must have nosymlinks set. +* +* These requirements are chosen defensively to minimize the ability of +* userspace to read or modify the contents, should a metadata file ever +* escape to userspace. +* +* There are further constraints on the directory tree itself: +* +* - Metadata inodes must never be resolvable through the root directory; +* - They must never be accessed by userspace; +* - Metadata directory entries must have correct ftype. +*/ +#define XFS_DIFLAG2_METADIR (1ULL << XFS_DIFLAG2_METADIR_BIT)#define XFS_DIFLAG2_ANY \ (XFS_DIFLAG2_DAX | XFS_DIFLAG2_REFLINK | XFS_DIFLAG2_COWEXTSIZE | \ - XFS_DIFLAG2_BIGTIME | XFS_DIFLAG2_NREXT64) + XFS_DIFLAG2_BIGTIME | XFS_DIFLAG2_NREXT64 | XFS_DIFLAG2_METADIR)static inline bool xfs_dinode_has_bigtime (const struct xfs_dinode *dip) {
fs/xfs/libxfs/xfs_inode_util.c +2 -0
@@ -225,6 +225,8 @@ xfs_inode_inherit_flags2( }if (pip->i_diflags2 &XFS_DIFLAG2_DAX ) ip->i_diflags2 |=XFS_DIFLAG2_DAX ; +if (pip->i_diflags2 &XFS_DIFLAG2_METADIR ) + ip->i_diflags2 |=XFS_DIFLAG2_METADIR ;/* Don't let invalid cowextsize hints propagate. */ failaddr = xfs_inode_validate_cowextsize(ip->i_mount, ip->i_cowextsize,
fs/xfs/libxfs/xfs_sb.c +2 -0
@@ -178,6 +178,8 @@ xfs_sb_version_to_features( features |=XFS_FEAT_NREXT64 ;if (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_PARENT ) features |=XFS_FEAT_PARENT ; +if (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_METADIR ) + features |=XFS_FEAT_METADIR ;return features; }
fs/xfs/xfs_inode.h +13 -0
@@ -276,10 +276,23 @@ static inline bool xfs_is_reflink_inode(struct xfs_inode *ip)return ip->i_diflags2 &XFS_DIFLAG2_REFLINK ; } +static inline bool xfs_is_metadir_inode (struct xfs_inode *ip) +{ +return ip->i_diflags2 &XFS_DIFLAG2_METADIR ; +} +static inline bool xfs_is_metadata_inode (struct xfs_inode *ip) {struct xfs_mount *mp = ip->i_mount; +/* Any file in the metadata directory tree is a metadata inode. */ +if (xfs_has_metadir (mp)) +return xfs_is_metadir_inode (ip); + +/* +* Before metadata directories, the only metadata inodes were the +* three quota files, the realtime bitmap, and the realtime summary. +*/ return ip == mp->m_rbmip || ip == mp->m_rsumip ||xfs_is_quota_inode (&mp->m_sb, ip->i_ino); }
fs/xfs/xfs_mount.h +2 -0
@@ -292,6 +292,7 @@ typedef struct xfs_mount {#define XFS_FEAT_BIGTIME (1ULL << 24)/* large timestamps */ #define XFS_FEAT_NEEDSREPAIR (1ULL << 25)/* needs xfs_repair */ #define XFS_FEAT_NREXT64 (1ULL << 26)/* large extent counters */ +#define XFS_FEAT_METADIR (1ULL << 27)/* metadata directory tree */ /* Mount features */ #define XFS_FEAT_NOATTR2 (1ULL << 48)/* disable attr2 creation */
@@ -355,6 +356,7 @@ __XFS_HAS_FEAT(inobtcounts, INOBTCNT) __XFS_HAS_FEAT(bigtime, BIGTIME) __XFS_HAS_FEAT(needsrepair, NEEDSREPAIR) __XFS_HAS_FEAT(large_extent_counts, NREXT64) +__XFS_HAS_FEAT (metadir,METADIR )/* * Mount features
fs/xfs/xfs_super.c +4 -0
@@ -1713,6 +1713,10 @@ xfs_fs_fill_super( mp->m_features &= ~XFS_FEAT_DISCARD ; } +if (xfs_has_metadir (mp)) +xfs_warn (mp, +"EXPERIMENTAL metadata directory feature in use. Use at your own risk!" ); +if (xfs_has_reflink (mp)) {if (mp->m_sb.sb_rblocks) { xfs_alert(mp,
PATCH 8/32 xfs: update imeta transaction reservations for metadir
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Update the new metadata inode transaction reservations to handle metadata directories if that feature is enabled.
--- fs/xfs/libxfs/xfs_trans_resv.c | 101 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 98 insertions(+), 3 deletions(-)
fs/xfs/libxfs/xfs_trans_resv.c +98 -3
@@ -1109,6 +1109,81 @@ xfs_calc_sb_reservation(return xfs_calc_buf_res (1 , mp->m_sb.sb_sectsize); } +/* +* Metadata inode creation needs enough space to create or mkdir a directory, +* plus logging the superblock. +*/ +static unsigned int +xfs_calc_imeta_create_resv ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +unsigned int ret; + + ret =xfs_calc_buf_res (1 , mp->m_sb.sb_sectsize); + ret += resp->tr_create.tr_logres; +return ret; +} + +/* Metadata inode creation needs enough rounds to create or mkdir a directory */ +static int +xfs_calc_imeta_create_count ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +return resp->tr_create.tr_logcount; +} + +/* +* Metadata inode link needs enough space to add a file plus logging the +* superblock. +*/ +static unsigned int +xfs_calc_imeta_link_resv ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +unsigned int ret; + + ret =xfs_calc_buf_res (1 , mp->m_sb.sb_sectsize); + ret += resp->tr_link.tr_logres; +return ret; +} + +/* Metadata inode linking needs enough rounds to remove a file. */ +static int +xfs_calc_imeta_link_count ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +return resp->tr_link.tr_logcount; +} + +/* +* Metadata inode unlink needs enough space to remove a file plus logging the +* superblock. +*/ +static unsigned int +xfs_calc_imeta_unlink_resv ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +unsigned int ret; + + ret =xfs_calc_buf_res (1 , mp->m_sb.sb_sectsize); + ret += resp->tr_remove.tr_logres; +return ret; +} + +/* Metadata inode unlinking needs enough rounds to remove a file. */ +static int +xfs_calc_imeta_unlink_count ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +return resp->tr_remove.tr_logcount; +} +/* * Namespace reservations. *
@@ -1251,7 +1326,27 @@ xfs_trans_resv_calc( resp->tr_qm_dqalloc.tr_logcount += logcount_adj;/* metadata inode creation and unlink */ - resp->tr_imeta_create = resp->tr_create; - resp->tr_imeta_link = resp->tr_link; - resp->tr_imeta_unlink = resp->tr_remove; +if (xfs_has_metadir (mp)) { + resp->tr_imeta_create.tr_logres = +xfs_calc_imeta_create_resv (mp, resp); + resp->tr_imeta_create.tr_logcount = +xfs_calc_imeta_create_count (mp, resp); + resp->tr_imeta_create.tr_logflags |=XFS_TRANS_PERM_LOG_RES ; + + resp->tr_imeta_link.tr_logres = +xfs_calc_imeta_link_resv (mp, resp); + resp->tr_imeta_link.tr_logcount = +xfs_calc_imeta_link_count (mp, resp); + resp->tr_imeta_link.tr_logflags |=XFS_TRANS_PERM_LOG_RES ; + + resp->tr_imeta_unlink.tr_logres = +xfs_calc_imeta_unlink_resv (mp, resp); + resp->tr_imeta_unlink.tr_logcount = +xfs_calc_imeta_unlink_count (mp, resp); + resp->tr_imeta_unlink.tr_logflags |=XFS_TRANS_PERM_LOG_RES ; + }else { + resp->tr_imeta_create = resp->tr_create; + resp->tr_imeta_link = resp->tr_link; + resp->tr_imeta_unlink = resp->tr_remove; + } }
PATCH 9/32 xfs: load metadata directory root at mount time
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Load the metadata directory root inode into memory at mount time and release it at unmount time. We also make sure that the obsolete inode pointers in the superblock are not logged or read from the superblock.
--- fs/xfs/libxfs/xfs_sb.c | 31 +++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_types.c | 2 +- fs/xfs/xfs_mount.c | 22 +++++++++++++++++++--- fs/xfs/xfs_mount.h | 1 + 4 files changed, 52 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_sb.c +31 -0
@@ -682,6 +682,25 @@ __xfs_sb_from_disk(/* Convert on-disk flags to in-memory flags? */ if (convert_xquota)xfs_sb_quota_from_disk (to); + +if (to->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_METADIR ) { +/* +* Set metadirino here and null out the in-core fields for +* the other inodes because metadir initialization will load +* them later. +*/ + to->sb_metadirino =be64_to_cpu (from->sb_rbmino); + to->sb_rbmino =NULLFSINO ; + to->sb_rsumino =NULLFSINO ; + +/* +* We don't have to worry about quota inode conversion here +* because metadir requires a v5 filesystem. +*/ + to->sb_uquotino =NULLFSINO ; + to->sb_gquotino =NULLFSINO ; + to->sb_pquotino =NULLFSINO ; + } }void
@@ -829,6 +848,18 @@ xfs_sb_to_disk( to->sb_lsn =cpu_to_be64 (from->sb_lsn);if (from->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_META_UUID )uuid_copy (&to->sb_meta_uuid, &from->sb_meta_uuid); + +if (from->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_METADIR ) { +/* +* Save metadirino here and null out the on-disk fields for +* the other inodes, at least until we reuse the fields. +*/ + to->sb_rbmino =cpu_to_be64 (from->sb_metadirino); + to->sb_rsumino =cpu_to_be64 (NULLFSINO ); + to->sb_uquotino =cpu_to_be64 (NULLFSINO ); + to->sb_gquotino =cpu_to_be64 (NULLFSINO ); + to->sb_pquotino =cpu_to_be64 (NULLFSINO ); + } }/*
fs/xfs/libxfs/xfs_types.c +1 -1
@@ -128,7 +128,7 @@ xfs_verify_dir_ino( struct xfs_mount *mp, xfs_ino_t ino) { - if (xfs_internal_inum(mp, ino)) +if (!xfs_has_metadir (mp) &&xfs_internal_inum (mp, ino))return false;return xfs_verify_ino (mp, ino); }
fs/xfs/xfs_mount.c +19 -3
@@ -622,6 +622,18 @@ xfs_mount_setup_metadir(if (error)return error; +/* Load the metadata directory root inode into memory. */ +if (xfs_has_metadir (mp)) { + error =xfs_imeta_iget (tp, mp->m_sb.sb_metadirino, +XFS_DIR3_FT_DIR , &mp->m_metadirip); +if (error) { +xfs_warn (mp, +"Failed to load metadir root directory, error %d" , + error); + goto err_cancel; + } + } + error =xfs_imeta_mount (tp);if (error) { xfs_warn(mp, "Failed to load metadata inodes, error %d",
@@ -872,7 +884,7 @@ xfs_mountfs( error =xfs_mount_setup_metadir (mp);if (error) - goto out_log_dealloc; + goto out_free_metadir;/* * Get and sanity-check the root inode.
@@ -884,7 +896,7 @@ xfs_mountfs(xfs_warn (mp,"Failed to read root inode 0x%llx, error %d" , sbp->sb_rootino, -error); - goto out_log_dealloc; + goto out_free_metadir; }ASSERT (rip !=NULL );
@@ -1027,6 +1039,9 @@ xfs_mountfs(xfs_irele (rip);/* Clean out dquots that might be in memory after quotacheck. */ xfs_qm_unmount (mp); + out_free_metadir: +if (mp->m_metadirip) +xfs_imeta_irele (mp->m_metadirip);/* * Inactivate all inodes that might still be in memory after a log
@@ -1048,7 +1063,6 @@ xfs_mountfs(* quota inodes. */ xfs_unmount_flush_inodes (mp); - out_log_dealloc:xfs_log_mount_cancel (mp); out_inodegc_shrinker:shrinker_free (mp->m_inodegc_shrinker);
@@ -1101,6 +1115,8 @@ xfs_unmountfs(xfs_qm_unmount_quotas (mp);xfs_rtunmount_inodes (mp);xfs_irele (mp->m_rootip); +if (mp->m_metadirip) +xfs_imeta_irele (mp->m_metadirip);xfs_unmount_flush_inodes (mp);
fs/xfs/xfs_mount.h +1 -0
@@ -93,6 +93,7 @@ typedef struct xfs_mount {struct xfs_inode *m_rbmip;/* pointer to bitmap inode */ struct xfs_inode *m_rsumip;/* pointer to summary inode */ struct xfs_inode *m_rootip;/* pointer to root directory */ +struct xfs_inode *m_metadirip;/* ptr to metadata directory */ struct xfs_quotainfo *m_quotainfo;/* disk quota information */ xfs_buftarg_t *m_ddev_targp;/* saves taking the address */ xfs_buftarg_t *m_logdev_targp;/* ptr to log device */
PATCH 10/32 xfs: convert metadata inode lookup keys to use paths
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Convert the magic metadata inode lookup keys to use actual strings for paths.
--- fs/xfs/libxfs/xfs_imeta.c | 48 ++++++++++++++++++++++++--------------------- fs/xfs/libxfs/xfs_imeta.h | 27 +++++++++++++++++++++++-- fs/xfs/xfs_trace.h | 10 ++++++++- 3 files changed, 59 insertions(+), 26 deletions(-)
fs/xfs/libxfs/xfs_imeta.c +26 -22
@@ -49,26 +49,17 @@*/ /* Static metadata inode paths */ - -const struct xfs_imeta_path XFS_IMETA_RTBITMAP = { - .bogus =0 , -}; - -const struct xfs_imeta_path XFS_IMETA_RTSUMMARY = { - .bogus =1 , -}; - -const struct xfs_imeta_path XFS_IMETA_USRQUOTA = { - .bogus =2 , -}; - -const struct xfs_imeta_path XFS_IMETA_GRPQUOTA = { - .bogus =3 , -}; - -const struct xfs_imeta_path XFS_IMETA_PRJQUOTA = { - .bogus =4 , -}; +static const unsigned char *rtbitmap_path[] = {"realtime" ,"bitmap" }; +static const unsigned char *rtsummary_path[] = {"realtime" ,"summary" }; +static const unsigned char *usrquota_path[] = {"quota" ,"user" }; +static const unsigned char *grpquota_path[] = {"quota" ,"group" }; +static const unsigned char *prjquota_path[] = {"quota" ,"project" }; + +XFS_IMETA_DEFINE_PATH (XFS_IMETA_RTBITMAP , rtbitmap_path); +XFS_IMETA_DEFINE_PATH (XFS_IMETA_RTSUMMARY , rtsummary_path); +XFS_IMETA_DEFINE_PATH (XFS_IMETA_USRQUOTA , usrquota_path); +XFS_IMETA_DEFINE_PATH (XFS_IMETA_GRPQUOTA , grpquota_path); +XFS_IMETA_DEFINE_PATH (XFS_IMETA_PRJQUOTA , prjquota_path);/* Are these two paths equal? */ STATIC bool
@@ -76,7 +67,20 @@ xfs_imeta_path_compare(const struct xfs_imeta_path *a, const struct xfs_imeta_path *b) { - return a == b; + unsigned int i; + +if (a == b) +return true; + +if (a->im_depth != b->im_depth) +return false; + +for (i =0 ; i < a->im_depth; i++) +if (a->im_path[i] != b->im_path[i] && +strcmp (a->im_path[i], b->im_path[i])) +return false; + +return true; }/* Is this path ok? */
@@ -84,7 +88,7 @@ static inline boolxfs_imeta_path_check ( const struct xfs_imeta_path *path) { -return true; +return path->im_depth <=XFS_IMETA_MAX_DEPTH ; }/* Functions for storing and retrieving superblock inode values. */
fs/xfs/libxfs/xfs_imeta.h +25 -2
@@ -6,10 +6,23 @@#ifndef __XFS_IMETA_H__#define __XFS_IMETA_H__ +/* How deep can we nest metadata dirs? */ +#define XFS_IMETA_MAX_DEPTH 64 + +/* Form an imeta path from a simple array of strings. */ +#define XFS_IMETA_DEFINE_PATH (name, path) \ +const struct xfs_imeta_path name = { \ + .im_path = (path), \ + .im_depth = ARRAY_SIZE(path), \ +} +/* Key for looking up metadata inodes. */ struct xfs_imeta_path { -/* Temporary: integer to keep the static imeta definitions unique */ -int bogus; +/* Array of string pointers. */ +const unsigned char **im_path; + +/* Number of strings in path. */ +uint8_t im_depth; };/* Cleanup widget for metadata inode creation and deletion. */
@@ -25,6 +38,16 @@ struct xfs_imeta_update { unsigned int ip_locked:1; }; +/* Grab the last path component, mostly for tracing. */ +static inline const unsigned char * +xfs_imeta_lastpath ( +const struct xfs_imeta_update *upd) +{ +if (upd->path && upd->path->im_path && upd->path->im_depth >0 ) +return upd->path->im_path[upd->path->im_depth -1 ]; +return "?" ; +} +/* Lookup keys for static metadata inodes. */ extern const struct xfs_imeta_path XFS_IMETA_RTBITMAP ;extern const struct xfs_imeta_path XFS_IMETA_RTSUMMARY ;
fs/xfs/xfs_trace.h +8 -2
@@ -5091,13 +5091,16 @@ DECLARE_EVENT_CLASS(xfs_imeta_update_class,TP_STRUCT__entry (__field (dev_t ,dev )__field (xfs_ino_t, ino) +__string (fname,xfs_imeta_lastpath (upd)) ),TP_fast_assign ( __entry->dev = upd->mp->m_super->s_dev; __entry->ino = upd->ip ? upd->ip->i_ino :NULLFSINO ; +__assign_str (fname,xfs_imeta_lastpath (upd)); ), -TP_printk ("dev %d:%d ino 0x%llx" , +TP_printk ("dev %d:%d fname '%s' ino 0x%llx" ,MAJOR (__entry->dev),MINOR (__entry->dev), +__get_str (fname), __entry->ino) )
@@ -5121,14 +5124,17 @@ DECLARE_EVENT_CLASS(xfs_imeta_update_error_class, __field(dev_t, dev) __field(xfs_ino_t, ino) __field(int, error) +__string (fname,xfs_imeta_lastpath (upd)) ),TP_fast_assign ( __entry->dev = upd->mp->m_super->s_dev; __entry->ino = upd->ip ? upd->ip->i_ino :NULLFSINO ; __entry->error = error; +__assign_str (fname,xfs_imeta_lastpath (upd)); ), -TP_printk ("dev %d:%d ino 0x%llx error %d" , +TP_printk ("dev %d:%d fname '%s' ino 0x%llx error %d" ,MAJOR (__entry->dev),MINOR (__entry->dev), +__get_str (fname), __entry->ino, __entry->error) )
PATCH 11/32 xfs: enforce metadata inode flag
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add checks for the metadata inode flag so that we don't ever leak metadata inodes out to userspace, and we don't ever try to read a regular inode as metadata.
--- fs/xfs/libxfs/xfs_inode_buf.c | 73 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_inode_buf.h | 3 ++ fs/xfs/scrub/common.c | 10 ++++-- fs/xfs/scrub/inode.c | 25 +++++++++++++- fs/xfs/scrub/inode_repair.c | 10 ++++++ fs/xfs/xfs_icache.c | 2 + fs/xfs/xfs_inode.c | 13 +++++++ 7 files changed, 132 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_inode_buf.c +73 -0
@@ -460,6 +460,73 @@ xfs_dinode_verify_nrext64(return NULL ; } +/* +* Validate all the picky requirements we have for a file that claims to be +* filesystem metadata. +*/ +xfs_failaddr_t +xfs_dinode_verify_metadir ( +struct xfs_mount *mp, +struct xfs_dinode *dip, +uint16_t mode, +uint16_t flags, +uint64_t flags2) +{ +if (!xfs_has_metadir (mp)) +return __this_address; + +/* V5 filesystem only */ +if (dip->di_version <3 ) +return __this_address; + +/* V3 inode fields that are always zero */ +if (dip->di_onlink) +return __this_address; +if ((flags2 &XFS_DIFLAG2_NREXT64 ) && dip->di_nrext64_pad) +return __this_address; +if (!(flags2 &XFS_DIFLAG2_NREXT64 ) && dip->di_flushiter) +return __this_address; + +/* Metadata files can only be directories or regular files */ +if (!S_ISDIR (mode) && !S_ISREG (mode)) +return __this_address; + +/* They must have zero access permissions */ +if (mode &0777 ) +return __this_address; + +/* DMAPI event and state masks are zero */ +if (dip->di_dmevmask || dip->di_dmstate) +return __this_address; + +/* User, group, and project IDs must be zero */ +if (dip->di_uid || dip->di_gid || + dip->di_projid_lo || dip->di_projid_hi) +return __this_address; + +/* Immutable, sync, noatime, nodump, and nodefrag flags must be set */ +if (!(flags &XFS_DIFLAG_IMMUTABLE )) +return __this_address; +if (!(flags &XFS_DIFLAG_SYNC )) +return __this_address; +if (!(flags &XFS_DIFLAG_NOATIME )) +return __this_address; +if (!(flags &XFS_DIFLAG_NODUMP )) +return __this_address; +if (!(flags &XFS_DIFLAG_NODEFRAG )) +return __this_address; + +/* Directories must have nosymlinks flags set */ +if (S_ISDIR (mode) && !(flags &XFS_DIFLAG_NOSYMLINKS )) +return __this_address; + +/* dax flags2 must not be set */ +if (flags2 &XFS_DIFLAG2_DAX ) +return __this_address; + +return NULL ; +} + xfs_failaddr_t xfs_dinode_verify( struct xfs_mount *mp,
@@ -624,6 +691,12 @@ xfs_dinode_verify( !xfs_has_bigtime(mp))return __this_address; +if (flags2 &XFS_DIFLAG2_METADIR ) { + fa =xfs_dinode_verify_metadir (mp, dip, mode, flags, flags2); +if (fa) +return fa; + } +return NULL ; }
fs/xfs/libxfs/xfs_inode_buf.h +3 -0
@@ -28,6 +28,9 @@ int xfs_inode_from_disk(struct xfs_inode *ip, struct xfs_dinode *from);xfs_failaddr_t xfs_dinode_verify (struct xfs_mount *mp,xfs_ino_t ino,struct xfs_dinode *dip); +xfs_failaddr_t xfs_dinode_verify_metadir (struct xfs_mount *mp, +struct xfs_dinode *dip,uint16_t mode,uint16_t flags, +uint64_t flags2);xfs_failaddr_t xfs_inode_validate_extsize (struct xfs_mount *mp,uint32_t extsize,uint16_t mode,uint16_t flags); xfs_failaddr_t xfs_inode_validate_cowextsize(struct xfs_mount *mp,
fs/xfs/scrub/common.c +8 -2
@@ -942,9 +942,15 @@ xchk_iget_for_scrubbing(if (sc->sm->sm_ino ==0 || sc->sm->sm_ino == ip_in->i_ino)return xchk_install_live_inode (sc, ip_in); -/* Reject internal metadata files and obviously bad inode numbers. */ -if (xfs_internal_inum (mp, sc->sm->sm_ino)) +/* +* On pre-metadir filesystems, reject internal metadata files. For +* metadir filesystems, scrubbing any file in the metadata directory +* tree by handle is allowed, because that is the only way to validate +* the metadata directory structure. +*/ +if (!xfs_has_metadir (mp) &&xfs_internal_inum (mp, sc->sm->sm_ino))return -ENOENT ; +/* Reject obviously bad inode numbers. */ if (!xfs_verify_ino (sc->mp, sc->sm->sm_ino))return -ENOENT ;
fs/xfs/scrub/inode.c +23 -2
@@ -60,6 +60,22 @@ xchk_install_handle_iscrub(if (error)return error; +/* +* Don't allow scrubbing by handle of any inodes in the metadata +* directory tree. We don't know if any of the scans launched by +* this scrubber will end up indirectly trying to lock this file. +* +* Scrubbers of inode-rooted metadata files (i.e. the non-dir files) +* will attach all the resources needed to scrub the inode and call +* xchk_inode directly. Hence we do not let userspace call us +* directly. +*/ +if (xfs_is_metadir_inode (ip) && !S_ISDIR (VFS_I (ip)->i_mode)) { +xchk_irele (sc, ip); + sc->ip =NULL ; +return -ENOENT ; + } +return xchk_prepare_iscrub (sc); }
@@ -94,9 +110,14 @@ xchk_setup_inode(return xchk_prepare_iscrub (sc); } -/* Reject internal metadata files and obviously bad inode numbers. */ -if (xfs_internal_inum (mp, sc->sm->sm_ino)) +/* +* On pre-metadir filesystems, reject internal metadata files. For +* metadir filesystems, scrubbing directory inodes in the metadata +* directory tree by handle is allowed. +*/ +if (!xfs_has_metadir (mp) &&xfs_internal_inum (mp, sc->sm->sm_ino))return -ENOENT ; +/* Reject obviously bad inode numbers. */ if (!xfs_verify_ino (sc->mp, sc->sm->sm_ino))return -ENOENT ;
fs/xfs/scrub/inode_repair.c +10 -0
@@ -517,6 +517,16 @@ xrep_dinode_flags( dip->di_nrext64_pad =0 ; else if (dip->di_version >= 3) dip->di_v3_pad = 0; + +if (flags2 &XFS_DIFLAG2_METADIR ) { +xfs_failaddr_t fa; + + fa =xfs_dinode_verify_metadir (sc->mp, dip, mode, flags, + flags2); +if (fa) + flags2 &= ~XFS_DIFLAG2_METADIR ; + } + dip->di_flags =cpu_to_be16 (flags); dip->di_flags2 =cpu_to_be64 (flags2); }
fs/xfs/xfs_icache.c +2 -0
@@ -841,6 +841,8 @@ xfs_imeta_iget( goto bad_rele;if (xfs_mode_to_ftype (VFS_I (ip)->i_mode) != ftype) goto bad_rele; +if (xfs_has_metadir (mp) && !xfs_is_metadir_inode (ip)) + goto bad_rele; *ipp = ip;return 0 ;
fs/xfs/xfs_inode.c +13 -0
@@ -577,8 +577,19 @@ xfs_lookup(if (error) goto out_free_name; +/* +* Fail if a directory entry in the regular directory tree points to +* a metadata file. +*/ +if (XFS_IS_CORRUPT (dp->i_mount,xfs_is_metadir_inode (*ipp))) { + error = -EFSCORRUPTED ; + goto out_irele; + } +return 0 ; +out_irele: +xfs_irele (*ipp); out_free_name:if (ci_name)kmem_free (ci_name->name);
@@ -2746,6 +2757,8 @@ voidxfs_imeta_irele ( struct xfs_inode *ip) { +ASSERT (!xfs_has_metadir (ip->i_mount) ||xfs_is_metadir_inode (ip)); +xfs_irele (ip); }
PATCH 12/32 xfs: allow deletion of metadata directory files
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Make it possible to free metadata files once we've unlinked them from the directory structure. We don't do this in the kernel, at least not yet, but don't leave a logic bomb for later.
--- fs/xfs/libxfs/xfs_imeta.c | 49 ++++++++++++++++++++++++++++++++++++++++++++- fs/xfs/xfs_inode.c | 2 +- fs/xfs/xfs_inode.h | 3 +++ 3 files changed, 52 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_imeta.c +48 -1
@@ -23,6 +23,7 @@#include "xfs_da_format.h" #include "xfs_da_btree.h" #include "xfs_trans_space.h" +#include "xfs_ag.h" /* * Metadata File Management
@@ -360,6 +361,38 @@ xfs_imeta_create(return error; } +/* Free a file from the metadata directory tree. */ +STATIC int +xfs_imeta_ifree ( +struct xfs_trans *tp, +struct xfs_inode *ip) +{ +struct xfs_mount *mp = ip->i_mount; +struct xfs_perag *pag; +struct xfs_icluster xic = {0 }; +int error; + +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL )); +ASSERT (VFS_I (ip)->i_nlink ==0 ); +ASSERT (ip->i_df.if_nextents ==0 ); +ASSERT (ip->i_disk_size ==0 || !S_ISREG (VFS_I (ip)->i_mode)); +ASSERT (ip->i_nblocks ==0 ); + + pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, ip->i_ino)); + + error =xfs_dir_ifree (tp, pag, ip, &xic); +if (error) + goto out; + +/* Metadata files do not support ownership changes or DMAPI. */ + +if (xic.deleted) + error =xfs_ifree_cluster (tp, pag, ip, &xic); +out: +xfs_perag_put (pag); +return error; +} +/* * Unlink a metadata inode @upd->ip from the metadata directory given by @path. * The path must already exist.
@@ -368,10 +401,24 @@ intxfs_imeta_unlink ( struct xfs_imeta_update *upd) { +int error; +ASSERT (xfs_imeta_path_check (upd->path));ASSERT (xfs_imeta_verify (upd->mp, upd->ip->i_ino)); -return xfs_imeta_sb_unlink (upd); + error =xfs_imeta_sb_unlink (upd); +if (error) +return error; + +/* +* Metadata files require explicit resource cleanup. In other words, +* the inactivation system will not touch these files, so we must free +* the ondisk inode by ourselves if warranted. +*/ +if (VFS_I (upd->ip)->i_nlink >0 ) +return 0 ; + +return xfs_imeta_ifree (upd->tp, upd->ip); }/*
fs/xfs/xfs_inode.c +1 -1
@@ -1807,7 +1807,7 @@ xfs_ifree_mark_inode_stale(* inodes that are in memory - they all must be marked stale and attached to * the cluster buffer. */ -static int +int xfs_ifree_cluster( struct xfs_trans *tp, struct xfs_perag *pag,
fs/xfs/xfs_inode.h +3 -0
@@ -550,6 +550,9 @@ uint xfs_ilock_data_map_shared(struct xfs_inode *);uint xfs_ilock_attr_map_shared (struct xfs_inode *);int xfs_ifree (struct xfs_trans *,struct xfs_inode *); +int xfs_ifree_cluster (struct xfs_trans *tp,struct xfs_perag *pag, +struct xfs_inode *free_ip, +struct xfs_icluster *xic);int xfs_itruncate_extents_flags (struct xfs_trans **,struct xfs_inode *,int ,xfs_fsize_t ,int );void xfs_iext_realloc (xfs_inode_t *,int ,int );
PATCH 13/32 xfs: read and write metadata inode directory
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Plumb in the bits we need to look up metadata inode numbers from the metadata inode directory and save them back.
--- fs/xfs/libxfs/xfs_imeta.c | 563 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_imeta.h | 17 + fs/xfs/libxfs/xfs_inode_util.c | 3 fs/xfs/libxfs/xfs_trans_resv.c | 8 - fs/xfs/xfs_imeta_utils.c | 77 +++++ fs/xfs/xfs_trace.h | 50 +++- 6 files changed, 704 insertions(+), 14 deletions(-)
fs/xfs/libxfs/xfs_imeta.c +557 -6
@@ -24,6 +24,8 @@#include "xfs_da_btree.h" #include "xfs_trans_space.h" #include "xfs_ag.h" +#include "xfs_dir2.h" +#include "xfs_dir2_priv.h" /* * Metadata File Management
@@ -44,9 +46,16 @@* this structure must be passed to xfs_imeta_end_update to free resources that * cannot be freed during the transaction. * -* Right now we only support callers passing in the predefined metadata inode -* paths; the goal is that callers will some day locate metadata inodes based -* on path lookups into a metadata directory structure. +* When the metadata directory tree (metadir) feature is enabled, we can create +* a complex directory tree in which to store metadata inodes. Inodes within +* the metadata directory tree should have the "metadata" inode flag set to +* prevent them from being exposed to the outside world. +* +* Callers are not expected to take the IOLOCK of metadata directories. They +* are expected to take the ILOCK of any inode in the metadata directory tree +* (just like the regular to synchronize access to that inode. It is not +* necessary to take the MMAPLOCK since metadata inodes should never be exposed +* to user space. */ /* Static metadata inode paths */
@@ -62,6 +71,11 @@ XFS_IMETA_DEFINE_PATH(XFS_IMETA_USRQUOTA, usrquota_path);XFS_IMETA_DEFINE_PATH (XFS_IMETA_GRPQUOTA , grpquota_path);XFS_IMETA_DEFINE_PATH (XFS_IMETA_PRJQUOTA , prjquota_path); +const struct xfs_imeta_path XFS_IMETA_METADIR = { + .im_depth =0 , + .im_ftype =XFS_DIR3_FT_DIR , +}; +/* Are these two paths equal? */ STATIC bool xfs_imeta_path_compare(
@@ -119,6 +133,10 @@ static const struct xfs_imeta_sbmap { .path = &XFS_IMETA_PRJQUOTA, .offset = offsetof(struct xfs_sb, sb_pquotino), }, + { + .path = &XFS_IMETA_METADIR, + .offset = offsetof(struct xfs_sb, sb_metadirino), + }, { NULL, 0 }, };
@@ -288,6 +306,521 @@ xfs_imeta_sb_link(return 0 ; } +/* Functions for storing and retrieving metadata directory inode values. */ + +static inline void +xfs_imeta_set_xname ( +struct xfs_name *xname, +const struct xfs_imeta_path *path, +unsigned int path_idx, +unsigned char ftype) +{ + xname->name = (const unsigned char *)path->im_path[path_idx]; + xname->len =strlen (path->im_path[path_idx]); + xname->type = ftype; +} + +/* +* Look up the inode number and filetype for an exact name in a directory. +* Caller must hold ILOCK_EXCL. +*/ +static inline int +xfs_imeta_dir_lookup ( +struct xfs_trans *tp, +struct xfs_inode *dp, +struct xfs_name *xname, +xfs_ino_t *ino) +{ +struct xfs_da_args args = { + .trans = tp, + .dp = dp, + .geo = dp->i_mount->m_dir_geo, + .name = xname->name, + .namelen = xname->len, + .hashval =xfs_dir2_hashname (dp->i_mount, xname), + .whichfork =XFS_DATA_FORK , + .op_flags =XFS_DA_OP_OKNOENT , + .owner = dp->i_ino, + }; +bool isblock, isleaf; +int error; + +if (xfs_is_shutdown (dp->i_mount)) +return -EIO ; + +if (dp->i_df.if_format ==XFS_DINODE_FMT_LOCAL ) { + error =xfs_dir2_sf_lookup (&args); + goto out_unlock; + } + +/* dir2 functions require that the data fork is loaded */ + error =xfs_iread_extents (tp, dp,XFS_DATA_FORK ); +if (error) + goto out_unlock; + + error =xfs_dir2_isblock (&args, &isblock); +if (error) + goto out_unlock; + +if (isblock) { + error =xfs_dir2_block_lookup (&args); + goto out_unlock; + } + + error =xfs_dir2_isleaf (&args, &isleaf); +if (error) + goto out_unlock; + +if (isleaf) { + error =xfs_dir2_leaf_lookup (&args); + goto out_unlock; + } + + error =xfs_dir2_node_lookup (&args); + +out_unlock: +if (error == -EEXIST ) + error =0 ; +if (error) +return error; + + *ino = args.inumber; + xname->type = args.filetype; +return 0 ; +} + +/* +* Given a parent directory @dp and a metadata inode path component @xname, +* Look up the inode number in the directory, returning it in @ino. +* @xname.type must match the directory entry's ftype. +* +* Caller must hold ILOCK_EXCL. +*/ +static inline int +xfs_imeta_dir_lookup_component ( +struct xfs_trans *tp, +struct xfs_inode *dp, +struct xfs_name *xname, +xfs_ino_t *ino) +{ +int type_wanted = xname->type; +int error; + +if (!S_ISDIR (VFS_I (dp)->i_mode)) +return -EFSCORRUPTED ; + + error =xfs_imeta_dir_lookup (tp, dp, xname, ino); +if (error) +return error; +if (!xfs_verify_ino (dp->i_mount, *ino)) +return -EFSCORRUPTED ; +if (type_wanted !=XFS_DIR3_FT_UNKNOWN && xname->type != type_wanted) +return -EFSCORRUPTED ; + +trace_xfs_imeta_dir_lookup (dp, xname, *ino); +return 0 ; +} + +/* +* Traverse a metadata directory tree path, returning the inode corresponding +* to the parent of the last path component. If any of the path components do +* not exist, return -ENOENT. Caller must supply a transaction to avoid +* livelocks on btree cycles. +* +* @dp is returned without any locks held. +*/ +int +xfs_imeta_dir_parent ( +struct xfs_trans *tp, +const struct xfs_imeta_path *path, +struct xfs_inode **dpp) +{ +struct xfs_name xname; +struct xfs_mount *mp = tp->t_mountp; +struct xfs_inode *dp =NULL ; +xfs_ino_t ino; +unsigned int i; +int error; + +/* Caller wanted the root, we're done! */ +if (path->im_depth ==0 ) + goto out; + +/* No metadata directory means no parent. */ +if (mp->m_metadirip ==NULL ) +return -ENOENT ; + +/* Grab a new reference to the metadir root dir. */ + error =xfs_imeta_iget (tp, mp->m_metadirip->i_ino,XFS_DIR3_FT_DIR , + &dp); +if (error) +return error; + +for (i =0 ; i < path->im_depth -1 ; i++) { +struct xfs_inode *ip =NULL ; + +xfs_ilock (dp,XFS_ILOCK_EXCL ); + +/* Look up the name in the current directory. */ +xfs_imeta_set_xname (&xname, path, i,XFS_DIR3_FT_DIR ); + error =xfs_imeta_dir_lookup_component (tp, dp, &xname, &ino); +if (error) + goto out_rele; + +/* +* Grab the child inode while we still have the parent +* directory locked. +*/ + error =xfs_imeta_iget (tp, ino,XFS_DIR3_FT_DIR , &ip); +if (error) + goto out_rele; + +xfs_iunlock (dp,XFS_ILOCK_EXCL ); +xfs_imeta_irele (dp); + dp = ip; + } + +out: + *dpp = dp; +return 0 ; + +out_rele: +xfs_iunlock (dp,XFS_ILOCK_EXCL ); +xfs_imeta_irele (dp); +return error; +} + +/* +* Look up a metadata inode from the metadata directory. If the last path +* component doesn't exist, return NULLFSINO. If any other part of the path +* does not exist, return -ENOENT so we can distinguish the two. +*/ +STATIC int +xfs_imeta_dir_lookup_int ( +struct xfs_trans *tp, +const struct xfs_imeta_path *path, +xfs_ino_t *inop) +{ +struct xfs_name xname; +struct xfs_inode *dp =NULL ; +xfs_ino_t ino; +int error; + +/* metadir ino is recorded in superblock */ +if (xfs_imeta_path_compare (path, &XFS_IMETA_METADIR )) +return xfs_imeta_sb_lookup (tp->t_mountp, path, inop); + +ASSERT (path->im_depth >0 ); + +/* Find the parent of the last path component. */ + error =xfs_imeta_dir_parent (tp, path, &dp); +if (error) +return error; + +xfs_ilock (dp,XFS_ILOCK_EXCL ); + +/* Look up the name in the current directory. */ +xfs_imeta_set_xname (&xname, path, path->im_depth -1 , path->im_ftype); + error =xfs_imeta_dir_lookup_component (tp, dp, &xname, &ino); +switch (error) { +case 0 : + *inop = ino; +break ; +case -ENOENT : + *inop =NULLFSINO ; + error =0 ; +break ; + } + +xfs_iunlock (dp,XFS_ILOCK_EXCL ); +xfs_imeta_irele (dp); +return error; +} + +/* +* Load all the metadata inode pointers that are cached in the in-core +* superblock but live somewhere in the metadata directory tree. +*/ +STATIC int +xfs_imeta_dir_mount ( +struct xfs_trans *tp) +{ +struct xfs_mount *mp = tp->t_mountp; +const struct xfs_imeta_sbmap *p; +xfs_ino_t *sb_inop; +int err2; +int error =0 ; + +for (p = xfs_imeta_sbmaps; p->path && p->path->im_depth >0 ; p++) { +if (p->path == &XFS_IMETA_METADIR ) +continue ; + sb_inop =xfs_imeta_sbmap_to_inop (mp, p); + err2 =xfs_imeta_dir_lookup_int (tp, p->path, sb_inop); +if (err2 == -ENOENT ) { + *sb_inop =NULLFSINO ; +continue ; + } +if (!error && err2) + error = err2; + } + +return error; +} + +/* Set up an inode to be recognized as a metadata directory inode. */ +void +xfs_imeta_set_iflag ( +struct xfs_trans *tp, +struct xfs_inode *ip) +{ +VFS_I (ip)->i_mode &= ~0777 ; +VFS_I (ip)->i_uid =GLOBAL_ROOT_UID ; +VFS_I (ip)->i_gid =GLOBAL_ROOT_GID ; + ip->i_projid =0 ; + ip->i_diflags |= (XFS_DIFLAG_IMMUTABLE |XFS_DIFLAG_SYNC | +XFS_DIFLAG_NOATIME |XFS_DIFLAG_NODUMP | +XFS_DIFLAG_NODEFRAG ); +if (S_ISDIR (VFS_I (ip)->i_mode)) + ip->i_diflags |=XFS_DIFLAG_NOSYMLINKS ; + ip->i_diflags2 &= ~XFS_DIFLAG2_DAX ; + ip->i_diflags2 |=XFS_DIFLAG2_METADIR ; +xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); +} + + +/* Clear the metadata directory inode flag. */ +void +xfs_imeta_clear_iflag ( +struct xfs_trans *tp, +struct xfs_inode *ip) +{ +ASSERT (xfs_is_metadir_inode (ip)); +ASSERT (VFS_I (ip)->i_nlink ==0 ); + + ip->i_diflags2 &= ~XFS_DIFLAG2_METADIR ; +xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); +} +/* +* Create a new metadata inode accessible via the given metadata directory path. +* Callers must ensure that the directory entry does not already exist; a new +* one will be created. +*/ +STATIC int +xfs_imeta_dir_create ( +struct xfs_imeta_update *upd, +umode_t mode) +{ +struct xfs_icreate_args args = { + .pip = upd->dp, + .nlink =S_ISDIR (mode) ?2 :1 , + }; +struct xfs_name xname; +struct xfs_dir_update du = { + .dp = upd->dp, + .name = &xname, + .ppargs = upd->ppargs, + }; +struct xfs_mount *mp = upd->mp; +xfs_ino_t *sb_inop; +xfs_ino_t ino; +unsigned int resblks; +int error; + +ASSERT (xfs_isilocked (upd->dp,XFS_ILOCK_EXCL )); + +/* metadir ino is recorded in superblock; only mkfs gets to do this */ +if (xfs_imeta_path_compare (upd->path, &XFS_IMETA_METADIR )) { + error =xfs_imeta_sb_create (upd, mode); +if (error) +return error; + +/* Set the metadata iflag, initialize directory. */ +xfs_imeta_set_iflag (upd->tp, upd->ip); +return xfs_dir_init (upd->tp, upd->ip, upd->ip); + } + +ASSERT (upd->path->im_depth >0 ); + +xfs_icreate_args_rootfile (&args, mp, mode,xfs_has_parent (mp)); + +/* Check that the name does not already exist in the directory. */ +xfs_imeta_set_xname (&xname, upd->path, upd->path->im_depth -1 , +XFS_DIR3_FT_UNKNOWN ); + error =xfs_imeta_dir_lookup_component (upd->tp, upd->dp, &xname, &ino); +switch (error) { +case -ENOENT : +break ; +case 0 : + error = -EEXIST ; + fallthrough; +default : +return error; + } + +/* +* A newly created regular or special file just has one directory +* entry pointing to them, but a directory also the "." entry +* pointing to itself. +*/ + error =xfs_dialloc (&upd->tp, upd->dp->i_ino, mode, &ino); +if (error) +return error; + error =xfs_icreate (upd->tp, ino, &args, &upd->ip); +if (error) +return error; + du.ip = upd->ip; +xfs_imeta_set_iflag (upd->tp, upd->ip); + upd->ip_locked = true; + +/* +* Join the directory inode to the transaction. We do not do it +* earlier because xfs_dialloc rolls the transaction. +*/ +xfs_trans_ijoin (upd->tp, upd->dp,0 ); + +/* Create the entry. */ +if (S_ISDIR (args.mode)) + resblks =xfs_mkdir_space_res (mp, xname.len); +else + resblks =xfs_create_space_res (mp, xname.len); + xname.type =xfs_mode_to_ftype (args.mode); + +trace_xfs_imeta_dir_try_create (upd); + + error =xfs_dir_create_child (upd->tp, resblks, &du); +if (error) +return error; + +/* Metadir files are not accounted to quota. */ + +trace_xfs_imeta_dir_create (upd); + +/* Update the in-core superblock value if there is one. */ + sb_inop =xfs_imeta_path_to_sb_inop (mp, upd->path); +if (sb_inop) + *sb_inop = ino; +return 0 ; +} + +/* +* Remove the given entry from the metadata directory and drop the link count +* of the metadata inode. +*/ +STATIC int +xfs_imeta_dir_unlink ( +struct xfs_imeta_update *upd) +{ +struct xfs_name xname; +struct xfs_dir_update du = { + .dp = upd->dp, + .name = &xname, + .ip = upd->ip, + .ppargs = upd->ppargs, + }; +struct xfs_mount *mp = upd->mp; +xfs_ino_t *sb_inop; +xfs_ino_t ino; +unsigned int resblks; +int error; + +ASSERT (xfs_isilocked (upd->dp,XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (upd->ip,XFS_ILOCK_EXCL )); + +/* Metadata directory root cannot be unlinked. */ +if (xfs_imeta_path_compare (upd->path, &XFS_IMETA_METADIR )) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } + +ASSERT (upd->path->im_depth >0 ); + +/* Look up the name in the current directory. */ +xfs_imeta_set_xname (&xname, upd->path, upd->path->im_depth -1 , +xfs_mode_to_ftype (VFS_I (upd->ip)->i_mode)); + error =xfs_imeta_dir_lookup_component (upd->tp, upd->dp, &xname, &ino); +switch (error) { +case 0 : +if (ino != upd->ip->i_ino) + error = -ENOENT ; +break ; +case -ENOENT : + error = -EFSCORRUPTED ; +break ; + } +if (error) +return error; + + resblks =xfs_remove_space_res (mp, xname.len); + error =xfs_dir_remove_child (upd->tp, resblks, &du); +if (error) +return error; + +trace_xfs_imeta_dir_unlink (upd); + +/* Update the in-core superblock value if there is one. */ + sb_inop =xfs_imeta_path_to_sb_inop (mp, upd->path); +if (sb_inop) + *sb_inop =NULLFSINO ; +return 0 ; +} + +/* Set the given path in the metadata directory to point to an inode. */ +STATIC int +xfs_imeta_dir_link ( +struct xfs_imeta_update *upd) +{ +struct xfs_name xname; +struct xfs_dir_update du = { + .dp = upd->dp, + .name = &xname, + .ip = upd->ip, + .ppargs = upd->ppargs, + }; +struct xfs_mount *mp = upd->mp; +xfs_ino_t *sb_inop; +xfs_ino_t ino; +unsigned int resblks; +int error; + +ASSERT (xfs_isilocked (upd->dp,XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (upd->ip,XFS_ILOCK_EXCL )); + +/* Metadata directory root cannot be linked. */ +if (xfs_imeta_path_compare (upd->path, &XFS_IMETA_METADIR )) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } + +ASSERT (upd->path->im_depth >0 ); + +/* Look up the name in the current directory. */ +xfs_imeta_set_xname (&xname, upd->path, upd->path->im_depth -1 , +xfs_mode_to_ftype (VFS_I (upd->ip)->i_mode)); + error =xfs_imeta_dir_lookup_component (upd->tp, upd->dp, &xname, &ino); +switch (error) { +case -ENOENT : +break ; +case 0 : + error = -EEXIST ; + fallthrough; +default : +return error; + } + + resblks =xfs_link_space_res (mp, xname.len); + error =xfs_dir_add_child (upd->tp, resblks, &du); +if (error) +return error; + +trace_xfs_imeta_dir_link (upd); + +/* Update the in-core superblock value if there is one. */ + sb_inop =xfs_imeta_path_to_sb_inop (mp, upd->path); +if (sb_inop) + *sb_inop = upd->ip->i_ino; +return 0 ; +} +/* General functions for managing metadata inode pointers */ /*
@@ -318,7 +851,13 @@ xfs_imeta_lookup(ASSERT (xfs_imeta_path_check (path)); - error =xfs_imeta_sb_lookup (mp, path, &ino); +if (xfs_has_metadir (mp)) { + error =xfs_imeta_dir_lookup_int (tp, path, &ino); +if (error == -ENOENT ) +return -EFSCORRUPTED ; + }else { + error =xfs_imeta_sb_lookup (mp, path, &ino); + }if (error)return error;
@@ -350,13 +889,17 @@ xfs_imeta_create(umode_t mode, struct xfs_inode **ipp) { + struct xfs_mount *mp = upd->mp;int error;ASSERT (xfs_imeta_path_check (upd->path)); *ipp =NULL ; - error =xfs_imeta_sb_create (upd, mode); +if (xfs_has_metadir (mp)) + error =xfs_imeta_dir_create (upd, mode); +else + error =xfs_imeta_sb_create (upd, mode); *ipp = upd->ip;return error; }
@@ -406,7 +949,10 @@ xfs_imeta_unlink(ASSERT (xfs_imeta_path_check (upd->path));ASSERT (xfs_imeta_verify (upd->mp, upd->ip->i_ino)); - error =xfs_imeta_sb_unlink (upd); +if (xfs_has_metadir (upd->mp)) + error =xfs_imeta_dir_unlink (upd); +else + error =xfs_imeta_sb_unlink (upd);if (error)return error;
@@ -432,6 +978,8 @@ xfs_imeta_link( {ASSERT (xfs_imeta_path_check (upd->path)); +if (xfs_has_metadir (upd->mp)) +return xfs_imeta_dir_link (upd);return xfs_imeta_sb_link (upd); }
@@ -462,5 +1010,8 @@ intxfs_imeta_mount ( struct xfs_trans *tp) { +if (xfs_has_metadir (tp->t_mountp)) +return xfs_imeta_dir_mount (tp); +return 0 ; }
fs/xfs/libxfs/xfs_imeta.h +17 -0
@@ -13,6 +13,7 @@#define XFS_IMETA_DEFINE_PATH (name, path) \ const struct xfs_imeta_path name = { \ .im_path = (path), \ + .im_ftype = XFS_DIR3_FT_REG_FILE, \ .im_depth = ARRAY_SIZE(path), \ }
@@ -23,6 +24,9 @@ struct xfs_imeta_path {/* Number of strings in path. */ uint8_t im_depth; + +/* Expected file type. */ +uint8_t im_ftype; };/* Cleanup widget for metadata inode creation and deletion. */
@@ -32,9 +36,16 @@ struct xfs_imeta_update {const struct xfs_imeta_path *path; +/* Parent pointer update context */ +struct xfs_parent_args *ppargs; + +/* Parent directory */ +struct xfs_inode *dp; +/* Metadata inode */ struct xfs_inode *ip; + unsigned int dp_locked:1; unsigned int ip_locked:1; };
@@ -54,9 +65,15 @@ extern const struct xfs_imeta_path XFS_IMETA_RTSUMMARY;extern const struct xfs_imeta_path XFS_IMETA_USRQUOTA ;extern const struct xfs_imeta_path XFS_IMETA_GRPQUOTA ;extern const struct xfs_imeta_path XFS_IMETA_PRJQUOTA ; +extern const struct xfs_imeta_path XFS_IMETA_METADIR ;int xfs_imeta_lookup (struct xfs_trans *tp,const struct xfs_imeta_path *path,xfs_ino_t *ino); +int xfs_imeta_dir_parent (struct xfs_trans *tp, +const struct xfs_imeta_path *path,struct xfs_inode **dpp); + +void xfs_imeta_set_iflag (struct xfs_trans *tp,struct xfs_inode *ip); +void xfs_imeta_clear_iflag (struct xfs_trans *tp,struct xfs_inode *ip);int xfs_imeta_create (struct xfs_imeta_update *upd,umode_t mode,struct xfs_inode **ipp);
fs/xfs/libxfs/xfs_inode_util.c +3 -0
@@ -23,6 +23,7 @@#include "xfs_ag.h" #include "xfs_iunlink_item.h" #include "xfs_inode_item.h" +#include "xfs_imeta.h" uint16_t xfs_flags2diflags(
@@ -649,6 +650,8 @@ xfs_droplink(if (inode->i_nlink)return 0 ; +if (xfs_is_metadir_inode (ip)) +xfs_imeta_clear_iflag (tp, ip);return xfs_iunlink (tp, ip); }
fs/xfs/libxfs/xfs_trans_resv.c +7 -1
@@ -1121,7 +1121,10 @@ xfs_calc_imeta_create_resv(unsigned int ret; ret =xfs_calc_buf_res (1 , mp->m_sb.sb_sectsize); - ret += resp->tr_create.tr_logres; +if (xfs_has_metadir (mp)) + ret +=max (resp->tr_create.tr_logres, resp->tr_mkdir.tr_logres); +else + ret += resp->tr_create.tr_logres;return ret; }
@@ -1131,6 +1134,9 @@ xfs_calc_imeta_create_count( struct xfs_mount *mp, struct xfs_trans_resv *resp) { + if (xfs_has_metadir(mp)) + return max(resp->tr_create.tr_logcount, + resp->tr_mkdir.tr_logcount);return resp->tr_create.tr_logcount; }
fs/xfs/xfs_imeta_utils.c +72 -5
115 lines not on this page · raw message
fs/xfs/xfs_trace.h +48 -2
94 lines not on this page · raw message
PATCH 14/32 xfs: ensure metadata directory paths exist before creating files
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Since xfs_imeta_create can create new metadata files arbitrarily deep in the metadata directory tree, we must supply a function that can ensure that all directories in a path exist, and call it before the quota functions create the quota inodes.
--- fs/xfs/xfs_imeta_utils.c | 71 ++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_imeta_utils.h | 3 ++ fs/xfs/xfs_qm.c | 17 +++++++++++ 3 files changed, 91 insertions(+)
fs/xfs/xfs_imeta_utils.c +71 -0
@@ -265,3 +265,74 @@ xfs_imeta_cancel_update(xfs_imeta_teardown (upd, error); } + +/* Create a metadata for the last component of the path. */ +STATIC int +xfs_imeta_mkdir ( +struct xfs_mount *mp, +const struct xfs_imeta_path *path) +{ +struct xfs_imeta_update upd; +struct xfs_inode *ip =NULL ; +int error; + +if (xfs_is_shutdown (mp)) +return -EIO ; + +/* Allocate a transaction to create the last directory. */ + error =xfs_imeta_start_create (mp, path, &upd); +if (error) +return error; + +/* Create the subdirectory and take our reference. */ + error =xfs_imeta_create (&upd,S_IFDIR , &ip); +if (error) + goto out_cancel; + + error =xfs_imeta_commit_update (&upd); + +/* +* We don't pass the directory we just created to the caller, so finish +* setting up the inode, then release the dir and the dquots. +*/ + goto out_irele; + +out_cancel: +xfs_imeta_cancel_update (&upd, error); +out_irele: +/* Have to finish setting up the inode to ensure it's deleted. */ +if (ip) { +xfs_finish_inode_setup (ip); +xfs_irele (ip); + } +return error; +} + +/* +* Make sure that every metadata directory path component exists and is a +* directory. +*/ +int +xfs_imeta_ensure_dirpath ( +struct xfs_mount *mp, +const struct xfs_imeta_path *path) +{ +struct xfs_imeta_path temp_path = { + .im_path = path->im_path, + .im_depth =1 , + .im_ftype =XFS_DIR3_FT_DIR , + }; +unsigned int i; +int error =0 ; + +if (!xfs_has_metadir (mp)) +return 0 ; + +for (i =0 ; i < path->im_depth -1 ; i++, temp_path.im_depth++) { + error =xfs_imeta_mkdir (mp, &temp_path); +if (error && error != -EEXIST ) +return error; + } + +return 0 ; +}
fs/xfs/xfs_imeta_utils.h +3 -0
@@ -18,6 +18,9 @@ int xfs_imeta_start_unlink(struct xfs_mount *mp,const struct xfs_imeta_path *path, struct xfs_inode *ip, struct xfs_imeta_update *upd); +int xfs_imeta_ensure_dirpath (struct xfs_mount *mp, +const struct xfs_imeta_path *path); +int xfs_imeta_commit_update (struct xfs_imeta_update *upd);void xfs_imeta_cancel_update (struct xfs_imeta_update *upd,int error);
fs/xfs/xfs_qm.c +17 -0
@@ -836,6 +836,23 @@ xfs_qm_qino_alloc(return error;if (need_alloc) { +/* +* Ensure the quota directory exists, being careful to disable +* quotas while we do this. We'll have to quotacheck anyway, +* so the temporary undercount of the directory tree shouldn't +* affect the quota count. +*/ +if (xfs_has_metadir (mp)) { +unsigned int old_qflags; + + old_qflags = mp->m_qflags &XFS_ALL_QUOTA_ACCT ; + mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT ; + error =xfs_imeta_ensure_dirpath (mp, path); + mp->m_qflags |= old_qflags; +if (error) +return error; + } + error =xfs_imeta_start_create (mp, path, &upd); }else { error = xfs_trans_alloc(mp, &M_RES(mp)->tr_create, 0, 0, 0,
PATCH 15/32 xfs: disable the agi rotor for metadata inodes
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Ideally, we'd put all the metadata inodes in one place if we could, so that the metadata all stay reasonably close together instead of spreading out over the disk. Furthermore, if the log is internal we'd probably prefer to keep the metadata near the log. Therefore, disable AGI rotoring for metadata inode allocations.
--- fs/xfs/libxfs/xfs_ialloc.c | 56 ++++++++++++++++++++++++++++++-------------- fs/xfs/libxfs/xfs_ialloc.h | 2 +- fs/xfs/libxfs/xfs_imeta.c | 4 ++- fs/xfs/scrub/tempfile.c | 2 +- fs/xfs/xfs_inode.c | 4 ++- fs/xfs/xfs_symlink.c | 2 +- 6 files changed, 45 insertions(+), 25 deletions(-)
fs/xfs/libxfs/xfs_ialloc.c +38 -18
@@ -1799,6 +1799,37 @@ xfs_dialloc_try_ag(return error; } +/* +* Pick an AG for the new inode. +* +* Directories, symlinks, and regular files frequently allocate at least one +* block, so factor that potential expansion when we examine whether an AG has +* enough space for file creation. Try to keep metadata files all in the same +* AG. +*/ +static inline xfs_agnumber_t +xfs_dialloc_pick_ag ( +struct xfs_mount *mp, +struct xfs_inode *dp, +umode_t mode) +{ +xfs_agnumber_t start_agno; + +if (!dp) +return 0 ; +if (xfs_is_metadir_inode (dp)) +return 0 ; + +if (S_ISDIR (mode)) +return (atomic_inc_return (&mp->m_agirotor) -1 ) % mp->m_maxagi; + + start_agno =XFS_INO_TO_AGNO (mp, dp->i_ino); +if (start_agno >= mp->m_maxagi) + start_agno =0 ; + +return start_agno; +} +/* * Allocate an on-disk inode. *
@@ -1810,34 +1841,23 @@ xfs_dialloc_try_ag(int xfs_dialloc (struct xfs_trans **tpp, -xfs_ino_t parent, +struct xfs_inode *dp,umode_t mode,xfs_ino_t *new_ino) {struct xfs_mount *mp = (*tpp)->t_mountp; -xfs_agnumber_t agno; -int error =0 ; -xfs_agnumber_t start_agno;struct xfs_perag *pag;struct xfs_ino_geometry *igeo =M_IGEO (mp); +xfs_ino_t ino =NULLFSINO ; +xfs_ino_t parent = dp ? dp->i_ino :0 ; +xfs_agnumber_t agno; +xfs_agnumber_t start_agno;bool ok_alloc = true;bool low_space = false;int flags; -xfs_ino_t ino =NULLFSINO ; +int error =0 ; -/* -* Directories, symlinks, and regular files frequently allocate at least -* one block, so factor that potential expansion when we examine whether -* an AG has enough space for file creation. -*/ -if (S_ISDIR (mode)) - start_agno = (atomic_inc_return (&mp->m_agirotor) -1 ) % - mp->m_maxagi; -else { - start_agno =XFS_INO_TO_AGNO (mp, parent); -if (start_agno >= mp->m_maxagi) - start_agno =0 ; - } + start_agno =xfs_dialloc_pick_ag (mp, dp, mode);/* * If we have already hit the ceiling of inode blocks then clear
fs/xfs/libxfs/xfs_ialloc.h +1 -1
@@ -37,7 +37,7 @@ xfs_make_iptr(struct xfs_mount *mp, struct xfs_buf *b, int o)* Allocate an inode on disk. Mode is used to tell whether the new inode will * need space, and whether it is a directory. */ -int xfs_dialloc (struct xfs_trans **tpp,xfs_ino_t parent,umode_t mode, +int xfs_dialloc (struct xfs_trans **tpp,struct xfs_inode *dp,umode_t mode,xfs_ino_t *new_ino); int xfs_difree(struct xfs_trans *tp, struct xfs_perag *pag,
fs/xfs/libxfs/xfs_imeta.c +2 -2
@@ -230,7 +230,7 @@ xfs_imeta_sb_create(return -EEXIST ;/* Create a new inode and set the sb pointer. */ - error =xfs_dialloc (&upd->tp,0 , mode, &ino); + error =xfs_dialloc (&upd->tp,NULL , mode, &ino);if (error)return error; error =xfs_icreate (upd->tp, ino, &args, &upd->ip);
@@ -662,7 +662,7 @@ xfs_imeta_dir_create(* entry pointing to them, but a directory also the "." entry * pointing to itself. */ - error =xfs_dialloc (&upd->tp, upd->dp->i_ino, mode, &ino); + error =xfs_dialloc (&upd->tp, upd->dp, mode, &ino);if (error)return error; error =xfs_icreate (upd->tp, ino, &args, &upd->ip);
fs/xfs/scrub/tempfile.c +1 -1
@@ -87,7 +87,7 @@ xrep_tempfile_create( goto out_release_dquots;/* Allocate inode, set up directory. */ - error =xfs_dialloc (&tp, dp->i_ino, mode, &ino); + error =xfs_dialloc (&tp, dp, mode, &ino);if (error) goto out_trans_cancel; error =xfs_icreate (tp, ino, &args, &sc->tempip);
fs/xfs/xfs_inode.c +2 -2
@@ -768,7 +768,7 @@ xfs_create(* entry pointing to them, but a directory also the "." entry * pointing to itself. */ - error =xfs_dialloc (&tp, dp->i_ino, args->mode, &ino); + error =xfs_dialloc (&tp, dp, args->mode, &ino);if (!error) error =xfs_icreate (tp, ino, args, &du.ip);if (error)
@@ -879,7 +879,7 @@ xfs_create_tmpfile(if (error) goto out_release_dquots; - error =xfs_dialloc (&tp, dp->i_ino, args->mode, &ino); + error =xfs_dialloc (&tp, dp, args->mode, &ino);if (!error) error =xfs_icreate (tp, ino, args, &ip);if (error)
fs/xfs/xfs_symlink.c +1 -1
@@ -169,7 +169,7 @@ xfs_symlink(/* * Allocate an inode for the symlink. */ - error =xfs_dialloc (&tp, dp->i_ino,S_IFLNK , &ino); + error =xfs_dialloc (&tp, dp,S_IFLNK , &ino);if (!error) error =xfs_icreate (tp, ino, &args, &du.ip);if (error)
PATCH 16/32 xfs: hide metadata inodes from everyone because they are special
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Metadata inodes are private files and therefore cannot be exposed to userspace. This means no bulkstat, no open-by-handle, no linking them into the directory tree, and no feeding them to LSMs. As such, we mark them S_PRIVATE, which stops all that.
While we're at it, put them in a separate lockdep class so that it won't get confused by "recursive" i_rwsem locking such as what happens when we write to a rt file and need to allocate from the rt bitmap file.
--- fs/xfs/scrub/tempfile.c | 8 ++++++++ fs/xfs/xfs_iops.c | 34 ++++++++++++++++++++++++++++++++-- 2 files changed, 40 insertions(+), 2 deletions(-)
fs/xfs/scrub/tempfile.c +8 -0
@@ -867,6 +867,14 @@ xrep_is_tempfile( const struct xfs_inode *ip) {const struct inode *inode = &ip->i_vnode; +struct xfs_mount *mp = ip->i_mount; + +/* +* Files in the metadata directory tree also have S_PRIVATE set and +* IOP_XATTR unset, so we must distinguish them separately. +*/ +if (xfs_has_metadir (mp) && (ip->i_diflags2 &XFS_DIFLAG2_METADIR )) +return false;if (IS_PRIVATE (inode) && !(inode->i_opflags &IOP_XATTR ))return true;
fs/xfs/xfs_iops.c +32 -2
@@ -45,6 +45,15 @@static struct lock_class_key xfs_nondir_ilock_class;static struct lock_class_key xfs_dir_ilock_class; +/* +* Metadata directories and files are not exposed to userspace, which means +* that they never access any of the VFS IO locks and never experience page +* faults. Give them separate locking classes so that lockdep will not +* complain about conflicts that cannot happen. +*/ +static struct lock_class_key xfs_metadata_file_ilock_class; +static struct lock_class_key xfs_metadata_dir_ilock_class; + static int xfs_initxattrs( struct inode *inode,
@@ -1291,6 +1300,7 @@ xfs_setup_inode( {struct inode *inode = &ip->i_vnode;gfp_t gfp_mask; +bool is_meta =xfs_is_metadata_inode (ip); inode->i_ino = ip->i_ino; inode->i_state |=I_NEW ;
@@ -1302,6 +1312,16 @@ xfs_setup_inode(i_size_write (inode, ip->i_disk_size);xfs_diflags_to_iflags (ip, true); +/* +* Mark our metadata files as private so that LSMs and the ACL code +* don't try to add their own metadata or reason about these files, +* and users cannot ever obtain file handles to them. +*/ +if (is_meta) { + inode->i_flags |=S_PRIVATE ; + inode->i_opflags &= ~IOP_XATTR ; + } +if (S_ISDIR (inode->i_mode)) {/* * We set the i_rwsem class here to avoid potential races with
@@ -1311,9 +1331,19 @@ xfs_setup_inode(*/ lockdep_set_class (&inode->i_rwsem, &inode->i_sb->s_type->i_mutex_dir_key); -lockdep_set_class (&ip->i_lock.mr_lock, &xfs_dir_ilock_class); +if (is_meta) +lockdep_set_class (&ip->i_lock.mr_lock, + &xfs_metadata_dir_ilock_class); +else +lockdep_set_class (&ip->i_lock.mr_lock, + &xfs_dir_ilock_class); }else { -lockdep_set_class (&ip->i_lock.mr_lock, &xfs_nondir_ilock_class); +if (is_meta) +lockdep_set_class (&ip->i_lock.mr_lock, + &xfs_metadata_file_ilock_class); +else +lockdep_set_class (&ip->i_lock.mr_lock, + &xfs_nondir_ilock_class); }/*
PATCH 17/32 xfs: advertise metadata directory feature
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Advertise the existence of the metadata directory feature; this will be used by scrub to decide if it needs to scan the metadir too.
--- fs/xfs/libxfs/xfs_fs.h | 1 + fs/xfs/libxfs/xfs_sb.c | 2 ++ 2 files changed, 3 insertions(+)
fs/xfs/libxfs/xfs_fs.h +1 -0
@@ -239,6 +239,7 @@ typedef struct xfs_fsop_resblks {#define XFS_FSOP_GEOM_FLAGS_BIGTIME (1 << 21)/* 64-bit nsec timestamps */ #define XFS_FSOP_GEOM_FLAGS_INOBTCNT (1 << 22)/* inobt btree counter */ #define XFS_FSOP_GEOM_FLAGS_NREXT64 (1 << 23)/* large extent counters */ +#define XFS_FSOP_GEOM_FLAGS_METADIR (1U << 29)/* metadata directories */ #define XFS_FSOP_GEOM_FLAGS_PARENT (1U << 30)/* parent pointers */ /* atomic file extent swap available to userspace */
fs/xfs/libxfs/xfs_sb.c +2 -0
@@ -1298,6 +1298,8 @@ xfs_fs_geometry( geo->flags |=XFS_FSOP_GEOM_FLAGS_NREXT64 ;if (xfs_atomic_swap_supported (mp)) geo->flags |=XFS_FSOP_GEOM_FLAGS_ATOMIC_SWAP ; +if (xfs_has_metadir (mp)) + geo->flags |=XFS_FSOP_GEOM_FLAGS_METADIR ; geo->rtsectsize = sbp->sb_blocksize; geo->dirblocksize =xfs_dir2_dirblock_bytes (sbp);
PATCH 18/32 xfs: allow bulkstat to return metadata directories
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Allow the V5 bulkstat ioctl to return information about metadata directory files so that xfs_scrub can find and scrub them, since they are otherwise ordinary directories.
(Metadata files of course require per-file scrub code and hence do not need exposure.)
--- fs/xfs/libxfs/xfs_fs.h | 10 +++++++++- fs/xfs/xfs_ioctl.c | 7 +++++++ fs/xfs/xfs_itable.c | 34 ++++++++++++++++++++++++++++++---- fs/xfs/xfs_itable.h | 3 +++ 4 files changed, 49 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_fs.h +9 -1
@@ -491,9 +491,17 @@ struct xfs_bulk_ireq {*/ #define XFS_BULK_IREQ_NREXT64 (1U << 2) +/* +* Allow bulkstat to return information about metadata directories. This +* enables xfs_scrub to find them for scanning, as they are otherwise ordinary +* directories. +*/ +#define XFS_BULK_IREQ_METADIR (1U << 31) +#define XFS_BULK_IREQ_FLAGS_ALL (XFS_BULK_IREQ_AGNO | \ XFS_BULK_IREQ_SPECIAL | \ - XFS_BULK_IREQ_NREXT64) + XFS_BULK_IREQ_NREXT64 | \ + XFS_BULK_IREQ_METADIR)/* Operate on the root directory inode. */ #define XFS_BULK_IREQ_SPECIAL_ROOT (1)
fs/xfs/xfs_ioctl.c +7 -0
@@ -824,6 +824,10 @@ xfs_bulk_ireq_setup(if (hdr->flags &XFS_BULK_IREQ_NREXT64 ) breq->flags |=XFS_IBULK_NREXT64 ; +/* Caller wants to see metadata directories in bulkstat output. */ +if (hdr->flags &XFS_BULK_IREQ_METADIR ) + breq->flags |=XFS_IBULK_METADIR ; +return 0 ; }
@@ -914,6 +918,9 @@ xfs_ioc_inumbers(if (copy_from_user (&hdr, &arg->hdr,sizeof (hdr)))return -EFAULT ; +if (hdr.flags &XFS_BULK_IREQ_METADIR ) +return -EINVAL ; + error =xfs_bulk_ireq_setup (mp, &hdr, &breq, arg->inumbers);if (error == -ECANCELED ) goto out_teardown;
fs/xfs/xfs_itable.c +30 -4
@@ -36,6 +36,15 @@ struct xfs_bstat_chunk {struct xfs_bulkstat *buf; }; +static inline bool +want_metadir_file ( +struct xfs_inode *ip, +struct xfs_ibulk *breq) +{ +return xfs_is_metadir_inode (ip) && + (breq->flags &XFS_IBULK_METADIR ); +} +/* * Fill out the bulkstat info for a single inode and report it somewhere. *
@@ -69,9 +78,6 @@ xfs_bulkstat_one_int(vfsuid_t vfsuid;vfsgid_t vfsgid; -if (xfs_internal_inum (mp, ino)) - goto out_advance; - error =xfs_iget (mp, tp, ino, (XFS_IGET_DONTCACHE |XFS_IGET_UNTRUSTED ),XFS_ILOCK_SHARED , &ip);
@@ -97,8 +103,28 @@ xfs_bulkstat_one_int( vfsuid =i_uid_into_vfsuid (idmap, inode); vfsgid =i_gid_into_vfsgid (idmap, inode); +/* +* If caller wants files from the metadata directories, push out the +* bare minimum information for enabling scrub. +*/ +if (want_metadir_file (ip, bc->breq)) { +memset (buf,0 ,sizeof (*buf)); + buf->bs_ino = ino; + buf->bs_gen = inode->i_generation; + buf->bs_mode = inode->i_mode &S_IFMT ; +xfs_bulkstat_health (ip, buf); + buf->bs_version =XFS_BULKSTAT_VERSION_V5 ; +xfs_iunlock (ip,XFS_ILOCK_SHARED ); +xfs_irele (ip); + + error = bc->formatter (bc->breq, buf); +if (!error || error == -ECANCELED ) + goto out_advance; + goto out; + } +/* If this is a private inode, don't leak its details to userspace. */ -if (IS_PRIVATE (inode)) { +if (IS_PRIVATE (inode) ||xfs_internal_inum (mp, ino)) {xfs_iunlock (ip,XFS_ILOCK_SHARED );xfs_irele (ip); error = -EINVAL ;
fs/xfs/xfs_itable.h +3 -0
@@ -22,6 +22,9 @@ struct xfs_ibulk {/* Fill out the bs_extents64 field if set. */ #define XFS_IBULK_NREXT64 (1U << 1) +/* Signal that we can return metadata directories. */ +#define XFS_IBULK_METADIR (1U << 2) +/* * Advance the user buffer pointer by one record of the given size. If the * buffer is now full, return the appropriate error code.
PATCH 19/32 xfs: enable creation of dynamically allocated metadir path structures
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a few helper functions so that it's possible to allocate xfs_imeta_path objects dynamically, along with dynamically allocated path components. Eventually we're going to want to support paths of the form "/realtime/$rtgroup.rmap", and this is necessary for that.
--- fs/xfs/libxfs/xfs_imeta.c | 46 +++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_imeta.h | 15 +++++++++++++++ 2 files changed, 61 insertions(+)
fs/xfs/libxfs/xfs_imeta.c +46 -0
@@ -1015,3 +1015,49 @@ xfs_imeta_mount(return 0 ; } + +/* Create a path to a file within the metadata directory tree. */ +int +xfs_imeta_create_file_path ( +struct xfs_mount *mp, +unsigned int nr_components, +struct xfs_imeta_path **pathp) +{ +struct xfs_imeta_path *p; +unsigned char **components; + + p =kzalloc (sizeof (struct xfs_imeta_path ),GFP_KERNEL ); +if (!p) +return -ENOMEM ; + + components =kvcalloc (nr_components,sizeof (unsigned char *), +GFP_KERNEL ); +if (!components) { +kfree (p); +return -ENOMEM ; + } + + p->im_depth = nr_components; + p->im_path = (const unsigned char **)components; + p->im_ftype =XFS_DIR3_FT_REG_FILE ; + *pathp = p; +return 0 ; +} + +/* Free a metadata directory tree path. */ +void +xfs_imeta_free_path ( +const struct xfs_imeta_path *path) +{ +unsigned int i; + +if (path->im_flags &XFS_IMETA_PATH_STATIC ) +return ; + +for (i =0 ; i < path->im_depth; i++) { +if ((path->im_dynamicmask & (1ULL << i)) && path->im_path[i]) +kfree (path->im_path[i]); + } +kfree (path->im_path); +kfree (path); +}
fs/xfs/libxfs/xfs_imeta.h +15 -0
@@ -15,6 +15,8 @@ const struct xfs_imeta_path name = { \ .im_path = (path), \ .im_ftype = XFS_DIR3_FT_REG_FILE, \ .im_depth = ARRAY_SIZE(path), \ + .im_flags = XFS_IMETA_PATH_STATIC, \ + .im_dynamicmask = 0, \ }/* Key for looking up metadata inodes. */
@@ -22,6 +24,12 @@ struct xfs_imeta_path {/* Array of string pointers. */ const unsigned char **im_path; +/* Each bit corresponds to an element of im_path needing to be freed */ +unsigned long long im_dynamicmask; + +/* XFS_IMETA_* path flags */ +uint16_t im_flags; +/* Number of strings in path. */ uint8_t im_depth;
@@ -29,6 +37,9 @@ struct xfs_imeta_path {uint8_t im_ftype; }; +/* Path is statically allocated. */ +#define XFS_IMETA_PATH_STATIC (1U << 0) +/* Cleanup widget for metadata inode creation and deletion. */ struct xfs_imeta_update {struct xfs_mount *mp;
@@ -72,6 +83,10 @@ int xfs_imeta_lookup(struct xfs_trans *tp, const struct xfs_imeta_path *path,int xfs_imeta_dir_parent (struct xfs_trans *tp,const struct xfs_imeta_path *path,struct xfs_inode **dpp); +int xfs_imeta_create_file_path (struct xfs_mount *mp, +unsigned int nr_components,struct xfs_imeta_path **pathp); +void xfs_imeta_free_path (const struct xfs_imeta_path *path); +void xfs_imeta_set_iflag (struct xfs_trans *tp,struct xfs_inode *ip);void xfs_imeta_clear_iflag (struct xfs_trans *tp,struct xfs_inode *ip);
PATCH 20/32 xfs: don't count metadata directory files to quota
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Files in the metadata directory tree are internal to the filesystem. Don't count the inodes or the blocks they use in the root dquot because users do not need to know about their resource usage. This will also quiet down complaints about dquot usage not matching du output.
--- fs/xfs/xfs_dquot.c | 1 + fs/xfs/xfs_qm.c | 11 +++++++++++ fs/xfs/xfs_quota.h | 5 +++++ fs/xfs/xfs_trans_dquot.c | 6 ++++++ 4 files changed, 23 insertions(+)
fs/xfs/xfs_dquot.c +1 -0
@@ -979,6 +979,7 @@ xfs_qm_dqget_inode(ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL ));ASSERT (xfs_inode_dquot (ip, type) ==NULL ); +ASSERT (!xfs_is_metadir_inode (ip)); id =xfs_qm_id_for_quotatype (ip, type);
fs/xfs/xfs_qm.c +11 -0
@@ -305,6 +305,8 @@ xfs_qm_need_dqattach(return false;if (xfs_is_quota_inode (&mp->m_sb, ip->i_ino))return false; +if (xfs_is_metadir_inode (ip)) +return false;return true; }
@@ -327,6 +329,7 @@ xfs_qm_dqattach_locked(return 0 ;ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL )); +ASSERT (!xfs_is_metadir_inode (ip));if (XFS_IS_UQUOTA_ON (mp) && !ip->i_udquot) { error = xfs_qm_dqattach_one(ip, XFS_DQTYPE_USER,
@@ -1253,6 +1256,10 @@ xfs_qm_dqusage_adjust( } } +/* Metadata directory files are not accounted to user-visible quotas. */ +if (xfs_is_metadir_inode (ip)) + goto error0; +ASSERT (ip->i_delayed_blks ==0 );if (XFS_IS_REALTIME_INODE (ip)) {
@@ -1775,6 +1782,8 @@ xfs_qm_vop_dqalloc(if (!XFS_IS_QUOTA_ON (mp))return 0 ; +ASSERT (!xfs_is_metadir_inode (ip)); + lockflags =XFS_ILOCK_EXCL ;xfs_ilock (ip, lockflags);
@@ -1904,6 +1913,7 @@ xfs_qm_vop_chown(ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL ));ASSERT (XFS_IS_QUOTA_ON (ip->i_mount)); +ASSERT (!xfs_is_metadir_inode (ip));/* old dquot */ prevdq = *IO_olddq;
@@ -1991,6 +2001,7 @@ xfs_qm_vop_create_dqattach(return ;ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL )); +ASSERT (!xfs_is_metadir_inode (ip));if (udqp &&XFS_IS_UQUOTA_ON (mp)) {ASSERT (ip->i_udquot ==NULL );
fs/xfs/xfs_quota.h +5 -0
@@ -29,6 +29,11 @@ struct xfs_buf; (XFS_IS_GQUOTA_ON(mp) && (ip)->i_gdquot == NULL) || \ (XFS_IS_PQUOTA_ON(mp) && (ip)->i_pdquot == NULL)) +#define XFS_IS_DQDETACHED (mp, ip) \ + ((ip)->i_udquot == NULL || \ + (ip)->i_gdquot == NULL || \ + (ip)->i_pdquot == NULL) +#define XFS_QM_NEED_QUOTACHECK (mp) \ ((XFS_IS_UQUOTA_ON(mp) && \ (mp->m_sb.sb_qflags & XFS_UQUOTA_CHKD) == 0) || \
fs/xfs/xfs_trans_dquot.c +6 -0
@@ -156,6 +156,8 @@ xfs_trans_mod_ino_dquot( unsigned int field, int64_t delta) { +ASSERT (!xfs_is_metadir_inode (ip) ||XFS_IS_DQDETACHED (mp, ip)); +xfs_trans_mod_dquot (tp, dqp, field, delta);if (xfs_hooks_switched_on (&xfs_dqtrx_hooks_switch)) {
@@ -236,6 +238,8 @@ xfs_trans_mod_dquot_byino( xfs_is_quota_inode(&mp->m_sb, ip->i_ino)) return; +ASSERT (!xfs_is_metadir_inode (ip) ||XFS_IS_DQDETACHED (mp, ip)); +if (XFS_IS_UQUOTA_ON (mp) && ip->i_udquot)xfs_trans_mod_ino_dquot (tp, ip, ip->i_udquot, field, delta);if (XFS_IS_GQUOTA_ON (mp) && ip->i_gdquot)
@@ -951,6 +955,8 @@ xfs_trans_reserve_quota_nblks(if (!XFS_IS_QUOTA_ON (mp))return 0 ; +if (xfs_is_metadir_inode (ip)) +return 0 ;ASSERT (!xfs_is_quota_inode (&mp->m_sb, ip->i_ino));ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL ));
PATCH 21/32 xfs: adjust xfs_bmap_add_attrfork for metadir
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Online repair might use the xfs_bmap_add_attrfork to repair a file in the metadata directory tree if (say) the metadata file lacks the correct parent pointers. In that case, it is not correct to check that the file is dqattached -- metadata files must be not have /any/ dquot attached at all.
--- fs/xfs/libxfs/xfs_attr.c | 5 ++++- fs/xfs/libxfs/xfs_bmap.c | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_attr.c +4 -1
@@ -946,7 +946,10 @@ xfs_attr_add_fork(unsigned int blks;/* space reservation */ int error;/* error return value */ -ASSERT (!XFS_NOT_DQATTACHED (mp, ip)); +if (xfs_is_metadir_inode (ip)) +ASSERT (XFS_IS_DQDETACHED (ip->i_mount, ip)); +else +ASSERT (!XFS_NOT_DQATTACHED (mp, ip)); blks =XFS_ADDAFORK_SPACE_RES (mp);
fs/xfs/libxfs/xfs_bmap.c +4 -1
@@ -1024,7 +1024,10 @@ xfs_bmap_add_attrfork(int error;/* error return value */ ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL )); -ASSERT (!XFS_NOT_DQATTACHED (mp, ip)); +if (xfs_is_metadir_inode (ip)) +ASSERT (XFS_IS_DQDETACHED (ip->i_mount, ip)); +else +ASSERT (!XFS_NOT_DQATTACHED (mp, ip));ASSERT (!xfs_inode_has_attr_fork (ip));xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE );
PATCH 22/32 xfs: record health problems with the metadata directory
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Make a report to the health monitoring subsystem any time we encounter something in the metadata directory tree that looks like corruption.
--- fs/xfs/libxfs/xfs_fs.h | 1 + fs/xfs/libxfs/xfs_health.h | 4 +++- fs/xfs/libxfs/xfs_imeta.c | 24 +++++++++++++++++++----- fs/xfs/xfs_health.c | 1 + fs/xfs/xfs_icache.c | 1 + fs/xfs/xfs_imeta_utils.c | 5 ++++- fs/xfs/xfs_inode.c | 1 + 7 files changed, 30 insertions(+), 7 deletions(-)
fs/xfs/libxfs/xfs_fs.h +1 -0
@@ -197,6 +197,7 @@ struct xfs_fsop_geom {#define XFS_FSOP_GEOM_SICK_RT_SUMMARY (1 << 5)/* realtime summary */ #define XFS_FSOP_GEOM_SICK_QUOTACHECK (1 << 6)/* quota counts */ #define XFS_FSOP_GEOM_SICK_NLINKS (1 << 7)/* inode link counts */ +#define XFS_FSOP_GEOM_SICK_METADIR (1 << 8)/* metadata directory */ /* Output for XFS_FS_COUNTS */ typedef struct xfs_fsop_counts {
fs/xfs/libxfs/xfs_health.h +3 -1
@@ -60,6 +60,7 @@ struct xfs_da_args;#define XFS_SICK_FS_PQUOTA (1 << 3)/* project quota */ #define XFS_SICK_FS_QUOTACHECK (1 << 4)/* quota counts */ #define XFS_SICK_FS_NLINKS (1 << 5)/* inode link counts */ +#define XFS_SICK_FS_METADIR (1 << 6)/* metadata directory tree */ /* Observable health issues for realtime volume metadata. */ #define XFS_SICK_RT_BITMAP (1 << 0)/* realtime bitmap */
@@ -103,7 +104,8 @@ struct xfs_da_args;XFS_SICK_FS_GQUOTA | \XFS_SICK_FS_PQUOTA | \XFS_SICK_FS_QUOTACHECK | \ - XFS_SICK_FS_NLINKS) +XFS_SICK_FS_NLINKS | \ + XFS_SICK_FS_METADIR) #define XFS_SICK_RT_PRIMARY (XFS_SICK_RT_BITMAP | \XFS_SICK_RT_SUMMARY )
fs/xfs/libxfs/xfs_imeta.c +19 -5
@@ -26,6 +26,7 @@#include "xfs_ag.h" #include "xfs_dir2.h" #include "xfs_dir2_priv.h" +#include "xfs_health.h" /* * Metadata File Management
@@ -406,16 +407,22 @@ xfs_imeta_dir_lookup_component(int type_wanted = xname->type;int error; -if (!S_ISDIR (VFS_I (dp)->i_mode)) +if (!S_ISDIR (VFS_I (dp)->i_mode)) { +xfs_fs_mark_sick (dp->i_mount,XFS_SICK_FS_METADIR );return -EFSCORRUPTED ; + } error =xfs_imeta_dir_lookup (tp, dp, xname, ino);if (error)return error; -if (!xfs_verify_ino (dp->i_mount, *ino)) +if (!xfs_verify_ino (dp->i_mount, *ino)) { +xfs_fs_mark_sick (dp->i_mount,XFS_SICK_FS_METADIR );return -EFSCORRUPTED ; -if (type_wanted !=XFS_DIR3_FT_UNKNOWN && xname->type != type_wanted) + } +if (type_wanted !=XFS_DIR3_FT_UNKNOWN && xname->type != type_wanted) { +xfs_fs_mark_sick (dp->i_mount,XFS_SICK_FS_METADIR );return -EFSCORRUPTED ; + }trace_xfs_imeta_dir_lookup (dp, xname, *ino);return 0 ;
@@ -729,6 +736,7 @@ xfs_imeta_dir_unlink(/* Metadata directory root cannot be unlinked. */ if (xfs_imeta_path_compare (upd->path, &XFS_IMETA_METADIR )) {ASSERT (0 ); +xfs_fs_mark_sick (mp,XFS_SICK_FS_METADIR );return -EFSCORRUPTED ; }
@@ -744,6 +752,7 @@ xfs_imeta_dir_unlink( error = -ENOENT ;break ;case -ENOENT : +xfs_fs_mark_sick (mp,XFS_SICK_FS_METADIR ); error = -EFSCORRUPTED ;break ; }
@@ -788,6 +797,7 @@ xfs_imeta_dir_link(/* Metadata directory root cannot be linked. */ if (xfs_imeta_path_compare (upd->path, &XFS_IMETA_METADIR )) {ASSERT (0 ); +xfs_fs_mark_sick (mp,XFS_SICK_FS_METADIR );return -EFSCORRUPTED ; }
@@ -853,16 +863,20 @@ xfs_imeta_lookup(if (xfs_has_metadir (mp)) { error =xfs_imeta_dir_lookup_int (tp, path, &ino); -if (error == -ENOENT ) +if (error == -ENOENT ) { +xfs_fs_mark_sick (mp,XFS_SICK_FS_METADIR );return -EFSCORRUPTED ; + } }else { error =xfs_imeta_sb_lookup (mp, path, &ino); }if (error)return error; -if (!xfs_imeta_verify (mp, ino)) +if (!xfs_imeta_verify (mp, ino)) { +xfs_fs_mark_sick (mp,XFS_SICK_FS_METADIR );return -EFSCORRUPTED ; + } *inop = ino;return 0 ;
fs/xfs/xfs_health.c +1 -0
@@ -360,6 +360,7 @@ static const struct ioctl_sick_map fs_map[] = { { XFS_SICK_FS_PQUOTA, XFS_FSOP_GEOM_SICK_PQUOTA }, { XFS_SICK_FS_QUOTACHECK, XFS_FSOP_GEOM_SICK_QUOTACHECK }, { XFS_SICK_FS_NLINKS, XFS_FSOP_GEOM_SICK_NLINKS }, + { XFS_SICK_FS_METADIR, XFS_FSOP_GEOM_SICK_METADIR }, { 0, 0 }, };
fs/xfs/xfs_icache.c +1 -0
@@ -850,6 +850,7 @@ xfs_imeta_iget(xfs_irele (ip); whine:xfs_err (mp,"metadata inode 0x%llx is corrupt" , ino); +xfs_fs_mark_sick (mp,XFS_SICK_FS_METADIR );return -EFSCORRUPTED ; }
fs/xfs/xfs_imeta_utils.c +4 -1
@@ -23,6 +23,7 @@#include "xfs_imeta_utils.h" #include "xfs_trace.h" #include "xfs_parent.h" +#include "xfs_health.h" /* Initialize a metadata update structure. */ static inline int
@@ -52,8 +53,10 @@ xfs_imeta_init(return error; error =xfs_imeta_dir_parent (tp, upd->path, &upd->dp);xfs_trans_cancel (tp); -if (error == -ENOENT ) +if (error == -ENOENT ) { +xfs_fs_mark_sick (mp,XFS_SICK_FS_METADIR );return -EFSCORRUPTED ; + }if (error)return error;
fs/xfs/xfs_inode.c +1 -0
@@ -582,6 +582,7 @@ xfs_lookup(* a metadata file. */ if (XFS_IS_CORRUPT (dp->i_mount,xfs_is_metadir_inode (*ipp))) { +xfs_fs_mark_sick (dp->i_mount,XFS_SICK_FS_METADIR ); error = -EFSCORRUPTED ; goto out_irele; }
PATCH 23/32 xfs: do not count metadata directory files when doing online quotacheck
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Previously, we stated that files in the metadata directory tree are not counted in the dquot information. Fix the online quotacheck code to reflect this.
--- fs/xfs/scrub/quotacheck.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
fs/xfs/scrub/quotacheck.c +5 -2
@@ -398,10 +398,13 @@ xqcheck_collect_inode(bool isreg =S_ISREG (VFS_I (ip)->i_mode);int error =0 ; -if (xfs_is_quota_inode (&tp->t_mountp->m_sb, ip->i_ino)) { +if (xfs_is_metadir_inode (ip) || +xfs_is_quota_inode (&tp->t_mountp->m_sb, ip->i_ino)) {/* * Quota files are never counted towards quota, so we do not -* need to take the lock. +* need to take the lock. Files do not switch between the +* metadata and regular directory trees without a reallocation, +* so we do not need to ILOCK them either. */ xchk_iscan_mark_visited (&xqc->iscan, ip);return 0 ;
PATCH 24/32 xfs: scrub shouldn't tag metadata files with attr forks if metadir and parent pointers are on
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
If metadata directory trees and parent pointers are both enabled, it's ok for metadata files to have extended attribute forks. Don't flag these in online checking, and don't remove it during online repair.
--- fs/xfs/scrub/common.c | 8 ++++++-- fs/xfs/scrub/repair.c | 8 ++++++-- 2 files changed, 12 insertions(+), 4 deletions(-)
fs/xfs/scrub/common.c +6 -2
@@ -1248,8 +1248,12 @@ xchk_metadata_inode_forks(return 0 ; } -/* They also should never have extended attributes. */ -if (xfs_inode_hasattr (sc->ip)) { +/* +* Metadata files can only have extended attributes if parent pointers +* and the metadata directory tree are enabled. +*/ +if (xfs_inode_hasattr (sc->ip) && + !(xfs_has_parent (sc->mp) &&xfs_has_metadir (sc->mp))) {xchk_ino_set_corrupt (sc, sc->ip->i_ino);return 0 ; }
fs/xfs/scrub/repair.c +6 -2
@@ -1100,8 +1100,12 @@ xrep_metadata_inode_forks(return error; } -/* Clear the attr forks since metadata shouldn't have that. */ -if (xfs_inode_hasattr (sc->ip)) { +/* +* Clear the attr forks since metadata shouldn't have one unless +* parent pointers and the metadata directory tree are enabled. +*/ +if (xfs_inode_hasattr (sc->ip) && + !(xfs_has_parent (sc->mp) &&xfs_has_metadir (sc->mp))) {if (!dirty) { dirty = true;xfs_trans_ijoin (sc->tp, sc->ip,0 );
PATCH 25/32 xfs: scrub metadata directories
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Teach online scrub about the metadata directory tree.
--- fs/xfs/scrub/dir.c | 8 ++++++++ fs/xfs/scrub/dir_repair.c | 6 ++++++ fs/xfs/scrub/dirtree.c | 22 ++++++++++++++++++---- fs/xfs/scrub/dirtree.h | 2 ++ fs/xfs/scrub/findparent.c | 37 +++++++++++++++++++++++++++++++------ fs/xfs/scrub/parent.c | 30 +++++++++++++++++++++++------- fs/xfs/scrub/trace.h | 1 + 7 files changed, 89 insertions(+), 17 deletions(-)
fs/xfs/scrub/dir.c +8 -0
@@ -102,6 +102,14 @@ xchk_dir_check_ftype(if (xfs_mode_to_ftype (VFS_I (ip)->i_mode) != ftype)xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); + +/* +* Metadata and regular inodes cannot cross trees. This property +* cannot change without a full inode free and realloc cycle, so it's +* safe to check this without holding locks. +*/ +if (xfs_is_metadir_inode (ip) ^xfs_is_metadir_inode (sc->ip)) +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); }/*
fs/xfs/scrub/dir_repair.c +6 -0
@@ -440,6 +440,12 @@ xrep_dir_salvage_entry(if (error)return 0 ; +/* Don't mix metadata and regular directory trees. */ +if (xfs_is_metadir_inode (ip) ^xfs_is_metadir_inode (rd->sc->ip)) { +xchk_irele (sc, ip); +return 0 ; + } + xname.type =xfs_mode_to_ftype (VFS_I (ip)->i_mode);xchk_irele (sc, ip);
fs/xfs/scrub/dirtree.c +18 -4
@@ -350,7 +350,8 @@ xchk_dirpath_set_outcome( STATIC intxchk_dirpath_step_up (struct xchk_dirtree *dl, -struct xchk_dirpath *path) +struct xchk_dirpath *path, +bool is_metadir) {struct xfs_scrub *sc = dl->sc;struct xfs_inode *dp;
@@ -423,6 +424,14 @@ xchk_dirpath_step_up( goto out_scanlock; } +/* Parent must be in the same directory tree. */ +if (is_metadir !=xfs_is_metadir_inode (dp)) { +trace_xchk_dirpath_crosses_tree (dl->sc, dp, path->path_nr, + path->nr_steps, &dl->pptr); + error = -EFSCORRUPTED ; + goto out_scanlock; + } +/* * If the extended attributes look as though they has been zapped by * the inode record repair code, we cannot scan for parent pointers.
@@ -492,6 +501,7 @@ xchk_dirpath_walk_upwards( struct xchk_dirpath *path) {struct xfs_scrub *sc = dl->sc; +bool is_metadir;int error;ASSERT (sc->ilock_flags &XFS_ILOCK_EXCL );
@@ -521,6 +531,7 @@ xchk_dirpath_walk_upwards(* ILOCK state is no longer tracked in the scrub context. Hence we * must drop @sc->ip's ILOCK during the walk. */ + is_metadir =xfs_is_metadir_inode (sc->ip);mutex_unlock (&dl->lock);xchk_iunlock (sc,XFS_ILOCK_EXCL );
@@ -530,7 +541,7 @@ xchk_dirpath_walk_upwards(* If we see any kind of error here (including corruptions), the parent * pointer of @sc->ip is corrupt. Stop the whole scan. */ - error =xchk_dirpath_step_up (dl, path); + error =xchk_dirpath_step_up (dl, path, is_metadir);if (error) {xchk_ilock (sc,XFS_ILOCK_EXCL );mutex_lock (&dl->lock);
@@ -543,7 +554,7 @@ xchk_dirpath_walk_upwards(* *somewhere* in the path, but we don't need to stop scanning. */ while (!error && path->outcome ==XCHK_DIRPATH_SCANNING ) - error =xchk_dirpath_step_up (dl, path); + error =xchk_dirpath_step_up (dl, path, is_metadir);/* Retake the locks we had, mark paths, etc. */ xchk_ilock (sc,XFS_ILOCK_EXCL );
@@ -870,7 +881,10 @@ xchk_dirtree(* scan, because the hook doesn't detach until after sc->ip gets * released during teardown. */ - dl->root_ino = sc->mp->m_rootip->i_ino; +if (xfs_is_metadir_inode (sc->ip)) + dl->root_ino = sc->mp->m_metadirip->i_ino; +else + dl->root_ino = sc->mp->m_rootip->i_ino; dl->scan_ino = sc->ip->i_ino;trace_xchk_dirtree_start (sc->ip, sc->sm,0 );
fs/xfs/scrub/dirtree.h +2 -0
@@ -156,6 +156,8 @@ xchk_dirtree_parentless(const struct xchk_dirtree *dl)if (sc->ip == sc->mp->m_rootip)return true; +if (sc->ip == sc->mp->m_metadirip) +return true;if (VFS_I (sc->ip)->i_nlink ==0 )return true;return false;
fs/xfs/scrub/findparent.c +31 -6
@@ -172,6 +172,10 @@ xrep_findparent_walk_directory(*/ lock_mode =xfs_ilock_data_map_shared (dp); +/* Don't mix metadata and regular directory trees. */ +if (xfs_is_metadir_inode (dp) !=xfs_is_metadir_inode (sc->ip)) + goto out_unlock; +/* * If this directory is known to be sick, we cannot scan it reliably * and must abort.
@@ -360,15 +364,30 @@ xrep_findparent_confirm( };int error; -/* -* The root directory always points to itself. Unlinked dirs can point -* anywhere, so we point them at the root dir too. -*/ -if (sc->ip == sc->mp->m_rootip ||VFS_I (sc->ip)->i_nlink ==0 ) { +/* The root directory always points to itself. */ +if (sc->ip == sc->mp->m_rootip) { *parent_ino = sc->mp->m_sb.sb_rootino;return 0 ; } +/* The metadata root directory always points to itself. */ +if (sc->ip == sc->mp->m_metadirip) { + *parent_ino = sc->mp->m_sb.sb_metadirino; +return 0 ; + } + +/* +* Unlinked dirs can point anywhere, so we point them at the root dir +* of whichever tree is appropriate. +*/ +if (VFS_I (sc->ip)->i_nlink ==0 ) { +if (xfs_is_metadir_inode (sc->ip)) + *parent_ino = sc->mp->m_sb.sb_metadirino; +else + *parent_ino = sc->mp->m_sb.sb_rootino; +return 0 ; + } +/* Reject garbage parent inode numbers and self-referential parents. */ if (*parent_ino ==NULLFSINO )return 0 ;
@@ -410,8 +429,14 @@ xrep_findparent_self_reference(if (sc->ip->i_ino == sc->mp->m_sb.sb_rootino)return sc->mp->m_sb.sb_rootino; -if (VFS_I (sc->ip)->i_nlink ==0 ) +if (sc->ip->i_ino == sc->mp->m_sb.sb_metadirino) +return sc->mp->m_sb.sb_metadirino; + +if (VFS_I (sc->ip)->i_nlink ==0 ) { +if (xfs_is_metadir_inode (sc->ip)) +return sc->mp->m_sb.sb_metadirino;return sc->mp->m_sb.sb_rootino; + }return NULLFSINO ; }
fs/xfs/scrub/parent.c +23 -7
@@ -132,6 +132,14 @@ xchk_parent_validate(return 0 ; } +/* Is this the metadata root dir? Then '..' must point to itself. */ +if (sc->ip == mp->m_metadirip) { +if (sc->ip->i_ino != mp->m_sb.sb_metadirino || + sc->ip->i_ino != parent_ino) +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK ,0 ); +return 0 ; + } +/* '..' must not point to ourselves. */ if (sc->ip->i_ino == parent_ino) {xchk_fblock_set_corrupt (sc,XFS_DATA_FORK ,0 );
@@ -185,6 +193,12 @@ xchk_parent_validate( goto out_unlock; } +/* Metadata and regular inodes cannot cross trees. */ +if (xfs_is_metadir_inode (dp) !=xfs_is_metadir_inode (sc->ip)) { +xchk_fblock_set_corrupt (sc,XFS_DATA_FORK ,0 ); + goto out_unlock; + } +/* Look for a directory entry in the parent pointing to the child. */ error =xchk_dir_walk (sc, dp, xchk_parent_actor, &spc);if (!xchk_fblock_xref_process_error (sc,XFS_DATA_FORK ,0 , &error))
@@ -287,7 +301,7 @@ xchk_parent_pptr_and_dotdot( }/* Is this the root dir? Then '..' must point to itself. */ -if (sc->ip == sc->mp->m_rootip) { +if (sc->ip == sc->mp->m_rootip || sc->ip == sc->mp->m_metadirip) {if (sc->ip->i_ino != pp->parent_ino)xchk_fblock_set_corrupt (sc,XFS_DATA_FORK ,0 );return 0 ;
@@ -721,7 +735,8 @@ xchk_parent_count_pptrs( }if (S_ISDIR (VFS_I (sc->ip)->i_mode)) { -if (sc->ip == sc->mp->m_rootip) +if (sc->ip == sc->mp->m_rootip || + sc->ip == sc->mp->m_metadirip) pp->pptrs_found++;if (VFS_I (sc->ip)->i_nlink ==0 && pp->pptrs_found >0 )
@@ -911,15 +926,16 @@ xchk_pptr_looks_zapped(* of a parent pointer scan is always the empty set. It's safe to scan * them even if the attr fork was zapped. */ -if (ip == mp->m_rootip) +if (ip == mp->m_rootip || ip == mp->m_metadirip)return false;/* -* Metadata inodes are all rooted in the superblock and do not have -* any parents. Hence the attr fork will not be initialized, but -* there are no parent pointers that might have been zapped. +* Prior to metadata directories, all metadata inodes are rooted in the +* superblock and do not have any parents. Hence the attr fork will +* not be initialized, but there are no parent pointers that might have +* been zapped. */ -if (xfs_is_metadata_inode (ip)) +if (!xfs_has_metadir (mp) &&xfs_is_metadata_inode (ip))return false;/*
fs/xfs/scrub/trace.h +1 -0
@@ -1763,6 +1763,7 @@ DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_badgen);DEFINE_XCHK_DIRPATH_EVENT (xchk_dirpath_nondir_parent);DEFINE_XCHK_DIRPATH_EVENT (xchk_dirpath_unlinked_parent);DEFINE_XCHK_DIRPATH_EVENT (xchk_dirpath_found_next_step); +DEFINE_XCHK_DIRPATH_EVENT (xchk_dirpath_crosses_tree);TRACE_DEFINE_ENUM (XCHK_DIRPATH_SCANNING );TRACE_DEFINE_ENUM (XCHK_DIRPATH_DELETE );
PATCH 26/32 xfs: teach nlink scrubber to deal with metadata directory roots
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Enhance the inode link count online fsck code alter their behavior when they detect metadata directory tree roots, just like they do for the regular root directory.
--- fs/xfs/scrub/nlinks.c | 12 +++++++----- fs/xfs/scrub/nlinks_repair.c | 2 +- 2 files changed, 8 insertions(+), 6 deletions(-)
fs/xfs/scrub/nlinks.c +7 -5
@@ -275,7 +275,7 @@ xchk_nlinks_collect_dirent(* determine the backref count. */ if (dotdot) { -if (dp == sc->mp->m_rootip) +if (dp == sc->mp->m_rootip || dp == sc->mp->m_metadirip) error =xchk_nlinks_update_incore (xnc, ino,1 ,0 ,0 );else if (!xfs_has_parent (sc->mp)) error =xchk_nlinks_update_incore (xnc, ino,0 ,1 ,0 );
@@ -516,9 +516,11 @@ xchk_nlinks_collect(int error;/* Count the rt and quota files that are rooted in the superblock. */ - error =xchk_nlinks_collect_metafiles (xnc); -if (error) -return error; +if (!xfs_has_metadir (sc->mp)) { + error =xchk_nlinks_collect_metafiles (xnc); +if (error) +return error; + }/* * Set up for a potentially lengthy filesystem scan by reducing our
@@ -716,7 +718,7 @@ xchk_nlinks_compare_inode( } } -if (ip == sc->mp->m_rootip) { +if (ip == sc->mp->m_rootip || ip == sc->mp->m_metadirip) {/* * For the root of a directory tree, both the '.' and '..' * entries should point to the root directory. The dotdot
fs/xfs/scrub/nlinks_repair.c +1 -1
@@ -64,7 +64,7 @@ xrep_nlinks_is_orphaned(if (obs->parents !=0 )return false; -if (ip == mp->m_rootip || ip == sc->orphanage) +if (ip == mp->m_rootip || ip == sc->orphanage || ip == mp->m_metadirip)return false;return actual_nlink !=0 ; }
PATCH 27/32 xfs: don't check secondary super inode pointers when metadir enabled
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When metadata directories are enabled, the rt and quota inodes are no longer pointed to by the superblock, so it doesn't make sense to check these.
--- fs/xfs/scrub/agheader.c | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-)
fs/xfs/scrub/agheader.c +19 -10
@@ -144,11 +144,16 @@ xchk_superblock(if (sb->sb_rootino !=cpu_to_be64 (mp->m_sb.sb_rootino))xchk_block_set_preen (sc, bp); -if (sb->sb_rbmino !=cpu_to_be64 (mp->m_sb.sb_rbmino)) -xchk_block_set_preen (sc, bp); +if (xfs_has_metadir (sc->mp)) { +if (sb->sb_rbmino !=cpu_to_be64 (mp->m_sb.sb_metadirino)) +xchk_block_set_preen (sc, bp); + }else { +if (sb->sb_rbmino !=cpu_to_be64 (mp->m_sb.sb_rbmino)) +xchk_block_set_preen (sc, bp); -if (sb->sb_rsumino !=cpu_to_be64 (mp->m_sb.sb_rsumino)) -xchk_block_set_preen (sc, bp); +if (sb->sb_rsumino !=cpu_to_be64 (mp->m_sb.sb_rsumino)) +xchk_block_set_preen (sc, bp); + }if (sb->sb_rextsize !=cpu_to_be32 (mp->m_sb.sb_rextsize))xchk_block_set_corrupt (sc, bp);
@@ -225,11 +230,13 @@ xchk_superblock(* sb_icount, sb_ifree, sb_fdblocks, sb_frexents */ -if (sb->sb_uquotino !=cpu_to_be64 (mp->m_sb.sb_uquotino)) -xchk_block_set_preen (sc, bp); +if (!xfs_has_metadir (sc->mp)) { +if (sb->sb_uquotino !=cpu_to_be64 (mp->m_sb.sb_uquotino)) +xchk_block_set_preen (sc, bp); -if (sb->sb_gquotino !=cpu_to_be64 (mp->m_sb.sb_gquotino)) -xchk_block_set_preen (sc, bp); +if (sb->sb_gquotino !=cpu_to_be64 (mp->m_sb.sb_gquotino)) +xchk_block_set_preen (sc, bp); + }/* * Skip the quota flags since repair will force quotacheck.
@@ -338,8 +345,10 @@ xchk_superblock(if (sb->sb_spino_align !=cpu_to_be32 (mp->m_sb.sb_spino_align))xchk_block_set_corrupt (sc, bp); -if (sb->sb_pquotino !=cpu_to_be64 (mp->m_sb.sb_pquotino)) -xchk_block_set_preen (sc, bp); +if (!xfs_has_metadir (sc->mp)) { +if (sb->sb_pquotino !=cpu_to_be64 (mp->m_sb.sb_pquotino)) +xchk_block_set_preen (sc, bp); + }/* Don't care about sb_lsn */ }
PATCH 28/32 xfs: move repair temporary files to the metadata directory tree
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Due to resource acquisition rules, we have to create the ondisk temporary files used to stage a filesystem repair before we can acquire a reference to the inode that we actually want to repair. Therefore, we do not know at tempfile creation time whether the tempfile will belong to the regular directory tree or the metadata directory tree.
This distinction becomes important when the swapext code tries to figure out the quota accounting of the two files whose mappings are being swapped. The swapext code assumes that accounting updates are required for a file if dqattach attaches dquots. Metadir files are never accounted in quota, which means that swapext must not update the quota accounting when swapping in a repaired directory/xattr/rtbitmap structure.
Prior to the swapext call, therefore, both files must be marked as METADIR for dqattach so that dqattach will ignore them. Add support for a repair tempfile to be switched to the metadir tree and switched back before being released so that ifree will just free the file.
--- fs/xfs/scrub/common.c | 5 ++ fs/xfs/scrub/tempfile.c | 97 +++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/tempfile.h | 3 + 3 files changed, 105 insertions(+)
fs/xfs/scrub/common.c +5 -0
@@ -38,6 +38,7 @@#include "scrub/trace.h" #include "scrub/repair.h" #include "scrub/health.h" +#include "scrub/tempfile.h" /* Common code for the metadata scrubbers. */
@@ -1093,6 +1094,10 @@ xchk_setup_inode_contents(if (error)return error; + error =xrep_tempfile_adjust_directory_tree (sc); +if (error) +return error; +/* Lock the inode so the VFS cannot touch this file. */ xchk_ilock (sc,XFS_IOLOCK_EXCL );
fs/xfs/scrub/tempfile.c +97 -0
115 lines not on this page · raw message
fs/xfs/scrub/tempfile.h +3 -0
@@ -10,6 +10,8 @@int xrep_tempfile_create (struct xfs_scrub *sc,uint16_t mode);void xrep_tempfile_rele (struct xfs_scrub *sc); +int xrep_tempfile_adjust_directory_tree (struct xfs_scrub *sc); +bool xrep_tempfile_iolock_nowait (struct xfs_scrub *sc);int xrep_tempfile_iolock_polled (struct xfs_scrub *sc);void xrep_tempfile_iounlock (struct xfs_scrub *sc);
@@ -42,6 +44,7 @@ static inline void xrep_tempfile_iolock_both(struct xfs_scrub *sc) xchk_ilock(sc, XFS_IOLOCK_EXCL); }# define xrep_is_tempfile (ip) (false) +# define xrep_tempfile_adjust_directory_tree (sc) (0)# define xrep_tempfile_rele (sc)#endif /* CONFIG_XFS_ONLINE_REPAIR */
PATCH 29/32 xfs: check metadata directory file path connectivity
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new scrubber type that checks that well known metadata directory paths are connected to the metadata inode that the incore structures think is in use. IOWs, check that "/quota/user" in the metadata directory tree actually points to mp->m_quotainfo->qi_uquotaip->i_ino.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_fs.h | 17 +++ fs/xfs/libxfs/xfs_health.h | 4 + fs/xfs/scrub/common.h | 1 fs/xfs/scrub/health.c | 1 fs/xfs/scrub/metapath.c | 250 ++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/scrub.c | 9 ++ fs/xfs/scrub/scrub.h | 2 fs/xfs/scrub/stats.c | 1 fs/xfs/scrub/trace.c | 1 fs/xfs/scrub/trace.h | 45 ++++++++ fs/xfs/xfs_health.c | 1 12 files changed, 330 insertions(+), 3 deletions(-) create mode 100644 fs/xfs/scrub/metapath.c
fs/xfs/Makefile +1 -0
@@ -173,6 +173,7 @@ xfs-y += $(addprefix scrub/, \ inode.o \ iscan.o \ listxattr.o \ + metapath.o \ nlinks.o \ parent.o \ readdir.o \
fs/xfs/libxfs/xfs_fs.h +16 -1
@@ -198,6 +198,7 @@ struct xfs_fsop_geom {#define XFS_FSOP_GEOM_SICK_QUOTACHECK (1 << 6)/* quota counts */ #define XFS_FSOP_GEOM_SICK_NLINKS (1 << 7)/* inode link counts */ #define XFS_FSOP_GEOM_SICK_METADIR (1 << 8)/* metadata directory */ +#define XFS_FSOP_GEOM_SICK_METAPATH (1 << 9)/* metadir tree path */ /* Output for XFS_FS_COUNTS */ typedef struct xfs_fsop_counts {
@@ -731,9 +732,10 @@ struct xfs_scrub_metadata {#define XFS_SCRUB_TYPE_NLINKS 26/* inode link counts */ #define XFS_SCRUB_TYPE_HEALTHY 27/* everything checked out ok */ #define XFS_SCRUB_TYPE_DIRTREE 28/* directory tree structure */ +#define XFS_SCRUB_TYPE_METAPATH 29/* metadata directory tree paths */ /* Number of scrub subcommands. */ -#define XFS_SCRUB_TYPE_NR 29 +#define XFS_SCRUB_TYPE_NR 30/* * This special type code only applies to the vectored scrub implementation.
@@ -788,6 +790,19 @@ struct xfs_scrub_metadata { XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED)#define XFS_SCRUB_FLAGS_ALL (XFS_SCRUB_FLAGS_IN | XFS_SCRUB_FLAGS_OUT) +/* +* i: sm_ino values for XFS_SCRUB_TYPE_METAPATH to select a metadata file for +* path checking. +*/ +#define XFS_SCRUB_METAPATH_RTBITMAP 0 +#define XFS_SCRUB_METAPATH_RTSUMMARY 1 +#define XFS_SCRUB_METAPATH_USRQUOTA 2 +#define XFS_SCRUB_METAPATH_GRPQUOTA 3 +#define XFS_SCRUB_METAPATH_PRJQUOTA 4 + +/* Number of metapath sm_ino values */ +#define XFS_SCRUB_METAPATH_NR 5 +/* * ioctl limits */
fs/xfs/libxfs/xfs_health.h +3 -1
@@ -61,6 +61,7 @@ struct xfs_da_args;#define XFS_SICK_FS_QUOTACHECK (1 << 4)/* quota counts */ #define XFS_SICK_FS_NLINKS (1 << 5)/* inode link counts */ #define XFS_SICK_FS_METADIR (1 << 6)/* metadata directory tree */ +#define XFS_SICK_FS_METAPATH (1 << 7)/* metadata directory tree path */ /* Observable health issues for realtime volume metadata. */ #define XFS_SICK_RT_BITMAP (1 << 0)/* realtime bitmap */
@@ -105,7 +106,8 @@ struct xfs_da_args;XFS_SICK_FS_PQUOTA | \XFS_SICK_FS_QUOTACHECK | \XFS_SICK_FS_NLINKS | \ - XFS_SICK_FS_METADIR) +XFS_SICK_FS_METADIR | \ + XFS_SICK_FS_METAPATH) #define XFS_SICK_RT_PRIMARY (XFS_SICK_RT_BITMAP | \XFS_SICK_RT_SUMMARY )
fs/xfs/scrub/common.h +1 -0
@@ -68,6 +68,7 @@ int xchk_setup_xattr(struct xfs_scrub *sc);int xchk_setup_symlink (struct xfs_scrub *sc);int xchk_setup_parent (struct xfs_scrub *sc);int xchk_setup_dirtree (struct xfs_scrub *sc); +int xchk_setup_metapath (struct xfs_scrub *sc);#ifdef CONFIG_XFS_RT int xchk_setup_rtbitmap (struct xfs_scrub *sc);int xchk_setup_rtsummary (struct xfs_scrub *sc);
fs/xfs/scrub/health.c +1 -0
@@ -111,6 +111,7 @@ static const struct xchk_health_map type_to_health_flag[XFS_SCRUB_TYPE_NR] = { [XFS_SCRUB_TYPE_QUOTACHECK] = { XHG_FS, XFS_SICK_FS_QUOTACHECK }, [XFS_SCRUB_TYPE_NLINKS] = { XHG_FS, XFS_SICK_FS_NLINKS }, [XFS_SCRUB_TYPE_DIRTREE] = { XHG_INO, XFS_SICK_INO_DIRTREE }, + [XFS_SCRUB_TYPE_METAPATH] = { XHG_FS, XFS_SICK_FS_METAPATH }, };/* Return the health status mask for this scrub type. */
fs/xfs/scrub/metapath.c new file +250 -0
250 lines not on this page · raw message
fs/xfs/scrub/scrub.c +9 -0
@@ -447,6 +447,13 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .has = xfs_has_parent, .repair = xrep_dirtree, }, + [XFS_SCRUB_TYPE_METAPATH] = { /* metadata directory tree path */ + .type = ST_GENERIC, + .setup = xchk_setup_metapath, + .scrub = xchk_metapath, + .has = xfs_has_metadir, + .repair = xrep_notsupported, + }, }; static int
@@ -494,6 +501,8 @@ xchk_validate_inputs(if (sm->sm_agno || (sm->sm_gen && !sm->sm_ino)) goto out;break ; +case ST_GENERIC : +break ;default : goto out; }
fs/xfs/scrub/scrub.h +2 -0
@@ -66,6 +66,7 @@ enum xchk_type {ST_PERAG ,/* per-AG metadata */ ST_FS ,/* per-FS metadata */ ST_INODE ,/* per-inode metadata */ + ST_GENERIC, /* determined by the scrubber */ }; struct xchk_meta_ops {
@@ -250,6 +251,7 @@ int xchk_xattr(struct xfs_scrub *sc);int xchk_symlink (struct xfs_scrub *sc);int xchk_parent (struct xfs_scrub *sc);int xchk_dirtree (struct xfs_scrub *sc); +int xchk_metapath (struct xfs_scrub *sc);#ifdef CONFIG_XFS_RT int xchk_rtbitmap (struct xfs_scrub *sc);int xchk_rtsummary (struct xfs_scrub *sc);
fs/xfs/scrub/stats.c +1 -0
@@ -80,6 +80,7 @@ static const char *name_map[XFS_SCRUB_TYPE_NR] = { [XFS_SCRUB_TYPE_QUOTACHECK] = "quotacheck", [XFS_SCRUB_TYPE_NLINKS] = "nlinks", [XFS_SCRUB_TYPE_DIRTREE] = "dirtree", + [XFS_SCRUB_TYPE_METAPATH] = "metapath", };/* Format the scrub stats into a text buffer, similar to pcp style. */
fs/xfs/scrub/trace.c +1 -0
@@ -21,6 +21,7 @@#include "xfs_dir2.h" #include "xfs_rmap.h" #include "xfs_parent.h" +#include "xfs_imeta.h" #include "scrub/scrub.h" #include "scrub/xfile.h" #include "scrub/xfarray.h"
fs/xfs/scrub/trace.h +44 -1
69 lines not on this page · raw message
fs/xfs/xfs_health.c +1 -0
@@ -361,6 +361,7 @@ static const struct ioctl_sick_map fs_map[] = { { XFS_SICK_FS_QUOTACHECK, XFS_FSOP_GEOM_SICK_QUOTACHECK }, { XFS_SICK_FS_NLINKS, XFS_FSOP_GEOM_SICK_NLINKS }, { XFS_SICK_FS_METADIR, XFS_FSOP_GEOM_SICK_METADIR }, + { XFS_SICK_FS_METAPATH, XFS_FSOP_GEOM_SICK_METAPATH }, { 0, 0 }, };
PATCH 30/32 xfs: repair metadata directory file path connectivity
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Fix disconnected or incorrect metadata directory paths.
--- fs/xfs/scrub/metapath.c | 367 +++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.h | 3 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 5 + 4 files changed, 376 insertions(+), 1 deletion(-)
fs/xfs/scrub/metapath.c +367 -0
@@ -17,10 +17,15 @@#include "xfs_quota.h" #include "xfs_qm.h" #include "xfs_dir2.h" +#include "xfs_parent.h" +#include "xfs_bmap_btree.h" +#include "xfs_trans_space.h" +#include "xfs_attr.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h" #include "scrub/readdir.h" +#include "scrub/repair.h" /* * Metadata Directory Tree Paths
@@ -39,6 +44,9 @@ struct xchk_metapath {/* Name for lookup */ struct xfs_name xname; +/* Directory update for repairs */ +struct xfs_dir_update du; +/* Path for this metadata file */ const struct xfs_imeta_path *path;
@@ -47,6 +55,18 @@ struct xchk_metapath {/* Locks held on dp */ unsigned int dp_ilock_flags; + +/* Transaction block reservations */ +unsigned int link_resblks; +unsigned int unlink_resblks; + +/* Parent pointer updates */ +struct xfs_parent_args link_ppargs; +struct xfs_parent_args unlink_ppargs; + +/* Scratchpads for removing links */ +struct xfs_parent_name_irec pptr; +struct xfs_parent_scratch scratch; };/* Release resources tracked in the buffer. */
@@ -248,3 +268,350 @@ xchk_metapath(xchk_trans_cancel (sc);return error; } + +#ifdef CONFIG_XFS_ONLINE_REPAIR +/* Create the dirent represented by the final component of the path. */ +STATIC int +xrep_metapath_link ( +struct xchk_metapath *mpath) +{ +struct xfs_scrub *sc = mpath->sc; + + mpath->du.dp = mpath->dp; + mpath->du.name = &mpath->xname; + mpath->du.ip = sc->ip; + +if (xfs_has_parent (sc->mp)) + mpath->du.ppargs = &mpath->link_ppargs; +else + mpath->du.ppargs =NULL ; + +trace_xrep_metapath_link (sc, mpath->path, mpath->dp, sc->ip->i_ino); + +return xfs_dir_add_child (sc->tp, mpath->link_resblks, &mpath->du); +} + +/* Remove the dirent at the final component of the path. */ +STATIC int +xrep_metapath_unlink ( +struct xchk_metapath *mpath, +xfs_ino_t ino, +struct xfs_inode *ip) +{ +struct xfs_scrub *sc = mpath->sc; +struct xfs_mount *mp = sc->mp; +int error; + +trace_xrep_metapath_unlink (sc, mpath->path, mpath->dp, ino); + +if (!ip) { +/* The child inode isn't allocated. Junk the dirent. */ +xfs_trans_log_inode (sc->tp, mpath->dp,XFS_ILOG_CORE ); +return xfs_dir_removename (sc->tp, mpath->dp, &mpath->xname, + ino, mpath->unlink_resblks); + } + + mpath->du.dp = mpath->dp; + mpath->du.name = &mpath->xname; + mpath->du.ip = ip; + mpath->du.ppargs =NULL ; + +/* Figure out if we're removing a parent pointer too. */ +if (xfs_has_parent (mp)) { + mpath->pptr.p_ino = ip->i_ino; + mpath->pptr.p_gen =VFS_I (ip)->i_generation; + mpath->pptr.p_namelen = mpath->xname.len; +memcpy (mpath->pptr.p_name, mpath->xname.name, mpath->xname.len); +xfs_parent_irec_hashname (mp, &mpath->pptr); + + error =xfs_parent_lookup (sc->tp, ip, &mpath->pptr, + &mpath->scratch); +switch (error) { +case -ENOATTR : +break ; +case 0 : + mpath->du.ppargs = &mpath->unlink_ppargs; +break ; +default : +return error; + } + } + +return xfs_dir_remove_child (sc->tp, mpath->unlink_resblks, &mpath->du); +} + +/* +* Try to create a dirent in @mpath->dp with the name @mpath->xname that points +* to @sc->ip. Returns: +* +* -EEXIST and an @alleged_child if the dirent that points to the wrong inode; +* 0 if there is now a dirent pointing to @sc->ip; or +* A negative errno on error. +*/ +STATIC int +xrep_metapath_try_link ( +struct xchk_metapath *mpath, +xfs_ino_t *alleged_child) +{ +struct xfs_scrub *sc = mpath->sc; +xfs_ino_t ino; +int error; + +/* Allocate transaction, lock inodes, join to transaction. */ + error =xchk_trans_alloc (sc, mpath->link_resblks); +if (error) +return error; + + error =xchk_metapath_ilock_both (mpath); +if (error) { +xchk_trans_cancel (sc); +return error; + } +xfs_trans_ijoin (sc->tp, mpath->dp,0 ); +xfs_trans_ijoin (sc->tp, sc->ip,0 ); + + error =xchk_dir_lookup (sc, mpath->dp, &mpath->xname, &ino); +trace_xrep_metapath_lookup (sc, mpath->path, mpath->dp, ino); +if (error == -ENOENT ) { +/* +* There is no dirent in the directory. Create an entry +* pointing to @sc->ip. +*/ + error =xrep_metapath_link (mpath); +if (error) + goto out_cancel; + + error =xrep_trans_commit (sc); +xchk_metapath_iunlock (mpath); +return error; + } +if (error) + goto out_cancel; + +if (ino == sc->ip->i_ino) { +/* The dirent already points to @sc->ip; we're done. */ + error =0 ; + goto out_cancel; + } + +/* +* The dirent points elsewhere; pass that back so that the caller +* can try to remove the dirent. +*/ + *alleged_child = ino; + error = -EEXIST ; + +out_cancel: +xchk_trans_cancel (sc); +xchk_metapath_iunlock (mpath); +return error; +} + +/* +* Take the ILOCK on the metadata directory parent and a bad child, if one is +* supplied. We do not know that the metadata directory is not corrupt, so we +* lock the parent and try to lock the child. Returns 0 if successful, or +* -EINTR to abort the repair. The lock state of @dp is not recorded in @mpath. +*/ +STATIC int +xchk_metapath_ilock_parent_and_child ( +struct xchk_metapath *mpath, +struct xfs_inode *ip) +{ +struct xfs_scrub *sc = mpath->sc; +int error =0 ; + +while (true) { +xfs_ilock (mpath->dp,XFS_ILOCK_EXCL ); +if (!ip ||xfs_ilock_nowait (ip,XFS_ILOCK_EXCL )) +return 0 ; +xfs_iunlock (mpath->dp,XFS_ILOCK_EXCL ); + +if (xchk_should_terminate (sc, &error)) +return error; + +delay (1 ); + } + +ASSERT (0 ); +return -EINTR ; +} + +/* +* Try to remove a dirent in @mpath->dp with the name @mpath->xname that points +* to @alleged_child. Returns: +* +* 0 if there is no longer a dirent; +* -EEXIST if the dirent points to @sc->ip; +* -EAGAIN and an updated @alleged_child if the dirent points elsewhere; or +* A negative errno for any other error. +*/ +STATIC int +xrep_metapath_try_unlink ( +struct xchk_metapath *mpath, +xfs_ino_t *alleged_child) +{ +struct xfs_scrub *sc = mpath->sc; +struct xfs_inode *ip =NULL ; +xfs_ino_t ino; +int error; + +ASSERT (*alleged_child != sc->ip->i_ino); + +trace_xrep_metapath_try_unlink (sc, mpath->path, mpath->dp, + *alleged_child); + +/* +* Allocate transaction, grab the alleged child inode, lock inodes, +* join to transaction. +*/ + error =xchk_trans_alloc (sc, mpath->unlink_resblks); +if (error) +return error; + + error =xchk_iget (sc, *alleged_child, &ip); +if (error == -EINVAL || error == -ENOENT ) { +/* inode number is bogus, junk the dirent */ + error =0 ; + } +if (error) { +xchk_trans_cancel (sc); +return error; + } + + error =xchk_metapath_ilock_parent_and_child (mpath, ip); +if (error) { +xchk_trans_cancel (sc); +return error; + } +xfs_trans_ijoin (sc->tp, mpath->dp,0 ); +if (ip) +xfs_trans_ijoin (sc->tp, ip,0 ); + + error =xchk_dir_lookup (sc, mpath->dp, &mpath->xname, &ino); +trace_xrep_metapath_lookup (sc, mpath->path, mpath->dp, ino); +if (error == -ENOENT ) { +/* +* There is no dirent in the directory anymore. We're ready to +* try the link operation again. +*/ + error =0 ; + goto out_cancel; + } +if (error) + goto out_cancel; + +if (ino == sc->ip->i_ino) { +/* The dirent already points to @sc->ip; we're done. */ + error = -EEXIST ; + goto out_cancel; + } + +/* +* The dirent does not point to the alleged child. Update the caller +* and signal that we want to be called again. +*/ +if (ino != *alleged_child) { + *alleged_child = ino; + error = -EAGAIN ; + goto out_cancel; + } + +/* Remove the link to the child. */ + error =xrep_metapath_unlink (mpath, ino, ip); +if (error) + goto out_cancel; + + error =xrep_trans_commit (sc); + goto out_unlock; + +out_cancel: +xchk_trans_cancel (sc); +out_unlock: +xfs_iunlock (mpath->dp,XFS_ILOCK_EXCL ); +if (ip) { +xfs_iunlock (ip,XFS_ILOCK_EXCL ); +xchk_irele (sc, ip); + } +return error; +} + +/* +* Make sure the metadata directory path points to the child being examined. +* +* Repair needs to be able to create a directory structure, create its own +* transactions, and take ILOCKs. This function /must/ be called after all +* other repairs have completed. +*/ +int +xrep_metapath ( +struct xfs_scrub *sc) +{ +struct xchk_metapath *mpath = sc->buf; +struct xfs_mount *mp = sc->mp; +int error =0 ; + +/* +* Make sure the directory path exists all the way down to where the +* parent pointer should be. +*/ + error =xfs_imeta_ensure_dirpath (sc->mp, mpath->path); +if (error) +return error; + +/* Make sure the parent is attached now. */ + error =xchk_trans_alloc_empty (sc); +if (error) +return error; +if (!xchk_metapath_try_attach_parent (mpath)) { +xchk_trans_cancel (sc); +return -EFSCORRUPTED ; + } +xchk_trans_cancel (sc); + +/* +* Make sure the child file actually has an attr fork to receive a new +* parent pointer if the fs has parent pointers. +*/ +if (xfs_has_parent (mp)) { + error =xfs_attr_add_fork (sc->ip, +sizeof (struct xfs_attr_sf_hdr ),1 ); +if (error) +return error; + } + +/* Compute block reservation required to unlink and link a file. */ + mpath->unlink_resblks =xfs_remove_space_res (mp,MAXNAMELEN ); + mpath->link_resblks =xfs_link_space_res (mp,MAXNAMELEN ); + +/* Set up parent pointer tracking. */ +xfs_parent_args_init (mp, &mpath->link_ppargs); +xfs_parent_args_init (mp, &mpath->unlink_ppargs); + +do { +xfs_ino_t alleged_child; + +/* Re-establish the link, or tell us which inode to remove. */ + error =xrep_metapath_try_link (mpath, &alleged_child); +if (!error) +return 0 ; +if (error != -EEXIST ) +return error; + +/* +* Remove an incorrect link to an alleged child, or tell us +* which inode to remove. +*/ +do { + error =xrep_metapath_try_unlink (mpath, &alleged_child); + }while (error == -EAGAIN ); +if (error == -EEXIST ) { +/* Link established; we're done. */ + error =0 ; +break ; + } + }while (!error); + +return error; +} +#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/repair.h +3 -0
@@ -134,6 +134,7 @@ int xrep_directory(struct xfs_scrub *sc);int xrep_parent (struct xfs_scrub *sc);int xrep_symlink (struct xfs_scrub *sc);int xrep_dirtree (struct xfs_scrub *sc); +int xrep_metapath (struct xfs_scrub *sc);#ifdef CONFIG_XFS_RT int xrep_rtbitmap (struct xfs_scrub *sc);
@@ -208,6 +209,7 @@ xrep_setup_nothing(#define xrep_setup_parent xrep_setup_nothing#define xrep_setup_nlinks xrep_setup_nothing#define xrep_setup_dirtree xrep_setup_nothing +#define xrep_setup_metapath xrep_setup_nothing#define xrep_setup_inode (sc, imap) ((void)0)
@@ -243,6 +245,7 @@ static inline int xrep_setup_symlink(struct xfs_scrub *sc, unsigned int *x)#define xrep_parent xrep_notsupported#define xrep_symlink xrep_notsupported#define xrep_dirtree xrep_notsupported +#define xrep_metapath xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +1 -1
@@ -452,7 +452,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .setup = xchk_setup_metapath, .scrub = xchk_metapath, .has = xfs_has_metadir, - .repair = xrep_notsupported, + .repair = xrep_metapath, }, };
fs/xfs/scrub/trace.h +5 -0
@@ -3740,6 +3740,11 @@ DEFINE_XCHK_DIRTREE_EVENT(xrep_dirtree_delete_path);DEFINE_XCHK_DIRTREE_EVENT (xrep_dirtree_create_adoption);DEFINE_XCHK_DIRTREE_EVALUATE_EVENT (xrep_dirtree_decided_fate); +DEFINE_XCHK_METAPATH_EVENT (xrep_metapath_lookup); +DEFINE_XCHK_METAPATH_EVENT (xrep_metapath_try_unlink); +DEFINE_XCHK_METAPATH_EVENT (xrep_metapath_unlink); +DEFINE_XCHK_METAPATH_EVENT (xrep_metapath_link); +#endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */
PATCH 31/32 xfs: fix up repair functions for metadata directory roots
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Amend the directory and parent pointer repair code to handle the root of the metadata directory tree correctly.
--- fs/xfs/scrub/dir_repair.c | 2 +- fs/xfs/scrub/inode_repair.c | 8 ++++---- fs/xfs/scrub/orphanage.c | 2 ++ fs/xfs/scrub/parent_repair.c | 2 +- 4 files changed, 8 insertions(+), 6 deletions(-)
fs/xfs/scrub/dir_repair.c +1 -1
@@ -1324,7 +1324,7 @@ xrep_dir_scan_dirtree(int error;/* Roots of directory trees are their own parents. */ -if (sc->ip == sc->mp->m_rootip) +if (sc->ip == sc->mp->m_rootip || sc->ip == sc->mp->m_metadirip)xrep_findparent_scan_found (&rd->pscan, sc->ip->i_ino);/*
fs/xfs/scrub/inode_repair.c +4 -4
@@ -1718,14 +1718,14 @@ xrep_inode_pptr(return 0 ;/* The root directory doesn't have a parent pointer. */ -if (ip == mp->m_rootip) +if (ip == mp->m_rootip || ip == mp->m_metadirip)return 0 ;/* -* Metadata inodes are rooted in the superblock and do not have any -* parents. +* Prior to metadata directories, all metadata inodes are rooted in the +* superblock and do not have any parents. */ -if (xfs_is_metadata_inode (ip)) +if (!xfs_has_metadir (mp) &&xfs_is_metadata_inode (ip))return 0 ;/* Inode already has an attr fork; no further work possible here. */
fs/xfs/scrub/orphanage.c +2 -0
@@ -297,6 +297,8 @@ xrep_orphanage_can_adopt(return false;if (xfs_internal_inum (sc->mp, sc->ip->i_ino))return false; +if (xfs_is_metadata_inode (sc->ip)) +return false;return true; }
fs/xfs/scrub/parent_repair.c +1 -1
@@ -1345,7 +1345,7 @@ xrep_parent_rebuild_pptrs(* so that we can decide if we're moving this file to the orphanage. * For this purpose, root directories are their own parents. */ -if (sc->ip == sc->mp->m_rootip) { +if (sc->ip == sc->mp->m_rootip || sc->ip == sc->mp->m_metadirip) {xrep_findparent_scan_found (&rp->pscan, sc->ip->i_ino); }else { error =xrep_parent_lookup_pptrs (sc, &parent_ino);
PATCH 32/32 xfs: enable metadata directory feature
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Enable the metadata directory feature.
--- fs/xfs/libxfs/xfs_format.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_format.h +2 -1
@@ -398,7 +398,8 @@ xfs_sb_has_ro_compat_feature( XFS_SB_FEAT_INCOMPAT_BIGTIME| \ XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR| \ XFS_SB_FEAT_INCOMPAT_NREXT64| \ - XFS_SB_FEAT_INCOMPAT_PARENT) + XFS_SB_FEAT_INCOMPAT_PARENT | \ + XFS_SB_FEAT_INCOMPAT_METADIR)#define XFS_SB_FEAT_INCOMPAT_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_ALL static inline bool
PATCH 3/15 xfs: refactor realtime meta inode locking
In reply to Darrick J. WongHi all,
Replace all the open-coded locking of realtime metadata inodes with a single rtlock function that can lock all the pieces that the caller wants in a single call. This will be important for maintaining correct locking order later when we start adding more realtime metadata inodes.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=refactor-rt-locking
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=refactor-rt-locking
--- fs/xfs/libxfs/xfs_bmap.c | 7 +--- fs/xfs/libxfs/xfs_rtbitmap.c | 57 ++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_rtbitmap.h | 17 ++++++++++ fs/xfs/scrub/bmap.c | 2 + fs/xfs/scrub/common.c | 70 ++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 18 +++++++++++ fs/xfs/scrub/fscounters.c | 4 +- fs/xfs/scrub/rtbitmap.c | 7 +--- fs/xfs/scrub/rtsummary.c | 12 ++----- fs/xfs/scrub/scrub.c | 1 + fs/xfs/scrub/scrub.h | 9 +++++ fs/xfs/xfs_bmap_util.c | 5 +-- fs/xfs/xfs_fsmap.c | 4 +- fs/xfs/xfs_inode.c | 3 +- fs/xfs/xfs_inode.h | 13 ++------ fs/xfs/xfs_rtalloc.c | 62 ++++++++++++++++++++++++++----------- 16 files changed, 235 insertions(+), 56 deletions(-)
PATCH 1/4 xfs: refactor realtime scrubbing context management
From: Darrick J. Wong <[email protected]>
Create a pair of helpers to deal with setting up the necessary incore context to check metadata records against the realtime metadata. Right now this is limited to locking the realtime bitmap and summary inodes, but as we add rmap and reflink to the realtime device this will grow to include btree cursors.
--- fs/xfs/scrub/bmap.c | 2 + fs/xfs/scrub/common.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 18 ++++++++++++ fs/xfs/scrub/rtbitmap.c | 7 +---- fs/xfs/scrub/rtsummary.c | 12 ++------ fs/xfs/scrub/scrub.c | 1 + fs/xfs/scrub/scrub.h | 9 ++++++ 7 files changed, 104 insertions(+), 14 deletions(-)
fs/xfs/scrub/bmap.c +2 -0
@@ -314,8 +314,10 @@ xchk_bmap_rt_iextent_xref(struct xchk_bmap_info *info, struct xfs_bmbt_irec *irec) { + xchk_rt_init(info->sc, &info->sc->sr, XCHK_RTLOCK_BITMAP_SHARED);xchk_xref_is_used_rt_space (info->sc, irec->br_startblock, irec->br_blockcount); +xchk_rt_unlock (info->sc, &info->sc->sr); }/* Cross-reference a single datadev extent record. */
fs/xfs/scrub/common.c +69 -0
75 lines not on this page · raw message
fs/xfs/scrub/common.h +18 -0
@@ -129,6 +129,24 @@ xchk_ag_init_existing(return error == -ENOENT ? -EFSCORRUPTED : error; } +/* Lock the rt bitmap in exclusive mode */ +#define XCHK_RTLOCK_BITMAP (1U << 31) +/* Lock the rt bitmap in shared mode */ +#define XCHK_RTLOCK_BITMAP_SHARED (1U << 30) +/* Lock the rt summary in exclusive mode */ +#define XCHK_RTLOCK_SUMMARY (1U << 29) +/* Lock the rt summary in shared mode */ +#define XCHK_RTLOCK_SUMMARY_SHARED (1U << 28) + +#define XCHK_RTLOCK_ALL (XCHK_RTLOCK_BITMAP | \ + XCHK_RTLOCK_BITMAP_SHARED | \ + XCHK_RTLOCK_SUMMARY | \ + XCHK_RTLOCK_SUMMARY_SHARED) + +void xchk_rt_init (struct xfs_scrub *sc,struct xchk_rt *sr, +unsigned int xchk_rtlock_flags); +void xchk_rt_unlock (struct xfs_scrub *sc,struct xchk_rt *sr); +void xchk_rt_unlock_rtbitmap (struct xfs_scrub *sc);int xchk_ag_read_headers (struct xfs_scrub *sc,xfs_agnumber_t agno,struct xchk_ag *sa);void xchk_ag_btcur_free (struct xchk_ag *sa);
fs/xfs/scrub/rtbitmap.c +2 -5
@@ -52,7 +52,7 @@ xchk_setup_rtbitmap(if (error)return error; -xchk_ilock (sc,XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP ); +xchk_rt_init (sc, &sc->sr,XCHK_RTLOCK_BITMAP );/* * Now that we've locked the rtbitmap, we can't race with growfsrt
@@ -216,13 +216,10 @@ xchk_xref_is_used_rt_space( startext =xfs_rtb_to_rtx (sc->mp, rtbno); endext =xfs_rtb_to_rtx (sc->mp, rtbno + len -1 ); -xfs_ilock (sc->mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); error =xfs_rtalloc_extent_is_free (sc->mp, sc->tp, startext, endext - startext +1 , &is_free);if (!xchk_should_check_xref (sc, &error,NULL )) - goto out_unlock; +return ;if (is_free)xchk_ino_xref_set_corrupt (sc, sc->mp->m_rbmip->i_ino); -out_unlock: -xfs_iunlock (sc->mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); }
fs/xfs/scrub/rtsummary.c +3 -9
@@ -79,14 +79,8 @@ xchk_setup_rtsummary(if (error)return error; -/* -* Locking order requires us to take the rtbitmap first. We must be -* careful to unlock it ourselves when we are done with the rtbitmap -* file since the scrub infrastructure won't do that for us. Only -* then we can lock the rtsummary inode. -*/ -xfs_ilock (mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); -xchk_ilock (sc,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ); +xchk_rt_init (sc, &sc->sr, +XCHK_RTLOCK_SUMMARY |XCHK_RTLOCK_BITMAP_SHARED );/* * Now that we've locked the rtbitmap and rtsummary, we can't race with
@@ -365,6 +359,6 @@ xchk_rtsummary(* that order, so we're still protected against allocation activities * even if we continue on to the repair function. */ -xfs_iunlock (mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xchk_rt_unlock_rtbitmap (sc);return error; }
fs/xfs/scrub/scrub.c +1 -0
@@ -230,6 +230,7 @@ xchk_teardown(xfs_trans_cancel (sc->tp); sc->tp =NULL ; } +xchk_rt_unlock (sc, &sc->sr);if (sc->ip) {if (sc->ilock_flags)xchk_iunlock (sc, sc->ilock_flags);
fs/xfs/scrub/scrub.h +9 -0
@@ -111,6 +111,12 @@ struct xchk_ag {struct xfs_btree_cur *refc_cur; }; +/* Inode lock state for the RT volume. */ +struct xchk_rt { +/* XCHK_RTLOCK_* lock state */ +unsigned int rtlock_flags; +}; +struct xfs_scrub {/* General scrub state. */ struct xfs_mount *mp;
@@ -172,6 +178,9 @@ struct xfs_scrub {/* State tracking for single-AG operations. */ struct xchk_ag sa; + +/* State tracking for realtime operations. */ +struct xchk_rt sr; };/* XCHK state flags grow up from zero, XREP state flags grown down from 2^31 */
PATCH 2/4 xfs: use separate lock classes for realtime metadata inode ILOCKs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Realtime metadata files are not quite regular files because userspace can't access the realtime bitmap directly, and because we take the ILOCK of the rt bitmap file while holding the ILOCK of a realtime file. The double nature of inodes confuses lockdep, so up until now we've created lockdep subclasses to help lockdep keep things straight.
We've gotten away with using lockdep subclasses because there's only two rt metadata files, but with the coming addition of realtime rmap and refcounting, we'd need two more subclasses, which is a lot of class bits to burn on a side feature.
Therefore, switch to manually setting the lockdep class of the rt metadata ILOCKs. In the next patch we'll remove the rt-related ILOCK subclasses.
--- fs/xfs/xfs_rtalloc.c | 36 ++++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-)
fs/xfs/xfs_rtalloc.c +34 -2
@@ -25,6 +25,16 @@#include "xfs_da_format.h" #include "xfs_imeta.h" +/* +* Realtime metadata files are not quite regular files because userspace can't +* access the realtime bitmap directly, and because we take the ILOCK of the rt +* bitmap file while holding the ILOCK of a regular realtime file. This double +* locking confuses lockdep, so create different lockdep classes here to help +* it keep things straight. +*/ +static struct lock_class_key xfs_rbmip_key; +static struct lock_class_key xfs_rsumip_key; +/* * Read and return the summary information for a given extent size, * bitmap block combination.
@@ -1330,6 +1340,28 @@ xfs_rtalloc_reinit_frextents(return 0 ; } +static inline int +__xfs_rt_iget ( +struct xfs_trans *tp, +xfs_ino_t ino, +struct lock_class_key *lockdep_key, +const char *lockdep_key_name, +struct xfs_inode **ipp) +{ +int error; + + error =xfs_imeta_iget (tp, ino,XFS_DIR3_FT_REG_FILE , ipp); +if (error) +return error; + +lockdep_set_class_and_name (&(*ipp)->i_lock.mr_lock, lockdep_key, + lockdep_key_name); +return 0 ; +} + +#define xfs_rt_iget (tp, ino, lockdep_key, ipp) \ + __xfs_rt_iget((tp), (ino), (lockdep_key), #lockdep_key, (ipp)) +/* * Read in the bmbt of an rt metadata inode so that we never have to load them * at runtime. This enables the use of shared ILOCKs for rtbitmap scans. Use
@@ -1376,7 +1408,7 @@ xfs_rtmount_inodes(if (error)return error; - error =xfs_imeta_iget (tp, mp->m_sb.sb_rbmino,XFS_DIR3_FT_REG_FILE , + error =xfs_rt_iget (tp, mp->m_sb.sb_rbmino, &xfs_rbmip_key, &mp->m_rbmip);if (xfs_metadata_is_sick (error))xfs_rt_mark_sick (mp,XFS_SICK_RT_BITMAP );
@@ -1388,7 +1420,7 @@ xfs_rtmount_inodes(if (error) goto out_rele_bitmap; - error =xfs_imeta_iget (tp, mp->m_sb.sb_rsumino,XFS_DIR3_FT_REG_FILE , + error =xfs_rt_iget (tp, mp->m_sb.sb_rsumino, &xfs_rsumip_key, &mp->m_rsumip);if (xfs_metadata_is_sick (error))xfs_rt_mark_sick (mp,XFS_SICK_RT_SUMMARY );
PATCH 3/4 xfs: refactor realtime inode locking
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create helper functions to deal with locking realtime metadata inodes. This enables us to maintain correct locking order once we start adding the realtime rmap and refcount btree inodes.
--- fs/xfs/libxfs/xfs_bmap.c | 7 +---- fs/xfs/libxfs/xfs_rtbitmap.c | 57 ++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_rtbitmap.h | 17 +++++++++++++ fs/xfs/scrub/common.c | 1 + fs/xfs/scrub/fscounters.c | 4 +-- fs/xfs/xfs_bmap_util.c | 5 +--- fs/xfs/xfs_fsmap.c | 4 +-- fs/xfs/xfs_rtalloc.c | 15 ++++------- 8 files changed, 87 insertions(+), 23 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +2 -5
@@ -5376,12 +5376,9 @@ __xfs_bunmapi(if (isrt) {/* -* Synchronize by locking the bitmap inode. +* Synchronize by locking the realtime bitmap. */ -xfs_ilock (mp->m_rbmip,XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP ); -xfs_trans_ijoin (tp, mp->m_rbmip,XFS_ILOCK_EXCL ); -xfs_ilock (mp->m_rsumip,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ); -xfs_trans_ijoin (tp, mp->m_rsumip,XFS_ILOCK_EXCL ); +xfs_rtbitmap_lock (tp, mp); } extno =0 ;
fs/xfs/libxfs/xfs_rtbitmap.c +57 -0
60 lines not on this page · raw message
fs/xfs/libxfs/xfs_rtbitmap.h +17 -0
@@ -374,6 +374,19 @@ xfs_filblks_t xfs_rtsummary_blockcount(struct xfs_mount *mp, unsigned int rsumlevels, xfs_extlen_t rbmblocks);unsigned long long xfs_rtsummary_wordcount (struct xfs_mount *mp,unsigned int rsumlevels,xfs_extlen_t rbmblocks); + +void xfs_rtbitmap_lock (struct xfs_trans *tp,struct xfs_mount *mp); +void xfs_rtbitmap_unlock (struct xfs_mount *mp); + +/* Lock the rt bitmap inode in shared mode */ +#define XFS_RBMLOCK_BITMAP (1U << 0) +/* Lock the rt summary inode in shared mode */ +#define XFS_RBMLOCK_SUMMARY (1U << 1) + +void xfs_rtbitmap_lock_shared (struct xfs_mount *mp, +unsigned int rbmlock_flags); +void xfs_rtbitmap_unlock_shared (struct xfs_mount *mp, +unsigned int rbmlock_flags);#else /* CONFIG_XFS_RT */ # define xfs_rtfree_extent (t,b,l) (-ENOSYS)# define xfs_rtfree_blocks (t,rb,rl) (-ENOSYS)
@@ -394,6 +407,10 @@ xfs_rtbitmap_blockcount(struct xfs_mount *mp, xfs_rtbxlen_t rtextents)# define xfs_rtbitmap_wordcount (mp, r) (0)# define xfs_rtsummary_blockcount (mp, l, b) (0)# define xfs_rtsummary_wordcount (mp, l, b) (0) +# define xfs_rtbitmap_lock (tp, mp) do { } while (0) +# define xfs_rtbitmap_unlock (mp) do { } while (0) +# define xfs_rtbitmap_lock_shared (mp, lf) do { } while (0) +# define xfs_rtbitmap_unlock_shared (mp, lf) do { } while (0)#endif /* CONFIG_XFS_RT */ #endif /* __XFS_RTBITMAP_H__ */
fs/xfs/scrub/common.c +1 -0
@@ -33,6 +33,7 @@#include "xfs_error.h" #include "xfs_quota.h" #include "xfs_swapext.h" +#include "xfs_rtbitmap.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
fs/xfs/scrub/fscounters.c +2 -2
@@ -415,7 +415,7 @@ xchk_fscount_count_frextents(if (!xfs_has_realtime (mp))return 0 ; -xfs_ilock (sc->mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xfs_rtbitmap_lock_shared (sc->mp,XFS_RBMLOCK_BITMAP ); error =xfs_rtalloc_query_all (sc->mp, sc->tp, xchk_fscount_add_frextent, fsc);if (error) {
@@ -424,7 +424,7 @@ xchk_fscount_count_frextents( } out_unlock: -xfs_iunlock (sc->mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xfs_rtbitmap_unlock_shared (sc->mp,XFS_RBMLOCK_BITMAP );return error; }#else
fs/xfs/xfs_bmap_util.c +1 -4
@@ -131,10 +131,7 @@ xfs_bmap_rtalloc(* Lock out modifications to both the RT bitmap and summary inodes */ if (!rtlocked) { -xfs_ilock (mp->m_rbmip,XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP ); -xfs_trans_ijoin (ap->tp, mp->m_rbmip,XFS_ILOCK_EXCL ); -xfs_ilock (mp->m_rsumip,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ); -xfs_trans_ijoin (ap->tp, mp->m_rsumip,XFS_ILOCK_EXCL ); +xfs_rtbitmap_lock (ap->tp, mp); rtlocked = true; }
fs/xfs/xfs_fsmap.c +2 -2
@@ -533,7 +533,7 @@ xfs_getfsmap_rtdev_rtbitmap(trace_xfs_fsmap_low_key_linear (mp, info->dev, start_rtb);trace_xfs_fsmap_high_key_linear (mp, info->dev, end_rtb); -xfs_ilock (mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xfs_rtbitmap_lock_shared (mp,XFS_RBMLOCK_BITMAP );/* * Set up query parameters to return free rtextents covering the range
@@ -557,7 +557,7 @@ xfs_getfsmap_rtdev_rtbitmap(if (error) goto err; err: -xfs_iunlock (mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xfs_rtbitmap_unlock_shared (mp,XFS_RBMLOCK_BITMAP ); return error; }#endif /* CONFIG_XFS_RT */
fs/xfs/xfs_rtalloc.c +5 -10
@@ -1066,10 +1066,10 @@ xfs_growfs_rt( nargs.tp = tp;/* -* Lock out other callers by grabbing the bitmap inode lock. +* Lock out other callers by grabbing the bitmap and summary +* inode locks and joining them to the transaction. */ -xfs_ilock (mp->m_rbmip,XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP ); -xfs_trans_ijoin (tp, mp->m_rbmip,XFS_ILOCK_EXCL ); +xfs_rtbitmap_lock (tp, mp);/* * Update the bitmap inode's size ondisk and incore. We need * to update the incore size so that inode inactivation won't
@@ -1079,11 +1079,6 @@ xfs_growfs_rt( nsbp->sb_rbmblocks * nsbp->sb_blocksize;i_size_write (VFS_I (mp->m_rbmip), mp->m_rbmip->i_disk_size);xfs_trans_log_inode (tp, mp->m_rbmip,XFS_ILOG_CORE ); -/* -* Get the summary inode into the transaction. -*/ -xfs_ilock (mp->m_rsumip,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ); -xfs_trans_ijoin (tp, mp->m_rsumip,XFS_ILOCK_EXCL );/* * Update the summary inode's size. We need to update the * incore size so that inode inactivation won't punch what it
@@ -1326,10 +1321,10 @@ xfs_rtalloc_reinit_frextents(uint64_t val =0 ;int error; -xfs_ilock (mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xfs_rtbitmap_lock_shared (mp,XFS_RBMLOCK_BITMAP ); error =xfs_rtalloc_query_all (mp,NULL , xfs_rtalloc_count_frextent, &val); -xfs_iunlock (mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xfs_rtbitmap_unlock_shared (mp,XFS_RBMLOCK_BITMAP );if (error)return error;
PATCH 4/4 xfs: remove XFS_ILOCK_RT*
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we've centralized the realtime metadata locking routines, get rid of the ILOCK subclasses since we now use explicit lockdep classes.
--- fs/xfs/libxfs/xfs_rtbitmap.c | 16 ++++++++-------- fs/xfs/scrub/common.c | 10 +++++----- fs/xfs/xfs_inode.c | 3 +-- fs/xfs/xfs_inode.h | 13 ++++--------- fs/xfs/xfs_rtalloc.c | 11 +++++------ 5 files changed, 23 insertions(+), 30 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.c +8 -8
@@ -1205,11 +1205,11 @@ xfs_rtbitmap_lock(struct xfs_trans *tp, struct xfs_mount *mp) { - xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL | XFS_ILOCK_RTBITMAP); + xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL);if (tp)xfs_trans_ijoin (tp, mp->m_rbmip,XFS_ILOCK_EXCL ); -xfs_ilock (mp->m_rsumip,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ); +xfs_ilock (mp->m_rsumip,XFS_ILOCK_EXCL );if (tp)xfs_trans_ijoin (tp, mp->m_rsumip,XFS_ILOCK_EXCL ); }
@@ -1219,8 +1219,8 @@ voidxfs_rtbitmap_unlock ( struct xfs_mount *mp) { -xfs_iunlock (mp->m_rsumip,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ); -xfs_iunlock (mp->m_rbmip,XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP ); +xfs_iunlock (mp->m_rsumip,XFS_ILOCK_EXCL ); +xfs_iunlock (mp->m_rbmip,XFS_ILOCK_EXCL ); }/*
@@ -1233,10 +1233,10 @@ xfs_rtbitmap_lock_shared( unsigned int rbmlock_flags) {if (rbmlock_flags &XFS_RBMLOCK_BITMAP ) -xfs_ilock (mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xfs_ilock (mp->m_rbmip,XFS_ILOCK_SHARED );if (rbmlock_flags &XFS_RBMLOCK_SUMMARY ) -xfs_ilock (mp->m_rsumip,XFS_ILOCK_SHARED |XFS_ILOCK_RTSUM ); +xfs_ilock (mp->m_rsumip,XFS_ILOCK_SHARED ); }/* Unlock the realtime free space metadata inodes after a freespace scan. */
@@ -1246,8 +1246,8 @@ xfs_rtbitmap_unlock_shared( unsigned int rbmlock_flags) {if (rbmlock_flags &XFS_RBMLOCK_SUMMARY ) -xfs_iunlock (mp->m_rsumip,XFS_ILOCK_SHARED |XFS_ILOCK_RTSUM ); +xfs_iunlock (mp->m_rsumip,XFS_ILOCK_SHARED );if (rbmlock_flags &XFS_RBMLOCK_BITMAP ) -xfs_iunlock (mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xfs_iunlock (mp->m_rbmip,XFS_ILOCK_SHARED ); }
fs/xfs/scrub/common.c +5 -5
@@ -701,14 +701,14 @@ xchk_rt_init( XCHK_RTLOCK_SUMMARY_SHARED)) < 2);if (rtlock_flags &XCHK_RTLOCK_BITMAP ) -xfs_ilock (sc->mp->m_rbmip,XFS_ILOCK_EXCL |XFS_ILOCK_RTBITMAP ); +xfs_ilock (sc->mp->m_rbmip,XFS_ILOCK_EXCL );else if (rtlock_flags &XCHK_RTLOCK_BITMAP_SHARED ) -xfs_ilock (sc->mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xfs_ilock (sc->mp->m_rbmip,XFS_ILOCK_SHARED );if (rtlock_flags &XCHK_RTLOCK_SUMMARY ) -xfs_ilock (sc->mp->m_rsumip,XFS_ILOCK_EXCL |XFS_ILOCK_RTSUM ); +xfs_ilock (sc->mp->m_rsumip,XFS_ILOCK_EXCL );else if (rtlock_flags &XCHK_RTLOCK_SUMMARY_SHARED ) -xfs_ilock (sc->mp->m_rsumip,XFS_ILOCK_SHARED |XFS_ILOCK_RTSUM ); +xfs_ilock (sc->mp->m_rsumip,XFS_ILOCK_SHARED ); sr->rtlock_flags = rtlock_flags; }
@@ -745,7 +745,7 @@ xchk_rt_unlock_rtbitmap( {ASSERT (sc->sr.rtlock_flags &XCHK_RTLOCK_BITMAP_SHARED ); -xfs_iunlock (sc->mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); +xfs_iunlock (sc->mp->m_rbmip,XFS_ILOCK_SHARED ); sc->sr.rtlock_flags &= ~XCHK_RTLOCK_BITMAP_SHARED ; }
fs/xfs/xfs_inode.c +1 -2
@@ -364,8 +364,7 @@ xfs_lock_inumorder( {uint class =0 ; -ASSERT (!(lock_mode & (XFS_ILOCK_PARENT |XFS_ILOCK_RTBITMAP | -XFS_ILOCK_RTSUM ))); +ASSERT (!(lock_mode &XFS_ILOCK_PARENT ));ASSERT (xfs_lockdep_subclass_ok (subclass));if (lock_mode & (XFS_IOLOCK_SHARED |XFS_IOLOCK_EXCL )) {
fs/xfs/xfs_inode.h +4 -9
@@ -437,9 +437,8 @@ static inline bool xfs_inode_has_bigallocunit(struct xfs_inode *ip)* However, MAX_LOCKDEP_SUBCLASSES == 8, which means we are greatly * limited to the subclasses we can represent via nesting. We need at least * 5 inodes nest depth for the ILOCK through rename, and we also have to support -* XFS_ILOCK_PARENT, which gives 6 subclasses. Then we have XFS_ILOCK_RTBITMAP -* and XFS_ILOCK_RTSUM, which are another 2 unique subclasses, so that's all -* 8 subclasses supported by lockdep. +* XFS_ILOCK_PARENT, which gives 6 subclasses. That's 6 of the 8 subclasses +* supported by lockdep. * * This also means we have to number the sub-classes in the lowest bits of * the mask we keep, and we have to ensure we never exceed 3 bits of lockdep
@@ -465,8 +464,8 @@ static inline bool xfs_inode_has_bigallocunit(struct xfs_inode *ip)* ILOCK values * 0-4 subclass values * 5 PARENT subclass (not nestable) -* 6 RTBITMAP subclass (not nestable) -* 7 RTSUM subclass (not nestable) +* 6 unused +* 7 unused * */ #define XFS_IOLOCK_SHIFT 16
@@ -481,12 +480,8 @@ static inline bool xfs_inode_has_bigallocunit(struct xfs_inode *ip)#define XFS_ILOCK_SHIFT 24#define XFS_ILOCK_PARENT_VAL 5u#define XFS_ILOCK_MAX_SUBCLASS (XFS_ILOCK_PARENT_VAL - 1) -#define XFS_ILOCK_RTBITMAP_VAL 6u -#define XFS_ILOCK_RTSUM_VAL 7u#define XFS_ILOCK_DEP_MASK 0xff000000u#define XFS_ILOCK_PARENT (XFS_ILOCK_PARENT_VAL << XFS_ILOCK_SHIFT) -#define XFS_ILOCK_RTBITMAP (XFS_ILOCK_RTBITMAP_VAL << XFS_ILOCK_SHIFT) -#define XFS_ILOCK_RTSUM (XFS_ILOCK_RTSUM_VAL << XFS_ILOCK_SHIFT)#define XFS_LOCK_SUBCLASS_MASK (XFS_IOLOCK_DEP_MASK | \ XFS_MMAPLOCK_DEP_MASK | \
fs/xfs/xfs_rtalloc.c +5 -6
@@ -1365,12 +1365,11 @@ __xfs_rt_iget(static inline int xfs_rtmount_iread_extents (struct xfs_trans *tp, -struct xfs_inode *ip, -unsigned int lock_class) +struct xfs_inode *ip) {int error; -xfs_ilock (ip,XFS_ILOCK_EXCL | lock_class); +xfs_ilock (ip,XFS_ILOCK_EXCL ); error =xfs_iread_extents (tp, ip,XFS_DATA_FORK );if (error)
@@ -1383,7 +1382,7 @@ xfs_rtmount_iread_extents( } out_unlock: -xfs_iunlock (ip,XFS_ILOCK_EXCL | lock_class); +xfs_iunlock (ip,XFS_ILOCK_EXCL );return error; }
@@ -1411,7 +1410,7 @@ xfs_rtmount_inodes( goto out_trans;ASSERT (mp->m_rbmip !=NULL ); - error =xfs_rtmount_iread_extents (tp, mp->m_rbmip,XFS_ILOCK_RTBITMAP ); + error =xfs_rtmount_iread_extents (tp, mp->m_rbmip);if (error) goto out_rele_bitmap;
@@ -1423,7 +1422,7 @@ xfs_rtmount_inodes( goto out_rele_bitmap;ASSERT (mp->m_rsumip !=NULL ); - error =xfs_rtmount_iread_extents (tp, mp->m_rsumip,XFS_ILOCK_RTSUM ); + error =xfs_rtmount_iread_extents (tp, mp->m_rsumip);if (error) goto out_rele_summary;
PATCH 4/15 xfsprogs: shard the realtime section
In reply to Darrick J. WongHi all,
Right now, the realtime section uses a single pair of metadata inodes to store the free space information. This presents a scalability problem since every thread trying to allocate or free rt extents have to lock these files. It would be very useful if we could begin to tackle these problems by sharding the realtime section, so create the notion of realtime groups, which are similar to allocation groups on the data section.
While we're at it, define a superblock to be stamped into the start of each rt section. This enables utilities such as blkid to identify block devices containing realtime sections, and helpfully avoids the situation where a file extent can cross an rtgroup boundary.
The best advantage for rtgroups will become evident later when we get to adding rmap and reflink to the realtime volume, since the geometry constraints are the same for rt groups and AGs. Hence we can reuse all that code directly.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=realtime-groups
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=realtime-groups
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=realtime-groups
xfsdocs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-documentation.git/log/?h=realtime-groups
--- fs/xfs/Makefile | 3 fs/xfs/libxfs/xfs_bmap.h | 5 fs/xfs/libxfs/xfs_format.h | 96 ++++++ fs/xfs/libxfs/xfs_fs.h | 9 - fs/xfs/libxfs/xfs_fs_staging.h | 17 + fs/xfs/libxfs/xfs_health.h | 30 ++ fs/xfs/libxfs/xfs_ondisk.h | 2 fs/xfs/libxfs/xfs_rtbitmap.c | 143 +++++++++- fs/xfs/libxfs/xfs_rtbitmap.h | 68 ++++- fs/xfs/libxfs/xfs_rtgroup.c | 585 +++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_rtgroup.h | 252 +++++++++++++++++ fs/xfs/libxfs/xfs_sb.c | 126 ++++++++ fs/xfs/libxfs/xfs_shared.h | 4 fs/xfs/libxfs/xfs_types.c | 46 +++ fs/xfs/libxfs/xfs_types.h | 4 fs/xfs/scrub/common.c | 88 ++++++ fs/xfs/scrub/common.h | 52 ++- fs/xfs/scrub/health.c | 25 ++ fs/xfs/scrub/repair.h | 3 fs/xfs/scrub/rgsuper.c | 77 +++++ fs/xfs/scrub/rgsuper_repair.c | 48 +++ fs/xfs/scrub/rtbitmap.c | 127 ++++++++ fs/xfs/scrub/rtbitmap.h | 6 fs/xfs/scrub/rtsummary.c | 7 fs/xfs/scrub/rtsummary_repair.c | 15 + fs/xfs/scrub/scrub.c | 27 ++ fs/xfs/scrub/scrub.h | 42 +-- fs/xfs/scrub/stats.c | 2 fs/xfs/scrub/trace.h | 6 fs/xfs/xfs_bmap_item.c | 18 + fs/xfs/xfs_buf_item_recover.c | 43 +++ fs/xfs/xfs_fsops.c | 4 fs/xfs/xfs_health.c | 114 ++++++++ fs/xfs/xfs_ioctl.c | 35 ++ fs/xfs/xfs_log_recover.c | 6 fs/xfs/xfs_mount.c | 12 + fs/xfs/xfs_mount.h | 11 + fs/xfs/xfs_rtalloc.c | 273 +++++++++++++++++- fs/xfs/xfs_rtalloc.h | 5 fs/xfs/xfs_super.c | 18 + fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 63 ++++ fs/xfs/xfs_trans.c | 38 ++- fs/xfs/xfs_trans.h | 2 fs/xfs/xfs_trans_buf.c | 25 +- 45 files changed, 2460 insertions(+), 123 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_rtgroup.c create mode 100644 fs/xfs/libxfs/xfs_rtgroup.h create mode 100644 fs/xfs/scrub/rgsuper.c create mode 100644 fs/xfs/scrub/rgsuper_repair.c
PATCH 1/24 xfs: create incore realtime group structures
From: Darrick J. Wong <[email protected]>
Create an incore object that will contain information about a realtime allocation group. This will eventually enable us to shard the realtime section in a similar manner to how we shard the data section.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_format.h | 8 + fs/xfs/libxfs/xfs_rtgroup.c | 251 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_rtgroup.h | 132 +++++++++++++++++++++++ fs/xfs/libxfs/xfs_sb.c | 5 + fs/xfs/libxfs/xfs_types.h | 4 + fs/xfs/xfs_log_recover.c | 6 + fs/xfs/xfs_mount.c | 12 ++ fs/xfs/xfs_mount.h | 6 + fs/xfs/xfs_rtalloc.c | 8 + fs/xfs/xfs_super.c | 2 fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 38 +++++++ 13 files changed, 473 insertions(+), 1 deletion(-) create mode 100644 fs/xfs/libxfs/xfs_rtgroup.c create mode 100644 fs/xfs/libxfs/xfs_rtgroup.h
fs/xfs/Makefile +1 -0
@@ -59,6 +59,7 @@ xfs-y += $(addprefix libxfs/, \ # xfs_rtbitmap is shared with libxfs xfs-$(CONFIG_XFS_RT) += $(addprefix libxfs/, \ xfs_rtbitmap.o \ + xfs_rtgroup.o \ ) # highlevel code
fs/xfs/libxfs/xfs_format.h +8 -0
@@ -184,6 +184,14 @@ typedef struct xfs_sb {*/ xfs_ino_t sb_metadirino; +/* +* Realtime group geometry information. On disk these fields live in +* the rsumino slot, but we cache them separately in the in-core super +* for easy access. +*/ +xfs_rgblock_t sb_rgblocks;/* size of a realtime group */ +xfs_rgnumber_t sb_rgcount;/* number of realtime groups */ +/* must be padded to 64 bit alignment */ } xfs_sb_t;
fs/xfs/libxfs/xfs_rtgroup.c new file +251 -0
251 lines not on this page · raw message
fs/xfs/libxfs/xfs_rtgroup.h new file +132 -0
132 lines not on this page · raw message
fs/xfs/libxfs/xfs_sb.c +5 -0
@@ -701,6 +701,9 @@ __xfs_sb_from_disk( to->sb_gquotino =NULLFSINO ; to->sb_pquotino =NULLFSINO ; } + + to->sb_rgcount =0 ; + to->sb_rgblocks =0 ; }void
@@ -1015,6 +1018,8 @@ xfs_sb_mount_common( mp->m_blockwmask = mp->m_blockwsize -1 ; mp->m_rtxblklog =log2_if_power2 (sbp->sb_rextsize); mp->m_rtxblkmask =mask64_if_power2 (sbp->sb_rextsize); + mp->m_rgblklog =0 ; + mp->m_rgblkmask =0 ; mp->m_alloc_mxr[0 ] =xfs_allocbt_maxrecs (mp, sbp->sb_blocksize,1 ); mp->m_alloc_mxr[1 ] =xfs_allocbt_maxrecs (mp, sbp->sb_blocksize,0 );
fs/xfs/libxfs/xfs_types.h +4 -0
@@ -9,10 +9,12 @@typedef uint32_t prid_t ;/* project ID */ typedef uint32_t xfs_agblock_t ;/* blockno in alloc. group */ +typedef uint32_t xfs_rgblock_t ;/* blockno in realtime group */ typedef uint32_t xfs_agino_t ;/* inode # within allocation grp */ typedef uint32_t xfs_extlen_t ;/* extent length in blocks */ typedef uint32_t xfs_rtxlen_t ;/* file extent length in rtextents */ typedef uint32_t xfs_agnumber_t ;/* allocation group number */ +typedef uint32_t xfs_rgnumber_t ;/* realtime group number */ typedef uint64_t xfs_extnum_t ;/* # of extents in a file */ typedef uint32_t xfs_aextnum_t ;/* # extents in an attribute fork */ typedef int64_t xfs_fsize_t ;/* bytes in a file */
@@ -54,7 +56,9 @@ typedef void * xfs_failaddr_t;#define NULLRTEXTNO ((xfs_rtxnum_t)-1)#define NULLAGBLOCK ((xfs_agblock_t)-1) +#define NULLRGBLOCK ((xfs_rgblock_t)-1)#define NULLAGNUMBER ((xfs_agnumber_t)-1) +#define NULLRGNUMBER ((xfs_rgnumber_t)-1)#define NULLCOMMITLSN ((xfs_lsn_t)-1)
fs/xfs/xfs_log_recover.c +6 -0
@@ -28,6 +28,7 @@#include "xfs_ag.h" #include "xfs_quota.h" #include "xfs_reflink.h" +#include "xfs_rtgroup.h" #define BLK_AVG (blk1, blk2) ((blk1+blk2) >> 1)
@@ -3347,6 +3348,11 @@ xlog_do_recover(xfs_warn (mp,"Failed post-recovery per-ag init: %d" , error);return error; } + error =xfs_initialize_rtgroups (mp, sbp->sb_rgcount); +if (error) { +xfs_warn (mp,"Failed post-recovery rtgroup init: %d" , error); +return error; + } mp->m_alloc_set_aside =xfs_alloc_set_aside (mp);/* Normal transactions can now occur */
fs/xfs/xfs_mount.c +11 -1
@@ -35,6 +35,7 @@#include "xfs_trace.h" #include "xfs_ag.h" #include "xfs_imeta.h" +#include "xfs_rtgroup.h" #include "scrub/stats.h" static DEFINE_MUTEX (xfs_uuid_table_mutex);
@@ -842,10 +843,16 @@ xfs_mountfs( goto out_free_dir; } + error =xfs_initialize_rtgroups (mp, sbp->sb_rgcount); +if (error) { +xfs_warn (mp,"Failed rtgroup init: %d" , error); + goto out_free_perag; + } +if (XFS_IS_CORRUPT (mp, !sbp->sb_logblocks)) {xfs_warn (mp,"no log defined" ); error = -EFSCORRUPTED ; - goto out_free_perag; + goto out_free_rtgroup; } error =xfs_inodegc_register_shrinker (mp);
@@ -1070,6 +1077,8 @@ xfs_mountfs(if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)xfs_buftarg_drain (mp->m_logdev_targp);xfs_buftarg_drain (mp->m_ddev_targp); + out_free_rtgroup: +xfs_free_rtgroups (mp); out_free_perag:xfs_free_perag (mp); out_free_dir:
@@ -1151,6 +1160,7 @@ xfs_unmountfs(xfs_errortag_clearall (mp);#endif shrinker_free (mp->m_inodegc_shrinker); +xfs_free_rtgroups (mp);xfs_free_perag (mp);xfs_errortag_del (mp);
fs/xfs/xfs_mount.h +6 -0
@@ -121,6 +121,7 @@ typedef struct xfs_mount {uint8_t m_agno_log;/* log #ag's */ uint8_t m_sectbb_log;/* sectlog - BBSHIFT */ int8_t m_rtxblklog;/* log2 of rextsize, if possible */ +int8_t m_rgblklog;/* log2 of rt group sz if possible */ uint m_blockmask;/* sb_blocksize-1 */ uint m_blockwsize;/* sb_blocksize in words */ uint m_blockwmask;/* blockwsize-1 */
@@ -155,6 +156,7 @@ typedef struct xfs_mount {uint64_t m_low_space[XFS_LOWSP_MAX ];uint64_t m_low_rtexts[XFS_LOWSP_MAX ];uint64_t m_rtxblkmask;/* rt extent block mask */ +uint64_t m_rgblkmask;/* rt group block mask */ struct xfs_ino_geometry m_ino_geo;/* inode geometry */ struct xfs_trans_resv m_resv;/* precomputed res values */ /* low free space thresholds */
@@ -203,6 +205,8 @@ typedef struct xfs_mount {*/ atomic64_t m_allocbt_blks; +struct radix_tree_root m_rtgroup_tree;/* per-rt group info */ +spinlock_t m_rtgroup_lock;/* lock for m_rtgroup_tree */ struct radix_tree_root m_perag_tree;/* per-ag accounting info */ spinlock_t m_perag_lock;/* lock for m_perag_tree */ uint64_t m_resblks;/* total reserved blocks */
@@ -294,6 +298,7 @@ typedef struct xfs_mount {#define XFS_FEAT_NEEDSREPAIR (1ULL << 25)/* needs xfs_repair */ #define XFS_FEAT_NREXT64 (1ULL << 26)/* large extent counters */ #define XFS_FEAT_METADIR (1ULL << 27)/* metadata directory tree */ +#define XFS_FEAT_RTGROUPS (1ULL << 28)/* realtime groups */ /* Mount features */ #define XFS_FEAT_NOATTR2 (1ULL << 48)/* disable attr2 creation */
@@ -358,6 +363,7 @@ __XFS_HAS_FEAT(bigtime, BIGTIME) __XFS_HAS_FEAT(needsrepair, NEEDSREPAIR) __XFS_HAS_FEAT(large_extent_counts, NREXT64) __XFS_HAS_FEAT(metadir, METADIR) +__XFS_HAS_FEAT (rtgroups,RTGROUPS )/* * Mount features
fs/xfs/xfs_rtalloc.c +8 -0
@@ -24,6 +24,7 @@#include "xfs_health.h" #include "xfs_da_format.h" #include "xfs_imeta.h" +#include "xfs_rtgroup.h" /* * Realtime metadata files are not quite regular files because userspace can't
@@ -1396,6 +1397,8 @@ xfs_rtmount_inodes( {struct xfs_trans *tp;struct xfs_sb *sbp = &mp->m_sb; +struct xfs_rtgroup *rtg; +xfs_rgnumber_t rgno;int error; error =xfs_trans_alloc_empty (mp, &tp);
@@ -1426,6 +1429,11 @@ xfs_rtmount_inodes(if (error) goto out_rele_summary; +for_each_rtgroup (mp, rgno, rtg) { + rtg->rtg_blockcount =xfs_rtgroup_block_count (mp, + rtg->rtg_rgno); + } +xfs_alloc_rsum_cache (mp, sbp->sb_rbmblocks);xfs_trans_cancel (tp);return 0 ;
fs/xfs/xfs_super.c +2 -0
@@ -2002,6 +2002,8 @@ static int xfs_init_fs_context(spin_lock_init (&mp->m_sb_lock);INIT_RADIX_TREE (&mp->m_perag_tree,GFP_ATOMIC );spin_lock_init (&mp->m_perag_lock); +INIT_RADIX_TREE (&mp->m_rtgroup_tree,GFP_ATOMIC ); +spin_lock_init (&mp->m_rtgroup_lock);mutex_init (&mp->m_growlock);INIT_WORK (&mp->m_flush_inodes_work, xfs_flush_inodes_worker);INIT_DELAYED_WORK (&mp->m_reclaim_work, xfs_reclaim_worker);
fs/xfs/xfs_trace.c +1 -0
@@ -44,6 +44,7 @@#include "xfs_xchgrange.h" #include "xfs_parent.h" #include "xfs_imeta.h" +#include "xfs_rtgroup.h" /* * We include this last to have the helpers above available for the trace
fs/xfs/xfs_trace.h +38 -0
@@ -87,6 +87,7 @@ struct xfs_getparents;struct xfs_parent_name_irec ;struct xfs_attrlist_cursor_kern ;struct xfs_imeta_update ; +struct xfs_rtgroup ;#define XFS_ATTR_FILTER_FLAGS \ { XFS_ATTR_ROOT, "ROOT" }, \
@@ -216,6 +217,43 @@ DEFINE_PERAG_REF_EVENT(xfs_perag_rele);DEFINE_PERAG_REF_EVENT (xfs_perag_set_inode_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_clear_inode_tag); +#ifdef CONFIG_XFS_RT +DECLARE_EVENT_CLASS (xfs_rtgroup_class, + TP_PROTO(struct xfs_rtgroup *rtg, unsigned long caller_ip), +TP_ARGS (rtg, caller_ip), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_rgnumber_t, rgno) + __field(int, refcount) + __field(int, active_refcount) + __field(unsigned long, caller_ip) + ), +TP_fast_assign ( + __entry->dev = rtg->rtg_mount->m_super->s_dev; + __entry->rgno = rtg->rtg_rgno; + __entry->refcount = atomic_read(&rtg->rtg_ref); + __entry->active_refcount = atomic_read(&rtg->rtg_active_ref); + __entry->caller_ip = caller_ip; + ), +TP_printk ("dev %d:%d rgno 0x%x passive refs %d active refs %d caller %pS" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->rgno, + __entry->refcount, + __entry->active_refcount, + (char *)__entry->caller_ip) +); + +#define DEFINE_RTGROUP_REF_EVENT (name) \ +DEFINE_EVENT(xfs_rtgroup_class, name, \ + TP_PROTO(struct xfs_rtgroup *rtg, unsigned long caller_ip), \ + TP_ARGS(rtg, caller_ip)) +DEFINE_RTGROUP_REF_EVENT (xfs_rtgroup_get); +DEFINE_RTGROUP_REF_EVENT (xfs_rtgroup_hold); +DEFINE_RTGROUP_REF_EVENT (xfs_rtgroup_put); +DEFINE_RTGROUP_REF_EVENT (xfs_rtgroup_grab); +DEFINE_RTGROUP_REF_EVENT (xfs_rtgroup_rele); +#endif /* CONFIG_XFS_RT */ + TRACE_EVENT(xfs_inodegc_worker, TP_PROTO(struct xfs_mount *mp, unsigned int shrinker_hits), TP_ARGS(mp, shrinker_hits),
PATCH 2/24 xfs: define the format of rt groups
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Define the ondisk format of realtime group metadata.
--- fs/xfs/libxfs/xfs_format.h | 62 +++++++++++++++++++++++++++- fs/xfs/libxfs/xfs_ondisk.h | 1 fs/xfs/libxfs/xfs_rtgroup.c | 96 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_rtgroup.h | 83 +++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_sb.c | 86 +++++++++++++++++++++++++++++++++++++-- fs/xfs/libxfs/xfs_shared.h | 1 6 files changed, 324 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_format.h +61 -1
@@ -216,7 +216,17 @@ struct xfs_dsb {* pointers are no longer used. */ __be64 sb_rbmino; -__be64 sb_rsumino;/* summary inode for rt bitmap */ +/* +* rtgroups requires metadir, so we reuse the rsumino space to hold +* the rg block count and shift values. +*/ +union { +__be64 sb_rsumino;/* summary inode for rt bitmap */ +struct { +__be32 sb_rgcount;/* # of realtime groups */ +__be32 sb_rgblocks;/* rtblocks per group */ + }; + };__be32 sb_rextsize;/* realtime extent size, blocks */ __be32 sb_agblocks;/* size of an allocation group */ __be32 sb_agcount;/* number of allocation groups */
@@ -398,6 +408,7 @@ xfs_sb_has_ro_compat_feature(#define XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR (1 << 4)/* needs xfs_repair */ #define XFS_SB_FEAT_INCOMPAT_NREXT64 (1 << 5)/* large extent counters */ #define XFS_SB_FEAT_INCOMPAT_PARENT (1 << 6)/* parent pointers */ +#define XFS_SB_FEAT_INCOMPAT_RTGROUPS (1U << 30)/* realtime groups */ #define XFS_SB_FEAT_INCOMPAT_METADIR (1U << 31)/* metadata dir tree */ #define XFS_SB_FEAT_INCOMPAT_ALL \ (XFS_SB_FEAT_INCOMPAT_FTYPE| \
@@ -752,6 +763,55 @@ union xfs_suminfo_raw {__u32 old; }; +/* +* Realtime allocation groups break the rt section into multiple pieces that +* could be locked independently. Realtime block group numbers are 32-bit +* quantities. Block numbers within a group are also 32-bit quantities, but +* the upper bit must never be set. +*/ +#define XFS_MAX_RGBLOCKS ((xfs_rgblock_t)(1U << 31) - 1) +#define XFS_MAX_RGNUMBER ((xfs_rgnumber_t)(-1U)) + +#define XFS_RTSB_MAGIC 0x58524750/* 'XRGP' */ + +/* +* Realtime superblock - on disk version. Must be padded to 64 bit alignment. +* The first block of each realtime group contains this superblock; this is +* how we avoid having file data extents cross a group boundary. +*/ +struct xfs_rtsb { +__be32 rsb_magicnum;/* magic number == XFS_RTSB_MAGIC */ +__be32 rsb_blocksize;/* logical block size, bytes */ +__be64 rsb_rblocks;/* number of realtime blocks */ + +__be64 rsb_rextents;/* number of realtime extents */ +__be64 rsb_lsn;/* last write sequence */ + +__be32 rsb_rgcount;/* # of realtime groups */ +unsigned char rsb_fname[XFSLABEL_MAX ];/* rt volume name */ + +uuid_t rsb_uuid;/* user-visible file system unique id */ + +__be32 rsb_rextsize;/* realtime extent size, blocks */ +__be32 rsb_rbmblocks;/* number of rt bitmap blocks */ + +__be32 rsb_rgblocks;/* rt blocks per group */ +__u8 rsb_blocklog;/* log2 of sb_blocksize */ +__u8 rsb_sectlog;/* log2 of sb_sectsize */ +__u8 rsb_rextslog;/* log2 of sb_rextents */ +__u8 rsb_pad; + +__le32 rsb_crc;/* superblock crc */ +__le32 rsb_pad2; + +uuid_t rsb_meta_uuid;/* metadata file system unique id */ + +/* must be padded to 64 bit alignment */ +}; + +#define XFS_RTSB_CRC_OFF offsetof(struct xfs_rtsb, rsb_crc) +#define XFS_RTSB_DADDR ((xfs_daddr_t)0)/* daddr in rt section */ +/* * XFS Timestamps * ==============
fs/xfs/libxfs/xfs_ondisk.h +1 -0
@@ -53,6 +53,7 @@ xfs_check_ondisk_structs(void)XFS_CHECK_STRUCT_SIZE (xfs_inobt_ptr_t,4 );XFS_CHECK_STRUCT_SIZE (xfs_refcount_ptr_t,4 );XFS_CHECK_STRUCT_SIZE (xfs_rmap_ptr_t,4 ); + XFS_CHECK_STRUCT_SIZE(struct xfs_rtsb, 104);/* dir/attr trees */ XFS_CHECK_STRUCT_SIZE(struct xfs_attr3_leaf_hdr, 80);
fs/xfs/libxfs/xfs_rtgroup.c +96 -0
105 lines not on this page · raw message
fs/xfs/libxfs/xfs_rtgroup.h +83 -0
89 lines not on this page · raw message
fs/xfs/libxfs/xfs_sb.c +82 -4
128 lines not on this page · raw message
fs/xfs/libxfs/xfs_shared.h +1 -0
@@ -39,6 +39,7 @@ extern const struct xfs_buf_ops xfs_inode_buf_ra_ops;extern const struct xfs_buf_ops xfs_refcountbt_buf_ops;extern const struct xfs_buf_ops xfs_rmapbt_buf_ops;extern const struct xfs_buf_ops xfs_rtbuf_ops; +extern const struct xfs_buf_ops xfs_rtsb_buf_ops;extern const struct xfs_buf_ops xfs_sb_buf_ops;extern const struct xfs_buf_ops xfs_sb_quiet_buf_ops;extern const struct xfs_buf_ops xfs_symlink_buf_ops;
PATCH 3/24 xfs: reduce rt summary file levels for rtgroups filesystems
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The rt summary file is supposed to be large enough to track the number of log2(rtextentcount) free space extents that start in a given rt bitmap block. Prior to rt groups, there could be a single 2^52 block free extent, which implies a summary file with 53 levels.
However, each rtgroup uses its first rt extent to hold a superblock, so there can't be any free extents longer than the length of a group. Groups are limited to 2^32-1 blocks, which means that the longest freespace will be counted in level 31. Hence we only need 32 levels.
Adjust the rextslog computation to create smaller rt summary files for rtgroups filesystems.
--- fs/xfs/libxfs/xfs_format.h | 2 +- fs/xfs/libxfs/xfs_rtbitmap.c | 11 +++++++++++ fs/xfs/libxfs/xfs_rtbitmap.h | 4 ++-- fs/xfs/libxfs/xfs_sb.c | 2 +- fs/xfs/scrub/rtbitmap.c | 2 +- fs/xfs/scrub/rtsummary.c | 2 +- fs/xfs/xfs_rtalloc.c | 5 +++-- 7 files changed, 20 insertions(+), 8 deletions(-)
fs/xfs/libxfs/xfs_format.h +1 -1
@@ -313,7 +313,7 @@ struct xfs_dsb {#define XFS_SB_VERSION_NUM (sbp) ((sbp)->sb_versionnum & XFS_SB_VERSION_NUMBITS) -static inline bool xfs_sb_is_v5 (struct xfs_sb *sbp) +static inline bool xfs_sb_is_v5 (const struct xfs_sb *sbp) {return XFS_SB_VERSION_NUM (sbp) ==XFS_SB_VERSION_5 ; }
fs/xfs/libxfs/xfs_rtbitmap.c +11 -0
@@ -1144,10 +1144,21 @@ xfs_rtbitmap_blockcount(*/ uint8_t xfs_compute_rextslog ( +const struct xfs_sb *sbp,xfs_rtbxlen_t rtextents) {if (!rtextents)return 0 ; + +/* +* Realtime groups are never larger than 2^32 extents and are never +* fully free, so we can use highbit32 on the number of rtextents per +* group. +*/ +if (xfs_sb_is_v5 (sbp) && + (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_RTGROUPS )) +return xfs_highbit32 (sbp->sb_rgblocks / sbp->sb_rextsize); +return xfs_highbit64 (rtextents); }
fs/xfs/libxfs/xfs_rtbitmap.h +2 -2
@@ -351,7 +351,7 @@ xfs_rtfree_extent(int xfs_rtfree_blocks (struct xfs_trans *tp,xfs_fsblock_t rtbno,xfs_filblks_t rtlen); -uint8_t xfs_compute_rextslog (xfs_rtbxlen_t rtextents); +uint8_t xfs_compute_rextslog (const struct xfs_sb *sbp,xfs_rtbxlen_t rtextents);/* Do we support an rt volume having this number of rtextents? */ static inline bool
@@ -396,7 +396,7 @@ void xfs_rtbitmap_unlock_shared(struct xfs_mount *mp,# define xfs_rtsummary_read_buf (a,b) (-ENOSYS)# define xfs_rtbuf_cache_relse (a) (0)# define xfs_rtalloc_extent_is_free (m,t,s,l,i) (-ENOSYS) -# define xfs_compute_rextslog (rtx) (0) +# define xfs_compute_rextslog (sbp, rtx) (0)# define xfs_validate_rtextents (rtx) (false)static inline xfs_filblks_t xfs_rtbitmap_blockcount (struct xfs_mount *mp,xfs_rtbxlen_t rtextents)
fs/xfs/libxfs/xfs_sb.c +1 -1
@@ -583,7 +583,7 @@ xfs_validate_sb_common(if (!xfs_validate_rtextents (rexts) || sbp->sb_rextents != rexts || - sbp->sb_rextslog !=xfs_compute_rextslog (rexts) || + sbp->sb_rextslog !=xfs_compute_rextslog (sbp, rexts) || sbp->sb_rbmblocks != rbmblocks) {xfs_notice (mp,"realtime geometry sanity check failed" );
fs/xfs/scrub/rtbitmap.c +1 -1
@@ -61,7 +61,7 @@ xchk_setup_rtbitmap(*/ if (mp->m_sb.sb_rblocks) { rtb->rextents =xfs_rtb_to_rtx (mp, mp->m_sb.sb_rblocks); - rtb->rextslog =xfs_compute_rextslog (rtb->rextents); + rtb->rextslog =xfs_compute_rextslog (&mp->m_sb, rtb->rextents); rtb->rbmblocks =xfs_rtbitmap_blockcount (mp, rtb->rextents); }return 0 ;
fs/xfs/scrub/rtsummary.c +1 -1
@@ -92,7 +92,7 @@ xchk_setup_rtsummary(int rextslog; rts->rextents =xfs_rtb_to_rtx (mp, mp->m_sb.sb_rblocks); - rextslog =xfs_compute_rextslog (rts->rextents); + rextslog =xfs_compute_rextslog (&mp->m_sb, rts->rextents); rts->rsumlevels = rextslog +1 ; rts->rbmblocks =xfs_rtbitmap_blockcount (mp, rts->rextents); rsumblocks = xfs_rtsummary_blockcount(mp, rts->rsumlevels,
fs/xfs/xfs_rtalloc.c +3 -2
@@ -981,7 +981,7 @@ xfs_growfs_rt(if (!xfs_validate_rtextents (nrextents))return -EINVAL ; nrbmblocks =xfs_rtbitmap_blockcount (mp, nrextents); - nrextslog =xfs_compute_rextslog (nrextents); + nrextslog =xfs_compute_rextslog (&mp->m_sb, nrextents); nrsumlevels = nrextslog +1 ; nrsumblocks =xfs_rtsummary_blockcount (mp, nrsumlevels, nrbmblocks); nrsumsize =XFS_FSB_TO_B (mp, nrsumblocks);
@@ -1048,7 +1048,8 @@ xfs_growfs_rt( nsbp->sb_rblocks =min (nrblocks, nrblocks_step); nsbp->sb_rextents =xfs_rtb_to_rtx (nmp, nsbp->sb_rblocks);ASSERT (nsbp->sb_rextents !=0 ); - nsbp->sb_rextslog =xfs_compute_rextslog (nsbp->sb_rextents); + nsbp->sb_rextslog =xfs_compute_rextslog (&mp->m_sb, + nsbp->sb_rextents); nrsumlevels = nmp->m_rsumlevels = nsbp->sb_rextslog +1 ; nrsumblocks =xfs_rtsummary_blockcount (mp, nrsumlevels, nsbp->sb_rbmblocks);
PATCH 4/24 xfs: check the realtime superblock at mount time
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Check the realtime superblock at mount time, to ensure that the label actually matches the primary superblock. If the rt superblock is good, attach it to the xfs_mount so that the log can use ordered buffers to keep this primary in sync with the primary super on the data device.
--- fs/xfs/xfs_mount.h | 1 + fs/xfs/xfs_rtalloc.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_rtalloc.h | 5 +++++ fs/xfs/xfs_super.c | 16 ++++++++++++++-- 4 files changed, 70 insertions(+), 2 deletions(-)
fs/xfs/xfs_mount.h +1 -0
@@ -85,6 +85,7 @@ typedef struct xfs_mount {struct super_block *m_super;struct xfs_ail *m_ail;/* fs active log item list */ struct xfs_buf *m_sb_bp;/* buffer for superblock */ +struct xfs_buf *m_rtsb_bp;/* realtime superblock */ char *m_rtname;/* realtime device name */ char *m_logname;/* external log device name */ struct xfs_da_geometry *m_dir_geo;/* directory block geometry */
fs/xfs/xfs_rtalloc.c +50 -0
56 lines not on this page · raw message
fs/xfs/xfs_rtalloc.h +5 -0
@@ -33,6 +33,9 @@ xfs_rtallocate_extent( xfs_rtxnum_t *rtblock); /* out: start rtext allocated */ +int xfs_rtmount_readsb (struct xfs_mount *mp); +void xfs_rtmount_freesb (struct xfs_mount *mp); +/* * Initialize realtime fields in the mount structure. */
@@ -79,6 +82,8 @@ int xfs_rtalloc_reinit_frextents(struct xfs_mount *mp);# define xfs_rtpick_extent (m,t,l,rb) (-ENOSYS)# define xfs_growfs_rt (mp,in) (-ENOSYS)# define xfs_rtalloc_reinit_frextents (m) (0) +# define xfs_rtmount_readsb (mp) (0) +# define xfs_rtmount_freesb (mp) ((void)0)static inline int /* error */ xfs_rtmount_init (xfs_mount_t *mp)/* file system mount structure */
fs/xfs/xfs_super.c +14 -2
@@ -45,6 +45,7 @@#include "xfs_rtbitmap.h" #include "xfs_swapext_item.h" #include "xfs_parent.h" +#include "xfs_rtalloc.h" #include "scrub/stats.h" #include "scrub/rcbag_btree.h"
@@ -1152,6 +1153,7 @@ xfs_fs_put_super(xfs_filestream_unmount (mp);xfs_unmountfs (mp); +xfs_rtmount_freesb (mp);xfs_freesb (mp);xchk_mount_stats_free (mp);free_percpu (mp->m_stats.xs_stats);
@@ -1671,9 +1673,13 @@ xfs_fs_fill_super( goto out_free_sb; } + error =xfs_rtmount_readsb (mp); +if (error) + goto out_free_sb; + error =xfs_filestream_mount (mp);if (error) - goto out_free_sb; + goto out_free_rtsb;/* * we must configure the block size in the superblock before we run the
@@ -1717,6 +1723,10 @@ xfs_fs_fill_super(xfs_warn (mp,"EXPERIMENTAL metadata directory feature in use. Use at your own risk!" ); +if (xfs_has_rtgroups (mp)) +xfs_warn (mp, +"EXPERIMENTAL realtime allocation group feature in use. Use at your own risk!" ); +if (xfs_has_reflink (mp)) {if (mp->m_sb.sb_rblocks) { xfs_alert(mp,
@@ -1761,6 +1771,8 @@ xfs_fs_fill_super( out_filestream_unmount:xfs_filestream_unmount (mp); + out_free_rtsb: +xfs_rtmount_freesb (mp); out_free_sb:xfs_freesb (mp); out_free_scrub_stats:
@@ -1780,7 +1792,7 @@ xfs_fs_fill_super( out_unmount:xfs_filestream_unmount (mp);xfs_unmountfs (mp); - goto out_free_sb; + goto out_free_rtsb; } static int
PATCH 5/24 xfs: update primary realtime super every time we update the primary fs super
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Every time we update parts of the primary filesystem superblock that are echoed in the primary rt super, we should update that primary realtime super. Avoid an ondisk log format change by using ordered buffers to write the primary rt super.
--- fs/xfs/libxfs/xfs_rtgroup.c | 74 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_rtgroup.h | 6 +++ fs/xfs/libxfs/xfs_sb.c | 13 +++++++ fs/xfs/xfs_buf_item_recover.c | 18 ++++++++++ fs/xfs/xfs_trans.c | 10 ++++++ fs/xfs/xfs_trans.h | 1 + fs/xfs/xfs_trans_buf.c | 25 +++++++++++--- 7 files changed, 142 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_rtgroup.c +74 -0
@@ -345,3 +345,77 @@ const struct xfs_buf_ops xfs_rtsb_buf_ops = { .verify_write = xfs_rtsb_write_verify, .verify_struct = xfs_rtsb_verify, }; + +/* Update a realtime superblock from the primary fs super */ +void +xfs_rtgroup_update_super ( +struct xfs_buf *rtsb_bp, +const struct xfs_buf *sb_bp) +{ +const struct xfs_dsb *dsb = sb_bp->b_addr; +struct xfs_rtsb *rsb = rtsb_bp->b_addr; +const uuid_t *meta_uuid; + + rsb->rsb_magicnum =cpu_to_be32 (XFS_RTSB_MAGIC ); + rsb->rsb_blocksize = dsb->sb_blocksize; + rsb->rsb_rblocks = dsb->sb_rblocks; + + rsb->rsb_rextents = dsb->sb_rextents; + rsb->rsb_lsn =0 ; + +memcpy (&rsb->rsb_uuid, &dsb->sb_uuid,sizeof (rsb->rsb_uuid)); + + rsb->rsb_rgcount = dsb->sb_rgcount; +memcpy (&rsb->rsb_fname, &dsb->sb_fname,XFSLABEL_MAX ); + + rsb->rsb_rextsize = dsb->sb_rextsize; + rsb->rsb_rbmblocks = dsb->sb_rbmblocks; + + rsb->rsb_rgblocks = dsb->sb_rgblocks; + rsb->rsb_blocklog = dsb->sb_blocklog; + rsb->rsb_sectlog = dsb->sb_sectlog; + rsb->rsb_rextslog = dsb->sb_rextslog; + rsb->rsb_pad =0 ; + rsb->rsb_pad2 =0 ; + +/* +* The metadata uuid is the fs uuid if the metauuid feature is not +* enabled. +*/ +if (dsb->sb_features_incompat & +cpu_to_be32 (XFS_SB_FEAT_INCOMPAT_META_UUID )) + meta_uuid = &dsb->sb_meta_uuid; +else + meta_uuid = &dsb->sb_uuid; +memcpy (&rsb->rsb_meta_uuid, meta_uuid,sizeof (rsb->rsb_meta_uuid)); +} + +/* +* Update the primary realtime superblock from a filesystem superblock and +* log it to the given transaction. +*/ +void +xfs_rtgroup_log_super ( +struct xfs_trans *tp, +const struct xfs_buf *sb_bp) +{ +struct xfs_buf *rtsb_bp; + +if (!xfs_has_rtgroups (tp->t_mountp)) +return ; + + rtsb_bp =xfs_trans_getrtsb (tp); +if (!rtsb_bp) { +/* +* It's possible for the rtgroups feature to be enabled but +* there is no incore rt superblock buffer if the rt geometry +* was specified at mkfs time but the rt section has not yet +* been attached. In this case, rblocks must be zero. +*/ +ASSERT (tp->t_mountp->m_sb.sb_rblocks ==0 ); +return ; + } + +xfs_rtgroup_update_super (rtsb_bp, sb_bp); +xfs_trans_ordered_buf (tp, rtsb_bp); +}
fs/xfs/libxfs/xfs_rtgroup.h +6 -0
@@ -208,8 +208,14 @@ xfs_daddr_to_rgbno(#ifdef CONFIG_XFS_RT xfs_rgblock_t xfs_rtgroup_block_count (struct xfs_mount *mp,xfs_rgnumber_t rgno); + +void xfs_rtgroup_update_super (struct xfs_buf *rtsb_bp, +const struct xfs_buf *sb_bp); +void xfs_rtgroup_log_super (struct xfs_trans *tp,const struct xfs_buf *sb_bp);#else # define xfs_rtgroup_block_count (mp, rgno) (0) +# define xfs_rtgroup_update_super (bp, sb_bp) ((void)0) +# define xfs_rtgroup_log_super (tp, sb_bp) ((void)0)#endif /* CONFIG_XFS_RT */ #endif /* __LIBXFS_RTGROUP_H */
fs/xfs/libxfs/xfs_sb.c +13 -0
@@ -27,6 +27,7 @@#include "xfs_ag.h" #include "xfs_rtbitmap.h" #include "xfs_swapext.h" +#include "xfs_rtgroup.h" /* * Physical superblock buffer manipulations. Shared with libxfs in userspace.
@@ -1161,6 +1162,8 @@ xfs_log_sb(xfs_sb_to_disk (bp->b_addr, &mp->m_sb);xfs_trans_buf_set_type (tp, bp,XFS_BLFT_SB_BUF );xfs_trans_log_buf (tp, bp,0 ,sizeof (struct xfs_dsb ) -1 ); + +xfs_rtgroup_log_super (tp, bp); }/*
@@ -1277,6 +1280,7 @@ xfs_sync_sb_buf( {struct xfs_trans *tp;struct xfs_buf *bp; +struct xfs_buf *rtsb_bp =NULL ;int error; error =xfs_trans_alloc (mp, &M_RES (mp)->tr_sb,0 ,0 ,0 , &tp);
@@ -1286,6 +1290,11 @@ xfs_sync_sb_buf( bp =xfs_trans_getsb (tp);xfs_log_sb (tp);xfs_trans_bhold (tp, bp); +if (xfs_has_rtgroups (mp)) { + rtsb_bp =xfs_trans_getrtsb (tp); +if (rtsb_bp) +xfs_trans_bhold (tp, rtsb_bp); + }xfs_trans_set_sync (tp); error =xfs_trans_commit (tp);if (error)
@@ -1294,7 +1303,11 @@ xfs_sync_sb_buf(* write out the sb buffer to get the changes to disk */ error =xfs_bwrite (bp); +if (!error && rtsb_bp) + error =xfs_bwrite (rtsb_bp); out: +if (rtsb_bp) +xfs_buf_relse (rtsb_bp);xfs_buf_relse (bp);return error; }
fs/xfs/xfs_buf_item_recover.c +18 -0
@@ -22,6 +22,7 @@#include "xfs_inode.h" #include "xfs_dir2.h" #include "xfs_quota.h" +#include "xfs_rtgroup.h" /* * This is the number of entries in the l_buf_cancel_table used during
@@ -995,6 +996,23 @@ xlog_recover_buf_commit_pass2(ASSERT (bp->b_mount == mp); bp->b_flags |= _XBF_LOGRECOVERY;xfs_buf_delwri_queue (bp, buffer_list); + +/* +* Update the primary rt super if we just recovered the primary +* fs super. +*/ +if (xfs_has_rtgroups (mp) && bp->b_ops == &xfs_sb_buf_ops) { +struct xfs_buf *rtsb_bp = mp->m_rtsb_bp; + +if (rtsb_bp) { +xfs_buf_lock (rtsb_bp); +xfs_buf_hold (rtsb_bp); +xfs_rtgroup_update_super (rtsb_bp, bp); + rtsb_bp->b_flags |= _XBF_LOGRECOVERY; +xfs_buf_delwri_queue (rtsb_bp, buffer_list); +xfs_buf_relse (rtsb_bp); + } + } } out_release:
fs/xfs/xfs_trans.c +10 -0
@@ -25,6 +25,7 @@#include "xfs_dquot.h" #include "xfs_icache.h" #include "xfs_rtbitmap.h" +#include "xfs_rtgroup.h" struct kmem_cache *xfs_trans_cache;
@@ -477,6 +478,7 @@ xfs_trans_apply_sb_deltas( {struct xfs_dsb *sbp;struct xfs_buf *bp; +bool update_rtsb = false;int whole =0 ; bp =xfs_trans_getsb (tp);
@@ -537,22 +539,27 @@ xfs_trans_apply_sb_deltas(if (tp->t_rextsize_delta) {be32_add_cpu (&sbp->sb_rextsize, tp->t_rextsize_delta); whole =1 ; + update_rtsb = true; }if (tp->t_rbmblocks_delta) {be32_add_cpu (&sbp->sb_rbmblocks, tp->t_rbmblocks_delta); whole =1 ; + update_rtsb = true; }if (tp->t_rblocks_delta) {be64_add_cpu (&sbp->sb_rblocks, tp->t_rblocks_delta); whole =1 ; + update_rtsb = true; }if (tp->t_rextents_delta) {be64_add_cpu (&sbp->sb_rextents, tp->t_rextents_delta); whole =1 ; + update_rtsb = true; }if (tp->t_rextslog_delta) { sbp->sb_rextslog += tp->t_rextslog_delta; whole =1 ; + update_rtsb = true; }xfs_trans_buf_set_type (tp, bp,XFS_BLFT_SB_BUF );
@@ -569,6 +576,9 @@ xfs_trans_apply_sb_deltas(xfs_trans_log_buf (tp, bp, offsetof(struct xfs_dsb , sb_icount), offsetof(struct xfs_dsb , sb_frextents) +sizeof (sbp->sb_frextents) -1 ); + +if (update_rtsb) +xfs_rtgroup_log_super (tp, bp); }/*
fs/xfs/xfs_trans.h +1 -0
@@ -212,6 +212,7 @@ xfs_trans_read_buf( }struct xfs_buf *xfs_trans_getsb (struct xfs_trans *); +struct xfs_buf *xfs_trans_getrtsb (struct xfs_trans *tp);void xfs_trans_brelse (xfs_trans_t *,struct xfs_buf *);void xfs_trans_bjoin (xfs_trans_t *,struct xfs_buf *);
fs/xfs/xfs_trans_buf.c +20 -5
@@ -168,12 +168,11 @@ xfs_trans_get_buf_map(/* * Get and lock the superblock buffer for the given transaction. */ -struct xfs_buf * -xfs_trans_getsb ( -struct xfs_trans *tp) +static struct xfs_buf * +__xfs_trans_getsb ( +struct xfs_trans *tp, +struct xfs_buf *bp) { -struct xfs_buf *bp = tp->t_mountp->m_sb_bp; -/* * Just increment the lock recursion count if the buffer is already * attached to this transaction.
@@ -197,6 +196,22 @@ xfs_trans_getsb(return bp; } +struct xfs_buf * +xfs_trans_getsb ( +struct xfs_trans *tp) +{ +return __xfs_trans_getsb (tp, tp->t_mountp->m_sb_bp); +} + +struct xfs_buf * +xfs_trans_getrtsb ( +struct xfs_trans *tp) +{ +if (!tp->t_mountp->m_rtsb_bp) +return NULL ; +return __xfs_trans_getsb (tp, tp->t_mountp->m_rtsb_bp); +} +/* * Get and lock the buffer for the caller if it is not already * locked within the given transaction. If it has not yet been
PATCH 6/24 xfs: write secondary realtime superblocks to disk
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create some library functions to make it easy to update all the secondary realtime superblocks on disk; this will be used by growfs, xfs_db, mkfs, and xfs_repair.
--- fs/xfs/libxfs/xfs_rtgroup.c | 117 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_rtgroup.h | 2 + 2 files changed, 119 insertions(+)
fs/xfs/libxfs/xfs_rtgroup.c +117 -0
@@ -419,3 +419,120 @@ xfs_rtgroup_log_super(xfs_rtgroup_update_super (rtsb_bp, sb_bp);xfs_trans_ordered_buf (tp, rtsb_bp); } + +/* Initialize a secondary realtime superblock. */ +static int +xfs_rtgroup_init_secondary_super ( +struct xfs_mount *mp, +xfs_rgnumber_t rgno, +struct xfs_buf **bpp) +{ +struct xfs_buf *bp; +struct xfs_rtsb *rsb; +xfs_rtblock_t rtbno; +int error; + +ASSERT (rgno !=0 ); + + error =xfs_buf_get_uncached (mp->m_rtdev_targp,XFS_FSB_TO_BB (mp,1 ), +0 , &bp); +if (error) +return error; + + rtbno =xfs_rgbno_to_rtb (mp, rgno,0 ); + bp->b_maps[0 ].bm_bn =xfs_rtb_to_daddr (mp, rtbno); + bp->b_ops = &xfs_rtsb_buf_ops; +xfs_buf_zero (bp,0 ,BBTOB (bp->b_length)); + + rsb = bp->b_addr; + rsb->rsb_magicnum =cpu_to_be32 (XFS_RTSB_MAGIC ); + rsb->rsb_blocksize =cpu_to_be32 (mp->m_sb.sb_blocksize); + rsb->rsb_rblocks =cpu_to_be64 (mp->m_sb.sb_rblocks); + + rsb->rsb_rextents =cpu_to_be64 (mp->m_sb.sb_rextents); + +memcpy (&rsb->rsb_uuid, &mp->m_sb.sb_uuid,sizeof (rsb->rsb_uuid)); + + rsb->rsb_rgcount =cpu_to_be32 (mp->m_sb.sb_rgcount); +memcpy (&rsb->rsb_fname, &mp->m_sb.sb_fname,XFSLABEL_MAX ); + + rsb->rsb_rextsize =cpu_to_be32 (mp->m_sb.sb_rextsize); + rsb->rsb_rbmblocks =cpu_to_be32 (mp->m_sb.sb_rbmblocks); + + rsb->rsb_rgblocks =cpu_to_be32 (mp->m_sb.sb_rgblocks); + rsb->rsb_blocklog = mp->m_sb.sb_blocklog; + rsb->rsb_sectlog = mp->m_sb.sb_sectlog; + rsb->rsb_rextslog = mp->m_sb.sb_rextslog; + +memcpy (&rsb->rsb_meta_uuid, &mp->m_sb.sb_meta_uuid, +sizeof (rsb->rsb_meta_uuid)); + + *bpp = bp; +return 0 ; +} + +/* +* Update all the realtime superblocks to match the new state of the primary. +* Because we are completely overwriting all the existing fields in the +* secondary superblock buffers, there is no need to read them in from disk. +* Just get a new buffer, stamp it and write it. +* +* The rt super buffers do not need to be kept them in memory once they are +* written so we mark them as a one-shot buffer. +*/ +int +xfs_rtgroup_update_secondary_sbs ( +struct xfs_mount *mp) +{ +LIST_HEAD (buffer_list); +struct xfs_rtgroup *rtg; +xfs_rgnumber_t start_rgno =1 ; +int saved_error =0 ; +int error =0 ; + +for_each_rtgroup_from (mp, start_rgno, rtg) { +struct xfs_buf *bp; + + error =xfs_rtgroup_init_secondary_super (mp, rtg->rtg_rgno, + &bp); +/* +* If we get an error reading or writing alternate superblocks, +* continue. If we break early, we'll leave more superblocks +* un-updated than updated. +*/ +if (error) { +xfs_warn (mp, +"error allocating secondary superblock for rt group %d" , + rtg->rtg_rgno); +if (!saved_error) + saved_error = error; +continue ; + } + +xfs_buf_oneshot (bp); +xfs_buf_delwri_queue (bp, &buffer_list); +xfs_buf_relse (bp); + +/* don't hold too many buffers at once */ +if (rtg->rtg_rgno %16 ) +continue ; + + error =xfs_buf_delwri_submit (&buffer_list); +if (error) { +xfs_warn (mp, +"write error %d updating a secondary superblock near rt group %u" , + error, rtg->rtg_rgno); +if (!saved_error) + saved_error = error; +continue ; + } + } + error =xfs_buf_delwri_submit (&buffer_list); +if (error) { +xfs_warn (mp, +"write error %d updating a secondary superblock near rt group %u" , + error, start_rgno); + } + +return saved_error ? saved_error : error; +}
fs/xfs/libxfs/xfs_rtgroup.h +2 -0
@@ -212,10 +212,12 @@ xfs_rgblock_t xfs_rtgroup_block_count(struct xfs_mount *mp,void xfs_rtgroup_update_super (struct xfs_buf *rtsb_bp,const struct xfs_buf *sb_bp);void xfs_rtgroup_log_super (struct xfs_trans *tp,const struct xfs_buf *sb_bp); +int xfs_rtgroup_update_secondary_sbs (struct xfs_mount *mp);#else # define xfs_rtgroup_block_count (mp, rgno) (0)# define xfs_rtgroup_update_super (bp, sb_bp) ((void)0)# define xfs_rtgroup_log_super (tp, sb_bp) ((void)0) +# define xfs_rtgroup_update_secondary_sbs (mp) (0)#endif /* CONFIG_XFS_RT */ #endif /* __LIBXFS_RTGROUP_H */
PATCH 7/24 xfs: grow the realtime section when realtime groups are enabled
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Enable growing the rt section when realtime groups are enabled.
--- fs/xfs/libxfs/xfs_shared.h | 1 fs/xfs/xfs_rtalloc.c | 136 +++++++++++++++++++++++++++++++++++++++++++- fs/xfs/xfs_trans.c | 10 +++ fs/xfs/xfs_trans.h | 1 4 files changed, 144 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_shared.h +1 -0
@@ -111,6 +111,7 @@ void xfs_log_get_max_trans_res(struct xfs_mount *mp,#define XFS_TRANS_SB_RBLOCKS 0x00000800#define XFS_TRANS_SB_REXTENTS 0x00001000#define XFS_TRANS_SB_REXTSLOG 0x00002000 +#define XFS_TRANS_SB_RGCOUNT 0x00004000/* * Here we centralize the specification of XFS meta-data buffer reference count
fs/xfs/xfs_rtalloc.c +132 -4
194 lines not on this page · raw message
fs/xfs/xfs_trans.c +10 -0
@@ -456,6 +456,10 @@ xfs_trans_mod_sb(case XFS_TRANS_SB_REXTSLOG : tp->t_rextslog_delta += delta;break ; +case XFS_TRANS_SB_RGCOUNT : +ASSERT (delta >0 ); + tp->t_rgcount_delta += delta; +break ;default :ASSERT (0 );return ;
@@ -561,6 +565,11 @@ xfs_trans_apply_sb_deltas( whole =1 ; update_rtsb = true; } +if (tp->t_rgcount_delta) { +be32_add_cpu (&sbp->sb_rgcount, tp->t_rgcount_delta); + whole =1 ; + update_rtsb = true; + }xfs_trans_buf_set_type (tp, bp,XFS_BLFT_SB_BUF );if (whole)
@@ -674,6 +683,7 @@ xfs_trans_unreserve_and_mod_sb( mp->m_sb.sb_rblocks += tp->t_rblocks_delta; mp->m_sb.sb_rextents += tp->t_rextents_delta; mp->m_sb.sb_rextslog += tp->t_rextslog_delta; + mp->m_sb.sb_rgcount += tp->t_rgcount_delta;spin_unlock (&mp->m_sb_lock);/*
fs/xfs/xfs_trans.h +1 -0
@@ -146,6 +146,7 @@ typedef struct xfs_trans {int64_t t_rblocks_delta;/* superblock rblocks change */ int64_t t_rextents_delta;/* superblocks rextents chg */ int64_t t_rextslog_delta;/* superblocks rextslog chg */ +int64_t t_rgcount_delta;/* realtime group count */ struct list_head t_items;/* log item descriptors */ struct list_head t_busy;/* list of busy extents */ struct list_head t_dfops;/* deferred operations */
PATCH 8/24 xfs: always update secondary rt supers when we update secondary fs supers
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Make sure that any update to the secondary superblocks in the data section are also echoed to the secondary superblocks in the realtime section.
--- fs/xfs/xfs_fsops.c | 4 ++++ fs/xfs/xfs_ioctl.c | 3 +++ 2 files changed, 7 insertions(+)
fs/xfs/xfs_fsops.c +4 -0
@@ -21,6 +21,7 @@#include "xfs_ag.h" #include "xfs_ag_resv.h" #include "xfs_trace.h" +#include "xfs_rtgroup.h" /* * Write new AG headers to disk. Non-transactional, but need to be
@@ -319,6 +320,9 @@ xfs_growfs_data(/* Update secondary superblocks now the physical grow has completed */ error =xfs_update_secondary_sbs (mp); +if (error) + goto out_error; + error =xfs_rtgroup_update_secondary_sbs (mp); out_error:/*
fs/xfs/xfs_ioctl.c +3 -0
@@ -42,6 +42,7 @@#include "xfs_rtbitmap.h" #include "xfs_xchgrange.h" #include "xfs_file.h" +#include "xfs_rtgroup.h" #include <linux/mount.h> #include <linux/namei.h>
@@ -1874,6 +1875,8 @@ xfs_ioc_setlabel(*/ mutex_lock (&mp->m_growlock); error =xfs_update_secondary_sbs (mp); +if (!error) + error =xfs_rtgroup_update_secondary_sbs (mp);mutex_unlock (&mp->m_growlock);invalidate_bdev (bdev);
PATCH 9/24 xfs: export realtime group geometry via XFS_FSOP_GEOM
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Export the realtime geometry information so that userspace can query it.
--- fs/xfs/libxfs/xfs_fs.h | 4 +++- fs/xfs/libxfs/xfs_sb.c | 5 +++++ 2 files changed, 8 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_fs.h +3 -1
@@ -186,7 +186,9 @@ struct xfs_fsop_geom {__u32 logsunit;/* log stripe unit, bytes */ uint32_t sick;/* o: unhealthy fs & rt metadata */ uint32_t checked;/* o: checked fs & rt metadata */ -__u64 reserved[17 ];/* reserved space */ +__u32 rgblocks;/* rtblocks in a realtime group */ +__u32 rgcount;/* number of realtime groups */ +__u64 reserved[16 ];/* reserved space */ };#define XFS_FSOP_GEOM_SICK_COUNTERS (1 << 0)/* summary counters */
fs/xfs/libxfs/xfs_sb.c +5 -0
@@ -1411,6 +1411,11 @@ xfs_fs_geometry(return ; geo->version =XFS_FSOP_GEOM_VERSION_V5 ; + +if (xfs_has_rtgroups (mp)) { + geo->rgcount = sbp->sb_rgcount; + geo->rgblocks = sbp->sb_rgblocks; + } }/* Read a secondary superblock. */
PATCH 10/24 xfs: check that rtblock extents do not overlap with the rt group metadata
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The ondisk format specifies that the start of each realtime group must have a superblock so that rt space mappings never cross an rtgroup boundary. Check that rt block pointers obey this.
--- fs/xfs/libxfs/xfs_types.c | 46 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 44 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_types.c +44 -2
@@ -13,6 +13,8 @@#include "xfs_mount.h" #include "xfs_ag.h" #include "xfs_imeta.h" +#include "xfs_rtbitmap.h" +#include "xfs_rtgroup.h" /*
@@ -133,6 +135,26 @@ xfs_verify_dir_ino(return xfs_verify_ino (mp, ino); } +/* +* Verify that an rtgroup block number pointer neither points outside the +* rtgroup nor points at static metadata. +*/ +static inline bool +xfs_verify_rgno_rgbno ( +struct xfs_mount *mp, +xfs_rgnumber_t rgno, +xfs_rgblock_t rgbno) +{ +xfs_rgblock_t eorg; + + eorg =xfs_rtgroup_block_count (mp, rgno); +if (rgbno >= eorg) +return false; +if (rgbno < mp->m_sb.sb_rextsize) +return false; +return true; +} +/* * Verify that an realtime block number pointer doesn't point off the * end of the realtime device.
@@ -142,7 +164,20 @@ xfs_verify_rtbno( struct xfs_mount *mp, xfs_rtblock_t rtbno) { -return rtbno < mp->m_sb.sb_rblocks; +xfs_rgnumber_t rgno; +xfs_rgblock_t rgbno; + +if (rtbno >= mp->m_sb.sb_rblocks) +return false; + +if (!xfs_has_rtgroups (mp)) +return true; + + rgbno =xfs_rtb_to_rgbno (mp, rtbno, &rgno); +if (rgno >= mp->m_sb.sb_rgcount) +return false; + +return xfs_verify_rgno_rgbno (mp, rgno, rgbno); }/* Verify that a realtime device extent is fully contained inside the volume. */
@@ -158,7 +193,14 @@ xfs_verify_rtbext(if (!xfs_verify_rtbno (mp, rtbno))return false; -return xfs_verify_rtbno (mp, rtbno + len -1 ); +if (!xfs_verify_rtbno (mp, rtbno + len -1 )) +return false; + +if (xfs_has_rtgroups (mp) && +xfs_rtb_to_rgno (mp, rtbno) !=xfs_rtb_to_rgno (mp, rtbno + len -1 )) +return false; + +return true; }/* Calculate the range of valid icount values. */
PATCH 11/24 xfs: add frextents to the lazysbcounters when rtgroups enabled
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Make the free rt extent count a part of the lazy sb counters when the realtime groups feature is enabled. This is possible because the patch to recompute frextents from the rtbitmap during log recovery predates the code adding rtgroup support, hence we know that the value will always be correct during runtime.
--- fs/xfs/libxfs/xfs_sb.c | 5 +++++ fs/xfs/xfs_trans.c | 18 +++++++++++++++--- 2 files changed, 20 insertions(+), 3 deletions(-)
fs/xfs/libxfs/xfs_sb.c +5 -0
@@ -1150,6 +1150,9 @@ xfs_log_sb(* sb counters, despite having a percpu counter. It is always kept * consistent with the ondisk rtbitmap by xfs_trans_apply_sb_deltas() * and hence we don't need have to update it here. +* +* sb_frextents was added to the lazy sb counters when the rt groups +* feature was introduced. */ if (xfs_has_lazysbcount (mp)) { mp->m_sb.sb_icount =percpu_counter_sum (&mp->m_icount);
@@ -1158,6 +1161,8 @@ xfs_log_sb( mp->m_sb.sb_icount); mp->m_sb.sb_fdblocks =percpu_counter_sum (&mp->m_fdblocks); } +if (xfs_has_rtgroups (mp)) + mp->m_sb.sb_frextents =percpu_counter_sum (&mp->m_frextents);xfs_sb_to_disk (bp->b_addr, &mp->m_sb);xfs_trans_buf_set_type (tp, bp,XFS_BLFT_SB_BUF );
fs/xfs/xfs_trans.c +15 -3
@@ -421,6 +421,8 @@ xfs_trans_mod_sb(ASSERT (tp->t_rtx_res_used <= tp->t_rtx_res); } tp->t_frextents_delta += delta; +if (xfs_has_rtgroups (mp)) + flags &= ~XFS_TRANS_SB_DIRTY ;break ;case XFS_TRANS_SB_RES_FREXTENTS :/*
@@ -515,8 +517,14 @@ xfs_trans_apply_sb_deltas(* * Don't touch m_frextents because it includes incore reservations, * and those are handled by the unreserve function. +* +* sb_frextents was added to the lazy sb counters when the rt groups +* feature was introduced. This is possible because we know that all +* kernels supporting rtgroups will also recompute frextents from the +* realtime bitmap. */ -if (tp->t_frextents_delta || tp->t_res_frextents_delta) { +if ((tp->t_frextents_delta || tp->t_res_frextents_delta) && + !xfs_has_rtgroups (tp->t_mountp)) {struct xfs_mount *mp = tp->t_mountp;int64_t rtxdelta;
@@ -630,7 +638,8 @@ xfs_trans_unreserve_and_mod_sb(if (tp->t_rtx_res >0 ) rtxdelta = tp->t_rtx_res;if ((tp->t_frextents_delta !=0 ) && - (tp->t_flags &XFS_TRANS_SB_DIRTY )) + (xfs_has_rtgroups (mp) || + (tp->t_flags &XFS_TRANS_SB_DIRTY ))) rtxdelta += tp->t_frextents_delta; if (xfs_has_lazysbcount(mp) ||
@@ -669,8 +678,11 @@ xfs_trans_unreserve_and_mod_sb(* Do not touch sb_frextents here because we are dealing with incore * reservation. sb_frextents is not part of the lazy sb counters so it * must be consistent with the ondisk rtbitmap and must never include -* incore reservations. +* incore reservations. sb_frextents was added to the lazy sb counters +* when the realtime groups feature was introduced. */ +if (xfs_has_rtgroups (mp)) + mp->m_sb.sb_frextents += rtxdelta; mp->m_sb.sb_dblocks += tp->t_dblocks_delta; mp->m_sb.sb_agcount += tp->t_agcount_delta; mp->m_sb.sb_imax_pct += tp->t_imaxpct_delta;
PATCH 12/24 xfs: record rt group superblock errors in the health system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Record the state of per-rtgroup metadata sickness in the rtgroup structure for later reporting.
--- fs/xfs/libxfs/xfs_health.h | 28 ++++++++++++++ fs/xfs/libxfs/xfs_rtgroup.h | 8 ++++ fs/xfs/scrub/health.c | 24 ++++++++++++ fs/xfs/xfs_health.c | 86 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_trace.h | 25 +++++++++++++ 5 files changed, 170 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_health.h +27 -1
@@ -52,6 +52,7 @@ struct xfs_inode;struct xfs_fsop_geom ;struct xfs_btree_cur ;struct xfs_da_args ; +struct xfs_rtgroup ;/* Observable health issues for metadata spanning the entire filesystem. */ #define XFS_SICK_FS_COUNTERS (1 << 0)/* summary counters */
@@ -66,6 +67,7 @@ struct xfs_da_args;/* Observable health issues for realtime volume metadata. */ #define XFS_SICK_RT_BITMAP (1 << 0)/* realtime bitmap */ #define XFS_SICK_RT_SUMMARY (1 << 1)/* realtime summary */ +#define XFS_SICK_RT_SUPER (1 << 2)/* rt group superblock */ /* Observable health issues for AG metadata. */ #define XFS_SICK_AG_SB (1 << 0)/* superblock */
@@ -110,7 +112,8 @@ struct xfs_da_args; XFS_SICK_FS_METAPATH)#define XFS_SICK_RT_PRIMARY (XFS_SICK_RT_BITMAP | \ - XFS_SICK_RT_SUMMARY) + XFS_SICK_RT_SUMMARY | \ + XFS_SICK_RT_SUPER)#define XFS_SICK_AG_PRIMARY (XFS_SICK_AG_SB | \ XFS_SICK_AG_AGF | \
@@ -192,6 +195,14 @@ void xfs_rt_mark_healthy(struct xfs_mount *mp, unsigned int mask);void xfs_rt_measure_sickness (struct xfs_mount *mp,unsigned int *sick,unsigned int *checked); +void xfs_rgno_mark_sick (struct xfs_mount *mp,xfs_rgnumber_t rgno, +unsigned int mask); +void xfs_rtgroup_mark_sick (struct xfs_rtgroup *rtg,unsigned int mask); +void xfs_rtgroup_mark_checked (struct xfs_rtgroup *rtg,unsigned int mask); +void xfs_rtgroup_mark_healthy (struct xfs_rtgroup *rtg,unsigned int mask); +void xfs_rtgroup_measure_sickness (struct xfs_rtgroup *rtg,unsigned int *sick, +unsigned int *checked); +void xfs_agno_mark_sick (struct xfs_mount *mp,xfs_agnumber_t agno,unsigned int mask);void xfs_ag_mark_sick (struct xfs_perag *pag,unsigned int mask);
@@ -241,6 +252,15 @@ xfs_ag_has_sickness(struct xfs_perag *pag, unsigned int mask)return sick & mask; } +static inline bool +xfs_rtgroup_has_sickness (struct xfs_rtgroup *rtg,unsigned int mask) +{ +unsigned int sick, checked; + +xfs_rtgroup_measure_sickness (rtg, &sick, &checked); +return sick & mask; +} +static inline bool xfs_inode_has_sickness (struct xfs_inode *ip,unsigned int mask) {
@@ -262,6 +282,12 @@ xfs_rt_is_healthy(struct xfs_mount *mp)return !xfs_rt_has_sickness (mp,-1U ); } +static inline bool +xfs_rtgroup_is_healthy (struct xfs_rtgroup *rtg) +{ +return !xfs_rtgroup_has_sickness (rtg,-1U ); +} +static inline bool xfs_ag_is_healthy (struct xfs_perag *pag) {
fs/xfs/libxfs/xfs_rtgroup.h +8 -0
@@ -25,6 +25,14 @@ struct xfs_rtgroup {/* Number of blocks in this group */ xfs_rgblock_t rtg_blockcount; +/* +* Bitsets of per-rtgroup metadata that have been checked and/or are +* sick. Callers should hold rtg_state_lock before accessing this +* field. +*/ +uint16_t rtg_checked; +uint16_t rtg_sick; +#ifdef __KERNEL__/* -- kernel only structures below this line -- */ spinlock_t rtg_state_lock;
fs/xfs/scrub/health.c +24 -0
@@ -14,6 +14,7 @@#include "xfs_mount.h" #include "xfs_ag.h" #include "xfs_health.h" +#include "xfs_rtgroup.h" #include "scrub/scrub.h" #include "scrub/health.h" #include "scrub/common.h"
@@ -76,6 +77,7 @@ enum xchk_health_group {XHG_RT ,XHG_AG ,XHG_INO , + XHG_RTGROUP, }; struct xchk_health_map {
@@ -164,12 +166,16 @@ xchk_mark_all_healthy( struct xfs_mount *mp) {struct xfs_perag *pag; +struct xfs_rtgroup *rtg;xfs_agnumber_t agno; +xfs_rgnumber_t rgno;xfs_fs_mark_healthy (mp,XFS_SICK_FS_INDIRECT );xfs_rt_mark_healthy (mp,XFS_SICK_RT_INDIRECT );for_each_perag (mp, agno, pag)xfs_ag_mark_healthy (pag,XFS_SICK_AG_INDIRECT ); +for_each_rtgroup (mp, rgno, rtg) +xfs_rtgroup_mark_healthy (rtg,XFS_SICK_RT_INDIRECT ); }/*
@@ -187,6 +193,7 @@ xchk_update_health( struct xfs_scrub *sc) {struct xfs_perag *pag; +struct xfs_rtgroup *rtg;bool bad;/*
@@ -249,6 +256,15 @@ xchk_update_health( }else xfs_rt_mark_healthy (sc->mp, sc->sick_mask);break ; +case XHG_RTGROUP : + rtg =xfs_rtgroup_get (sc->mp, sc->sm->sm_agno); +if (bad) { +xfs_rtgroup_mark_sick (rtg, sc->sick_mask); +xfs_rtgroup_mark_checked (rtg, sc->sick_mask); + }else +xfs_rtgroup_mark_healthy (rtg, sc->sick_mask); +xfs_rtgroup_put (rtg); +break ;default :ASSERT (0 );break ;
@@ -336,7 +352,9 @@ xchk_health_record( {struct xfs_mount *mp = sc->mp;struct xfs_perag *pag; +struct xfs_rtgroup *rtg;xfs_agnumber_t agno; +xfs_rgnumber_t rgno;unsigned int sick;unsigned int checked;
@@ -355,5 +373,11 @@ xchk_health_record(xchk_set_corrupt (sc); } +for_each_rtgroup (mp, rgno, rtg) { +xfs_rtgroup_measure_sickness (rtg, &sick, &checked); +if (sick &XFS_SICK_RT_PRIMARY ) +xchk_set_corrupt (sc); + } +return 0 ; }
fs/xfs/xfs_health.c +86 -0
111 lines not on this page · raw message
fs/xfs/xfs_trace.h +25 -0
@@ -4307,6 +4307,31 @@ DEFINE_AG_CORRUPT_EVENT(xfs_ag_mark_sick);DEFINE_AG_CORRUPT_EVENT (xfs_ag_mark_healthy);DEFINE_AG_CORRUPT_EVENT (xfs_ag_unfixed_corruption); +DECLARE_EVENT_CLASS (xfs_rtgroup_corrupt_class, + TP_PROTO(struct xfs_rtgroup *rtg, unsigned int flags), +TP_ARGS (rtg, flags), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_rgnumber_t, rgno) + __field(unsigned int, flags) + ), +TP_fast_assign ( + __entry->dev = rtg->rtg_mount->m_super->s_dev; + __entry->rgno = rtg->rtg_rgno; + __entry->flags = flags; + ), +TP_printk ("dev %d:%d rgno 0x%x flags 0x%x" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->rgno, __entry->flags) +); +#define DEFINE_RTGROUP_CORRUPT_EVENT (name) \ +DEFINE_EVENT(xfs_rtgroup_corrupt_class, name, \ + TP_PROTO(struct xfs_rtgroup *rtg, unsigned int flags), \ + TP_ARGS(rtg, flags)) +DEFINE_RTGROUP_CORRUPT_EVENT (xfs_rtgroup_mark_sick); +DEFINE_RTGROUP_CORRUPT_EVENT (xfs_rtgroup_mark_healthy); +DEFINE_RTGROUP_CORRUPT_EVENT (xfs_rtgroup_unfixed_corruption); + DECLARE_EVENT_CLASS(xfs_inode_corrupt_class, TP_PROTO(struct xfs_inode *ip, unsigned int flags), TP_ARGS(ip, flags),
PATCH 13/24 xfs: define locking primitives for realtime groups
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Define helper functions to lock all metadata inodes related to a realtime group. There's not much to look at now, but this will become important when we add per-rtgroup metadata files and online fsck code for them.
--- fs/xfs/libxfs/xfs_rtgroup.c | 33 +++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_rtgroup.h | 14 ++++++++++++++ 2 files changed, 47 insertions(+)
fs/xfs/libxfs/xfs_rtgroup.c +33 -0
@@ -536,3 +536,36 @@ xfs_rtgroup_update_secondary_sbs(return saved_error ? saved_error : error; } + +/* Lock metadata inodes associated with this rt group. */ +void +xfs_rtgroup_lock ( +struct xfs_trans *tp, +struct xfs_rtgroup *rtg, +unsigned int rtglock_flags) +{ +ASSERT (!(rtglock_flags & ~XFS_RTGLOCK_ALL_FLAGS )); +ASSERT (!(rtglock_flags &XFS_RTGLOCK_BITMAP_SHARED ) || + !(rtglock_flags &XFS_RTGLOCK_BITMAP )); + +if (rtglock_flags &XFS_RTGLOCK_BITMAP ) +xfs_rtbitmap_lock (tp, rtg->rtg_mount); +else if (rtglock_flags &XFS_RTGLOCK_BITMAP_SHARED ) +xfs_rtbitmap_lock_shared (rtg->rtg_mount,XFS_RBMLOCK_BITMAP ); +} + +/* Unlock metadata inodes associated with this rt group. */ +void +xfs_rtgroup_unlock ( +struct xfs_rtgroup *rtg, +unsigned int rtglock_flags) +{ +ASSERT (!(rtglock_flags & ~XFS_RTGLOCK_ALL_FLAGS )); +ASSERT (!(rtglock_flags &XFS_RTGLOCK_BITMAP_SHARED ) || + !(rtglock_flags &XFS_RTGLOCK_BITMAP )); + +if (rtglock_flags &XFS_RTGLOCK_BITMAP ) +xfs_rtbitmap_unlock (rtg->rtg_mount); +else if (rtglock_flags &XFS_RTGLOCK_BITMAP_SHARED ) +xfs_rtbitmap_unlock_shared (rtg->rtg_mount,XFS_RBMLOCK_BITMAP ); +}
fs/xfs/libxfs/xfs_rtgroup.h +14 -0
@@ -221,11 +221,25 @@ void xfs_rtgroup_update_super(struct xfs_buf *rtsb_bp, const struct xfs_buf *sb_bp);void xfs_rtgroup_log_super (struct xfs_trans *tp,const struct xfs_buf *sb_bp);int xfs_rtgroup_update_secondary_sbs (struct xfs_mount *mp); + +/* Lock the rt bitmap inode in exclusive mode */ +#define XFS_RTGLOCK_BITMAP (1U << 0) +/* Lock the rt bitmap inode in shared mode */ +#define XFS_RTGLOCK_BITMAP_SHARED (1U << 1) + +#define XFS_RTGLOCK_ALL_FLAGS (XFS_RTGLOCK_BITMAP | \ + XFS_RTGLOCK_BITMAP_SHARED) + +void xfs_rtgroup_lock (struct xfs_trans *tp,struct xfs_rtgroup *rtg, +unsigned int rtglock_flags); +void xfs_rtgroup_unlock (struct xfs_rtgroup *rtg,unsigned int rtglock_flags);#else # define xfs_rtgroup_block_count (mp, rgno) (0)# define xfs_rtgroup_update_super (bp, sb_bp) ((void)0)# define xfs_rtgroup_log_super (tp, sb_bp) ((void)0)# define xfs_rtgroup_update_secondary_sbs (mp) (0) +# define xfs_rtgroup_lock (tp, rtg, gf) ((void)0) +# define xfs_rtgroup_unlock (rtg, gf) ((void)0)#endif /* CONFIG_XFS_RT */ #endif /* __LIBXFS_RTGROUP_H */
PATCH 14/24 xfs: export the geometry of realtime groups to userspace
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create an ioctl so that the kernel can report the status of realtime groups to userspace.
--- fs/xfs/libxfs/xfs_fs.h | 1 + fs/xfs/libxfs/xfs_fs_staging.h | 17 +++++++++++++++++ fs/xfs/libxfs/xfs_health.h | 2 ++ fs/xfs/libxfs/xfs_rtgroup.c | 14 ++++++++++++++ fs/xfs/libxfs/xfs_rtgroup.h | 4 ++++ fs/xfs/xfs_health.c | 28 ++++++++++++++++++++++++++++ fs/xfs/xfs_ioctl.c | 32 ++++++++++++++++++++++++++++++++ 7 files changed, 98 insertions(+)
fs/xfs/libxfs/xfs_fs.h +1 -0
@@ -852,6 +852,7 @@ struct xfs_scrub_metadata {/* XFS_IOC_SCRUBV_METADATA -- staging 60 */ #define XFS_IOC_AG_GEOMETRY _IOWR('X', 61, struct xfs_ag_geometry)/* XFS_IOC_GETPARENTS ---- staging 62 */ +/* XFS_IOC_RTGROUP_GEOMETRY - staging 63 */ /* * ioctl commands that replace IRIX syssgi()'s
fs/xfs/libxfs/xfs_fs_staging.h +17 -0
@@ -202,4 +202,21 @@ static inline size_t sizeof_xfs_scrub_vec(unsigned int nr)#define XFS_IOC_SCRUBV_METADATA _IOWR('X', 60, struct xfs_scrub_vec_head) +/* +* Output for XFS_IOC_RTGROUP_GEOMETRY +*/ +struct xfs_rtgroup_geometry { +__u32 rg_number;/* i/o: rtgroup number */ +__u32 rg_length;/* o: length in blocks */ +__u32 rg_sick;/* o: sick things in ag */ +__u32 rg_checked;/* o: checked metadata in ag */ +__u32 rg_flags;/* i/o: flags for this ag */ +__u32 rg_pad;/* o: zero */ +__u64 rg_reserved[13 ];/* o: zero */ +}; +#define XFS_RTGROUP_GEOM_SICK_SUPER (1 << 0)/* superblock */ +#define XFS_RTGROUP_GEOM_SICK_BITMAP (1 << 1)/* rtbitmap for this group */ + +#define XFS_IOC_RTGROUP_GEOMETRY _IOWR('X', 63, struct xfs_rtgroup_geometry) +#endif /* __XFS_FS_STAGING_H__ */
fs/xfs/libxfs/xfs_health.h +2 -0
@@ -302,6 +302,8 @@ xfs_inode_is_healthy(struct xfs_inode *ip)void xfs_fsop_geom_health (struct xfs_mount *mp,struct xfs_fsop_geom *geo);void xfs_ag_geom_health (struct xfs_perag *pag,struct xfs_ag_geometry *ageo); +void xfs_rtgroup_geom_health (struct xfs_rtgroup *rtg, +struct xfs_rtgroup_geometry *rgeo);void xfs_bulkstat_health (struct xfs_inode *ip,struct xfs_bulkstat *bs);#define xfs_metadata_is_sick (error) \
fs/xfs/libxfs/xfs_rtgroup.c +14 -0
@@ -569,3 +569,17 @@ xfs_rtgroup_unlock(else if (rtglock_flags &XFS_RTGLOCK_BITMAP_SHARED )xfs_rtbitmap_unlock_shared (rtg->rtg_mount,XFS_RBMLOCK_BITMAP ); } + +/* Retrieve rt group geometry. */ +int +xfs_rtgroup_get_geometry ( +struct xfs_rtgroup *rtg, +struct xfs_rtgroup_geometry *rgeo) +{ +/* Fill out form. */ +memset (rgeo,0 ,sizeof (*rgeo)); + rgeo->rg_number = rtg->rtg_rgno; + rgeo->rg_length = rtg->rtg_blockcount; +xfs_rtgroup_geom_health (rtg, rgeo); +return 0 ; +}
fs/xfs/libxfs/xfs_rtgroup.h +4 -0
@@ -233,6 +233,9 @@ int xfs_rtgroup_update_secondary_sbs(struct xfs_mount *mp);void xfs_rtgroup_lock (struct xfs_trans *tp,struct xfs_rtgroup *rtg,unsigned int rtglock_flags);void xfs_rtgroup_unlock (struct xfs_rtgroup *rtg,unsigned int rtglock_flags); + +int xfs_rtgroup_get_geometry (struct xfs_rtgroup *rtg, +struct xfs_rtgroup_geometry *rgeo);#else # define xfs_rtgroup_block_count (mp, rgno) (0)# define xfs_rtgroup_update_super (bp, sb_bp) ((void)0)
@@ -240,6 +243,7 @@ void xfs_rtgroup_unlock(struct xfs_rtgroup *rtg, unsigned int rtglock_flags);# define xfs_rtgroup_update_secondary_sbs (mp) (0)# define xfs_rtgroup_lock (tp, rtg, gf) ((void)0)# define xfs_rtgroup_unlock (rtg, gf) ((void)0) +# define xfs_rtgroup_get_geometry (rtg, rgeo) (-EOPNOTSUPP)#endif /* CONFIG_XFS_RT */ #endif /* __LIBXFS_RTGROUP_H */
fs/xfs/xfs_health.c +28 -0
@@ -529,6 +529,34 @@ xfs_ag_geom_health( } } +static const struct ioctl_sick_map rtgroup_map[] = { + {XFS_SICK_RT_SUPER ,XFS_RTGROUP_GEOM_SICK_SUPER }, + {XFS_SICK_RT_BITMAP ,XFS_RTGROUP_GEOM_SICK_BITMAP }, + {0 ,0 }, +}; + +/* Fill out rtgroup geometry health info. */ +void +xfs_rtgroup_geom_health ( +struct xfs_rtgroup *rtg, +struct xfs_rtgroup_geometry *rgeo) +{ +const struct ioctl_sick_map *m; +unsigned int sick; +unsigned int checked; + + rgeo->rg_sick =0 ; + rgeo->rg_checked =0 ; + +xfs_rtgroup_measure_sickness (rtg, &sick, &checked); +for (m = rtgroup_map; m->sick_mask; m++) { +if (checked & m->sick_mask) + rgeo->rg_checked |= m->ioctl_mask; +if (sick & m->sick_mask) + rgeo->rg_sick |= m->ioctl_mask; + } +} +static const struct ioctl_sick_map ino_map[] = { {XFS_SICK_INO_CORE ,XFS_BS_SICK_INODE }, {XFS_SICK_INO_BMBTD ,XFS_BS_SICK_BMBTD },
fs/xfs/xfs_ioctl.c +32 -0
@@ -995,6 +995,36 @@ xfs_ioc_ag_geometry(return 0 ; } +STATIC int +xfs_ioc_rtgroup_geometry ( +struct xfs_mount *mp, +void __user *arg) +{ +struct xfs_rtgroup *rtg; +struct xfs_rtgroup_geometry rgeo; +int error; + +if (copy_from_user (&rgeo, arg,sizeof (rgeo))) +return -EFAULT ; +if (rgeo.rg_flags || rgeo.rg_pad) +return -EINVAL ; +if (memchr_inv (&rgeo.rg_reserved,0 ,sizeof (rgeo.rg_reserved))) +return -EINVAL ; + + rtg =xfs_rtgroup_get (mp, rgeo.rg_number); +if (!rtg) +return -EINVAL ; + + error =xfs_rtgroup_get_geometry (rtg, &rgeo); +xfs_rtgroup_put (rtg); +if (error) +return error; + +if (copy_to_user (arg, &rgeo,sizeof (rgeo))) +return -EFAULT ; +return 0 ; +} +/* * Linux extended inode flags interface. */
@@ -2081,6 +2111,8 @@ xfs_file_ioctl(case XFS_IOC_AG_GEOMETRY :return xfs_ioc_ag_geometry (mp, arg); +case XFS_IOC_RTGROUP_GEOMETRY : +return xfs_ioc_rtgroup_geometry (mp, arg);case XFS_IOC_GETVERSION :return put_user (inode->i_generation, (int __user *)arg);
PATCH 15/24 xfs: add block headers to realtime bitmap blocks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Upgrade rtbitmap blocks to have self describing metadata like most every other thing in XFS.
--- fs/xfs/libxfs/xfs_format.h | 14 +++++ fs/xfs/libxfs/xfs_ondisk.h | 1 fs/xfs/libxfs/xfs_rtbitmap.c | 108 ++++++++++++++++++++++++++++++++++++++--- fs/xfs/libxfs/xfs_rtbitmap.h | 33 ++++++++++++- fs/xfs/libxfs/xfs_sb.c | 18 +++++-- fs/xfs/libxfs/xfs_shared.h | 1 fs/xfs/xfs_buf_item_recover.c | 20 +++++++- fs/xfs/xfs_mount.h | 3 + fs/xfs/xfs_rtalloc.c | 60 ++++++++++++++++------- 9 files changed, 224 insertions(+), 34 deletions(-)
fs/xfs/libxfs/xfs_format.h +14 -0
@@ -1300,6 +1300,20 @@ static inline bool xfs_dinode_has_large_extent_counts(/* * RT bit manipulation macros. */ +#define XFS_RTBITMAP_MAGIC 0x424D505A/* BMPZ */ + +struct xfs_rtbuf_blkinfo { +__be32 rt_magic;/* validity check on block */ +__be32 rt_crc;/* CRC of block */ +__be64 rt_owner;/* inode that owns the block */ +__be64 rt_blkno;/* first block of the buffer */ +__be64 rt_lsn;/* sequence number of last write */ +uuid_t rt_uuid;/* filesystem we belong to */ +}; + +#define XFS_RTBUF_CRC_OFF \ + offsetof(struct xfs_rtbuf_blkinfo, rt_crc) +#define XFS_RTMIN (a,b) ((a) < (b) ? (a) : (b))#define XFS_RTMAX (a,b) ((a) > (b) ? (a) : (b))
fs/xfs/libxfs/xfs_ondisk.h +1 -0
@@ -76,6 +76,7 @@ xfs_check_ondisk_structs(void)/* realtime structures */ XFS_CHECK_STRUCT_SIZE(union xfs_rtword_raw, 4); XFS_CHECK_STRUCT_SIZE(union xfs_suminfo_raw, 4); + XFS_CHECK_STRUCT_SIZE(struct xfs_rtbuf_blkinfo, 48);/* * m68k has problems with xfs_attr_leaf_name_remote_t, but we pad it to
fs/xfs/libxfs/xfs_rtbitmap.c +99 -9
159 lines not on this page · raw message
fs/xfs/libxfs/xfs_rtbitmap.h +32 -1
@@ -148,6 +148,9 @@ xfs_rtx_to_rbmblock( struct xfs_mount *mp, xfs_rtxnum_t rtx) { + if (xfs_has_rtgroups(mp)) + return div_u64(rtx, mp->m_rtx_per_rbmblock); +return rtx >> mp->m_blkbit_log; }
@@ -157,6 +160,13 @@ xfs_rtx_to_rbmword( struct xfs_mount *mp, xfs_rtxnum_t rtx) { + if (xfs_has_rtgroups(mp)) { +unsigned int mod; + +div_u64_rem (rtx >>XFS_NBWORDLOG , mp->m_blockwsize, &mod); +return mod; + } +return (rtx >>XFS_NBWORDLOG ) & (mp->m_blockwsize -1 ); }
@@ -166,6 +176,9 @@ xfs_rbmblock_to_rtx( struct xfs_mount *mp, xfs_fileoff_t rbmoff) { + if (xfs_has_rtgroups(mp)) + return rbmoff * mp->m_rtx_per_rbmblock; +return rbmoff << mp->m_blkbit_log; }
@@ -175,7 +188,14 @@ xfs_rbmblock_wordptr( struct xfs_rtalloc_args *args, unsigned int index) { -union xfs_rtword_raw *words = args->rbmbp->b_addr; +struct xfs_mount *mp = args->mp; +union xfs_rtword_raw *words; +struct xfs_rtbuf_blkinfo *hdr = args->rbmbp->b_addr; + +if (xfs_has_rtgroups (mp)) + words = (union xfs_rtword_raw *)(hdr +1 ); +else + words = args->rbmbp->b_addr;return words + index; }
@@ -277,6 +297,16 @@ xfs_suminfo_add(return info->old; } +static inline const struct xfs_buf_ops * +xfs_rtblock_ops ( +struct xfs_mount *mp, +bool issum) +{ +if (xfs_has_rtgroups (mp) && !issum) +return &xfs_rtbitmap_buf_ops; +return &xfs_rtbuf_ops; +} +/* * Functions for walking free space rtextents in the realtime bitmap. */
@@ -365,6 +395,7 @@ xfs_validate_rtextents(return true; } +xfs_rtxnum_t xfs_rtbitmap_rtx_per_rbmblock (struct xfs_mount *mp);xfs_filblks_t xfs_rtbitmap_blockcount (struct xfs_mount *mp,xfs_rtbxlen_t rtextents); unsigned long long xfs_rtbitmap_wordcount(struct xfs_mount *mp,
fs/xfs/libxfs/xfs_sb.c +14 -4
@@ -577,10 +577,15 @@ xfs_validate_sb_common( }else {uint64_t rexts;uint64_t rbmblocks; +unsigned int rbmblock_bytes = sbp->sb_blocksize; rexts =div_u64 (sbp->sb_rblocks, sbp->sb_rextsize); - rbmblocks =howmany_64 (sbp->sb_rextents, -NBBY * sbp->sb_blocksize); + +if (xfs_sb_is_v5 (sbp) && + (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_RTGROUPS )) + rbmblock_bytes -=sizeof (struct xfs_rtbuf_blkinfo ); + + rbmblocks =howmany_64 (sbp->sb_rextents,NBBY * rbmblock_bytes); if (!xfs_validate_rtextents(rexts) || sbp->sb_rextents != rexts ||
@@ -1093,8 +1098,13 @@ xfs_sb_mount_common( mp->m_sectbb_log = sbp->sb_sectlog -BBSHIFT ; mp->m_agno_log =xfs_highbit32 (sbp->sb_agcount -1 ) +1 ; mp->m_blockmask = sbp->sb_blocksize -1 ; - mp->m_blockwsize = sbp->sb_blocksize >>XFS_WORDLOG ; - mp->m_blockwmask = mp->m_blockwsize -1 ; +if (xfs_has_rtgroups (mp)) + mp->m_blockwsize = (sbp->sb_blocksize - +sizeof (struct xfs_rtbuf_blkinfo )) >> +XFS_WORDLOG ; +else + mp->m_blockwsize = sbp->sb_blocksize >>XFS_WORDLOG ; + mp->m_rtx_per_rbmblock = mp->m_blockwsize <<XFS_NBWORDLOG ; mp->m_rtxblklog =log2_if_power2 (sbp->sb_rextsize); mp->m_rtxblkmask =mask64_if_power2 (sbp->sb_rextsize); mp->m_rgblklog =log2_if_power2 (sbp->sb_rgblocks);
fs/xfs/libxfs/xfs_shared.h +1 -0
@@ -38,6 +38,7 @@ extern const struct xfs_buf_ops xfs_inode_buf_ops;extern const struct xfs_buf_ops xfs_inode_buf_ra_ops;extern const struct xfs_buf_ops xfs_refcountbt_buf_ops;extern const struct xfs_buf_ops xfs_rmapbt_buf_ops; +extern const struct xfs_buf_ops xfs_rtbitmap_buf_ops;extern const struct xfs_buf_ops xfs_rtbuf_ops;extern const struct xfs_buf_ops xfs_rtsb_buf_ops;extern const struct xfs_buf_ops xfs_sb_buf_ops;
fs/xfs/xfs_buf_item_recover.c +18 -2
@@ -23,6 +23,7 @@#include "xfs_dir2.h" #include "xfs_quota.h" #include "xfs_rtgroup.h" +#include "xfs_rtbitmap.h" /* * This is the number of entries in the l_buf_cancel_table used during
@@ -391,9 +392,15 @@ xlog_recover_validate_buf_type(break ;#ifdef CONFIG_XFS_RT case XFS_BLFT_RTBITMAP_BUF : +if (xfs_has_rtgroups (mp) && magic32 !=XFS_RTBITMAP_MAGIC ) { + warnmsg ="Bad rtbitmap magic!" ; +break ; + } + bp->b_ops =xfs_rtblock_ops (mp, false); +break ;case XFS_BLFT_RTSUMMARY_BUF :/* no magic numbers for verification of RT buffers */ - bp->b_ops = &xfs_rtbuf_ops; + bp->b_ops =xfs_rtblock_ops (mp, true);break ;#endif /* CONFIG_XFS_RT */ default :
@@ -728,11 +735,20 @@ xlog_recover_get_buf_lsn(* UUIDs, so we must recover them immediately. */ blft =xfs_blft_from_flags (buf_f); -if (blft ==XFS_BLFT_RTBITMAP_BUF || blft ==XFS_BLFT_RTSUMMARY_BUF ) +if (!xfs_has_rtgroups (mp) && blft ==XFS_BLFT_RTBITMAP_BUF ) + goto recover_immediately; +if (blft ==XFS_BLFT_RTSUMMARY_BUF ) goto recover_immediately; magic32 =be32_to_cpu (*(__be32 *)blk);switch (magic32) { +case XFS_RTBITMAP_MAGIC : { +struct xfs_rtbuf_blkinfo *hdr = blk; + + lsn =be64_to_cpu (hdr->rt_lsn); + uuid = &hdr->rt_uuid; +break ; + }case XFS_ABTB_CRC_MAGIC :case XFS_ABTC_CRC_MAGIC :case XFS_ABTB_MAGIC :
fs/xfs/xfs_mount.h +2 -1
@@ -125,7 +125,8 @@ typedef struct xfs_mount {int8_t m_rgblklog;/* log2 of rt group sz if possible */ uint m_blockmask;/* sb_blocksize-1 */ uint m_blockwsize;/* sb_blocksize in words */ -uint m_blockwmask;/* blockwsize-1 */ +/* number of rt extents per rt bitmap block if rtgroups enabled */ +unsigned int m_rtx_per_rbmblock;uint m_alloc_mxr[2 ];/* max alloc btree records */ uint m_alloc_mnr[2 ];/* min alloc btree records */ uint m_bmap_dmxr[2 ];/* max bmap btree records */
fs/xfs/xfs_rtalloc.c +43 -17
93 lines not on this page · raw message
PATCH 16/24 xfs: encode the rtbitmap in little endian format
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Currently, the ondisk realtime bitmap file is accessed in units of 32-bit words. There's no endian translation of the contents of this file, which means that the Bad Things Happen(tm) if you go from (say) x86 to powerpc. Since we have a new feature flag, let's take the opportunity to enforce an endianness on the file.
The natural format of a bitmap is (IMHO) little endian, because the byte offsets of the bitmap data should always increase in step with the information being indexed.
--- fs/xfs/libxfs/xfs_format.h | 4 +++- fs/xfs/libxfs/xfs_rtbitmap.h | 7 ++++++- 2 files changed, 9 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_format.h +3 -1
@@ -749,10 +749,12 @@ struct xfs_agfl {/* * Realtime bitmap information is accessed by the word, which is currently -* stored in host-endian format. +* stored in host-endian format. Starting with the realtime groups feature, +* the words are stored in le32 ondisk. */ union xfs_rtword_raw {__u32 old; +__le32 rtg; };/*
fs/xfs/libxfs/xfs_rtbitmap.h +6 -1
@@ -208,6 +208,8 @@ xfs_rtbitmap_getword( {union xfs_rtword_raw *word =xfs_rbmblock_wordptr (args, index); +if (xfs_has_rtgroups (args->mp)) +return le32_to_cpu (word->rtg);return word->old; }
@@ -220,7 +222,10 @@ xfs_rtbitmap_setword( {union xfs_rtword_raw *word =xfs_rbmblock_wordptr (args, index); - word->old = value; +if (xfs_has_rtgroups (args->mp)) + word->rtg =cpu_to_le32 (value); +else + word->old = value; }/*
PATCH 17/24 xfs: add block headers to realtime summary blocks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Upgrade rtsummary blocks to have self describing metadata like most every other thing in XFS.
--- fs/xfs/libxfs/xfs_format.h | 1 + fs/xfs/libxfs/xfs_rtbitmap.c | 18 +++++++++++++++--- fs/xfs/libxfs/xfs_rtbitmap.h | 19 +++++++++++++++++-- fs/xfs/libxfs/xfs_shared.h | 1 + fs/xfs/scrub/rtsummary_repair.c | 15 +++++++++++++-- fs/xfs/xfs_buf_item_recover.c | 11 +++++++---- fs/xfs/xfs_rtalloc.c | 7 +++++-- 7 files changed, 59 insertions(+), 13 deletions(-)
fs/xfs/libxfs/xfs_format.h +1 -0
@@ -1303,6 +1303,7 @@ static inline bool xfs_dinode_has_large_extent_counts(* RT bit manipulation macros. */ #define XFS_RTBITMAP_MAGIC 0x424D505A/* BMPZ */ +#define XFS_RTSUMMARY_MAGIC 0x53554D59/* SUMY */ struct xfs_rtbuf_blkinfo {__be32 rt_magic;/* validity check on block */
fs/xfs/libxfs/xfs_rtbitmap.c +15 -3
@@ -53,7 +53,7 @@ xfs_rtbuf_verify_read(struct xfs_rtbuf_blkinfo *hdr = bp->b_addr;xfs_failaddr_t fa; -if (!xfs_has_rtgroups (mp) || bp->b_ops != &xfs_rtbitmap_buf_ops) +if (!xfs_has_rtgroups (mp))return ;if (!xfs_log_check_lsn (mp,be64_to_cpu (hdr->rt_lsn))) {
@@ -84,7 +84,7 @@ xfs_rtbuf_verify_write(struct xfs_buf_log_item *bip = bp->b_log_item;xfs_failaddr_t fa; -if (!xfs_has_rtgroups (mp) || bp->b_ops != &xfs_rtbitmap_buf_ops) +if (!xfs_has_rtgroups (mp))return ; fa =xfs_rtbuf_verify (bp);
@@ -112,6 +112,14 @@ const struct xfs_buf_ops xfs_rtbitmap_buf_ops = { .verify_struct = xfs_rtbuf_verify, }; +const struct xfs_buf_ops xfs_rtsummary_buf_ops = { + .name ="xfs_rtsummary" , + .magic = {0 ,cpu_to_be32 (XFS_RTSUMMARY_MAGIC ) }, + .verify_read = xfs_rtbuf_verify_read, + .verify_write = xfs_rtbuf_verify_write, + .verify_struct = xfs_rtbuf_verify, +}; +/* Release cached rt bitmap and summary buffers. */ void xfs_rtbuf_cache_relse(
@@ -197,7 +205,7 @@ xfs_rtbuf_get(if (error)return error; -if (xfs_has_rtgroups (mp) && !issum) { +if (xfs_has_rtgroups (mp)) {struct xfs_rtbuf_blkinfo *hdr = bp->b_addr;if (hdr->rt_owner !=cpu_to_be64 (ip->i_ino)) {
@@ -1277,6 +1285,10 @@ xfs_rtsummary_blockcount(unsigned long long rsumwords; rsumwords = (unsigned long long )rsumlevels * rbmblocks; + +if (xfs_has_rtgroups (mp)) +return howmany_64 (rsumwords, mp->m_blockwsize); +return XFS_B_TO_FSB (mp, rsumwords <<XFS_WORDLOG ); }
fs/xfs/libxfs/xfs_rtbitmap.h +17 -2
@@ -250,6 +250,9 @@ xfs_rtsumoffs_to_block( struct xfs_mount *mp, xfs_rtsumoff_t rsumoff) { + if (xfs_has_rtgroups(mp)) + return rsumoff / mp->m_blockwsize; +return XFS_B_TO_FSBT (mp, rsumoff *sizeof (xfs_suminfo_t)); }
@@ -264,6 +267,9 @@ xfs_rtsumoffs_to_infoword( {unsigned int mask = mp->m_blockmask >>XFS_SUMINFOLOG ; +if (xfs_has_rtgroups (mp)) +return rsumoff % mp->m_blockwsize; +return rsumoff & mask; }
@@ -273,7 +279,13 @@ xfs_rsumblock_infoptr( struct xfs_rtalloc_args *args, unsigned int index) { -union xfs_suminfo_raw *info = args->sumbp->b_addr; +union xfs_suminfo_raw *info; +struct xfs_rtbuf_blkinfo *hdr = args->sumbp->b_addr; + +if (xfs_has_rtgroups (args->mp)) + info = (union xfs_suminfo_raw *)(hdr +1 ); +else + info = args->sumbp->b_addr;return info + index; }
@@ -307,8 +319,11 @@ xfs_rtblock_ops( struct xfs_mount *mp, bool issum) { - if (xfs_has_rtgroups(mp) && !issum) + if (xfs_has_rtgroups(mp)) { + if (issum) + return &xfs_rtsummary_buf_ops;return &xfs_rtbitmap_buf_ops; + }return &xfs_rtbuf_ops; }
fs/xfs/libxfs/xfs_shared.h +1 -0
@@ -39,6 +39,7 @@ extern const struct xfs_buf_ops xfs_inode_buf_ra_ops;extern const struct xfs_buf_ops xfs_refcountbt_buf_ops;extern const struct xfs_buf_ops xfs_rmapbt_buf_ops;extern const struct xfs_buf_ops xfs_rtbitmap_buf_ops; +extern const struct xfs_buf_ops xfs_rtsummary_buf_ops;extern const struct xfs_buf_ops xfs_rtbuf_ops;extern const struct xfs_buf_ops xfs_rtsb_buf_ops;extern const struct xfs_buf_ops xfs_sb_buf_ops;
fs/xfs/scrub/rtsummary_repair.c +13 -2
@@ -87,12 +87,23 @@ xrep_rtsummary_prep_buf( ondisk =xfs_rsumblock_infoptr (&rts->args,0 ); rts->args.sumbp =NULL ; - bp->b_ops = &xfs_rtbuf_ops; - error =xfsum_copyout (sc, rts->prep_wordoff, ondisk, mp->m_blockwsize);if (error)return error; +if (xfs_has_rtgroups (sc->mp)) { +struct xfs_rtbuf_blkinfo *hdr = bp->b_addr; + + hdr->rt_magic =cpu_to_be32 (XFS_RTSUMMARY_MAGIC ); + hdr->rt_owner =cpu_to_be64 (sc->ip->i_ino); + hdr->rt_blkno =cpu_to_be64 (xfs_buf_daddr (bp)); + hdr->rt_lsn =0 ; +uuid_copy (&hdr->rt_uuid, &sc->mp->m_sb.sb_meta_uuid); + bp->b_ops = &xfs_rtsummary_buf_ops; + }else { + bp->b_ops = &xfs_rtbuf_ops; + } + rts->prep_wordoff += mp->m_blockwsize;xfs_trans_buf_set_type (sc->tp, bp,XFS_BLFT_RTSUMMARY_BUF );return 0 ;
fs/xfs/xfs_buf_item_recover.c +7 -4
@@ -399,7 +399,10 @@ xlog_recover_validate_buf_type( bp->b_ops =xfs_rtblock_ops (mp, false);break ;case XFS_BLFT_RTSUMMARY_BUF : -/* no magic numbers for verification of RT buffers */ +if (xfs_has_rtgroups (mp) && magic32 !=XFS_RTSUMMARY_MAGIC ) { + warnmsg ="Bad rtsummary magic!" ; +break ; + } bp->b_ops =xfs_rtblock_ops (mp, true);break ;#endif /* CONFIG_XFS_RT */
@@ -735,13 +738,13 @@ xlog_recover_get_buf_lsn(* UUIDs, so we must recover them immediately. */ blft =xfs_blft_from_flags (buf_f); -if (!xfs_has_rtgroups (mp) && blft ==XFS_BLFT_RTBITMAP_BUF ) - goto recover_immediately; -if (blft ==XFS_BLFT_RTSUMMARY_BUF ) +if (!xfs_has_rtgroups (mp) && (blft ==XFS_BLFT_RTBITMAP_BUF || + blft ==XFS_BLFT_RTSUMMARY_BUF )) goto recover_immediately; magic32 =be32_to_cpu (*(__be32 *)blk);switch (magic32) { +case XFS_RTSUMMARY_MAGIC :case XFS_RTBITMAP_MAGIC : {struct xfs_rtbuf_blkinfo *hdr = blk;
fs/xfs/xfs_rtalloc.c +5 -2
@@ -784,10 +784,13 @@ xfs_growfs_init_rtbuf( bp->b_ops =xfs_rtblock_ops (mp, buf_type ==XFS_BLFT_RTSUMMARY_BUF );memset (bp->b_addr,0 , mp->m_sb.sb_blocksize); -if (xfs_has_rtgroups (mp) && buf_type ==XFS_BLFT_RTBITMAP_BUF ) { +if (xfs_has_rtgroups (mp)) {struct xfs_rtbuf_blkinfo *hdr = bp->b_addr; - hdr->rt_magic =cpu_to_be32 (XFS_RTBITMAP_MAGIC ); +if (buf_type ==XFS_BLFT_RTBITMAP_BUF ) + hdr->rt_magic =cpu_to_be32 (XFS_RTBITMAP_MAGIC ); +else + hdr->rt_magic =cpu_to_be32 (XFS_RTSUMMARY_MAGIC ); hdr->rt_owner =cpu_to_be64 (ip->i_ino); hdr->rt_blkno =cpu_to_be64 (d);uuid_copy (&hdr->rt_uuid, &mp->m_sb.sb_meta_uuid);
PATCH 18/24 xfs: encode the rtsummary in big endian format
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Currently, the ondisk realtime summary file counters are accessed in units of 32-bit words. There's no endian translation of the contents of this file, which means that the Bad Things Happen(tm) if you go from (say) x86 to powerpc. Since we have a new feature flag, let's take the opportunity to enforce an endianness on the file. Encode the summary information in big endian format, like most of the rest of the filesystem.
--- fs/xfs/libxfs/xfs_format.h | 4 +++- fs/xfs/libxfs/xfs_rtbitmap.h | 7 +++++++ fs/xfs/scrub/rtsummary.c | 5 +++++ 3 files changed, 15 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_format.h +3 -1
@@ -759,10 +759,12 @@ union xfs_rtword_raw {/* * Realtime summary counts are accessed by the word, which is currently -* stored in host-endian format. +* stored in host-endian format. Starting with the realtime groups feature, +* the words are stored in be32 ondisk. */ union xfs_suminfo_raw {__u32 old; +__be32 rtg; };/*
fs/xfs/libxfs/xfs_rtbitmap.h +7 -0
@@ -298,6 +298,8 @@ xfs_suminfo_get( {union xfs_suminfo_raw *info =xfs_rsumblock_infoptr (args, index); +if (xfs_has_rtgroups (args->mp)) +return be32_to_cpu (info->rtg);return info->old; }
@@ -310,6 +312,11 @@ xfs_suminfo_add( {union xfs_suminfo_raw *info =xfs_rsumblock_infoptr (args, index); +if (xfs_has_rtgroups (args->mp)) { +be32_add_cpu (&info->rtg, delta); +return be32_to_cpu (info->rtg); + } + info->old += delta;return info->old; }
fs/xfs/scrub/rtsummary.c +5 -0
@@ -142,6 +142,11 @@ xchk_rtsum_inc(struct xfs_mount *mp, union xfs_suminfo_raw *v) { + if (xfs_has_rtgroups(mp)) { + be32_add_cpu(&v->rtg, 1); +return be32_to_cpu (v->rtg); + } + v->old +=1 ;return v->old; }
PATCH 19/24 xfs: store rtgroup information with a bmap intent
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Make the bmap intent items take an active reference to the rtgroup containing the space that is being mapped or unmapped. We will need this functionality once we start enabling rmap and reflink on the rt volume.
--- fs/xfs/libxfs/xfs_bmap.h | 5 ++++- fs/xfs/xfs_bmap_item.c | 18 ++++++++++++++++-- 2 files changed, 20 insertions(+), 3 deletions(-)
fs/xfs/libxfs/xfs_bmap.h +4 -1
@@ -246,7 +246,10 @@ struct xfs_bmap_intent {enum xfs_bmap_intent_type bi_type;int bi_whichfork;struct xfs_inode *bi_owner; -struct xfs_perag *bi_pag; +union { +struct xfs_perag *bi_pag; +struct xfs_rtgroup *bi_rtg; + };struct xfs_bmbt_irec bi_bmap; };
fs/xfs/xfs_bmap_item.c +16 -2
@@ -26,6 +26,7 @@#include "xfs_log_recover.h" #include "xfs_ag.h" #include "xfs_trace.h" +#include "xfs_rtgroup.h" struct kmem_cache *xfs_bui_cache;struct kmem_cache *xfs_bud_cache;
@@ -326,8 +327,18 @@ xfs_bmap_update_get_group( {xfs_agnumber_t agno; -if (xfs_ifork_is_realtime (bi->bi_owner, bi->bi_whichfork)) +if (xfs_ifork_is_realtime (bi->bi_owner, bi->bi_whichfork)) { +if (xfs_has_rtgroups (mp)) { +xfs_rgnumber_t rgno; + + rgno =xfs_rtb_to_rgno (mp, bi->bi_bmap.br_startblock); + bi->bi_rtg =xfs_rtgroup_get (mp, rgno); + }else { + bi->bi_rtg =NULL ; + } +return ; + } agno =XFS_FSB_TO_AGNO (mp, bi->bi_bmap.br_startblock);
@@ -358,8 +369,11 @@ static inline voidxfs_bmap_update_put_group ( struct xfs_bmap_intent *bi) { -if (xfs_ifork_is_realtime (bi->bi_owner, bi->bi_whichfork)) +if (xfs_ifork_is_realtime (bi->bi_owner, bi->bi_whichfork)) { +if (xfs_has_rtgroups (bi->bi_owner->i_mount)) +xfs_rtgroup_put (bi->bi_rtg);return ; + }xfs_perag_intent_put (bi->bi_pag); }
PATCH 20/24 xfs: use an incore rtgroup rotor for rtpick
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
During the 6.7 merge window, Linus noticed that the realtime allocator was doing some sketchy things trying to encode a u64 sequence counter into the rtbitmap file's atime. The sketchy casting of a struct pointer to a u64 pointer has subtly broken several times over the past decade as the codebase has transitioned to using the VFS i_atime field and that field has changed in size and layout over time.
Since the goal of the rtpick code is to _suggest_ a starting place for new rt file allocations, the repeated breakage has not resulted in inconsistent metadata. IOWs, it's a hint.
For rtgroups, we don't need this complex code to cut the rtextents space into fractions. Add an rtgroup rotor and use that for rtpick, similar to AG rotoring on the data device. The new rotor does not persist, which reduces the logging overhead slightly.
--- fs/xfs/libxfs/xfs_rtbitmap.c | 12 ++++++++---- fs/xfs/xfs_mount.h | 1 + fs/xfs/xfs_rtalloc.c | 11 +++++++++++ 3 files changed, 20 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.c +8 -4
@@ -1064,10 +1064,14 @@ xfs_rtfree_extent(if (!(mp->m_rbmip->i_diflags &XFS_DIFLAG_NEWRTBM )) mp->m_rbmip->i_diflags |=XFS_DIFLAG_NEWRTBM ; - atime =inode_get_atime (VFS_I (mp->m_rbmip)); - atime.tv_sec =0 ; -inode_set_atime_to_ts (VFS_I (mp->m_rbmip), atime); -xfs_trans_log_inode (tp, mp->m_rbmip,XFS_ILOG_CORE ); +if (xfs_has_rtgroups (mp)) { + mp->m_rtgrotor =0 ; + }else { + atime =inode_get_atime (VFS_I (mp->m_rbmip)); + atime.tv_sec =0 ; +inode_set_atime_to_ts (VFS_I (mp->m_rbmip), atime); +xfs_trans_log_inode (tp, mp->m_rbmip,XFS_ILOG_CORE ); + } } error =0 ; out:
fs/xfs/xfs_mount.h +1 -0
@@ -224,6 +224,7 @@ typedef struct xfs_mount {#ifdef CONFIG_XFS_ONLINE_SCRUB_STATS struct xchk_stats *m_scrub_stats;#endif +xfs_rgnumber_t m_rtgrotor;/* last rtgroup rtpicked */ xfs_agnumber_t m_agfrotor;/* last ag where space found */ atomic_t m_agirotor;/* last ag dir inode alloced */
fs/xfs/xfs_rtalloc.c +11 -0
@@ -1688,6 +1688,17 @@ xfs_rtpick_extent(ASSERT (xfs_isilocked (mp->m_rbmip,XFS_ILOCK_EXCL )); +if (xfs_has_rtgroups (mp)) { +xfs_rtblock_t rtbno; + +/* Pick the first usable rtx of the group. */ + rtbno =xfs_rgbno_to_rtb (mp, mp->m_rtgrotor,0 ); + *pick =xfs_rtb_to_rtx (mp, rtbno) +1 ; + + mp->m_rtgrotor = (mp->m_rtgrotor +1 ) % mp->m_sb.sb_rgcount; +return 0 ; + } + ts =inode_get_atime (VFS_I (mp->m_rbmip));if (!(mp->m_rbmip->i_diflags &XFS_DIFLAG_NEWRTBM )) { mp->m_rbmip->i_diflags |=XFS_DIFLAG_NEWRTBM ;