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 size_t f2fs_xattr_generic_list(struct dentry
*dentry
, char *list
,
29 size_t list_size
, const char *name
, size_t name_len
, int type
)
31 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
32 int total_len
, prefix_len
= 0;
33 const char *prefix
= NULL
;
36 case F2FS_XATTR_INDEX_USER
:
37 if (!test_opt(sbi
, XATTR_USER
))
39 prefix
= XATTR_USER_PREFIX
;
40 prefix_len
= XATTR_USER_PREFIX_LEN
;
42 case F2FS_XATTR_INDEX_TRUSTED
:
43 if (!capable(CAP_SYS_ADMIN
))
45 prefix
= XATTR_TRUSTED_PREFIX
;
46 prefix_len
= XATTR_TRUSTED_PREFIX_LEN
;
48 case F2FS_XATTR_INDEX_SECURITY
:
49 prefix
= XATTR_SECURITY_PREFIX
;
50 prefix_len
= XATTR_SECURITY_PREFIX_LEN
;
56 total_len
= prefix_len
+ name_len
+ 1;
57 if (list
&& total_len
<= list_size
) {
58 memcpy(list
, prefix
, prefix_len
);
59 memcpy(list
+ prefix_len
, name
, name_len
);
60 list
[prefix_len
+ name_len
] = '\0';
65 static int f2fs_xattr_generic_get(struct dentry
*dentry
, const char *name
,
66 void *buffer
, size_t size
, int type
)
68 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
71 case F2FS_XATTR_INDEX_USER
:
72 if (!test_opt(sbi
, XATTR_USER
))
75 case F2FS_XATTR_INDEX_TRUSTED
:
76 if (!capable(CAP_SYS_ADMIN
))
79 case F2FS_XATTR_INDEX_SECURITY
:
84 if (strcmp(name
, "") == 0)
86 return f2fs_getxattr(dentry
->d_inode
, type
, name
, buffer
, size
);
89 static int f2fs_xattr_generic_set(struct dentry
*dentry
, const char *name
,
90 const void *value
, size_t size
, int flags
, int type
)
92 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
95 case F2FS_XATTR_INDEX_USER
:
96 if (!test_opt(sbi
, XATTR_USER
))
99 case F2FS_XATTR_INDEX_TRUSTED
:
100 if (!capable(CAP_SYS_ADMIN
))
103 case F2FS_XATTR_INDEX_SECURITY
:
108 if (strcmp(name
, "") == 0)
111 return f2fs_setxattr(dentry
->d_inode
, type
, name
, value
, size
, NULL
);
114 static size_t f2fs_xattr_advise_list(struct dentry
*dentry
, char *list
,
115 size_t list_size
, const char *name
, size_t name_len
, int type
)
117 const char *xname
= F2FS_SYSTEM_ADVISE_PREFIX
;
120 if (type
!= F2FS_XATTR_INDEX_ADVISE
)
123 size
= strlen(xname
) + 1;
124 if (list
&& size
<= list_size
)
125 memcpy(list
, xname
, size
);
129 static int f2fs_xattr_advise_get(struct dentry
*dentry
, const char *name
,
130 void *buffer
, size_t size
, int type
)
132 struct inode
*inode
= dentry
->d_inode
;
134 if (strcmp(name
, "") != 0)
137 *((char *)buffer
) = F2FS_I(inode
)->i_advise
;
141 static int f2fs_xattr_advise_set(struct dentry
*dentry
, const char *name
,
142 const void *value
, size_t size
, int flags
, int type
)
144 struct inode
*inode
= dentry
->d_inode
;
146 if (strcmp(name
, "") != 0)
148 if (!inode_owner_or_capable(inode
))
153 F2FS_I(inode
)->i_advise
|= *(char *)value
;
157 #ifdef CONFIG_F2FS_FS_SECURITY
158 static int __f2fs_setxattr(struct inode
*inode
, int name_index
,
159 const char *name
, const void *value
, size_t value_len
,
161 static int f2fs_initxattrs(struct inode
*inode
, const struct xattr
*xattr_array
,
164 const struct xattr
*xattr
;
167 for (xattr
= xattr_array
; xattr
->name
!= NULL
; xattr
++) {
168 err
= __f2fs_setxattr(inode
, F2FS_XATTR_INDEX_SECURITY
,
169 xattr
->name
, xattr
->value
,
170 xattr
->value_len
, (struct page
*)page
);
177 int f2fs_init_security(struct inode
*inode
, struct inode
*dir
,
178 const struct qstr
*qstr
, struct page
*ipage
)
180 return security_inode_init_security(inode
, dir
, qstr
,
181 &f2fs_initxattrs
, ipage
);
185 const struct xattr_handler f2fs_xattr_user_handler
= {
186 .prefix
= XATTR_USER_PREFIX
,
187 .flags
= F2FS_XATTR_INDEX_USER
,
188 .list
= f2fs_xattr_generic_list
,
189 .get
= f2fs_xattr_generic_get
,
190 .set
= f2fs_xattr_generic_set
,
193 const struct xattr_handler f2fs_xattr_trusted_handler
= {
194 .prefix
= XATTR_TRUSTED_PREFIX
,
195 .flags
= F2FS_XATTR_INDEX_TRUSTED
,
196 .list
= f2fs_xattr_generic_list
,
197 .get
= f2fs_xattr_generic_get
,
198 .set
= f2fs_xattr_generic_set
,
201 const struct xattr_handler f2fs_xattr_advise_handler
= {
202 .prefix
= F2FS_SYSTEM_ADVISE_PREFIX
,
203 .flags
= F2FS_XATTR_INDEX_ADVISE
,
204 .list
= f2fs_xattr_advise_list
,
205 .get
= f2fs_xattr_advise_get
,
206 .set
= f2fs_xattr_advise_set
,
209 const struct xattr_handler f2fs_xattr_security_handler
= {
210 .prefix
= XATTR_SECURITY_PREFIX
,
211 .flags
= F2FS_XATTR_INDEX_SECURITY
,
212 .list
= f2fs_xattr_generic_list
,
213 .get
= f2fs_xattr_generic_get
,
214 .set
= f2fs_xattr_generic_set
,
217 static const struct xattr_handler
*f2fs_xattr_handler_map
[] = {
218 [F2FS_XATTR_INDEX_USER
] = &f2fs_xattr_user_handler
,
219 #ifdef CONFIG_F2FS_FS_POSIX_ACL
220 [F2FS_XATTR_INDEX_POSIX_ACL_ACCESS
] = &posix_acl_access_xattr_handler
,
221 [F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT
] = &posix_acl_default_xattr_handler
,
223 [F2FS_XATTR_INDEX_TRUSTED
] = &f2fs_xattr_trusted_handler
,
224 #ifdef CONFIG_F2FS_FS_SECURITY
225 [F2FS_XATTR_INDEX_SECURITY
] = &f2fs_xattr_security_handler
,
227 [F2FS_XATTR_INDEX_ADVISE
] = &f2fs_xattr_advise_handler
,
230 const struct xattr_handler
*f2fs_xattr_handlers
[] = {
231 &f2fs_xattr_user_handler
,
232 #ifdef CONFIG_F2FS_FS_POSIX_ACL
233 &posix_acl_access_xattr_handler
,
234 &posix_acl_default_xattr_handler
,
236 &f2fs_xattr_trusted_handler
,
237 #ifdef CONFIG_F2FS_FS_SECURITY
238 &f2fs_xattr_security_handler
,
240 &f2fs_xattr_advise_handler
,
244 static inline const struct xattr_handler
*f2fs_xattr_handler(int name_index
)
246 const struct xattr_handler
*handler
= NULL
;
248 if (name_index
> 0 && name_index
< ARRAY_SIZE(f2fs_xattr_handler_map
))
249 handler
= f2fs_xattr_handler_map
[name_index
];
253 static struct f2fs_xattr_entry
*__find_xattr(void *base_addr
, int name_index
,
254 size_t name_len
, const char *name
)
256 struct f2fs_xattr_entry
*entry
;
258 list_for_each_xattr(entry
, base_addr
) {
259 if (entry
->e_name_index
!= name_index
)
261 if (entry
->e_name_len
!= name_len
)
263 if (!memcmp(entry
->e_name
, name
, name_len
))
269 static void *read_all_xattrs(struct inode
*inode
, struct page
*ipage
)
271 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
272 struct f2fs_xattr_header
*header
;
273 size_t size
= PAGE_SIZE
, inline_size
= 0;
276 inline_size
= inline_xattr_size(inode
);
278 txattr_addr
= kzalloc(inline_size
+ size
, GFP_F2FS_ZERO
);
282 /* read from inline xattr */
284 struct page
*page
= NULL
;
288 inline_addr
= inline_xattr_addr(ipage
);
290 page
= get_node_page(sbi
, inode
->i_ino
);
293 inline_addr
= inline_xattr_addr(page
);
295 memcpy(txattr_addr
, inline_addr
, inline_size
);
296 f2fs_put_page(page
, 1);
299 /* read from xattr node block */
300 if (F2FS_I(inode
)->i_xattr_nid
) {
304 /* The inode already has an extended attribute block. */
305 xpage
= get_node_page(sbi
, F2FS_I(inode
)->i_xattr_nid
);
309 xattr_addr
= page_address(xpage
);
310 memcpy(txattr_addr
+ inline_size
, xattr_addr
, PAGE_SIZE
);
311 f2fs_put_page(xpage
, 1);
314 header
= XATTR_HDR(txattr_addr
);
316 /* never been allocated xattrs */
317 if (le32_to_cpu(header
->h_magic
) != F2FS_XATTR_MAGIC
) {
318 header
->h_magic
= cpu_to_le32(F2FS_XATTR_MAGIC
);
319 header
->h_refcount
= cpu_to_le32(1);
327 static inline int write_all_xattrs(struct inode
*inode
, __u32 hsize
,
328 void *txattr_addr
, struct page
*ipage
)
330 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
331 size_t inline_size
= 0;
337 inline_size
= inline_xattr_size(inode
);
339 if (hsize
> inline_size
&& !F2FS_I(inode
)->i_xattr_nid
)
340 if (!alloc_nid(sbi
, &new_nid
))
343 /* write to inline xattr */
345 struct page
*page
= NULL
;
349 inline_addr
= inline_xattr_addr(ipage
);
351 page
= get_node_page(sbi
, inode
->i_ino
);
353 alloc_nid_failed(sbi
, new_nid
);
354 return PTR_ERR(page
);
356 inline_addr
= inline_xattr_addr(page
);
358 memcpy(inline_addr
, txattr_addr
, inline_size
);
359 f2fs_put_page(page
, 1);
361 /* no need to use xattr node block */
362 if (hsize
<= inline_size
) {
363 err
= truncate_xattr_node(inode
, ipage
);
364 alloc_nid_failed(sbi
, new_nid
);
369 /* write to xattr node block */
370 if (F2FS_I(inode
)->i_xattr_nid
) {
371 xpage
= get_node_page(sbi
, F2FS_I(inode
)->i_xattr_nid
);
373 alloc_nid_failed(sbi
, new_nid
);
374 return PTR_ERR(xpage
);
376 f2fs_bug_on(new_nid
);
378 struct dnode_of_data dn
;
379 set_new_dnode(&dn
, inode
, NULL
, NULL
, new_nid
);
380 xpage
= new_node_page(&dn
, XATTR_NODE_OFFSET
, ipage
);
382 alloc_nid_failed(sbi
, new_nid
);
383 return PTR_ERR(xpage
);
385 alloc_nid_done(sbi
, new_nid
);
388 xattr_addr
= page_address(xpage
);
389 memcpy(xattr_addr
, txattr_addr
+ inline_size
, PAGE_SIZE
-
390 sizeof(struct node_footer
));
391 set_page_dirty(xpage
);
392 f2fs_put_page(xpage
, 1);
394 /* need to checkpoint during fsync */
395 F2FS_I(inode
)->xattr_ver
= cur_cp_version(F2FS_CKPT(sbi
));
399 int f2fs_getxattr(struct inode
*inode
, int name_index
, const char *name
,
400 void *buffer
, size_t buffer_size
)
402 struct f2fs_xattr_entry
*entry
;
405 size_t value_len
, name_len
;
409 name_len
= strlen(name
);
410 if (name_len
> F2FS_NAME_LEN
)
413 base_addr
= read_all_xattrs(inode
, NULL
);
417 entry
= __find_xattr(base_addr
, name_index
, name_len
, name
);
418 if (IS_XATTR_LAST_ENTRY(entry
)) {
423 value_len
= le16_to_cpu(entry
->e_value_size
);
425 if (buffer
&& value_len
> buffer_size
) {
431 char *pval
= entry
->e_name
+ entry
->e_name_len
;
432 memcpy(buffer
, pval
, value_len
);
441 ssize_t
f2fs_listxattr(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
443 struct inode
*inode
= dentry
->d_inode
;
444 struct f2fs_xattr_entry
*entry
;
447 size_t rest
= buffer_size
;
449 base_addr
= read_all_xattrs(inode
, NULL
);
453 list_for_each_xattr(entry
, base_addr
) {
454 const struct xattr_handler
*handler
=
455 f2fs_xattr_handler(entry
->e_name_index
);
461 size
= handler
->list(dentry
, buffer
, rest
, entry
->e_name
,
462 entry
->e_name_len
, handler
->flags
);
463 if (buffer
&& size
> rest
) {
472 error
= buffer_size
- rest
;
478 static int __f2fs_setxattr(struct inode
*inode
, int name_index
,
479 const char *name
, const void *value
, size_t value_len
,
482 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
483 struct f2fs_xattr_entry
*here
, *last
;
496 name_len
= strlen(name
);
498 if (name_len
> F2FS_NAME_LEN
|| value_len
> MAX_VALUE_LEN(inode
))
501 base_addr
= read_all_xattrs(inode
, ipage
);
505 /* find entry with wanted name. */
506 here
= __find_xattr(base_addr
, name_index
, name_len
, name
);
508 found
= IS_XATTR_LAST_ENTRY(here
) ? 0 : 1;
511 while (!IS_XATTR_LAST_ENTRY(last
))
512 last
= XATTR_NEXT_ENTRY(last
);
514 newsize
= XATTR_ALIGN(sizeof(struct f2fs_xattr_entry
) +
515 name_len
+ value_len
);
521 * If value is NULL, it is remove operation.
522 * In case of update operation, we caculate free.
524 free
= MIN_OFFSET(inode
) - ((char *)last
- (char *)base_addr
);
526 free
= free
+ ENTRY_SIZE(here
);
528 if (unlikely(free
< newsize
)) {
534 /* 2. Remove old entry */
537 * If entry is found, remove old entry.
538 * If not found, remove operation is not needed.
540 struct f2fs_xattr_entry
*next
= XATTR_NEXT_ENTRY(here
);
541 int oldsize
= ENTRY_SIZE(here
);
543 memmove(here
, next
, (char *)last
- (char *)next
);
544 last
= (struct f2fs_xattr_entry
*)((char *)last
- oldsize
);
545 memset(last
, 0, oldsize
);
548 new_hsize
= (char *)last
- (char *)base_addr
;
550 /* 3. Write new entry */
554 * Before we come here, old entry is removed.
555 * We just write new entry.
557 memset(last
, 0, newsize
);
558 last
->e_name_index
= name_index
;
559 last
->e_name_len
= name_len
;
560 memcpy(last
->e_name
, name
, name_len
);
561 pval
= last
->e_name
+ name_len
;
562 memcpy(pval
, value
, value_len
);
563 last
->e_value_size
= cpu_to_le16(value_len
);
564 new_hsize
+= newsize
;
567 error
= write_all_xattrs(inode
, new_hsize
, base_addr
, ipage
);
571 if (is_inode_flag_set(fi
, FI_ACL_MODE
)) {
572 inode
->i_mode
= fi
->i_acl_mode
;
573 inode
->i_ctime
= CURRENT_TIME
;
574 clear_inode_flag(fi
, FI_ACL_MODE
);
578 update_inode(inode
, ipage
);
580 update_inode_page(inode
);
586 int f2fs_setxattr(struct inode
*inode
, int name_index
, const char *name
,
587 const void *value
, size_t value_len
, struct page
*ipage
)
589 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
592 f2fs_balance_fs(sbi
);
595 /* protect xattr_ver */
596 down_write(&F2FS_I(inode
)->i_sem
);
597 err
= __f2fs_setxattr(inode
, name_index
, name
, value
, value_len
, ipage
);
598 up_write(&F2FS_I(inode
)->i_sem
);