1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
8 * Portions of this code from linux/fs/ext2/xattr.c
10 * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
12 * Fix by Harrison Xing <harrison@mountainviewdata.com>.
13 * Extended attributes for symlinks and special files added per
14 * suggestion of Luka Renko <luka.renko@hermes.si>.
15 * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
18 #include <linux/rwsem.h>
19 #include <linux/f2fs_fs.h>
20 #include <linux/security.h>
21 #include <linux/posix_acl_xattr.h>
25 static int f2fs_xattr_generic_get(const struct xattr_handler
*handler
,
26 struct dentry
*unused
, struct inode
*inode
,
27 const char *name
, void *buffer
, size_t size
)
29 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
31 switch (handler
->flags
) {
32 case F2FS_XATTR_INDEX_USER
:
33 if (!test_opt(sbi
, XATTR_USER
))
36 case F2FS_XATTR_INDEX_TRUSTED
:
37 case F2FS_XATTR_INDEX_SECURITY
:
42 return f2fs_getxattr(inode
, handler
->flags
, name
,
46 static int f2fs_xattr_generic_set(const struct xattr_handler
*handler
,
47 struct dentry
*unused
, struct inode
*inode
,
48 const char *name
, const void *value
,
49 size_t size
, int flags
)
51 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
53 switch (handler
->flags
) {
54 case F2FS_XATTR_INDEX_USER
:
55 if (!test_opt(sbi
, XATTR_USER
))
58 case F2FS_XATTR_INDEX_TRUSTED
:
59 case F2FS_XATTR_INDEX_SECURITY
:
64 return f2fs_setxattr(inode
, handler
->flags
, name
,
65 value
, size
, NULL
, flags
);
68 static bool f2fs_xattr_user_list(struct dentry
*dentry
)
70 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
72 return test_opt(sbi
, XATTR_USER
);
75 static bool f2fs_xattr_trusted_list(struct dentry
*dentry
)
77 return capable(CAP_SYS_ADMIN
);
80 static int f2fs_xattr_advise_get(const struct xattr_handler
*handler
,
81 struct dentry
*unused
, struct inode
*inode
,
82 const char *name
, void *buffer
, size_t size
)
85 *((char *)buffer
) = F2FS_I(inode
)->i_advise
;
89 static int f2fs_xattr_advise_set(const struct xattr_handler
*handler
,
90 struct dentry
*unused
, struct inode
*inode
,
91 const char *name
, const void *value
,
92 size_t size
, int flags
)
94 unsigned char old_advise
= F2FS_I(inode
)->i_advise
;
95 unsigned char new_advise
;
97 if (!inode_owner_or_capable(inode
))
102 new_advise
= *(char *)value
;
103 if (new_advise
& ~FADVISE_MODIFIABLE_BITS
)
106 new_advise
= new_advise
& FADVISE_MODIFIABLE_BITS
;
107 new_advise
|= old_advise
& ~FADVISE_MODIFIABLE_BITS
;
109 F2FS_I(inode
)->i_advise
= new_advise
;
110 f2fs_mark_inode_dirty_sync(inode
, true);
114 #ifdef CONFIG_F2FS_FS_SECURITY
115 static int f2fs_initxattrs(struct inode
*inode
, const struct xattr
*xattr_array
,
118 const struct xattr
*xattr
;
121 for (xattr
= xattr_array
; xattr
->name
!= NULL
; xattr
++) {
122 err
= f2fs_setxattr(inode
, F2FS_XATTR_INDEX_SECURITY
,
123 xattr
->name
, xattr
->value
,
124 xattr
->value_len
, (struct page
*)page
, 0);
131 int f2fs_init_security(struct inode
*inode
, struct inode
*dir
,
132 const struct qstr
*qstr
, struct page
*ipage
)
134 return security_inode_init_security(inode
, dir
, qstr
,
135 &f2fs_initxattrs
, ipage
);
139 const struct xattr_handler f2fs_xattr_user_handler
= {
140 .prefix
= XATTR_USER_PREFIX
,
141 .flags
= F2FS_XATTR_INDEX_USER
,
142 .list
= f2fs_xattr_user_list
,
143 .get
= f2fs_xattr_generic_get
,
144 .set
= f2fs_xattr_generic_set
,
147 const struct xattr_handler f2fs_xattr_trusted_handler
= {
148 .prefix
= XATTR_TRUSTED_PREFIX
,
149 .flags
= F2FS_XATTR_INDEX_TRUSTED
,
150 .list
= f2fs_xattr_trusted_list
,
151 .get
= f2fs_xattr_generic_get
,
152 .set
= f2fs_xattr_generic_set
,
155 const struct xattr_handler f2fs_xattr_advise_handler
= {
156 .name
= F2FS_SYSTEM_ADVISE_NAME
,
157 .flags
= F2FS_XATTR_INDEX_ADVISE
,
158 .get
= f2fs_xattr_advise_get
,
159 .set
= f2fs_xattr_advise_set
,
162 const struct xattr_handler f2fs_xattr_security_handler
= {
163 .prefix
= XATTR_SECURITY_PREFIX
,
164 .flags
= F2FS_XATTR_INDEX_SECURITY
,
165 .get
= f2fs_xattr_generic_get
,
166 .set
= f2fs_xattr_generic_set
,
169 static const struct xattr_handler
*f2fs_xattr_handler_map
[] = {
170 [F2FS_XATTR_INDEX_USER
] = &f2fs_xattr_user_handler
,
171 #ifdef CONFIG_F2FS_FS_POSIX_ACL
172 [F2FS_XATTR_INDEX_POSIX_ACL_ACCESS
] = &posix_acl_access_xattr_handler
,
173 [F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT
] = &posix_acl_default_xattr_handler
,
175 [F2FS_XATTR_INDEX_TRUSTED
] = &f2fs_xattr_trusted_handler
,
176 #ifdef CONFIG_F2FS_FS_SECURITY
177 [F2FS_XATTR_INDEX_SECURITY
] = &f2fs_xattr_security_handler
,
179 [F2FS_XATTR_INDEX_ADVISE
] = &f2fs_xattr_advise_handler
,
182 const struct xattr_handler
*f2fs_xattr_handlers
[] = {
183 &f2fs_xattr_user_handler
,
184 #ifdef CONFIG_F2FS_FS_POSIX_ACL
185 &posix_acl_access_xattr_handler
,
186 &posix_acl_default_xattr_handler
,
188 &f2fs_xattr_trusted_handler
,
189 #ifdef CONFIG_F2FS_FS_SECURITY
190 &f2fs_xattr_security_handler
,
192 &f2fs_xattr_advise_handler
,
196 static inline const struct xattr_handler
*f2fs_xattr_handler(int index
)
198 const struct xattr_handler
*handler
= NULL
;
200 if (index
> 0 && index
< ARRAY_SIZE(f2fs_xattr_handler_map
))
201 handler
= f2fs_xattr_handler_map
[index
];
205 static struct f2fs_xattr_entry
*__find_xattr(void *base_addr
, int index
,
206 size_t len
, const char *name
)
208 struct f2fs_xattr_entry
*entry
;
210 list_for_each_xattr(entry
, base_addr
) {
211 if (entry
->e_name_index
!= index
)
213 if (entry
->e_name_len
!= len
)
215 if (!memcmp(entry
->e_name
, name
, len
))
221 static struct f2fs_xattr_entry
*__find_inline_xattr(struct inode
*inode
,
222 void *base_addr
, void **last_addr
, int index
,
223 size_t len
, const char *name
)
225 struct f2fs_xattr_entry
*entry
;
226 unsigned int inline_size
= inline_xattr_size(inode
);
228 list_for_each_xattr(entry
, base_addr
) {
229 if ((void *)entry
+ sizeof(__u32
) > base_addr
+ inline_size
||
230 (void *)XATTR_NEXT_ENTRY(entry
) + sizeof(__u32
) >
231 base_addr
+ inline_size
) {
235 if (entry
->e_name_index
!= index
)
237 if (entry
->e_name_len
!= len
)
239 if (!memcmp(entry
->e_name
, name
, len
))
245 static int read_inline_xattr(struct inode
*inode
, struct page
*ipage
,
248 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
249 unsigned int inline_size
= inline_xattr_size(inode
);
250 struct page
*page
= NULL
;
254 inline_addr
= inline_xattr_addr(inode
, ipage
);
256 page
= f2fs_get_node_page(sbi
, inode
->i_ino
);
258 return PTR_ERR(page
);
260 inline_addr
= inline_xattr_addr(inode
, page
);
262 memcpy(txattr_addr
, inline_addr
, inline_size
);
263 f2fs_put_page(page
, 1);
268 static int read_xattr_block(struct inode
*inode
, void *txattr_addr
)
270 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
271 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
272 unsigned int inline_size
= inline_xattr_size(inode
);
276 /* The inode already has an extended attribute block. */
277 xpage
= f2fs_get_node_page(sbi
, xnid
);
279 return PTR_ERR(xpage
);
281 xattr_addr
= page_address(xpage
);
282 memcpy(txattr_addr
+ inline_size
, xattr_addr
, VALID_XATTR_BLOCK_SIZE
);
283 f2fs_put_page(xpage
, 1);
288 static int lookup_all_xattrs(struct inode
*inode
, struct page
*ipage
,
289 unsigned int index
, unsigned int len
,
290 const char *name
, struct f2fs_xattr_entry
**xe
,
293 void *cur_addr
, *txattr_addr
, *last_addr
= NULL
;
294 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
295 unsigned int size
= xnid
? VALID_XATTR_BLOCK_SIZE
: 0;
296 unsigned int inline_size
= inline_xattr_size(inode
);
299 if (!size
&& !inline_size
)
302 txattr_addr
= f2fs_kzalloc(F2FS_I_SB(inode
),
303 inline_size
+ size
+ XATTR_PADDING_SIZE
, GFP_NOFS
);
307 /* read from inline xattr */
309 err
= read_inline_xattr(inode
, ipage
, txattr_addr
);
313 *xe
= __find_inline_xattr(inode
, txattr_addr
, &last_addr
,
319 /* read from xattr node block */
321 err
= read_xattr_block(inode
, txattr_addr
);
327 cur_addr
= XATTR_HDR(last_addr
) - 1;
329 cur_addr
= txattr_addr
;
331 *xe
= __find_xattr(cur_addr
, index
, len
, name
);
333 if (IS_XATTR_LAST_ENTRY(*xe
)) {
338 *base_addr
= txattr_addr
;
345 static int read_all_xattrs(struct inode
*inode
, struct page
*ipage
,
348 struct f2fs_xattr_header
*header
;
349 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
350 unsigned int size
= VALID_XATTR_BLOCK_SIZE
;
351 unsigned int inline_size
= inline_xattr_size(inode
);
355 txattr_addr
= f2fs_kzalloc(F2FS_I_SB(inode
),
356 inline_size
+ size
+ XATTR_PADDING_SIZE
, GFP_NOFS
);
360 /* read from inline xattr */
362 err
= read_inline_xattr(inode
, ipage
, txattr_addr
);
367 /* read from xattr node block */
369 err
= read_xattr_block(inode
, txattr_addr
);
374 header
= XATTR_HDR(txattr_addr
);
376 /* never been allocated xattrs */
377 if (le32_to_cpu(header
->h_magic
) != F2FS_XATTR_MAGIC
) {
378 header
->h_magic
= cpu_to_le32(F2FS_XATTR_MAGIC
);
379 header
->h_refcount
= cpu_to_le32(1);
381 *base_addr
= txattr_addr
;
388 static inline int write_all_xattrs(struct inode
*inode
, __u32 hsize
,
389 void *txattr_addr
, struct page
*ipage
)
391 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
392 size_t inline_size
= inline_xattr_size(inode
);
393 struct page
*in_page
= NULL
;
395 void *inline_addr
= NULL
;
400 if (hsize
> inline_size
&& !F2FS_I(inode
)->i_xattr_nid
)
401 if (!f2fs_alloc_nid(sbi
, &new_nid
))
404 /* write to inline xattr */
407 inline_addr
= inline_xattr_addr(inode
, ipage
);
409 in_page
= f2fs_get_node_page(sbi
, inode
->i_ino
);
410 if (IS_ERR(in_page
)) {
411 f2fs_alloc_nid_failed(sbi
, new_nid
);
412 return PTR_ERR(in_page
);
414 inline_addr
= inline_xattr_addr(inode
, in_page
);
417 f2fs_wait_on_page_writeback(ipage
? ipage
: in_page
,
419 /* no need to use xattr node block */
420 if (hsize
<= inline_size
) {
421 err
= f2fs_truncate_xattr_node(inode
);
422 f2fs_alloc_nid_failed(sbi
, new_nid
);
424 f2fs_put_page(in_page
, 1);
427 memcpy(inline_addr
, txattr_addr
, inline_size
);
428 set_page_dirty(ipage
? ipage
: in_page
);
433 /* write to xattr node block */
434 if (F2FS_I(inode
)->i_xattr_nid
) {
435 xpage
= f2fs_get_node_page(sbi
, F2FS_I(inode
)->i_xattr_nid
);
437 err
= PTR_ERR(xpage
);
438 f2fs_alloc_nid_failed(sbi
, new_nid
);
441 f2fs_bug_on(sbi
, new_nid
);
442 f2fs_wait_on_page_writeback(xpage
, NODE
, true);
444 struct dnode_of_data dn
;
445 set_new_dnode(&dn
, inode
, NULL
, NULL
, new_nid
);
446 xpage
= f2fs_new_node_page(&dn
, XATTR_NODE_OFFSET
);
448 err
= PTR_ERR(xpage
);
449 f2fs_alloc_nid_failed(sbi
, new_nid
);
452 f2fs_alloc_nid_done(sbi
, new_nid
);
454 xattr_addr
= page_address(xpage
);
457 memcpy(inline_addr
, txattr_addr
, inline_size
);
458 memcpy(xattr_addr
, txattr_addr
+ inline_size
, VALID_XATTR_BLOCK_SIZE
);
461 set_page_dirty(ipage
? ipage
: in_page
);
462 set_page_dirty(xpage
);
464 f2fs_put_page(xpage
, 1);
466 f2fs_put_page(in_page
, 1);
470 int f2fs_getxattr(struct inode
*inode
, int index
, const char *name
,
471 void *buffer
, size_t buffer_size
, struct page
*ipage
)
473 struct f2fs_xattr_entry
*entry
= NULL
;
475 unsigned int size
, len
;
476 void *base_addr
= NULL
;
482 if (len
> F2FS_NAME_LEN
)
485 down_read(&F2FS_I(inode
)->i_xattr_sem
);
486 error
= lookup_all_xattrs(inode
, ipage
, index
, len
, name
,
488 up_read(&F2FS_I(inode
)->i_xattr_sem
);
492 size
= le16_to_cpu(entry
->e_value_size
);
494 if (buffer
&& size
> buffer_size
) {
500 char *pval
= entry
->e_name
+ entry
->e_name_len
;
501 memcpy(buffer
, pval
, size
);
509 ssize_t
f2fs_listxattr(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
511 struct inode
*inode
= d_inode(dentry
);
512 struct f2fs_xattr_entry
*entry
;
515 size_t rest
= buffer_size
;
517 down_read(&F2FS_I(inode
)->i_xattr_sem
);
518 error
= read_all_xattrs(inode
, NULL
, &base_addr
);
519 up_read(&F2FS_I(inode
)->i_xattr_sem
);
523 list_for_each_xattr(entry
, base_addr
) {
524 const struct xattr_handler
*handler
=
525 f2fs_xattr_handler(entry
->e_name_index
);
530 if (!handler
|| (handler
->list
&& !handler
->list(dentry
)))
533 prefix
= handler
->prefix
?: handler
->name
;
534 prefix_len
= strlen(prefix
);
535 size
= prefix_len
+ entry
->e_name_len
+ 1;
541 memcpy(buffer
, prefix
, prefix_len
);
542 buffer
+= prefix_len
;
543 memcpy(buffer
, entry
->e_name
, entry
->e_name_len
);
544 buffer
+= entry
->e_name_len
;
549 error
= buffer_size
- rest
;
555 static bool f2fs_xattr_value_same(struct f2fs_xattr_entry
*entry
,
556 const void *value
, size_t size
)
558 void *pval
= entry
->e_name
+ entry
->e_name_len
;
560 return (le16_to_cpu(entry
->e_value_size
) == size
) &&
561 !memcmp(pval
, value
, size
);
564 static int __f2fs_setxattr(struct inode
*inode
, int index
,
565 const char *name
, const void *value
, size_t size
,
566 struct page
*ipage
, int flags
)
568 struct f2fs_xattr_entry
*here
, *last
;
583 if (len
> F2FS_NAME_LEN
)
586 if (size
> MAX_VALUE_LEN(inode
))
589 error
= read_all_xattrs(inode
, ipage
, &base_addr
);
593 /* find entry with wanted name. */
594 here
= __find_xattr(base_addr
, index
, len
, name
);
596 found
= IS_XATTR_LAST_ENTRY(here
) ? 0 : 1;
599 if ((flags
& XATTR_CREATE
)) {
604 if (value
&& f2fs_xattr_value_same(here
, value
, size
))
606 } else if ((flags
& XATTR_REPLACE
)) {
612 while (!IS_XATTR_LAST_ENTRY(last
))
613 last
= XATTR_NEXT_ENTRY(last
);
615 newsize
= XATTR_ALIGN(sizeof(struct f2fs_xattr_entry
) + len
+ size
);
621 * If value is NULL, it is remove operation.
622 * In case of update operation, we calculate free.
624 free
= MIN_OFFSET(inode
) - ((char *)last
- (char *)base_addr
);
626 free
= free
+ ENTRY_SIZE(here
);
628 if (unlikely(free
< newsize
)) {
634 /* 2. Remove old entry */
637 * If entry is found, remove old entry.
638 * If not found, remove operation is not needed.
640 struct f2fs_xattr_entry
*next
= XATTR_NEXT_ENTRY(here
);
641 int oldsize
= ENTRY_SIZE(here
);
643 memmove(here
, next
, (char *)last
- (char *)next
);
644 last
= (struct f2fs_xattr_entry
*)((char *)last
- oldsize
);
645 memset(last
, 0, oldsize
);
648 new_hsize
= (char *)last
- (char *)base_addr
;
650 /* 3. Write new entry */
654 * Before we come here, old entry is removed.
655 * We just write new entry.
657 last
->e_name_index
= index
;
658 last
->e_name_len
= len
;
659 memcpy(last
->e_name
, name
, len
);
660 pval
= last
->e_name
+ len
;
661 memcpy(pval
, value
, size
);
662 last
->e_value_size
= cpu_to_le16(size
);
663 new_hsize
+= newsize
;
666 error
= write_all_xattrs(inode
, new_hsize
, base_addr
, ipage
);
670 if (is_inode_flag_set(inode
, FI_ACL_MODE
)) {
671 inode
->i_mode
= F2FS_I(inode
)->i_acl_mode
;
672 inode
->i_ctime
= current_time(inode
);
673 clear_inode_flag(inode
, FI_ACL_MODE
);
675 if (index
== F2FS_XATTR_INDEX_ENCRYPTION
&&
676 !strcmp(name
, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
))
677 f2fs_set_encrypted_inode(inode
);
678 f2fs_mark_inode_dirty_sync(inode
, true);
679 if (!error
&& S_ISDIR(inode
->i_mode
))
680 set_sbi_flag(F2FS_I_SB(inode
), SBI_NEED_CP
);
686 int f2fs_setxattr(struct inode
*inode
, int index
, const char *name
,
687 const void *value
, size_t size
,
688 struct page
*ipage
, int flags
)
690 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
693 err
= dquot_initialize(inode
);
697 /* this case is only from f2fs_init_inode_metadata */
699 return __f2fs_setxattr(inode
, index
, name
, value
,
701 f2fs_balance_fs(sbi
, true);
704 /* protect xattr_ver */
705 down_write(&F2FS_I(inode
)->i_sem
);
706 down_write(&F2FS_I(inode
)->i_xattr_sem
);
707 err
= __f2fs_setxattr(inode
, index
, name
, value
, size
, ipage
, flags
);
708 up_write(&F2FS_I(inode
)->i_xattr_sem
);
709 up_write(&F2FS_I(inode
)->i_sem
);
712 f2fs_update_time(sbi
, REQ_TIME
);