| 1 |
// SPDX-License-Identifier: GPL-2.0 |
| 2 |
/* |
| 3 |
File: fs/ext4/xattr.h |
| 4 |
|
| 5 |
On-disk format of extended attributes for the ext4 filesystem. |
| 6 |
|
| 7 |
(C) 2001 Andreas Gruenbacher, <[email protected]> |
| 8 |
*/ |
| 9 |
|
| 10 |
#include <linux/xattr.h> |
| 11 |
|
| 12 |
/* Magic value in attribute blocks */ |
| 13 |
#define EXT4_XATTR_MAGIC 0xEA020000 |
| 14 |
|
| 15 |
/* Maximum number of references to one attribute block */ |
| 16 |
#define EXT4_XATTR_REFCOUNT_MAX 1024 |
| 17 |
|
| 18 |
/* Name indexes */ |
| 19 |
#define EXT4_XATTR_INDEX_USER 1 |
| 20 |
#define EXT4_XATTR_INDEX_POSIX_ACL_ACCESS 2 |
| 21 |
#define EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT 3 |
| 22 |
#define EXT4_XATTR_INDEX_TRUSTED 4 |
| 23 |
#define EXT4_XATTR_INDEX_LUSTRE 5 |
| 24 |
#define EXT4_XATTR_INDEX_SECURITY 6 |
| 25 |
#define EXT4_XATTR_INDEX_SYSTEM 7 |
| 26 |
#define EXT4_XATTR_INDEX_RICHACL 8 |
| 27 |
#define EXT4_XATTR_INDEX_ENCRYPTION 9 |
| 28 |
#define EXT4_XATTR_INDEX_HURD 10 /* Reserved for Hurd */ |
| 29 |
|
| 30 |
struct ext4_xattr_header { |
| 31 |
__le32 h_magic; /* magic number for identification */ |
| 32 |
__le32 h_refcount; /* reference count */ |
| 33 |
__le32 h_blocks; /* number of disk blocks used */ |
| 34 |
__le32 h_hash; /* hash value of all attributes */ |
| 35 |
__le32 h_checksum; /* crc32c(uuid+blknum+xattrblock) */ |
| 36 |
__u32 h_reserved[3]; /* zero right now */ |
| 37 |
}; |
| 38 |
|
| 39 |
struct ext4_xattr_ibody_header { |
| 40 |
__le32 h_magic; /* magic number for identification */ |
| 41 |
}; |
| 42 |
|
| 43 |
struct ext4_xattr_entry { |
| 44 |
__u8 e_name_len; /* length of name */ |
| 45 |
__u8 e_name_index; /* attribute name index */ |
| 46 |
__le16 e_value_offs; /* offset in disk block of value */ |
| 47 |
__le32 e_value_inum; /* inode in which the value is stored */ |
| 48 |
__le32 e_value_size; /* size of attribute value */ |
| 49 |
__le32 e_hash; /* hash value of name and value */ |
| 50 |
char e_name[]; /* attribute name */ |
| 51 |
}; |
| 52 |
|
| 53 |
#define EXT4_XATTR_PAD_BITS 2 |
| 54 |
#define EXT4_XATTR_PAD (1<<EXT4_XATTR_PAD_BITS) |
| 55 |
#define EXT4_XATTR_ROUND (EXT4_XATTR_PAD-1) |
| 56 |
#define EXT4_XATTR_LEN(name_len) \ |
| 57 |
(((name_len) + EXT4_XATTR_ROUND + \ |
| 58 |
sizeof(struct ext4_xattr_entry)) & ~EXT4_XATTR_ROUND) |
| 59 |
#define EXT4_XATTR_NEXT(entry) \ |
| 60 |
((struct ext4_xattr_entry *)( \ |
| 61 |
(char *)(entry) + EXT4_XATTR_LEN((entry)->e_name_len))) |
| 62 |
#define EXT4_XATTR_SIZE(size) \ |
| 63 |
(((size) + EXT4_XATTR_ROUND) & ~EXT4_XATTR_ROUND) |
| 64 |
|
| 65 |
#define IHDR(inode, raw_inode) \ |
| 66 |
((struct ext4_xattr_ibody_header *) \ |
| 67 |
((void *)raw_inode + \ |
| 68 |
EXT4_GOOD_OLD_INODE_SIZE + \ |
| 69 |
EXT4_I(inode)->i_extra_isize)) |
| 70 |
#define ITAIL(inode, raw_inode) \ |
| 71 |
((void *)(raw_inode) + \ |
| 72 |
EXT4_SB((inode)->i_sb)->s_inode_size) |
| 73 |
#define IFIRST(hdr) ((struct ext4_xattr_entry *)((hdr)+1)) |
| 74 |
|
| 75 |
/* |
| 76 |
* XATTR_SIZE_MAX is currently 64k, but for the purposes of checking |
| 77 |
* for file system consistency errors, we use a somewhat bigger value. |
| 78 |
* This allows XATTR_SIZE_MAX to grow in the future, but by using this |
| 79 |
* instead of INT_MAX for certain consistency checks, we don't need to |
| 80 |
* worry about arithmetic overflows. (Actually XATTR_SIZE_MAX is |
| 81 |
* defined in include/uapi/linux/limits.h, so changing it is going |
| 82 |
* not going to be trivial....) |
| 83 |
*/ |
| 84 |
#define EXT4_XATTR_SIZE_MAX (1 << 24) |
| 85 |
|
| 86 |
/* |
| 87 |
* The minimum size of EA value when you start storing it in an external inode |
| 88 |
* size of block - size of header - size of 1 entry - 4 null bytes |
| 89 |
*/ |
| 90 |
#define EXT4_XATTR_MIN_LARGE_EA_SIZE(b) \ |
| 91 |
((b) - EXT4_XATTR_LEN(3) - sizeof(struct ext4_xattr_header) - 4) |
| 92 |
|
| 93 |
#define BHDR(bh) ((struct ext4_xattr_header *)((bh)->b_data)) |
| 94 |
#define ENTRY(ptr) ((struct ext4_xattr_entry *)(ptr)) |
| 95 |
#define BFIRST(bh) ENTRY(BHDR(bh)+1) |
| 96 |
#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0) |
| 97 |
|
| 98 |
#define EXT4_ZERO_XATTR_VALUE ((void *)-1) |
| 99 |
|
| 100 |
/* |
| 101 |
* If we want to add an xattr to the inode, we should make sure that |
| 102 |
* i_extra_isize is not 0 and that the inode size is not less than |
| 103 |
* EXT4_GOOD_OLD_INODE_SIZE + extra_isize + pad. |
| 104 |
* EXT4_GOOD_OLD_INODE_SIZE extra_isize header entry pad data |
| 105 |
* |--------------------------|------------|------|---------|---|-------| |
| 106 |
*/ |
| 107 |
#define EXT4_INODE_HAS_XATTR_SPACE(inode) \ |
| 108 |
((EXT4_I(inode)->i_extra_isize != 0) && \ |
| 109 |
(EXT4_GOOD_OLD_INODE_SIZE + EXT4_I(inode)->i_extra_isize + \ |
| 110 |
sizeof(struct ext4_xattr_ibody_header) + EXT4_XATTR_PAD <= \ |
| 111 |
EXT4_INODE_SIZE((inode)->i_sb))) |
| 112 |
|
| 113 |
struct ext4_xattr_info { |
| 114 |
const char *name; |
| 115 |
const void *value; |
| 116 |
size_t value_len; |
| 117 |
int name_index; |
| 118 |
int in_inode; |
| 119 |
}; |
| 120 |
|
| 121 |
struct ext4_xattr_search { |
| 122 |
struct ext4_xattr_entry *first; |
| 123 |
void *base; |
| 124 |
void *end; |
| 125 |
struct ext4_xattr_entry *here; |
| 126 |
int not_found; |
| 127 |
}; |
| 128 |
|
| 129 |
struct ext4_xattr_ibody_find { |
| 130 |
struct ext4_xattr_search s; |
| 131 |
struct ext4_iloc iloc; |
| 132 |
}; |
| 133 |
|
| 134 |
struct ext4_xattr_inode_array { |
| 135 |
unsigned int count; |
| 136 |
struct inode *inodes[] __counted_by(count); |
| 137 |
}; |
| 138 |
|
| 139 |
extern const struct xattr_handler ext4_xattr_user_handler; |
| 140 |
extern const struct xattr_handler ext4_xattr_trusted_handler; |
| 141 |
extern const struct xattr_handler ext4_xattr_security_handler; |
| 142 |
extern const struct xattr_handler ext4_xattr_hurd_handler; |
| 143 |
|
| 144 |
#define EXT4_XATTR_NAME_ENCRYPTION_CONTEXT "c" |
| 145 |
|
| 146 |
/* |
| 147 |
* The EXT4_STATE_NO_EXPAND is overloaded and used for two purposes. |
| 148 |
* The first is to signal that there the inline xattrs and data are |
| 149 |
* taking up so much space that we might as well not keep trying to |
| 150 |
* expand it. The second is that xattr_sem is taken for writing, so |
| 151 |
* we shouldn't try to recurse into the inode expansion. For this |
| 152 |
* second case, we need to make sure that we take save and restore the |
| 153 |
* NO_EXPAND state flag appropriately. |
| 154 |
*/ |
| 155 |
static inline void ext4_write_lock_xattr(struct inode *inode, int *save) |
| 156 |
{ |
| 157 |
down_write(&EXT4_I(inode)->xattr_sem); |
| 158 |
*save = ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND); |
| 159 |
ext4_set_inode_state(inode, EXT4_STATE_NO_EXPAND); |
| 160 |
} |
| 161 |
|
| 162 |
static inline int ext4_write_trylock_xattr(struct inode *inode, int *save) |
| 163 |
{ |
| 164 |
if (down_write_trylock(&EXT4_I(inode)->xattr_sem) == 0) |
| 165 |
return 0; |
| 166 |
*save = ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND); |
| 167 |
ext4_set_inode_state(inode, EXT4_STATE_NO_EXPAND); |
| 168 |
return 1; |
| 169 |
} |
| 170 |
|
| 171 |
static inline void ext4_write_unlock_xattr(struct inode *inode, int *save) |
| 172 |
{ |
| 173 |
if (*save == 0) |
| 174 |
ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND); |
| 175 |
up_write(&EXT4_I(inode)->xattr_sem); |
| 176 |
} |
| 177 |
|
| 178 |
extern ssize_t ext4_listxattr(struct dentry *, char *, size_t); |
| 179 |
|
| 180 |
extern int ext4_xattr_get(struct inode *, int, const char *, void *, size_t); |
| 181 |
extern int ext4_xattr_set(struct inode *, int, const char *, const void *, size_t, int); |
| 182 |
extern int ext4_xattr_set_handle(handle_t *, struct inode *, int, const char *, const void *, size_t, int); |
| 183 |
extern int ext4_xattr_set_credits(struct inode *inode, size_t value_len, |
| 184 |
bool is_create, int *credits); |
| 185 |
extern int __ext4_xattr_set_credits(struct super_block *sb, struct inode *inode, |
| 186 |
struct buffer_head *block_bh, size_t value_len, |
| 187 |
bool is_create); |
| 188 |
|
| 189 |
extern int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode, |
| 190 |
struct ext4_xattr_inode_array **array, |
| 191 |
int extra_credits); |
| 192 |
extern void ext4_xattr_inode_array_free(struct ext4_xattr_inode_array *array); |
| 193 |
|
| 194 |
extern int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize, |
| 195 |
struct ext4_inode *raw_inode, handle_t *handle); |
| 196 |
extern void ext4_evict_ea_inode(struct inode *inode); |
| 197 |
|
| 198 |
extern const struct xattr_handler * const ext4_xattr_handlers[]; |
| 199 |
|
| 200 |
extern int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i, |
| 201 |
struct ext4_xattr_ibody_find *is); |
| 202 |
extern int ext4_xattr_ibody_get(struct inode *inode, int name_index, |
| 203 |
const char *name, |
| 204 |
void *buffer, size_t buffer_size); |
| 205 |
extern int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode, |
| 206 |
struct ext4_xattr_info *i, |
| 207 |
struct ext4_xattr_ibody_find *is); |
| 208 |
|
| 209 |
extern struct mb_cache *ext4_xattr_create_cache(void); |
| 210 |
extern void ext4_xattr_destroy_cache(struct mb_cache *); |
| 211 |
|
| 212 |
extern int |
| 213 |
__xattr_check_inode(struct inode *inode, struct ext4_xattr_ibody_header *header, |
| 214 |
void *end, const char *function, unsigned int line); |
| 215 |
|
| 216 |
#define xattr_check_inode(inode, header, end) \ |
| 217 |
__xattr_check_inode((inode), (header), (end), __func__, __LINE__) |
| 218 |
|
| 219 |
#ifdef CONFIG_EXT4_FS_SECURITY |
| 220 |
extern int ext4_init_security(handle_t *handle, struct inode *inode, |
| 221 |
struct inode *dir, const struct qstr *qstr); |
| 222 |
#else |
| 223 |
static inline int ext4_init_security(handle_t *handle, struct inode *inode, |
| 224 |
struct inode *dir, const struct qstr *qstr) |
| 225 |
{ |
| 226 |
return 0; |
| 227 |
} |
| 228 |
#endif |
| 229 |
|
| 230 |
#ifdef CONFIG_LOCKDEP |
| 231 |
extern void ext4_xattr_inode_set_class(struct inode *ea_inode); |
| 232 |
#else |
| 233 |
static inline void ext4_xattr_inode_set_class(struct inode *ea_inode) { } |
| 234 |
#endif |
| 235 |
|
| 236 |
extern int ext4_get_inode_usage(struct inode *inode, qsize_t *usage); |