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
,
206 void *last_base_addr
, int index
,
207 size_t len
, const char *name
)
209 struct f2fs_xattr_entry
*entry
;
211 list_for_each_xattr(entry
, base_addr
) {
212 if ((void *)(entry
) + sizeof(__u32
) > last_base_addr
||
213 (void *)XATTR_NEXT_ENTRY(entry
) > last_base_addr
)
216 if (entry
->e_name_index
!= index
)
218 if (entry
->e_name_len
!= len
)
220 if (!memcmp(entry
->e_name
, name
, len
))
226 static struct f2fs_xattr_entry
*__find_inline_xattr(struct inode
*inode
,
227 void *base_addr
, void **last_addr
, int index
,
228 size_t len
, const char *name
)
230 struct f2fs_xattr_entry
*entry
;
231 unsigned int inline_size
= inline_xattr_size(inode
);
232 void *max_addr
= base_addr
+ inline_size
;
234 list_for_each_xattr(entry
, base_addr
) {
235 if ((void *)entry
+ sizeof(__u32
) > max_addr
||
236 (void *)XATTR_NEXT_ENTRY(entry
) > max_addr
) {
240 if (entry
->e_name_index
!= index
)
242 if (entry
->e_name_len
!= len
)
244 if (!memcmp(entry
->e_name
, name
, len
))
248 /* inline xattr header or entry across max inline xattr size */
249 if (IS_XATTR_LAST_ENTRY(entry
) &&
250 (void *)entry
+ sizeof(__u32
) > max_addr
) {
257 static int read_inline_xattr(struct inode
*inode
, struct page
*ipage
,
260 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
261 unsigned int inline_size
= inline_xattr_size(inode
);
262 struct page
*page
= NULL
;
266 inline_addr
= inline_xattr_addr(inode
, ipage
);
268 page
= f2fs_get_node_page(sbi
, inode
->i_ino
);
270 return PTR_ERR(page
);
272 inline_addr
= inline_xattr_addr(inode
, page
);
274 memcpy(txattr_addr
, inline_addr
, inline_size
);
275 f2fs_put_page(page
, 1);
280 static int read_xattr_block(struct inode
*inode
, void *txattr_addr
)
282 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
283 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
284 unsigned int inline_size
= inline_xattr_size(inode
);
288 /* The inode already has an extended attribute block. */
289 xpage
= f2fs_get_node_page(sbi
, xnid
);
291 return PTR_ERR(xpage
);
293 xattr_addr
= page_address(xpage
);
294 memcpy(txattr_addr
+ inline_size
, xattr_addr
, VALID_XATTR_BLOCK_SIZE
);
295 f2fs_put_page(xpage
, 1);
300 static int lookup_all_xattrs(struct inode
*inode
, struct page
*ipage
,
301 unsigned int index
, unsigned int len
,
302 const char *name
, struct f2fs_xattr_entry
**xe
,
303 void **base_addr
, int *base_size
)
305 void *cur_addr
, *txattr_addr
, *last_txattr_addr
;
306 void *last_addr
= NULL
;
307 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
308 unsigned int inline_size
= inline_xattr_size(inode
);
311 if (!xnid
&& !inline_size
)
314 *base_size
= XATTR_SIZE(xnid
, inode
) + XATTR_PADDING_SIZE
;
315 txattr_addr
= f2fs_kzalloc(F2FS_I_SB(inode
), *base_size
, GFP_NOFS
);
319 last_txattr_addr
= (void *)txattr_addr
+ XATTR_SIZE(xnid
, inode
);
321 /* read from inline xattr */
323 err
= read_inline_xattr(inode
, ipage
, txattr_addr
);
327 *xe
= __find_inline_xattr(inode
, txattr_addr
, &last_addr
,
330 *base_size
= inline_size
;
335 /* read from xattr node block */
337 err
= read_xattr_block(inode
, txattr_addr
);
343 cur_addr
= XATTR_HDR(last_addr
) - 1;
345 cur_addr
= txattr_addr
;
347 *xe
= __find_xattr(cur_addr
, last_txattr_addr
, index
, len
, name
);
353 if (IS_XATTR_LAST_ENTRY(*xe
)) {
358 *base_addr
= txattr_addr
;
365 static int read_all_xattrs(struct inode
*inode
, struct page
*ipage
,
368 struct f2fs_xattr_header
*header
;
369 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
370 unsigned int size
= VALID_XATTR_BLOCK_SIZE
;
371 unsigned int inline_size
= inline_xattr_size(inode
);
375 txattr_addr
= f2fs_kzalloc(F2FS_I_SB(inode
),
376 inline_size
+ size
+ XATTR_PADDING_SIZE
, GFP_NOFS
);
380 /* read from inline xattr */
382 err
= read_inline_xattr(inode
, ipage
, txattr_addr
);
387 /* read from xattr node block */
389 err
= read_xattr_block(inode
, txattr_addr
);
394 header
= XATTR_HDR(txattr_addr
);
396 /* never been allocated xattrs */
397 if (le32_to_cpu(header
->h_magic
) != F2FS_XATTR_MAGIC
) {
398 header
->h_magic
= cpu_to_le32(F2FS_XATTR_MAGIC
);
399 header
->h_refcount
= cpu_to_le32(1);
401 *base_addr
= txattr_addr
;
408 static inline int write_all_xattrs(struct inode
*inode
, __u32 hsize
,
409 void *txattr_addr
, struct page
*ipage
)
411 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
412 size_t inline_size
= inline_xattr_size(inode
);
413 struct page
*in_page
= NULL
;
415 void *inline_addr
= NULL
;
420 if (hsize
> inline_size
&& !F2FS_I(inode
)->i_xattr_nid
)
421 if (!f2fs_alloc_nid(sbi
, &new_nid
))
424 /* write to inline xattr */
427 inline_addr
= inline_xattr_addr(inode
, ipage
);
429 in_page
= f2fs_get_node_page(sbi
, inode
->i_ino
);
430 if (IS_ERR(in_page
)) {
431 f2fs_alloc_nid_failed(sbi
, new_nid
);
432 return PTR_ERR(in_page
);
434 inline_addr
= inline_xattr_addr(inode
, in_page
);
437 f2fs_wait_on_page_writeback(ipage
? ipage
: in_page
,
439 /* no need to use xattr node block */
440 if (hsize
<= inline_size
) {
441 err
= f2fs_truncate_xattr_node(inode
);
442 f2fs_alloc_nid_failed(sbi
, new_nid
);
444 f2fs_put_page(in_page
, 1);
447 memcpy(inline_addr
, txattr_addr
, inline_size
);
448 set_page_dirty(ipage
? ipage
: in_page
);
453 /* write to xattr node block */
454 if (F2FS_I(inode
)->i_xattr_nid
) {
455 xpage
= f2fs_get_node_page(sbi
, F2FS_I(inode
)->i_xattr_nid
);
457 err
= PTR_ERR(xpage
);
458 f2fs_alloc_nid_failed(sbi
, new_nid
);
461 f2fs_bug_on(sbi
, new_nid
);
462 f2fs_wait_on_page_writeback(xpage
, NODE
, true, true);
464 struct dnode_of_data dn
;
465 set_new_dnode(&dn
, inode
, NULL
, NULL
, new_nid
);
466 xpage
= f2fs_new_node_page(&dn
, XATTR_NODE_OFFSET
);
468 err
= PTR_ERR(xpage
);
469 f2fs_alloc_nid_failed(sbi
, new_nid
);
472 f2fs_alloc_nid_done(sbi
, new_nid
);
474 xattr_addr
= page_address(xpage
);
477 memcpy(inline_addr
, txattr_addr
, inline_size
);
478 memcpy(xattr_addr
, txattr_addr
+ inline_size
, VALID_XATTR_BLOCK_SIZE
);
481 set_page_dirty(ipage
? ipage
: in_page
);
482 set_page_dirty(xpage
);
484 f2fs_put_page(xpage
, 1);
486 f2fs_put_page(in_page
, 1);
490 int f2fs_getxattr(struct inode
*inode
, int index
, const char *name
,
491 void *buffer
, size_t buffer_size
, struct page
*ipage
)
493 struct f2fs_xattr_entry
*entry
= NULL
;
495 unsigned int size
, len
;
496 void *base_addr
= NULL
;
503 if (len
> F2FS_NAME_LEN
)
506 down_read(&F2FS_I(inode
)->i_xattr_sem
);
507 error
= lookup_all_xattrs(inode
, ipage
, index
, len
, name
,
508 &entry
, &base_addr
, &base_size
);
509 up_read(&F2FS_I(inode
)->i_xattr_sem
);
513 size
= le16_to_cpu(entry
->e_value_size
);
515 if (buffer
&& size
> buffer_size
) {
521 char *pval
= entry
->e_name
+ entry
->e_name_len
;
523 if (base_size
- (pval
- (char *)base_addr
) < size
) {
527 memcpy(buffer
, pval
, size
);
535 ssize_t
f2fs_listxattr(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
537 struct inode
*inode
= d_inode(dentry
);
538 struct f2fs_xattr_entry
*entry
;
541 size_t rest
= buffer_size
;
543 down_read(&F2FS_I(inode
)->i_xattr_sem
);
544 error
= read_all_xattrs(inode
, NULL
, &base_addr
);
545 up_read(&F2FS_I(inode
)->i_xattr_sem
);
549 list_for_each_xattr(entry
, base_addr
) {
550 const struct xattr_handler
*handler
=
551 f2fs_xattr_handler(entry
->e_name_index
);
556 if (!handler
|| (handler
->list
&& !handler
->list(dentry
)))
559 prefix
= xattr_prefix(handler
);
560 prefix_len
= strlen(prefix
);
561 size
= prefix_len
+ entry
->e_name_len
+ 1;
567 memcpy(buffer
, prefix
, prefix_len
);
568 buffer
+= prefix_len
;
569 memcpy(buffer
, entry
->e_name
, entry
->e_name_len
);
570 buffer
+= entry
->e_name_len
;
575 error
= buffer_size
- rest
;
581 static bool f2fs_xattr_value_same(struct f2fs_xattr_entry
*entry
,
582 const void *value
, size_t size
)
584 void *pval
= entry
->e_name
+ entry
->e_name_len
;
586 return (le16_to_cpu(entry
->e_value_size
) == size
) &&
587 !memcmp(pval
, value
, size
);
590 static int __f2fs_setxattr(struct inode
*inode
, int index
,
591 const char *name
, const void *value
, size_t size
,
592 struct page
*ipage
, int flags
)
594 struct f2fs_xattr_entry
*here
, *last
;
595 void *base_addr
, *last_base_addr
;
596 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
610 if (len
> F2FS_NAME_LEN
)
613 if (size
> MAX_VALUE_LEN(inode
))
616 error
= read_all_xattrs(inode
, ipage
, &base_addr
);
620 last_base_addr
= (void *)base_addr
+ XATTR_SIZE(xnid
, inode
);
622 /* find entry with wanted name. */
623 here
= __find_xattr(base_addr
, last_base_addr
, index
, len
, name
);
629 found
= IS_XATTR_LAST_ENTRY(here
) ? 0 : 1;
632 if ((flags
& XATTR_CREATE
)) {
637 if (value
&& f2fs_xattr_value_same(here
, value
, size
))
639 } else if ((flags
& XATTR_REPLACE
)) {
645 while (!IS_XATTR_LAST_ENTRY(last
))
646 last
= XATTR_NEXT_ENTRY(last
);
648 newsize
= XATTR_ALIGN(sizeof(struct f2fs_xattr_entry
) + len
+ size
);
654 * If value is NULL, it is remove operation.
655 * In case of update operation, we calculate free.
657 free
= MIN_OFFSET(inode
) - ((char *)last
- (char *)base_addr
);
659 free
= free
+ ENTRY_SIZE(here
);
661 if (unlikely(free
< newsize
)) {
667 /* 2. Remove old entry */
670 * If entry is found, remove old entry.
671 * If not found, remove operation is not needed.
673 struct f2fs_xattr_entry
*next
= XATTR_NEXT_ENTRY(here
);
674 int oldsize
= ENTRY_SIZE(here
);
676 memmove(here
, next
, (char *)last
- (char *)next
);
677 last
= (struct f2fs_xattr_entry
*)((char *)last
- oldsize
);
678 memset(last
, 0, oldsize
);
681 new_hsize
= (char *)last
- (char *)base_addr
;
683 /* 3. Write new entry */
687 * Before we come here, old entry is removed.
688 * We just write new entry.
690 last
->e_name_index
= index
;
691 last
->e_name_len
= len
;
692 memcpy(last
->e_name
, name
, len
);
693 pval
= last
->e_name
+ len
;
694 memcpy(pval
, value
, size
);
695 last
->e_value_size
= cpu_to_le16(size
);
696 new_hsize
+= newsize
;
699 error
= write_all_xattrs(inode
, new_hsize
, base_addr
, ipage
);
703 if (is_inode_flag_set(inode
, FI_ACL_MODE
)) {
704 inode
->i_mode
= F2FS_I(inode
)->i_acl_mode
;
705 inode
->i_ctime
= current_time(inode
);
706 clear_inode_flag(inode
, FI_ACL_MODE
);
708 if (index
== F2FS_XATTR_INDEX_ENCRYPTION
&&
709 !strcmp(name
, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
))
710 f2fs_set_encrypted_inode(inode
);
711 f2fs_mark_inode_dirty_sync(inode
, true);
712 if (!error
&& S_ISDIR(inode
->i_mode
))
713 set_sbi_flag(F2FS_I_SB(inode
), SBI_NEED_CP
);
719 int f2fs_setxattr(struct inode
*inode
, int index
, const char *name
,
720 const void *value
, size_t size
,
721 struct page
*ipage
, int flags
)
723 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
726 err
= dquot_initialize(inode
);
730 /* this case is only from f2fs_init_inode_metadata */
732 return __f2fs_setxattr(inode
, index
, name
, value
,
734 f2fs_balance_fs(sbi
, true);
737 /* protect xattr_ver */
738 down_write(&F2FS_I(inode
)->i_sem
);
739 down_write(&F2FS_I(inode
)->i_xattr_sem
);
740 err
= __f2fs_setxattr(inode
, index
, name
, value
, size
, ipage
, flags
);
741 up_write(&F2FS_I(inode
)->i_xattr_sem
);
742 up_write(&F2FS_I(inode
)->i_sem
);
745 f2fs_update_time(sbi
, REQ_TIME
);