4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
7 * Portions of this code from linux/fs/ext2/xattr.c
9 * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
11 * Fix by Harrison Xing <harrison@mountainviewdata.com>.
12 * Extended attributes for symlinks and special files added per
13 * suggestion of Luka Renko <luka.renko@hermes.si>.
14 * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License version 2 as
19 * published by the Free Software Foundation.
21 #include <linux/rwsem.h>
22 #include <linux/f2fs_fs.h>
23 #include <linux/security.h>
24 #include <linux/posix_acl_xattr.h>
28 static int f2fs_xattr_generic_get(const struct xattr_handler
*handler
,
29 struct dentry
*unused
, struct inode
*inode
,
30 const char *name
, void *buffer
, size_t size
)
32 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
34 switch (handler
->flags
) {
35 case F2FS_XATTR_INDEX_USER
:
36 if (!test_opt(sbi
, XATTR_USER
))
39 case F2FS_XATTR_INDEX_TRUSTED
:
40 if (!capable(CAP_SYS_ADMIN
))
43 case F2FS_XATTR_INDEX_SECURITY
:
48 return f2fs_getxattr(inode
, handler
->flags
, name
,
52 static int f2fs_xattr_generic_set(const struct xattr_handler
*handler
,
53 struct dentry
*unused
, struct inode
*inode
,
54 const char *name
, const void *value
,
55 size_t size
, int flags
)
57 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
59 switch (handler
->flags
) {
60 case F2FS_XATTR_INDEX_USER
:
61 if (!test_opt(sbi
, XATTR_USER
))
64 case F2FS_XATTR_INDEX_TRUSTED
:
65 if (!capable(CAP_SYS_ADMIN
))
68 case F2FS_XATTR_INDEX_SECURITY
:
73 return f2fs_setxattr(inode
, handler
->flags
, name
,
74 value
, size
, NULL
, flags
);
77 static bool f2fs_xattr_user_list(struct dentry
*dentry
)
79 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
81 return test_opt(sbi
, XATTR_USER
);
84 static bool f2fs_xattr_trusted_list(struct dentry
*dentry
)
86 return capable(CAP_SYS_ADMIN
);
89 static int f2fs_xattr_advise_get(const struct xattr_handler
*handler
,
90 struct dentry
*unused
, struct inode
*inode
,
91 const char *name
, void *buffer
, size_t size
)
94 *((char *)buffer
) = F2FS_I(inode
)->i_advise
;
98 static int f2fs_xattr_advise_set(const struct xattr_handler
*handler
,
99 struct dentry
*unused
, struct inode
*inode
,
100 const char *name
, const void *value
,
101 size_t size
, int flags
)
103 if (!inode_owner_or_capable(inode
))
108 F2FS_I(inode
)->i_advise
|= *(char *)value
;
109 f2fs_mark_inode_dirty_sync(inode
, true);
113 #ifdef CONFIG_F2FS_FS_SECURITY
114 static int f2fs_initxattrs(struct inode
*inode
, const struct xattr
*xattr_array
,
117 const struct xattr
*xattr
;
120 for (xattr
= xattr_array
; xattr
->name
!= NULL
; xattr
++) {
121 err
= f2fs_setxattr(inode
, F2FS_XATTR_INDEX_SECURITY
,
122 xattr
->name
, xattr
->value
,
123 xattr
->value_len
, (struct page
*)page
, 0);
130 int f2fs_init_security(struct inode
*inode
, struct inode
*dir
,
131 const struct qstr
*qstr
, struct page
*ipage
)
133 return security_inode_init_security(inode
, dir
, qstr
,
134 &f2fs_initxattrs
, ipage
);
138 const struct xattr_handler f2fs_xattr_user_handler
= {
139 .prefix
= XATTR_USER_PREFIX
,
140 .flags
= F2FS_XATTR_INDEX_USER
,
141 .list
= f2fs_xattr_user_list
,
142 .get
= f2fs_xattr_generic_get
,
143 .set
= f2fs_xattr_generic_set
,
146 const struct xattr_handler f2fs_xattr_trusted_handler
= {
147 .prefix
= XATTR_TRUSTED_PREFIX
,
148 .flags
= F2FS_XATTR_INDEX_TRUSTED
,
149 .list
= f2fs_xattr_trusted_list
,
150 .get
= f2fs_xattr_generic_get
,
151 .set
= f2fs_xattr_generic_set
,
154 const struct xattr_handler f2fs_xattr_advise_handler
= {
155 .name
= F2FS_SYSTEM_ADVISE_NAME
,
156 .flags
= F2FS_XATTR_INDEX_ADVISE
,
157 .get
= f2fs_xattr_advise_get
,
158 .set
= f2fs_xattr_advise_set
,
161 const struct xattr_handler f2fs_xattr_security_handler
= {
162 .prefix
= XATTR_SECURITY_PREFIX
,
163 .flags
= F2FS_XATTR_INDEX_SECURITY
,
164 .get
= f2fs_xattr_generic_get
,
165 .set
= f2fs_xattr_generic_set
,
168 static const struct xattr_handler
*f2fs_xattr_handler_map
[] = {
169 [F2FS_XATTR_INDEX_USER
] = &f2fs_xattr_user_handler
,
170 #ifdef CONFIG_F2FS_FS_POSIX_ACL
171 [F2FS_XATTR_INDEX_POSIX_ACL_ACCESS
] = &posix_acl_access_xattr_handler
,
172 [F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT
] = &posix_acl_default_xattr_handler
,
174 [F2FS_XATTR_INDEX_TRUSTED
] = &f2fs_xattr_trusted_handler
,
175 #ifdef CONFIG_F2FS_FS_SECURITY
176 [F2FS_XATTR_INDEX_SECURITY
] = &f2fs_xattr_security_handler
,
178 [F2FS_XATTR_INDEX_ADVISE
] = &f2fs_xattr_advise_handler
,
181 const struct xattr_handler
*f2fs_xattr_handlers
[] = {
182 &f2fs_xattr_user_handler
,
183 #ifdef CONFIG_F2FS_FS_POSIX_ACL
184 &posix_acl_access_xattr_handler
,
185 &posix_acl_default_xattr_handler
,
187 &f2fs_xattr_trusted_handler
,
188 #ifdef CONFIG_F2FS_FS_SECURITY
189 &f2fs_xattr_security_handler
,
191 &f2fs_xattr_advise_handler
,
195 static inline const struct xattr_handler
*f2fs_xattr_handler(int index
)
197 const struct xattr_handler
*handler
= NULL
;
199 if (index
> 0 && index
< ARRAY_SIZE(f2fs_xattr_handler_map
))
200 handler
= f2fs_xattr_handler_map
[index
];
204 static struct f2fs_xattr_entry
*__find_xattr(void *base_addr
, int index
,
205 size_t len
, const char *name
)
207 struct f2fs_xattr_entry
*entry
;
209 list_for_each_xattr(entry
, base_addr
) {
210 if (entry
->e_name_index
!= index
)
212 if (entry
->e_name_len
!= len
)
214 if (!memcmp(entry
->e_name
, name
, len
))
220 static struct f2fs_xattr_entry
*__find_inline_xattr(struct inode
*inode
,
221 void *base_addr
, void **last_addr
, int index
,
222 size_t len
, const char *name
)
224 struct f2fs_xattr_entry
*entry
;
225 unsigned int inline_size
= inline_xattr_size(inode
);
227 list_for_each_xattr(entry
, base_addr
) {
228 if ((void *)entry
+ sizeof(__u32
) > base_addr
+ inline_size
||
229 (void *)XATTR_NEXT_ENTRY(entry
) + sizeof(__u32
) >
230 base_addr
+ inline_size
) {
234 if (entry
->e_name_index
!= index
)
236 if (entry
->e_name_len
!= len
)
238 if (!memcmp(entry
->e_name
, name
, len
))
244 static int read_inline_xattr(struct inode
*inode
, struct page
*ipage
,
247 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
248 unsigned int inline_size
= inline_xattr_size(inode
);
249 struct page
*page
= NULL
;
253 inline_addr
= inline_xattr_addr(inode
, ipage
);
255 page
= get_node_page(sbi
, inode
->i_ino
);
257 return PTR_ERR(page
);
259 inline_addr
= inline_xattr_addr(inode
, page
);
261 memcpy(txattr_addr
, inline_addr
, inline_size
);
262 f2fs_put_page(page
, 1);
267 static int read_xattr_block(struct inode
*inode
, void *txattr_addr
)
269 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
270 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
271 unsigned int inline_size
= inline_xattr_size(inode
);
275 /* The inode already has an extended attribute block. */
276 xpage
= get_node_page(sbi
, xnid
);
278 return PTR_ERR(xpage
);
280 xattr_addr
= page_address(xpage
);
281 memcpy(txattr_addr
+ inline_size
, xattr_addr
, VALID_XATTR_BLOCK_SIZE
);
282 f2fs_put_page(xpage
, 1);
287 static int lookup_all_xattrs(struct inode
*inode
, struct page
*ipage
,
288 unsigned int index
, unsigned int len
,
289 const char *name
, struct f2fs_xattr_entry
**xe
,
292 void *cur_addr
, *txattr_addr
, *last_addr
= NULL
;
293 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
294 unsigned int size
= xnid
? VALID_XATTR_BLOCK_SIZE
: 0;
295 unsigned int inline_size
= inline_xattr_size(inode
);
298 if (!size
&& !inline_size
)
301 txattr_addr
= f2fs_kzalloc(F2FS_I_SB(inode
),
302 inline_size
+ size
+ XATTR_PADDING_SIZE
, GFP_NOFS
);
306 /* read from inline xattr */
308 err
= read_inline_xattr(inode
, ipage
, txattr_addr
);
312 *xe
= __find_inline_xattr(inode
, txattr_addr
, &last_addr
,
318 /* read from xattr node block */
320 err
= read_xattr_block(inode
, txattr_addr
);
326 cur_addr
= XATTR_HDR(last_addr
) - 1;
328 cur_addr
= txattr_addr
;
330 *xe
= __find_xattr(cur_addr
, index
, len
, name
);
332 if (IS_XATTR_LAST_ENTRY(*xe
)) {
337 *base_addr
= txattr_addr
;
344 static int read_all_xattrs(struct inode
*inode
, struct page
*ipage
,
347 struct f2fs_xattr_header
*header
;
348 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
349 unsigned int size
= VALID_XATTR_BLOCK_SIZE
;
350 unsigned int inline_size
= inline_xattr_size(inode
);
354 txattr_addr
= f2fs_kzalloc(F2FS_I_SB(inode
),
355 inline_size
+ size
+ XATTR_PADDING_SIZE
, GFP_NOFS
);
359 /* read from inline xattr */
361 err
= read_inline_xattr(inode
, ipage
, txattr_addr
);
366 /* read from xattr node block */
368 err
= read_xattr_block(inode
, txattr_addr
);
373 header
= XATTR_HDR(txattr_addr
);
375 /* never been allocated xattrs */
376 if (le32_to_cpu(header
->h_magic
) != F2FS_XATTR_MAGIC
) {
377 header
->h_magic
= cpu_to_le32(F2FS_XATTR_MAGIC
);
378 header
->h_refcount
= cpu_to_le32(1);
380 *base_addr
= txattr_addr
;
387 static inline int write_all_xattrs(struct inode
*inode
, __u32 hsize
,
388 void *txattr_addr
, struct page
*ipage
)
390 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
391 size_t inline_size
= inline_xattr_size(inode
);
392 struct page
*in_page
= NULL
;
394 void *inline_addr
= NULL
;
399 if (hsize
> inline_size
&& !F2FS_I(inode
)->i_xattr_nid
)
400 if (!alloc_nid(sbi
, &new_nid
))
403 /* write to inline xattr */
406 inline_addr
= inline_xattr_addr(inode
, ipage
);
408 in_page
= get_node_page(sbi
, inode
->i_ino
);
409 if (IS_ERR(in_page
)) {
410 alloc_nid_failed(sbi
, new_nid
);
411 return PTR_ERR(in_page
);
413 inline_addr
= inline_xattr_addr(inode
, in_page
);
416 f2fs_wait_on_page_writeback(ipage
? ipage
: in_page
,
418 /* no need to use xattr node block */
419 if (hsize
<= inline_size
) {
420 err
= truncate_xattr_node(inode
);
421 alloc_nid_failed(sbi
, new_nid
);
423 f2fs_put_page(in_page
, 1);
426 memcpy(inline_addr
, txattr_addr
, inline_size
);
427 set_page_dirty(ipage
? ipage
: in_page
);
432 /* write to xattr node block */
433 if (F2FS_I(inode
)->i_xattr_nid
) {
434 xpage
= get_node_page(sbi
, F2FS_I(inode
)->i_xattr_nid
);
436 err
= PTR_ERR(xpage
);
437 alloc_nid_failed(sbi
, new_nid
);
440 f2fs_bug_on(sbi
, new_nid
);
441 f2fs_wait_on_page_writeback(xpage
, NODE
, true);
443 struct dnode_of_data dn
;
444 set_new_dnode(&dn
, inode
, NULL
, NULL
, new_nid
);
445 xpage
= new_node_page(&dn
, XATTR_NODE_OFFSET
);
447 err
= PTR_ERR(xpage
);
448 alloc_nid_failed(sbi
, new_nid
);
451 alloc_nid_done(sbi
, new_nid
);
453 xattr_addr
= page_address(xpage
);
456 memcpy(inline_addr
, txattr_addr
, inline_size
);
457 memcpy(xattr_addr
, txattr_addr
+ inline_size
, VALID_XATTR_BLOCK_SIZE
);
460 set_page_dirty(ipage
? ipage
: in_page
);
461 set_page_dirty(xpage
);
463 f2fs_put_page(xpage
, 1);
465 f2fs_put_page(in_page
, 1);
469 int f2fs_getxattr(struct inode
*inode
, int index
, const char *name
,
470 void *buffer
, size_t buffer_size
, struct page
*ipage
)
472 struct f2fs_xattr_entry
*entry
= NULL
;
474 unsigned int size
, len
;
475 void *base_addr
= NULL
;
481 if (len
> F2FS_NAME_LEN
)
484 down_read(&F2FS_I(inode
)->i_xattr_sem
);
485 error
= lookup_all_xattrs(inode
, ipage
, index
, len
, name
,
487 up_read(&F2FS_I(inode
)->i_xattr_sem
);
491 size
= le16_to_cpu(entry
->e_value_size
);
493 if (buffer
&& size
> buffer_size
) {
499 char *pval
= entry
->e_name
+ entry
->e_name_len
;
500 memcpy(buffer
, pval
, size
);
508 ssize_t
f2fs_listxattr(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
510 struct inode
*inode
= d_inode(dentry
);
511 struct f2fs_xattr_entry
*entry
;
514 size_t rest
= buffer_size
;
516 down_read(&F2FS_I(inode
)->i_xattr_sem
);
517 error
= read_all_xattrs(inode
, NULL
, &base_addr
);
518 up_read(&F2FS_I(inode
)->i_xattr_sem
);
522 list_for_each_xattr(entry
, base_addr
) {
523 const struct xattr_handler
*handler
=
524 f2fs_xattr_handler(entry
->e_name_index
);
529 if (!handler
|| (handler
->list
&& !handler
->list(dentry
)))
532 prefix
= handler
->prefix
?: handler
->name
;
533 prefix_len
= strlen(prefix
);
534 size
= prefix_len
+ entry
->e_name_len
+ 1;
540 memcpy(buffer
, prefix
, prefix_len
);
541 buffer
+= prefix_len
;
542 memcpy(buffer
, entry
->e_name
, entry
->e_name_len
);
543 buffer
+= entry
->e_name_len
;
548 error
= buffer_size
- rest
;
554 static bool f2fs_xattr_value_same(struct f2fs_xattr_entry
*entry
,
555 const void *value
, size_t size
)
557 void *pval
= entry
->e_name
+ entry
->e_name_len
;
559 return (le16_to_cpu(entry
->e_value_size
) == size
) &&
560 !memcmp(pval
, value
, size
);
563 static int __f2fs_setxattr(struct inode
*inode
, int index
,
564 const char *name
, const void *value
, size_t size
,
565 struct page
*ipage
, int flags
)
567 struct f2fs_xattr_entry
*here
, *last
;
582 if (len
> F2FS_NAME_LEN
)
585 if (size
> MAX_VALUE_LEN(inode
))
588 error
= read_all_xattrs(inode
, ipage
, &base_addr
);
592 /* find entry with wanted name. */
593 here
= __find_xattr(base_addr
, index
, len
, name
);
595 found
= IS_XATTR_LAST_ENTRY(here
) ? 0 : 1;
598 if ((flags
& XATTR_CREATE
)) {
603 if (value
&& f2fs_xattr_value_same(here
, value
, size
))
605 } else if ((flags
& XATTR_REPLACE
)) {
611 while (!IS_XATTR_LAST_ENTRY(last
))
612 last
= XATTR_NEXT_ENTRY(last
);
614 newsize
= XATTR_ALIGN(sizeof(struct f2fs_xattr_entry
) + len
+ size
);
620 * If value is NULL, it is remove operation.
621 * In case of update operation, we calculate free.
623 free
= MIN_OFFSET(inode
) - ((char *)last
- (char *)base_addr
);
625 free
= free
+ ENTRY_SIZE(here
);
627 if (unlikely(free
< newsize
)) {
633 /* 2. Remove old entry */
636 * If entry is found, remove old entry.
637 * If not found, remove operation is not needed.
639 struct f2fs_xattr_entry
*next
= XATTR_NEXT_ENTRY(here
);
640 int oldsize
= ENTRY_SIZE(here
);
642 memmove(here
, next
, (char *)last
- (char *)next
);
643 last
= (struct f2fs_xattr_entry
*)((char *)last
- oldsize
);
644 memset(last
, 0, oldsize
);
647 new_hsize
= (char *)last
- (char *)base_addr
;
649 /* 3. Write new entry */
653 * Before we come here, old entry is removed.
654 * We just write new entry.
656 last
->e_name_index
= index
;
657 last
->e_name_len
= len
;
658 memcpy(last
->e_name
, name
, len
);
659 pval
= last
->e_name
+ len
;
660 memcpy(pval
, value
, size
);
661 last
->e_value_size
= cpu_to_le16(size
);
662 new_hsize
+= newsize
;
665 error
= write_all_xattrs(inode
, new_hsize
, base_addr
, ipage
);
669 if (is_inode_flag_set(inode
, FI_ACL_MODE
)) {
670 inode
->i_mode
= F2FS_I(inode
)->i_acl_mode
;
671 inode
->i_ctime
= current_time(inode
);
672 clear_inode_flag(inode
, FI_ACL_MODE
);
674 if (index
== F2FS_XATTR_INDEX_ENCRYPTION
&&
675 !strcmp(name
, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
))
676 f2fs_set_encrypted_inode(inode
);
677 f2fs_mark_inode_dirty_sync(inode
, true);
678 if (!error
&& S_ISDIR(inode
->i_mode
))
679 set_sbi_flag(F2FS_I_SB(inode
), SBI_NEED_CP
);
685 int f2fs_setxattr(struct inode
*inode
, int index
, const char *name
,
686 const void *value
, size_t size
,
687 struct page
*ipage
, int flags
)
689 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
692 err
= dquot_initialize(inode
);
696 /* this case is only from init_inode_metadata */
698 return __f2fs_setxattr(inode
, index
, name
, value
,
700 f2fs_balance_fs(sbi
, true);
703 /* protect xattr_ver */
704 down_write(&F2FS_I(inode
)->i_sem
);
705 down_write(&F2FS_I(inode
)->i_xattr_sem
);
706 err
= __f2fs_setxattr(inode
, index
, name
, value
, size
, ipage
, flags
);
707 up_write(&F2FS_I(inode
)->i_xattr_sem
);
708 up_write(&F2FS_I(inode
)->i_sem
);
711 f2fs_update_time(sbi
, REQ_TIME
);