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>
27 static size_t f2fs_xattr_generic_list(struct dentry
*dentry
, char *list
,
28 size_t list_size
, const char *name
, size_t name_len
, int type
)
30 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
31 int total_len
, prefix_len
= 0;
32 const char *prefix
= NULL
;
35 case F2FS_XATTR_INDEX_USER
:
36 if (!test_opt(sbi
, XATTR_USER
))
38 prefix
= XATTR_USER_PREFIX
;
39 prefix_len
= XATTR_USER_PREFIX_LEN
;
41 case F2FS_XATTR_INDEX_TRUSTED
:
42 if (!capable(CAP_SYS_ADMIN
))
44 prefix
= XATTR_TRUSTED_PREFIX
;
45 prefix_len
= XATTR_TRUSTED_PREFIX_LEN
;
47 case F2FS_XATTR_INDEX_SECURITY
:
48 prefix
= XATTR_SECURITY_PREFIX
;
49 prefix_len
= XATTR_SECURITY_PREFIX_LEN
;
55 total_len
= prefix_len
+ name_len
+ 1;
56 if (list
&& total_len
<= list_size
) {
57 memcpy(list
, prefix
, prefix_len
);
58 memcpy(list
+ prefix_len
, name
, name_len
);
59 list
[prefix_len
+ name_len
] = '\0';
64 static int f2fs_xattr_generic_get(struct dentry
*dentry
, const char *name
,
65 void *buffer
, size_t size
, int type
)
67 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
70 case F2FS_XATTR_INDEX_USER
:
71 if (!test_opt(sbi
, XATTR_USER
))
74 case F2FS_XATTR_INDEX_TRUSTED
:
75 if (!capable(CAP_SYS_ADMIN
))
78 case F2FS_XATTR_INDEX_SECURITY
:
83 if (strcmp(name
, "") == 0)
85 return f2fs_getxattr(dentry
->d_inode
, type
, name
, buffer
, size
);
88 static int f2fs_xattr_generic_set(struct dentry
*dentry
, const char *name
,
89 const void *value
, size_t size
, int flags
, int type
)
91 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
94 case F2FS_XATTR_INDEX_USER
:
95 if (!test_opt(sbi
, XATTR_USER
))
98 case F2FS_XATTR_INDEX_TRUSTED
:
99 if (!capable(CAP_SYS_ADMIN
))
102 case F2FS_XATTR_INDEX_SECURITY
:
107 if (strcmp(name
, "") == 0)
110 return f2fs_setxattr(dentry
->d_inode
, type
, name
, value
, size
, NULL
);
113 static size_t f2fs_xattr_advise_list(struct dentry
*dentry
, char *list
,
114 size_t list_size
, const char *name
, size_t name_len
, int type
)
116 const char *xname
= F2FS_SYSTEM_ADVISE_PREFIX
;
119 if (type
!= F2FS_XATTR_INDEX_ADVISE
)
122 size
= strlen(xname
) + 1;
123 if (list
&& size
<= list_size
)
124 memcpy(list
, xname
, size
);
128 static int f2fs_xattr_advise_get(struct dentry
*dentry
, const char *name
,
129 void *buffer
, size_t size
, int type
)
131 struct inode
*inode
= dentry
->d_inode
;
133 if (strcmp(name
, "") != 0)
136 *((char *)buffer
) = F2FS_I(inode
)->i_advise
;
140 static int f2fs_xattr_advise_set(struct dentry
*dentry
, const char *name
,
141 const void *value
, size_t size
, int flags
, int type
)
143 struct inode
*inode
= dentry
->d_inode
;
145 if (strcmp(name
, "") != 0)
147 if (!inode_owner_or_capable(inode
))
152 F2FS_I(inode
)->i_advise
|= *(char *)value
;
156 #ifdef CONFIG_F2FS_FS_SECURITY
157 static int __f2fs_setxattr(struct inode
*inode
, int name_index
,
158 const char *name
, const void *value
, size_t value_len
,
160 static int f2fs_initxattrs(struct inode
*inode
, const struct xattr
*xattr_array
,
163 const struct xattr
*xattr
;
166 for (xattr
= xattr_array
; xattr
->name
!= NULL
; xattr
++) {
167 err
= __f2fs_setxattr(inode
, F2FS_XATTR_INDEX_SECURITY
,
168 xattr
->name
, xattr
->value
,
169 xattr
->value_len
, (struct page
*)page
);
176 int f2fs_init_security(struct inode
*inode
, struct inode
*dir
,
177 const struct qstr
*qstr
, struct page
*ipage
)
179 return security_inode_init_security(inode
, dir
, qstr
,
180 &f2fs_initxattrs
, ipage
);
184 const struct xattr_handler f2fs_xattr_user_handler
= {
185 .prefix
= XATTR_USER_PREFIX
,
186 .flags
= F2FS_XATTR_INDEX_USER
,
187 .list
= f2fs_xattr_generic_list
,
188 .get
= f2fs_xattr_generic_get
,
189 .set
= f2fs_xattr_generic_set
,
192 const struct xattr_handler f2fs_xattr_trusted_handler
= {
193 .prefix
= XATTR_TRUSTED_PREFIX
,
194 .flags
= F2FS_XATTR_INDEX_TRUSTED
,
195 .list
= f2fs_xattr_generic_list
,
196 .get
= f2fs_xattr_generic_get
,
197 .set
= f2fs_xattr_generic_set
,
200 const struct xattr_handler f2fs_xattr_advise_handler
= {
201 .prefix
= F2FS_SYSTEM_ADVISE_PREFIX
,
202 .flags
= F2FS_XATTR_INDEX_ADVISE
,
203 .list
= f2fs_xattr_advise_list
,
204 .get
= f2fs_xattr_advise_get
,
205 .set
= f2fs_xattr_advise_set
,
208 const struct xattr_handler f2fs_xattr_security_handler
= {
209 .prefix
= XATTR_SECURITY_PREFIX
,
210 .flags
= F2FS_XATTR_INDEX_SECURITY
,
211 .list
= f2fs_xattr_generic_list
,
212 .get
= f2fs_xattr_generic_get
,
213 .set
= f2fs_xattr_generic_set
,
216 static const struct xattr_handler
*f2fs_xattr_handler_map
[] = {
217 [F2FS_XATTR_INDEX_USER
] = &f2fs_xattr_user_handler
,
218 #ifdef CONFIG_F2FS_FS_POSIX_ACL
219 [F2FS_XATTR_INDEX_POSIX_ACL_ACCESS
] = &f2fs_xattr_acl_access_handler
,
220 [F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT
] = &f2fs_xattr_acl_default_handler
,
222 [F2FS_XATTR_INDEX_TRUSTED
] = &f2fs_xattr_trusted_handler
,
223 #ifdef CONFIG_F2FS_FS_SECURITY
224 [F2FS_XATTR_INDEX_SECURITY
] = &f2fs_xattr_security_handler
,
226 [F2FS_XATTR_INDEX_ADVISE
] = &f2fs_xattr_advise_handler
,
229 const struct xattr_handler
*f2fs_xattr_handlers
[] = {
230 &f2fs_xattr_user_handler
,
231 #ifdef CONFIG_F2FS_FS_POSIX_ACL
232 &f2fs_xattr_acl_access_handler
,
233 &f2fs_xattr_acl_default_handler
,
235 &f2fs_xattr_trusted_handler
,
236 #ifdef CONFIG_F2FS_FS_SECURITY
237 &f2fs_xattr_security_handler
,
239 &f2fs_xattr_advise_handler
,
243 static inline const struct xattr_handler
*f2fs_xattr_handler(int name_index
)
245 const struct xattr_handler
*handler
= NULL
;
247 if (name_index
> 0 && name_index
< ARRAY_SIZE(f2fs_xattr_handler_map
))
248 handler
= f2fs_xattr_handler_map
[name_index
];
252 static struct f2fs_xattr_entry
*__find_xattr(void *base_addr
, int name_index
,
253 size_t name_len
, const char *name
)
255 struct f2fs_xattr_entry
*entry
;
257 list_for_each_xattr(entry
, base_addr
) {
258 if (entry
->e_name_index
!= name_index
)
260 if (entry
->e_name_len
!= name_len
)
262 if (!memcmp(entry
->e_name
, name
, name_len
))
268 static void *read_all_xattrs(struct inode
*inode
, struct page
*ipage
)
270 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
271 struct f2fs_xattr_header
*header
;
272 size_t size
= PAGE_SIZE
, inline_size
= 0;
275 inline_size
= inline_xattr_size(inode
);
277 txattr_addr
= kzalloc(inline_size
+ size
, GFP_KERNEL
);
281 /* read from inline xattr */
283 struct page
*page
= NULL
;
287 inline_addr
= inline_xattr_addr(ipage
);
289 page
= get_node_page(sbi
, inode
->i_ino
);
292 inline_addr
= inline_xattr_addr(page
);
294 memcpy(txattr_addr
, inline_addr
, inline_size
);
295 f2fs_put_page(page
, 1);
298 /* read from xattr node block */
299 if (F2FS_I(inode
)->i_xattr_nid
) {
303 /* The inode already has an extended attribute block. */
304 xpage
= get_node_page(sbi
, F2FS_I(inode
)->i_xattr_nid
);
308 xattr_addr
= page_address(xpage
);
309 memcpy(txattr_addr
+ inline_size
, xattr_addr
, PAGE_SIZE
);
310 f2fs_put_page(xpage
, 1);
313 header
= XATTR_HDR(txattr_addr
);
315 /* never been allocated xattrs */
316 if (le32_to_cpu(header
->h_magic
) != F2FS_XATTR_MAGIC
) {
317 header
->h_magic
= cpu_to_le32(F2FS_XATTR_MAGIC
);
318 header
->h_refcount
= cpu_to_le32(1);
326 static inline int write_all_xattrs(struct inode
*inode
, __u32 hsize
,
327 void *txattr_addr
, struct page
*ipage
)
329 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
330 size_t inline_size
= 0;
336 inline_size
= inline_xattr_size(inode
);
338 if (hsize
> inline_size
&& !F2FS_I(inode
)->i_xattr_nid
)
339 if (!alloc_nid(sbi
, &new_nid
))
342 /* write to inline xattr */
344 struct page
*page
= NULL
;
348 inline_addr
= inline_xattr_addr(ipage
);
350 page
= get_node_page(sbi
, inode
->i_ino
);
352 alloc_nid_failed(sbi
, new_nid
);
353 return PTR_ERR(page
);
355 inline_addr
= inline_xattr_addr(page
);
357 memcpy(inline_addr
, txattr_addr
, inline_size
);
358 f2fs_put_page(page
, 1);
360 /* no need to use xattr node block */
361 if (hsize
<= inline_size
) {
362 err
= truncate_xattr_node(inode
, ipage
);
363 alloc_nid_failed(sbi
, new_nid
);
368 /* write to xattr node block */
369 if (F2FS_I(inode
)->i_xattr_nid
) {
370 xpage
= get_node_page(sbi
, F2FS_I(inode
)->i_xattr_nid
);
372 alloc_nid_failed(sbi
, new_nid
);
373 return PTR_ERR(xpage
);
375 f2fs_bug_on(new_nid
);
377 struct dnode_of_data dn
;
378 set_new_dnode(&dn
, inode
, NULL
, NULL
, new_nid
);
379 xpage
= new_node_page(&dn
, XATTR_NODE_OFFSET
, ipage
);
381 alloc_nid_failed(sbi
, new_nid
);
382 return PTR_ERR(xpage
);
384 alloc_nid_done(sbi
, new_nid
);
387 xattr_addr
= page_address(xpage
);
388 memcpy(xattr_addr
, txattr_addr
+ inline_size
, PAGE_SIZE
-
389 sizeof(struct node_footer
));
390 set_page_dirty(xpage
);
391 f2fs_put_page(xpage
, 1);
393 /* need to checkpoint during fsync */
394 F2FS_I(inode
)->xattr_ver
= cur_cp_version(F2FS_CKPT(sbi
));
398 int f2fs_getxattr(struct inode
*inode
, int name_index
, const char *name
,
399 void *buffer
, size_t buffer_size
)
401 struct f2fs_xattr_entry
*entry
;
404 size_t value_len
, name_len
;
408 name_len
= strlen(name
);
410 base_addr
= read_all_xattrs(inode
, NULL
);
414 entry
= __find_xattr(base_addr
, name_index
, name_len
, name
);
415 if (IS_XATTR_LAST_ENTRY(entry
)) {
420 value_len
= le16_to_cpu(entry
->e_value_size
);
422 if (buffer
&& value_len
> buffer_size
) {
428 char *pval
= entry
->e_name
+ entry
->e_name_len
;
429 memcpy(buffer
, pval
, value_len
);
438 ssize_t
f2fs_listxattr(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
440 struct inode
*inode
= dentry
->d_inode
;
441 struct f2fs_xattr_entry
*entry
;
444 size_t rest
= buffer_size
;
446 base_addr
= read_all_xattrs(inode
, NULL
);
450 list_for_each_xattr(entry
, base_addr
) {
451 const struct xattr_handler
*handler
=
452 f2fs_xattr_handler(entry
->e_name_index
);
458 size
= handler
->list(dentry
, buffer
, rest
, entry
->e_name
,
459 entry
->e_name_len
, handler
->flags
);
460 if (buffer
&& size
> rest
) {
469 error
= buffer_size
- rest
;
475 static int __f2fs_setxattr(struct inode
*inode
, int name_index
,
476 const char *name
, const void *value
, size_t value_len
,
479 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
480 struct f2fs_xattr_entry
*here
, *last
;
493 name_len
= strlen(name
);
495 if (name_len
> F2FS_NAME_LEN
|| value_len
> MAX_VALUE_LEN(inode
))
498 base_addr
= read_all_xattrs(inode
, ipage
);
502 /* find entry with wanted name. */
503 here
= __find_xattr(base_addr
, name_index
, name_len
, name
);
505 found
= IS_XATTR_LAST_ENTRY(here
) ? 0 : 1;
508 while (!IS_XATTR_LAST_ENTRY(last
))
509 last
= XATTR_NEXT_ENTRY(last
);
511 newsize
= XATTR_ALIGN(sizeof(struct f2fs_xattr_entry
) +
512 name_len
+ value_len
);
518 * If value is NULL, it is remove operation.
519 * In case of update operation, we caculate free.
521 free
= MIN_OFFSET(inode
) - ((char *)last
- (char *)base_addr
);
523 free
= free
+ ENTRY_SIZE(here
);
525 if (free
< newsize
) {
531 /* 2. Remove old entry */
534 * If entry is found, remove old entry.
535 * If not found, remove operation is not needed.
537 struct f2fs_xattr_entry
*next
= XATTR_NEXT_ENTRY(here
);
538 int oldsize
= ENTRY_SIZE(here
);
540 memmove(here
, next
, (char *)last
- (char *)next
);
541 last
= (struct f2fs_xattr_entry
*)((char *)last
- oldsize
);
542 memset(last
, 0, oldsize
);
545 new_hsize
= (char *)last
- (char *)base_addr
;
547 /* 3. Write new entry */
551 * Before we come here, old entry is removed.
552 * We just write new entry.
554 memset(last
, 0, newsize
);
555 last
->e_name_index
= name_index
;
556 last
->e_name_len
= name_len
;
557 memcpy(last
->e_name
, name
, name_len
);
558 pval
= last
->e_name
+ name_len
;
559 memcpy(pval
, value
, value_len
);
560 last
->e_value_size
= cpu_to_le16(value_len
);
561 new_hsize
+= newsize
;
564 error
= write_all_xattrs(inode
, new_hsize
, base_addr
, ipage
);
568 if (is_inode_flag_set(fi
, FI_ACL_MODE
)) {
569 inode
->i_mode
= fi
->i_acl_mode
;
570 inode
->i_ctime
= CURRENT_TIME
;
571 clear_inode_flag(fi
, FI_ACL_MODE
);
575 update_inode(inode
, ipage
);
577 update_inode_page(inode
);
583 int f2fs_setxattr(struct inode
*inode
, int name_index
, const char *name
,
584 const void *value
, size_t value_len
, struct page
*ipage
)
586 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
589 f2fs_balance_fs(sbi
);
592 err
= __f2fs_setxattr(inode
, name_index
, name
, value
, value_len
, ipage
);