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
*dentry
, const char *name
, const void *value
,
54 size_t size
, int flags
)
56 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
58 switch (handler
->flags
) {
59 case F2FS_XATTR_INDEX_USER
:
60 if (!test_opt(sbi
, XATTR_USER
))
63 case F2FS_XATTR_INDEX_TRUSTED
:
64 if (!capable(CAP_SYS_ADMIN
))
67 case F2FS_XATTR_INDEX_SECURITY
:
72 return f2fs_setxattr(d_inode(dentry
), handler
->flags
, name
,
73 value
, size
, NULL
, flags
);
76 static bool f2fs_xattr_user_list(struct dentry
*dentry
)
78 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
80 return test_opt(sbi
, XATTR_USER
);
83 static bool f2fs_xattr_trusted_list(struct dentry
*dentry
)
85 return capable(CAP_SYS_ADMIN
);
88 static int f2fs_xattr_advise_get(const struct xattr_handler
*handler
,
89 struct dentry
*unused
, struct inode
*inode
,
90 const char *name
, void *buffer
, size_t size
)
93 *((char *)buffer
) = F2FS_I(inode
)->i_advise
;
97 static int f2fs_xattr_advise_set(const struct xattr_handler
*handler
,
98 struct dentry
*dentry
, const char *name
, const void *value
,
99 size_t size
, int flags
)
101 struct inode
*inode
= d_inode(dentry
);
103 if (!inode_owner_or_capable(inode
))
108 F2FS_I(inode
)->i_advise
|= *(char *)value
;
109 mark_inode_dirty(inode
);
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 void *read_all_xattrs(struct inode
*inode
, struct page
*ipage
)
222 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
223 struct f2fs_xattr_header
*header
;
224 size_t size
= PAGE_SIZE
, inline_size
= 0;
227 inline_size
= inline_xattr_size(inode
);
229 txattr_addr
= kzalloc(inline_size
+ size
, GFP_F2FS_ZERO
);
233 /* read from inline xattr */
235 struct page
*page
= NULL
;
239 inline_addr
= inline_xattr_addr(ipage
);
241 page
= get_node_page(sbi
, inode
->i_ino
);
244 inline_addr
= inline_xattr_addr(page
);
246 memcpy(txattr_addr
, inline_addr
, inline_size
);
247 f2fs_put_page(page
, 1);
250 /* read from xattr node block */
251 if (F2FS_I(inode
)->i_xattr_nid
) {
255 /* The inode already has an extended attribute block. */
256 xpage
= get_node_page(sbi
, F2FS_I(inode
)->i_xattr_nid
);
260 xattr_addr
= page_address(xpage
);
261 memcpy(txattr_addr
+ inline_size
, xattr_addr
, PAGE_SIZE
);
262 f2fs_put_page(xpage
, 1);
265 header
= XATTR_HDR(txattr_addr
);
267 /* never been allocated xattrs */
268 if (le32_to_cpu(header
->h_magic
) != F2FS_XATTR_MAGIC
) {
269 header
->h_magic
= cpu_to_le32(F2FS_XATTR_MAGIC
);
270 header
->h_refcount
= cpu_to_le32(1);
278 static inline int write_all_xattrs(struct inode
*inode
, __u32 hsize
,
279 void *txattr_addr
, struct page
*ipage
)
281 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
282 size_t inline_size
= 0;
288 inline_size
= inline_xattr_size(inode
);
290 if (hsize
> inline_size
&& !F2FS_I(inode
)->i_xattr_nid
)
291 if (!alloc_nid(sbi
, &new_nid
))
294 /* write to inline xattr */
296 struct page
*page
= NULL
;
300 inline_addr
= inline_xattr_addr(ipage
);
301 f2fs_wait_on_page_writeback(ipage
, NODE
, true);
303 page
= get_node_page(sbi
, inode
->i_ino
);
305 alloc_nid_failed(sbi
, new_nid
);
306 return PTR_ERR(page
);
308 inline_addr
= inline_xattr_addr(page
);
309 f2fs_wait_on_page_writeback(page
, NODE
, true);
311 memcpy(inline_addr
, txattr_addr
, inline_size
);
312 f2fs_put_page(page
, 1);
314 /* no need to use xattr node block */
315 if (hsize
<= inline_size
) {
316 err
= truncate_xattr_node(inode
, ipage
);
317 alloc_nid_failed(sbi
, new_nid
);
322 /* write to xattr node block */
323 if (F2FS_I(inode
)->i_xattr_nid
) {
324 xpage
= get_node_page(sbi
, F2FS_I(inode
)->i_xattr_nid
);
326 alloc_nid_failed(sbi
, new_nid
);
327 return PTR_ERR(xpage
);
329 f2fs_bug_on(sbi
, new_nid
);
330 f2fs_wait_on_page_writeback(xpage
, NODE
, true);
332 struct dnode_of_data dn
;
333 set_new_dnode(&dn
, inode
, NULL
, NULL
, new_nid
);
334 xpage
= new_node_page(&dn
, XATTR_NODE_OFFSET
, ipage
);
336 alloc_nid_failed(sbi
, new_nid
);
337 return PTR_ERR(xpage
);
339 alloc_nid_done(sbi
, new_nid
);
342 xattr_addr
= page_address(xpage
);
343 memcpy(xattr_addr
, txattr_addr
+ inline_size
, PAGE_SIZE
-
344 sizeof(struct node_footer
));
345 set_page_dirty(xpage
);
346 f2fs_put_page(xpage
, 1);
348 /* need to checkpoint during fsync */
349 F2FS_I(inode
)->xattr_ver
= cur_cp_version(F2FS_CKPT(sbi
));
353 int f2fs_getxattr(struct inode
*inode
, int index
, const char *name
,
354 void *buffer
, size_t buffer_size
, struct page
*ipage
)
356 struct f2fs_xattr_entry
*entry
;
365 if (len
> F2FS_NAME_LEN
)
368 base_addr
= read_all_xattrs(inode
, ipage
);
372 entry
= __find_xattr(base_addr
, index
, len
, name
);
373 if (IS_XATTR_LAST_ENTRY(entry
)) {
378 size
= le16_to_cpu(entry
->e_value_size
);
380 if (buffer
&& size
> buffer_size
) {
386 char *pval
= entry
->e_name
+ entry
->e_name_len
;
387 memcpy(buffer
, pval
, size
);
396 ssize_t
f2fs_listxattr(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
398 struct inode
*inode
= d_inode(dentry
);
399 struct f2fs_xattr_entry
*entry
;
402 size_t rest
= buffer_size
;
404 base_addr
= read_all_xattrs(inode
, NULL
);
408 list_for_each_xattr(entry
, base_addr
) {
409 const struct xattr_handler
*handler
=
410 f2fs_xattr_handler(entry
->e_name_index
);
415 if (!handler
|| (handler
->list
&& !handler
->list(dentry
)))
418 prefix
= handler
->prefix
?: handler
->name
;
419 prefix_len
= strlen(prefix
);
420 size
= prefix_len
+ entry
->e_name_len
+ 1;
426 memcpy(buffer
, prefix
, prefix_len
);
427 buffer
+= prefix_len
;
428 memcpy(buffer
, entry
->e_name
, entry
->e_name_len
);
429 buffer
+= entry
->e_name_len
;
434 error
= buffer_size
- rest
;
440 static int __f2fs_setxattr(struct inode
*inode
, int index
,
441 const char *name
, const void *value
, size_t size
,
442 struct page
*ipage
, int flags
)
444 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
445 struct f2fs_xattr_entry
*here
, *last
;
460 if (len
> F2FS_NAME_LEN
)
463 if (size
> MAX_VALUE_LEN(inode
))
466 base_addr
= read_all_xattrs(inode
, ipage
);
470 /* find entry with wanted name. */
471 here
= __find_xattr(base_addr
, index
, len
, name
);
473 found
= IS_XATTR_LAST_ENTRY(here
) ? 0 : 1;
475 if ((flags
& XATTR_REPLACE
) && !found
) {
478 } else if ((flags
& XATTR_CREATE
) && found
) {
484 while (!IS_XATTR_LAST_ENTRY(last
))
485 last
= XATTR_NEXT_ENTRY(last
);
487 newsize
= XATTR_ALIGN(sizeof(struct f2fs_xattr_entry
) + len
+ size
);
493 * If value is NULL, it is remove operation.
494 * In case of update operation, we calculate free.
496 free
= MIN_OFFSET(inode
) - ((char *)last
- (char *)base_addr
);
498 free
= free
+ ENTRY_SIZE(here
);
500 if (unlikely(free
< newsize
)) {
506 /* 2. Remove old entry */
509 * If entry is found, remove old entry.
510 * If not found, remove operation is not needed.
512 struct f2fs_xattr_entry
*next
= XATTR_NEXT_ENTRY(here
);
513 int oldsize
= ENTRY_SIZE(here
);
515 memmove(here
, next
, (char *)last
- (char *)next
);
516 last
= (struct f2fs_xattr_entry
*)((char *)last
- oldsize
);
517 memset(last
, 0, oldsize
);
520 new_hsize
= (char *)last
- (char *)base_addr
;
522 /* 3. Write new entry */
526 * Before we come here, old entry is removed.
527 * We just write new entry.
529 memset(last
, 0, newsize
);
530 last
->e_name_index
= index
;
531 last
->e_name_len
= len
;
532 memcpy(last
->e_name
, name
, len
);
533 pval
= last
->e_name
+ len
;
534 memcpy(pval
, value
, size
);
535 last
->e_value_size
= cpu_to_le16(size
);
536 new_hsize
+= newsize
;
539 error
= write_all_xattrs(inode
, new_hsize
, base_addr
, ipage
);
543 if (is_inode_flag_set(fi
, FI_ACL_MODE
)) {
544 inode
->i_mode
= fi
->i_acl_mode
;
545 inode
->i_ctime
= CURRENT_TIME
;
546 clear_inode_flag(fi
, FI_ACL_MODE
);
548 if (index
== F2FS_XATTR_INDEX_ENCRYPTION
&&
549 !strcmp(name
, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
))
550 f2fs_set_encrypted_inode(inode
);
553 update_inode(inode
, ipage
);
555 update_inode_page(inode
);
561 int f2fs_setxattr(struct inode
*inode
, int index
, const char *name
,
562 const void *value
, size_t size
,
563 struct page
*ipage
, int flags
)
565 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
568 /* this case is only from init_inode_metadata */
570 return __f2fs_setxattr(inode
, index
, name
, value
,
572 f2fs_balance_fs(sbi
, true);
575 /* protect xattr_ver */
576 down_write(&F2FS_I(inode
)->i_sem
);
577 err
= __f2fs_setxattr(inode
, index
, name
, value
, size
, ipage
, flags
);
578 up_write(&F2FS_I(inode
)->i_sem
);
581 f2fs_update_time(sbi
, REQ_TIME
);