1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Copyright (c) 2000,2002-2003,2005 Silicon Graphics, Inc.
4  * All Rights Reserved.
5  */
6 #ifndef __XFS_ATTR_H__
7 #define	__XFS_ATTR_H__
8 
9 struct xfs_inode;
10 struct xfs_da_args;
11 struct xfs_attr_list_context;
12 
13 /*
14  * Large attribute lists are structured around Btrees where all the data
15  * elements are in the leaf nodes.  Attribute names are hashed into an int,
16  * then that int is used as the index into the Btree.  Since the hashval
17  * of an attribute name may not be unique, we may have duplicate keys.
18  * The internal links in the Btree are logical block offsets into the file.
19  *
20  * Small attribute lists use a different format and are packed as tightly
21  * as possible so as to fit into the literal area of the inode.
22  */
23 
24 /*
25  * The maximum size (into the kernel or returned from the kernel) of an
26  * attribute value or the buffer used for an attr_list() call.  Larger
27  * sizes will result in an ERANGE return code.
28  */
29 #define	ATTR_MAX_VALUELEN	(64*1024)	/* max length of a value */
30 
31 /*
32  * Kernel-internal version of the attrlist cursor.
33  */
34 struct xfs_attrlist_cursor_kern {
35 	__u32	hashval;	/* hash value of next entry to add */
36 	__u32	blkno;		/* block containing entry (suggestion) */
37 	__u32	offset;		/* offset in list of equal-hashvals */
38 	__u16	pad1;		/* padding to match user-level */
39 	__u8	pad2;		/* padding to match user-level */
40 	__u8	initted;	/* T/F: cursor has been initialized */
41 };
42 
43 
44 /*========================================================================
45  * Structure used to pass context around among the routines.
46  *========================================================================*/
47 
48 
49 /* void; state communicated via *context */
50 typedef void (*put_listent_func_t)(struct xfs_attr_list_context *, int,
51 			      unsigned char *, int, int);
52 
53 struct xfs_attr_list_context {
54 	struct xfs_trans	*tp;
55 	struct xfs_inode	*dp;		/* inode */
56 	struct xfs_attrlist_cursor_kern cursor;	/* position in list */
57 	void			*buffer;	/* output buffer */
58 
59 	/*
60 	 * Abort attribute list iteration if non-zero.  Can be used to pass
61 	 * error values to the xfs_attr_list caller.
62 	 */
63 	int			seen_enough;
64 	bool			allow_incomplete;
65 
66 	ssize_t			count;		/* num used entries */
67 	int			dupcnt;		/* count dup hashvals seen */
68 	int			bufsize;	/* total buffer size */
69 	int			firstu;		/* first used byte in buffer */
70 	unsigned int		attr_filter;	/* XFS_ATTR_{ROOT,SECURE} */
71 	int			resynch;	/* T/F: resynch with cursor */
72 	put_listent_func_t	put_listent;	/* list output fmt function */
73 	int			index;		/* index into output buffer */
74 };
75 
76 
77 /*
78  * ========================================================================
79  * Structure used to pass context around among the delayed routines.
80  * ========================================================================
81  */
82 
83 /*
84  * Below is a state machine diagram for attr remove operations. The  XFS_DAS_*
85  * states indicate places where the function would return -EAGAIN, and then
86  * immediately resume from after being called by the calling function. States
87  * marked as a "subroutine state" indicate that they belong to a subroutine, and
88  * so the calling function needs to pass them back to that subroutine to allow
89  * it to finish where it left off. But they otherwise do not have a role in the
90  * calling function other than just passing through.
91  *
92  * xfs_attr_remove_iter()
93  *              │
94  *              v
95  *        have attr to remove? ──n──> done
96  *              │
97  *              y
98  *              │
99  *              v
100  *        are we short form? ──y──> xfs_attr_shortform_remove ──> done
101  *              │
102  *              n
103  *              │
104  *              V
105  *        are we leaf form? ──y──> xfs_attr_leaf_removename ──> done
106  *              │
107  *              n
108  *              │
109  *              V
110  *   ┌── need to setup state?
111  *   │          │
112  *   n          y
113  *   │          │
114  *   │          v
115  *   │ find attr and get state
116  *   │ attr has remote blks? ──n─┐
117  *   │          │                v
118  *   │          │         find and invalidate
119  *   │          y         the remote blocks.
120  *   │          │         mark attr incomplete
121  *   │          ├────────────────┘
122  *   └──────────┤
123  *              │
124  *              v
125  *   Have remote blks to remove? ───y─────┐
126  *              │        ^          remove the blks
127  *              │        │                │
128  *              │        │                v
129  *              │  XFS_DAS_RMTBLK <─n── done?
130  *              │  re-enter with          │
131  *              │  one less blk to        y
132  *              │      remove             │
133  *              │                         V
134  *              │                  refill the state
135  *              n                         │
136  *              │                         v
137  *              │                   XFS_DAS_RM_NAME
138  *              │                         │
139  *              ├─────────────────────────┘
140  *              │
141  *              v
142  *       remove leaf and
143  *       update hash with
144  *   xfs_attr_node_remove_cleanup
145  *              │
146  *              v
147  *           need to
148  *        shrink tree? ─n─┐
149  *              │         │
150  *              y         │
151  *              │         │
152  *              v         │
153  *          join leaf     │
154  *              │         │
155  *              v         │
156  *      XFS_DAS_RM_SHRINK │
157  *              │         │
158  *              v         │
159  *       do the shrink    │
160  *              │         │
161  *              v         │
162  *          free state <──┘
163  *              │
164  *              v
165  *            done
166  *
167  *
168  * Below is a state machine diagram for attr set operations.
169  *
170  * It seems the challenge with understanding this system comes from trying to
171  * absorb the state machine all at once, when really one should only be looking
172  * at it with in the context of a single function. Once a state sensitive
173  * function is called, the idea is that it "takes ownership" of the
174  * state machine. It isn't concerned with the states that may have belonged to
175  * it's calling parent. Only the states relevant to itself or any other
176  * subroutines there in. Once a calling function hands off the state machine to
177  * a subroutine, it needs to respect the simple rule that it doesn't "own" the
178  * state machine anymore, and it's the responsibility of that calling function
179  * to propagate the -EAGAIN back up the call stack. Upon reentry, it is
180  * committed to re-calling that subroutine until it returns something other than
181  * -EAGAIN. Once that subroutine signals completion (by returning anything other
182  * than -EAGAIN), the calling function can resume using the state machine.
183  *
184  *  xfs_attr_set_iter()
185  *              │
186  *              v
187  *   ┌─y─ has an attr fork?
188  *   │          |
189  *   │          n
190  *   │          |
191  *   │          V
192  *   │       add a fork
193  *   │          │
194  *   └──────────┤
195  *              │
196  *              V
197  *   ┌─── is shortform?
198  *   │          │
199  *   │          y
200  *   │          │
201  *   │          V
202  *   │   xfs_attr_set_fmt
203  *   │          |
204  *   │          V
205  *   │ xfs_attr_try_sf_addname
206  *   │          │
207  *   │          V
208  *   │      had enough ──y──> done
209  *   │        space?
210  *   n          │
211  *   │          n
212  *   │          │
213  *   │          V
214  *   │   transform to leaf
215  *   │          │
216  *   │          V
217  *   │   hold the leaf buffer
218  *   │          │
219  *   │          V
220  *   │     return -EAGAIN
221  *   │      Re-enter in
222  *   │       leaf form
223  *   │
224  *   └─> release leaf buffer
225  *          if needed
226  *              │
227  *              V
228  *   ┌───n── fork has
229  *   │      only 1 blk?
230  *   │          │
231  *   │          y
232  *   │          │
233  *   │          v
234  *   │ xfs_attr_leaf_try_add()
235  *   │          │
236  *   │          v
237  *   │      had enough ──────────────y─────────────┐
238  *   │        space?                               │
239  *   │          │                                  │
240  *   │          n                                  │
241  *   │          │                                  │
242  *   │          v                                  │
243  *   │    return -EAGAIN                           │
244  *   │      re-enter in                            │
245  *   │        node form                            │
246  *   │          │                                  │
247  *   └──────────┤                                  │
248  *              │                                  │
249  *              V                                  │
250  * xfs_attr_node_addname_find_attr                 │
251  *        determines if this                       │
252  *       is create or rename                       │
253  *     find space to store attr                    │
254  *              │                                  │
255  *              v                                  │
256  *     xfs_attr_node_addname                       │
257  *              │                                  │
258  *              v                                  │
259  *   fits in a node leaf? ────n─────┐              │
260  *              │     ^             v              │
261  *              │     │       single leaf node?    │
262  *              │     │         │            │     │
263  *              y     │         y            n     │
264  *              │     │         │            │     │
265  *              v     │         v            v     │
266  *            update  │    grow the leaf  split if │
267  *           hashvals └── return -EAGAIN   needed  │
268  *              │         retry leaf add     │     │
269  *              │           on reentry       │     │
270  *              ├────────────────────────────┘     │
271  *              │                                  │
272  *              v                                  │
273  *         need to alloc                           │
274  *   ┌─y── or flip flag?                           │
275  *   │          │                                  │
276  *   │          n                                  │
277  *   │          │                                  │
278  *   │          v                                  │
279  *   │         done                                │
280  *   │                                             │
281  *   │                                             │
282  *   │         XFS_DAS_FOUND_LBLK <────────────────┘
283  *   │                  │
284  *   │                  V
285  *   │        xfs_attr_leaf_addname()
286  *   │                  │
287  *   │                  v
288  *   │      ┌──first time through?
289  *   │      │          │
290  *   │      │          y
291  *   │      │          │
292  *   │      n          v
293  *   │      │    if we have rmt blks
294  *   │      │    find space for them
295  *   │      │          │
296  *   │      └──────────┤
297  *   │                 │
298  *   │                 v
299  *   │            still have
300  *   │      ┌─n─ blks to alloc? <──┐
301  *   │      │          │           │
302  *   │      │          y           │
303  *   │      │          │           │
304  *   │      │          v           │
305  *   │      │     alloc one blk    │
306  *   │      │     return -EAGAIN ──┘
307  *   │      │    re-enter with one
308  *   │      │    less blk to alloc
309  *   │      │
310  *   │      │
311  *   │      └───> set the rmt
312  *   │               value
313  *   │                 │
314  *   │                 v
315  *   │               was this
316  *   │              a rename? ──n─┐
317  *   │                 │          │
318  *   │                 y          │
319  *   │                 │          │
320  *   │                 v          │
321  *   │           flip incomplete  │
322  *   │               flag         │
323  *   │                 │          │
324  *   │                 v          │
325  *   │         XFS_DAS_FLIP_LFLAG │
326  *   │                 │          │
327  *   │                 v          │
328  *   │          need to remove    │
329  *   │              old bks? ──n──┤
330  *   │                 │          │
331  *   │                 y          │
332  *   │                 │          │
333  *   │                 V          │
334  *   │               remove       │
335  *   │        ┌───> old blks      │
336  *   │        │        │          │
337  *   │ XFS_DAS_RM_LBLK │          │
338  *   │        ^        │          │
339  *   │        │        v          │
340  *   │        └──y── more to      │
341  *   │              remove?       │
342  *   │                 │          │
343  *   │                 n          │
344  *   │                 │          │
345  *   │                 v          │
346  *   │          XFS_DAS_RD_LEAF   │
347  *   │                 │          │
348  *   │                 v          │
349  *   │            remove leaf     │
350  *   │                 │          │
351  *   │                 v          │
352  *   │            shrink to sf    │
353  *   │             if needed      │
354  *   │                 │          │
355  *   │                 v          │
356  *   │                done <──────┘
357  *   │
358  *   └──────> XFS_DAS_FOUND_NBLK
359  *                     │
360  *                     v
361  *       ┌─────n──  need to
362  *       │        alloc blks?
363  *       │             │
364  *       │             y
365  *       │             │
366  *       │             v
367  *       │        find space
368  *       │             │
369  *       │             v
370  *       │  ┌─>XFS_DAS_ALLOC_NODE
371  *       │  │          │
372  *       │  │          v
373  *       │  │      alloc blk
374  *       │  │          │
375  *       │  │          v
376  *       │  └──y── need to alloc
377  *       │         more blocks?
378  *       │             │
379  *       │             n
380  *       │             │
381  *       │             v
382  *       │      set the rmt value
383  *       │             │
384  *       │             v
385  *       │          was this
386  *       └────────> a rename? ──n─┐
387  *                     │          │
388  *                     y          │
389  *                     │          │
390  *                     v          │
391  *               flip incomplete  │
392  *                   flag         │
393  *                     │          │
394  *                     v          │
395  *             XFS_DAS_FLIP_NFLAG │
396  *                     │          │
397  *                     v          │
398  *                 need to        │
399  *               remove blks? ─n──┤
400  *                     │          │
401  *                     y          │
402  *                     │          │
403  *                     v          │
404  *                   remove       │
405  *        ┌────────> old blks     │
406  *        │            │          │
407  *  XFS_DAS_RM_NBLK    │          │
408  *        ^            │          │
409  *        │            v          │
410  *        └──────y── more to      │
411  *                   remove       │
412  *                     │          │
413  *                     n          │
414  *                     │          │
415  *                     v          │
416  *              XFS_DAS_CLR_FLAG  │
417  *                     │          │
418  *                     v          │
419  *                clear flags     │
420  *                     │          │
421  *                     ├──────────┘
422  *                     │
423  *                     v
424  *                   done
425  */
426 
427 /*
428  * Enum values for xfs_attr_intent.xattri_da_state
429  *
430  * These values are used by delayed attribute operations to keep track  of where
431  * they were before they returned -EAGAIN.  A return code of -EAGAIN signals the
432  * calling function to roll the transaction, and then call the subroutine to
433  * finish the operation.  The enum is then used by the subroutine to jump back
434  * to where it was and resume executing where it left off.
435  */
436 enum xfs_delattr_state {
437 	XFS_DAS_UNINIT		= 0,	/* No state has been set yet */
438 
439 	/*
440 	 * Initial sequence states. The replace setup code relies on the
441 	 * ADD and REMOVE states for a specific format to be sequential so
442 	 * that we can transform the initial operation to be performed
443 	 * according to the xfs_has_larp() state easily.
444 	 */
445 	XFS_DAS_SF_ADD,			/* Initial sf add state */
446 	XFS_DAS_SF_REMOVE,		/* Initial sf replace/remove state */
447 
448 	XFS_DAS_LEAF_ADD,		/* Initial leaf add state */
449 	XFS_DAS_LEAF_REMOVE,		/* Initial leaf replace/remove state */
450 
451 	XFS_DAS_NODE_ADD,		/* Initial node add state */
452 	XFS_DAS_NODE_REMOVE,		/* Initial node replace/remove state */
453 
454 	/* Leaf state set/replace/remove sequence */
455 	XFS_DAS_LEAF_SET_RMT,		/* set a remote xattr from a leaf */
456 	XFS_DAS_LEAF_ALLOC_RMT,		/* We are allocating remote blocks */
457 	XFS_DAS_LEAF_REPLACE,		/* Perform replace ops on a leaf */
458 	XFS_DAS_LEAF_REMOVE_OLD,	/* Start removing old attr from leaf */
459 	XFS_DAS_LEAF_REMOVE_RMT,	/* A rename is removing remote blocks */
460 	XFS_DAS_LEAF_REMOVE_ATTR,	/* Remove the old attr from a leaf */
461 
462 	/* Node state sequence, must match leaf state above */
463 	XFS_DAS_NODE_SET_RMT,		/* set a remote xattr from a node */
464 	XFS_DAS_NODE_ALLOC_RMT,		/* We are allocating remote blocks */
465 	XFS_DAS_NODE_REPLACE,		/* Perform replace ops on a node */
466 	XFS_DAS_NODE_REMOVE_OLD,	/* Start removing old attr from node */
467 	XFS_DAS_NODE_REMOVE_RMT,	/* A rename is removing remote blocks */
468 	XFS_DAS_NODE_REMOVE_ATTR,	/* Remove the old attr from a node */
469 
470 	XFS_DAS_DONE,			/* finished operation */
471 };
472 
473 #define XFS_DAS_STRINGS	\
474 	{ XFS_DAS_UNINIT,		"XFS_DAS_UNINIT" }, \
475 	{ XFS_DAS_SF_ADD,		"XFS_DAS_SF_ADD" }, \
476 	{ XFS_DAS_SF_REMOVE,		"XFS_DAS_SF_REMOVE" }, \
477 	{ XFS_DAS_LEAF_ADD,		"XFS_DAS_LEAF_ADD" }, \
478 	{ XFS_DAS_LEAF_REMOVE,		"XFS_DAS_LEAF_REMOVE" }, \
479 	{ XFS_DAS_NODE_ADD,		"XFS_DAS_NODE_ADD" }, \
480 	{ XFS_DAS_NODE_REMOVE,		"XFS_DAS_NODE_REMOVE" }, \
481 	{ XFS_DAS_LEAF_SET_RMT,		"XFS_DAS_LEAF_SET_RMT" }, \
482 	{ XFS_DAS_LEAF_ALLOC_RMT,	"XFS_DAS_LEAF_ALLOC_RMT" }, \
483 	{ XFS_DAS_LEAF_REPLACE,		"XFS_DAS_LEAF_REPLACE" }, \
484 	{ XFS_DAS_LEAF_REMOVE_OLD,	"XFS_DAS_LEAF_REMOVE_OLD" }, \
485 	{ XFS_DAS_LEAF_REMOVE_RMT,	"XFS_DAS_LEAF_REMOVE_RMT" }, \
486 	{ XFS_DAS_LEAF_REMOVE_ATTR,	"XFS_DAS_LEAF_REMOVE_ATTR" }, \
487 	{ XFS_DAS_NODE_SET_RMT,		"XFS_DAS_NODE_SET_RMT" }, \
488 	{ XFS_DAS_NODE_ALLOC_RMT,	"XFS_DAS_NODE_ALLOC_RMT" },  \
489 	{ XFS_DAS_NODE_REPLACE,		"XFS_DAS_NODE_REPLACE" },  \
490 	{ XFS_DAS_NODE_REMOVE_OLD,	"XFS_DAS_NODE_REMOVE_OLD" }, \
491 	{ XFS_DAS_NODE_REMOVE_RMT,	"XFS_DAS_NODE_REMOVE_RMT" }, \
492 	{ XFS_DAS_NODE_REMOVE_ATTR,	"XFS_DAS_NODE_REMOVE_ATTR" }, \
493 	{ XFS_DAS_DONE,			"XFS_DAS_DONE" }
494 
495 struct xfs_attri_log_nameval;
496 
497 /*
498  * Context used for keeping track of delayed attribute operations
499  */
500 struct xfs_attr_intent {
501 	/*
502 	 * used to log this item to an intent containing a list of attrs to
503 	 * commit later
504 	 */
505 	struct list_head		xattri_list;
506 
507 	/* Used in xfs_attr_node_removename to roll through removing blocks */
508 	struct xfs_da_state		*xattri_da_state;
509 
510 	struct xfs_da_args		*xattri_da_args;
511 
512 	/*
513 	 * Shared buffer containing the attr name and value so that the logging
514 	 * code can share large memory buffers between log items.
515 	 */
516 	struct xfs_attri_log_nameval	*xattri_nameval;
517 
518 	/* Used to keep track of current state of delayed operation */
519 	enum xfs_delattr_state		xattri_dela_state;
520 
521 	/*
522 	 * Attr operation being performed - XFS_ATTRI_OP_FLAGS_*
523 	 */
524 	unsigned int			xattri_op_flags;
525 
526 	/* Used in xfs_attr_rmtval_set_blk to roll through allocating blocks */
527 	xfs_dablk_t			xattri_lblkno;
528 	int				xattri_blkcnt;
529 	struct xfs_bmbt_irec		xattri_map;
530 };
531 
532 
533 /*========================================================================
534  * Function prototypes for the kernel.
535  *========================================================================*/
536 
537 /*
538  * Overall external interface routines.
539  */
540 int xfs_attr_inactive(struct xfs_inode *dp);
541 int xfs_attr_list_ilocked(struct xfs_attr_list_context *);
542 int xfs_attr_list(struct xfs_attr_list_context *);
543 int xfs_inode_hasattr(struct xfs_inode *ip);
544 bool xfs_attr_is_leaf(struct xfs_inode *ip);
545 int xfs_attr_get_ilocked(struct xfs_da_args *args);
546 int xfs_attr_get(struct xfs_da_args *args);
547 int xfs_attr_set(struct xfs_da_args *args);
548 int xfs_attr_set_iter(struct xfs_attr_intent *attr);
549 int xfs_attr_remove_iter(struct xfs_attr_intent *attr);
550 bool xfs_attr_namecheck(const void *name, size_t length);
551 int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
552 void xfs_init_attr_trans(struct xfs_da_args *args, struct xfs_trans_res *tres,
553 			 unsigned int *total);
554 
555 /*
556  * Check to see if the attr should be upgraded from non-existent or shortform to
557  * single-leaf-block attribute list.
558  */
559 static inline bool
xfs_attr_is_shortform(struct xfs_inode * ip)560 xfs_attr_is_shortform(
561 	struct xfs_inode    *ip)
562 {
563 	return ip->i_af.if_format == XFS_DINODE_FMT_LOCAL ||
564 	       (ip->i_af.if_format == XFS_DINODE_FMT_EXTENTS &&
565 		ip->i_af.if_nextents == 0);
566 }
567 
568 static inline enum xfs_delattr_state
xfs_attr_init_add_state(struct xfs_da_args * args)569 xfs_attr_init_add_state(struct xfs_da_args *args)
570 {
571 	/*
572 	 * When called from the completion of a attr remove to determine the
573 	 * next state, the attribute fork may be null. This can occur only occur
574 	 * on a pure remove, but we grab the next state before we check if a
575 	 * replace operation is being performed. If we are called from any other
576 	 * context, i_af is guaranteed to exist. Hence if the attr fork is
577 	 * null, we were called from a pure remove operation and so we are done.
578 	 */
579 	if (!xfs_inode_has_attr_fork(args->dp))
580 		return XFS_DAS_DONE;
581 
582 	args->op_flags |= XFS_DA_OP_ADDNAME;
583 	if (xfs_attr_is_shortform(args->dp))
584 		return XFS_DAS_SF_ADD;
585 	if (xfs_attr_is_leaf(args->dp))
586 		return XFS_DAS_LEAF_ADD;
587 	return XFS_DAS_NODE_ADD;
588 }
589 
590 static inline enum xfs_delattr_state
xfs_attr_init_remove_state(struct xfs_da_args * args)591 xfs_attr_init_remove_state(struct xfs_da_args *args)
592 {
593 	args->op_flags |= XFS_DA_OP_REMOVE;
594 	if (xfs_attr_is_shortform(args->dp))
595 		return XFS_DAS_SF_REMOVE;
596 	if (xfs_attr_is_leaf(args->dp))
597 		return XFS_DAS_LEAF_REMOVE;
598 	return XFS_DAS_NODE_REMOVE;
599 }
600 
601 /*
602  * If we are logging the attributes, then we have to start with removal of the
603  * old attribute so that there is always consistent state that we can recover
604  * from if the system goes down part way through. We always log the new attr
605  * value, so even when we remove the attr first we still have the information in
606  * the log to finish the replace operation atomically.
607  */
608 static inline enum xfs_delattr_state
xfs_attr_init_replace_state(struct xfs_da_args * args)609 xfs_attr_init_replace_state(struct xfs_da_args *args)
610 {
611 	args->op_flags |= XFS_DA_OP_ADDNAME | XFS_DA_OP_REPLACE;
612 	if (args->op_flags & XFS_DA_OP_LOGGED)
613 		return xfs_attr_init_remove_state(args);
614 	return xfs_attr_init_add_state(args);
615 }
616 
617 extern struct kmem_cache *xfs_attr_intent_cache;
618 int __init xfs_attr_intent_init_cache(void);
619 void xfs_attr_intent_destroy_cache(void);
620 
621 #endif	/* __XFS_ATTR_H__ */
622