forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
499 lines
19 KiB
499 lines
19 KiB
/* SPDX-License-Identifier: GPL-2.0 */ |
|
/* |
|
* Copyright (c) 2000,2002-2003,2005 Silicon Graphics, Inc. |
|
* All Rights Reserved. |
|
*/ |
|
#ifndef __XFS_ATTR_H__ |
|
#define __XFS_ATTR_H__ |
|
|
|
struct xfs_inode; |
|
struct xfs_da_args; |
|
struct xfs_attr_list_context; |
|
|
|
/* |
|
* Large attribute lists are structured around Btrees where all the data |
|
* elements are in the leaf nodes. Attribute names are hashed into an int, |
|
* then that int is used as the index into the Btree. Since the hashval |
|
* of an attribute name may not be unique, we may have duplicate keys. |
|
* The internal links in the Btree are logical block offsets into the file. |
|
* |
|
* Small attribute lists use a different format and are packed as tightly |
|
* as possible so as to fit into the literal area of the inode. |
|
*/ |
|
|
|
/* |
|
* The maximum size (into the kernel or returned from the kernel) of an |
|
* attribute value or the buffer used for an attr_list() call. Larger |
|
* sizes will result in an ERANGE return code. |
|
*/ |
|
#define ATTR_MAX_VALUELEN (64*1024) /* max length of a value */ |
|
|
|
/* |
|
* Kernel-internal version of the attrlist cursor. |
|
*/ |
|
struct xfs_attrlist_cursor_kern { |
|
__u32 hashval; /* hash value of next entry to add */ |
|
__u32 blkno; /* block containing entry (suggestion) */ |
|
__u32 offset; /* offset in list of equal-hashvals */ |
|
__u16 pad1; /* padding to match user-level */ |
|
__u8 pad2; /* padding to match user-level */ |
|
__u8 initted; /* T/F: cursor has been initialized */ |
|
}; |
|
|
|
|
|
/*======================================================================== |
|
* Structure used to pass context around among the routines. |
|
*========================================================================*/ |
|
|
|
|
|
/* void; state communicated via *context */ |
|
typedef void (*put_listent_func_t)(struct xfs_attr_list_context *, int, |
|
unsigned char *, int, int); |
|
|
|
struct xfs_attr_list_context { |
|
struct xfs_trans *tp; |
|
struct xfs_inode *dp; /* inode */ |
|
struct xfs_attrlist_cursor_kern cursor; /* position in list */ |
|
void *buffer; /* output buffer */ |
|
|
|
/* |
|
* Abort attribute list iteration if non-zero. Can be used to pass |
|
* error values to the xfs_attr_list caller. |
|
*/ |
|
int seen_enough; |
|
bool allow_incomplete; |
|
|
|
ssize_t count; /* num used entries */ |
|
int dupcnt; /* count dup hashvals seen */ |
|
int bufsize; /* total buffer size */ |
|
int firstu; /* first used byte in buffer */ |
|
unsigned int attr_filter; /* XFS_ATTR_{ROOT,SECURE} */ |
|
int resynch; /* T/F: resynch with cursor */ |
|
put_listent_func_t put_listent; /* list output fmt function */ |
|
int index; /* index into output buffer */ |
|
}; |
|
|
|
|
|
/* |
|
* ======================================================================== |
|
* Structure used to pass context around among the delayed routines. |
|
* ======================================================================== |
|
*/ |
|
|
|
/* |
|
* Below is a state machine diagram for attr remove operations. The XFS_DAS_* |
|
* states indicate places where the function would return -EAGAIN, and then |
|
* immediately resume from after being called by the calling function. States |
|
* marked as a "subroutine state" indicate that they belong to a subroutine, and |
|
* so the calling function needs to pass them back to that subroutine to allow |
|
* it to finish where it left off. But they otherwise do not have a role in the |
|
* calling function other than just passing through. |
|
* |
|
* xfs_attr_remove_iter() |
|
* │ |
|
* v |
|
* have attr to remove? ──n──> done |
|
* │ |
|
* y |
|
* │ |
|
* v |
|
* are we short form? ──y──> xfs_attr_shortform_remove ──> done |
|
* │ |
|
* n |
|
* │ |
|
* V |
|
* are we leaf form? ──y──> xfs_attr_leaf_removename ──> done |
|
* │ |
|
* n |
|
* │ |
|
* V |
|
* ┌── need to setup state? |
|
* │ │ |
|
* n y |
|
* │ │ |
|
* │ v |
|
* │ find attr and get state |
|
* │ attr has remote blks? ──n─┐ |
|
* │ │ v |
|
* │ │ find and invalidate |
|
* │ y the remote blocks. |
|
* │ │ mark attr incomplete |
|
* │ ├────────────────┘ |
|
* └──────────┤ |
|
* │ |
|
* v |
|
* Have remote blks to remove? ───y─────┐ |
|
* │ ^ remove the blks |
|
* │ │ │ |
|
* │ │ v |
|
* │ XFS_DAS_RMTBLK <─n── done? |
|
* │ re-enter with │ |
|
* │ one less blk to y |
|
* │ remove │ |
|
* │ V |
|
* │ refill the state |
|
* n │ |
|
* │ v |
|
* │ XFS_DAS_RM_NAME |
|
* │ │ |
|
* ├─────────────────────────┘ |
|
* │ |
|
* v |
|
* remove leaf and |
|
* update hash with |
|
* xfs_attr_node_remove_cleanup |
|
* │ |
|
* v |
|
* need to |
|
* shrink tree? ─n─┐ |
|
* │ │ |
|
* y │ |
|
* │ │ |
|
* v │ |
|
* join leaf │ |
|
* │ │ |
|
* v │ |
|
* XFS_DAS_RM_SHRINK │ |
|
* │ │ |
|
* v │ |
|
* do the shrink │ |
|
* │ │ |
|
* v │ |
|
* free state <──┘ |
|
* │ |
|
* v |
|
* done |
|
* |
|
* |
|
* Below is a state machine diagram for attr set operations. |
|
* |
|
* It seems the challenge with understanding this system comes from trying to |
|
* absorb the state machine all at once, when really one should only be looking |
|
* at it with in the context of a single function. Once a state sensitive |
|
* function is called, the idea is that it "takes ownership" of the |
|
* state machine. It isn't concerned with the states that may have belonged to |
|
* it's calling parent. Only the states relevant to itself or any other |
|
* subroutines there in. Once a calling function hands off the state machine to |
|
* a subroutine, it needs to respect the simple rule that it doesn't "own" the |
|
* state machine anymore, and it's the responsibility of that calling function |
|
* to propagate the -EAGAIN back up the call stack. Upon reentry, it is |
|
* committed to re-calling that subroutine until it returns something other than |
|
* -EAGAIN. Once that subroutine signals completion (by returning anything other |
|
* than -EAGAIN), the calling function can resume using the state machine. |
|
* |
|
* xfs_attr_set_iter() |
|
* │ |
|
* v |
|
* ┌─y─ has an attr fork? |
|
* │ | |
|
* │ n |
|
* │ | |
|
* │ V |
|
* │ add a fork |
|
* │ │ |
|
* └──────────┤ |
|
* │ |
|
* V |
|
* ┌─── is shortform? |
|
* │ │ |
|
* │ y |
|
* │ │ |
|
* │ V |
|
* │ xfs_attr_set_fmt |
|
* │ | |
|
* │ V |
|
* │ xfs_attr_try_sf_addname |
|
* │ │ |
|
* │ V |
|
* │ had enough ──y──> done |
|
* │ space? |
|
* n │ |
|
* │ n |
|
* │ │ |
|
* │ V |
|
* │ transform to leaf |
|
* │ │ |
|
* │ V |
|
* │ hold the leaf buffer |
|
* │ │ |
|
* │ V |
|
* │ return -EAGAIN |
|
* │ Re-enter in |
|
* │ leaf form |
|
* │ |
|
* └─> release leaf buffer |
|
* if needed |
|
* │ |
|
* V |
|
* ┌───n── fork has |
|
* │ only 1 blk? |
|
* │ │ |
|
* │ y |
|
* │ │ |
|
* │ v |
|
* │ xfs_attr_leaf_try_add() |
|
* │ │ |
|
* │ v |
|
* │ had enough ──────────────y─────────────┐ |
|
* │ space? │ |
|
* │ │ │ |
|
* │ n │ |
|
* │ │ │ |
|
* │ v │ |
|
* │ return -EAGAIN │ |
|
* │ re-enter in │ |
|
* │ node form │ |
|
* │ │ │ |
|
* └──────────┤ │ |
|
* │ │ |
|
* V │ |
|
* xfs_attr_node_addname_find_attr │ |
|
* determines if this │ |
|
* is create or rename │ |
|
* find space to store attr │ |
|
* │ │ |
|
* v │ |
|
* xfs_attr_node_addname │ |
|
* │ │ |
|
* v │ |
|
* fits in a node leaf? ────n─────┐ │ |
|
* │ ^ v │ |
|
* │ │ single leaf node? │ |
|
* │ │ │ │ │ |
|
* y │ y n │ |
|
* │ │ │ │ │ |
|
* v │ v v │ |
|
* update │ grow the leaf split if │ |
|
* hashvals └── return -EAGAIN needed │ |
|
* │ retry leaf add │ │ |
|
* │ on reentry │ │ |
|
* ├────────────────────────────┘ │ |
|
* │ │ |
|
* v │ |
|
* need to alloc │ |
|
* ┌─y── or flip flag? │ |
|
* │ │ │ |
|
* │ n │ |
|
* │ │ │ |
|
* │ v │ |
|
* │ done │ |
|
* │ │ |
|
* │ │ |
|
* │ XFS_DAS_FOUND_LBLK <────────────────┘ |
|
* │ │ |
|
* │ V |
|
* │ xfs_attr_leaf_addname() |
|
* │ │ |
|
* │ v |
|
* │ ┌──first time through? |
|
* │ │ │ |
|
* │ │ y |
|
* │ │ │ |
|
* │ n v |
|
* │ │ if we have rmt blks |
|
* │ │ find space for them |
|
* │ │ │ |
|
* │ └──────────┤ |
|
* │ │ |
|
* │ v |
|
* │ still have |
|
* │ ┌─n─ blks to alloc? <──┐ |
|
* │ │ │ │ |
|
* │ │ y │ |
|
* │ │ │ │ |
|
* │ │ v │ |
|
* │ │ alloc one blk │ |
|
* │ │ return -EAGAIN ──┘ |
|
* │ │ re-enter with one |
|
* │ │ less blk to alloc |
|
* │ │ |
|
* │ │ |
|
* │ └───> set the rmt |
|
* │ value |
|
* │ │ |
|
* │ v |
|
* │ was this |
|
* │ a rename? ──n─┐ |
|
* │ │ │ |
|
* │ y │ |
|
* │ │ │ |
|
* │ v │ |
|
* │ flip incomplete │ |
|
* │ flag │ |
|
* │ │ │ |
|
* │ v │ |
|
* │ XFS_DAS_FLIP_LFLAG │ |
|
* │ │ │ |
|
* │ v │ |
|
* │ need to remove │ |
|
* │ old bks? ──n──┤ |
|
* │ │ │ |
|
* │ y │ |
|
* │ │ │ |
|
* │ V │ |
|
* │ remove │ |
|
* │ ┌───> old blks │ |
|
* │ │ │ │ |
|
* │ XFS_DAS_RM_LBLK │ │ |
|
* │ ^ │ │ |
|
* │ │ v │ |
|
* │ └──y── more to │ |
|
* │ remove? │ |
|
* │ │ │ |
|
* │ n │ |
|
* │ │ │ |
|
* │ v │ |
|
* │ XFS_DAS_RD_LEAF │ |
|
* │ │ │ |
|
* │ v │ |
|
* │ remove leaf │ |
|
* │ │ │ |
|
* │ v │ |
|
* │ shrink to sf │ |
|
* │ if needed │ |
|
* │ │ │ |
|
* │ v │ |
|
* │ done <──────┘ |
|
* │ |
|
* └──────> XFS_DAS_FOUND_NBLK |
|
* │ |
|
* v |
|
* ┌─────n── need to |
|
* │ alloc blks? |
|
* │ │ |
|
* │ y |
|
* │ │ |
|
* │ v |
|
* │ find space |
|
* │ │ |
|
* │ v |
|
* │ ┌─>XFS_DAS_ALLOC_NODE |
|
* │ │ │ |
|
* │ │ v |
|
* │ │ alloc blk |
|
* │ │ │ |
|
* │ │ v |
|
* │ └──y── need to alloc |
|
* │ more blocks? |
|
* │ │ |
|
* │ n |
|
* │ │ |
|
* │ v |
|
* │ set the rmt value |
|
* │ │ |
|
* │ v |
|
* │ was this |
|
* └────────> a rename? ──n─┐ |
|
* │ │ |
|
* y │ |
|
* │ │ |
|
* v │ |
|
* flip incomplete │ |
|
* flag │ |
|
* │ │ |
|
* v │ |
|
* XFS_DAS_FLIP_NFLAG │ |
|
* │ │ |
|
* v │ |
|
* need to │ |
|
* remove blks? ─n──┤ |
|
* │ │ |
|
* y │ |
|
* │ │ |
|
* v │ |
|
* remove │ |
|
* ┌────────> old blks │ |
|
* │ │ │ |
|
* XFS_DAS_RM_NBLK │ │ |
|
* ^ │ │ |
|
* │ v │ |
|
* └──────y── more to │ |
|
* remove │ |
|
* │ │ |
|
* n │ |
|
* │ │ |
|
* v │ |
|
* XFS_DAS_CLR_FLAG │ |
|
* │ │ |
|
* v │ |
|
* clear flags │ |
|
* │ │ |
|
* ├──────────┘ |
|
* │ |
|
* v |
|
* done |
|
*/ |
|
|
|
/* |
|
* Enum values for xfs_delattr_context.da_state |
|
* |
|
* These values are used by delayed attribute operations to keep track of where |
|
* they were before they returned -EAGAIN. A return code of -EAGAIN signals the |
|
* calling function to roll the transaction, and then call the subroutine to |
|
* finish the operation. The enum is then used by the subroutine to jump back |
|
* to where it was and resume executing where it left off. |
|
*/ |
|
enum xfs_delattr_state { |
|
XFS_DAS_UNINIT = 0, /* No state has been set yet */ |
|
XFS_DAS_RMTBLK, /* Removing remote blks */ |
|
XFS_DAS_RM_NAME, /* Remove attr name */ |
|
XFS_DAS_RM_SHRINK, /* We are shrinking the tree */ |
|
XFS_DAS_FOUND_LBLK, /* We found leaf blk for attr */ |
|
XFS_DAS_FOUND_NBLK, /* We found node blk for attr */ |
|
XFS_DAS_FLIP_LFLAG, /* Flipped leaf INCOMPLETE attr flag */ |
|
XFS_DAS_RM_LBLK, /* A rename is removing leaf blocks */ |
|
XFS_DAS_RD_LEAF, /* Read in the new leaf */ |
|
XFS_DAS_ALLOC_NODE, /* We are allocating node blocks */ |
|
XFS_DAS_FLIP_NFLAG, /* Flipped node INCOMPLETE attr flag */ |
|
XFS_DAS_RM_NBLK, /* A rename is removing node blocks */ |
|
XFS_DAS_CLR_FLAG, /* Clear incomplete flag */ |
|
}; |
|
|
|
/* |
|
* Defines for xfs_delattr_context.flags |
|
*/ |
|
#define XFS_DAC_DEFER_FINISH 0x01 /* finish the transaction */ |
|
#define XFS_DAC_LEAF_ADDNAME_INIT 0x02 /* xfs_attr_leaf_addname init*/ |
|
|
|
/* |
|
* Context used for keeping track of delayed attribute operations |
|
*/ |
|
struct xfs_delattr_context { |
|
struct xfs_da_args *da_args; |
|
|
|
/* Used in xfs_attr_rmtval_set_blk to roll through allocating blocks */ |
|
struct xfs_bmbt_irec map; |
|
xfs_dablk_t lblkno; |
|
int blkcnt; |
|
|
|
/* Used in xfs_attr_node_removename to roll through removing blocks */ |
|
struct xfs_da_state *da_state; |
|
|
|
/* Used to keep track of current state of delayed operation */ |
|
unsigned int flags; |
|
enum xfs_delattr_state dela_state; |
|
}; |
|
|
|
/*======================================================================== |
|
* Function prototypes for the kernel. |
|
*========================================================================*/ |
|
|
|
/* |
|
* Overall external interface routines. |
|
*/ |
|
int xfs_attr_inactive(struct xfs_inode *dp); |
|
int xfs_attr_list_ilocked(struct xfs_attr_list_context *); |
|
int xfs_attr_list(struct xfs_attr_list_context *); |
|
int xfs_inode_hasattr(struct xfs_inode *ip); |
|
bool xfs_attr_is_leaf(struct xfs_inode *ip); |
|
int xfs_attr_get_ilocked(struct xfs_da_args *args); |
|
int xfs_attr_get(struct xfs_da_args *args); |
|
int xfs_attr_set(struct xfs_da_args *args); |
|
int xfs_attr_set_args(struct xfs_da_args *args); |
|
int xfs_attr_remove_args(struct xfs_da_args *args); |
|
int xfs_attr_remove_iter(struct xfs_delattr_context *dac); |
|
bool xfs_attr_namecheck(const void *name, size_t length); |
|
void xfs_delattr_context_init(struct xfs_delattr_context *dac, |
|
struct xfs_da_args *args); |
|
|
|
#endif /* __XFS_ATTR_H__ */
|
|
|