blob: fb16f71e4c23122c6f1d53143740003779eee85e [file] [log] [blame]
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09001/*
Jaegeuk Kimaf48b852012-11-02 17:12:17 +09002 * fs/f2fs/xattr.c
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 *
7 * Portions of this code from linux/fs/ext2/xattr.c
8 *
9 * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
10 *
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>,
15 * Red Hat Inc.
16 *
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.
20 */
21#include <linux/rwsem.h>
22#include <linux/f2fs_fs.h>
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +090023#include <linux/security.h>
Jaegeuk Kimaf48b852012-11-02 17:12:17 +090024#include "f2fs.h"
25#include "xattr.h"
26
27static 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)
29{
30 struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
31 int total_len, prefix_len = 0;
32 const char *prefix = NULL;
33
34 switch (type) {
35 case F2FS_XATTR_INDEX_USER:
36 if (!test_opt(sbi, XATTR_USER))
37 return -EOPNOTSUPP;
38 prefix = XATTR_USER_PREFIX;
39 prefix_len = XATTR_USER_PREFIX_LEN;
40 break;
41 case F2FS_XATTR_INDEX_TRUSTED:
42 if (!capable(CAP_SYS_ADMIN))
43 return -EPERM;
44 prefix = XATTR_TRUSTED_PREFIX;
45 prefix_len = XATTR_TRUSTED_PREFIX_LEN;
46 break;
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +090047 case F2FS_XATTR_INDEX_SECURITY:
48 prefix = XATTR_SECURITY_PREFIX;
49 prefix_len = XATTR_SECURITY_PREFIX_LEN;
50 break;
Jaegeuk Kimaf48b852012-11-02 17:12:17 +090051 default:
52 return -EINVAL;
53 }
54
55 total_len = prefix_len + name_len + 1;
56 if (list && total_len <= list_size) {
57 memcpy(list, prefix, prefix_len);
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +090058 memcpy(list + prefix_len, name, name_len);
Jaegeuk Kimaf48b852012-11-02 17:12:17 +090059 list[prefix_len + name_len] = '\0';
60 }
61 return total_len;
62}
63
64static int f2fs_xattr_generic_get(struct dentry *dentry, const char *name,
65 void *buffer, size_t size, int type)
66{
67 struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
68
69 switch (type) {
70 case F2FS_XATTR_INDEX_USER:
71 if (!test_opt(sbi, XATTR_USER))
72 return -EOPNOTSUPP;
73 break;
74 case F2FS_XATTR_INDEX_TRUSTED:
75 if (!capable(CAP_SYS_ADMIN))
76 return -EPERM;
77 break;
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +090078 case F2FS_XATTR_INDEX_SECURITY:
79 break;
Jaegeuk Kimaf48b852012-11-02 17:12:17 +090080 default:
81 return -EINVAL;
82 }
83 if (strcmp(name, "") == 0)
84 return -EINVAL;
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +090085 return f2fs_getxattr(dentry->d_inode, type, name, buffer, size);
Jaegeuk Kimaf48b852012-11-02 17:12:17 +090086}
87
88static int f2fs_xattr_generic_set(struct dentry *dentry, const char *name,
89 const void *value, size_t size, int flags, int type)
90{
91 struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
92
93 switch (type) {
94 case F2FS_XATTR_INDEX_USER:
95 if (!test_opt(sbi, XATTR_USER))
96 return -EOPNOTSUPP;
97 break;
98 case F2FS_XATTR_INDEX_TRUSTED:
99 if (!capable(CAP_SYS_ADMIN))
100 return -EPERM;
101 break;
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +0900102 case F2FS_XATTR_INDEX_SECURITY:
103 break;
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900104 default:
105 return -EINVAL;
106 }
107 if (strcmp(name, "") == 0)
108 return -EINVAL;
109
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +0900110 return f2fs_setxattr(dentry->d_inode, type, name, value, size, NULL);
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900111}
112
Jaegeuk Kim573ea5f2012-11-30 17:32:08 +0900113static 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)
115{
116 const char *xname = F2FS_SYSTEM_ADVISE_PREFIX;
117 size_t size;
118
119 if (type != F2FS_XATTR_INDEX_ADVISE)
120 return 0;
121
122 size = strlen(xname) + 1;
123 if (list && size <= list_size)
124 memcpy(list, xname, size);
125 return size;
126}
127
128static int f2fs_xattr_advise_get(struct dentry *dentry, const char *name,
129 void *buffer, size_t size, int type)
130{
131 struct inode *inode = dentry->d_inode;
132
133 if (strcmp(name, "") != 0)
134 return -EINVAL;
135
136 *((char *)buffer) = F2FS_I(inode)->i_advise;
137 return sizeof(char);
138}
139
140static int f2fs_xattr_advise_set(struct dentry *dentry, const char *name,
141 const void *value, size_t size, int flags, int type)
142{
143 struct inode *inode = dentry->d_inode;
144
145 if (strcmp(name, "") != 0)
146 return -EINVAL;
147 if (!inode_owner_or_capable(inode))
148 return -EPERM;
149 if (value == NULL)
150 return -EINVAL;
151
152 F2FS_I(inode)->i_advise |= *(char *)value;
153 return 0;
154}
155
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +0900156#ifdef CONFIG_F2FS_FS_SECURITY
157static int f2fs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
158 void *page)
159{
160 const struct xattr *xattr;
161 int err = 0;
162
163 for (xattr = xattr_array; xattr->name != NULL; xattr++) {
164 err = f2fs_setxattr(inode, F2FS_XATTR_INDEX_SECURITY,
165 xattr->name, xattr->value,
166 xattr->value_len, (struct page *)page);
167 if (err < 0)
168 break;
169 }
170 return err;
171}
172
173int f2fs_init_security(struct inode *inode, struct inode *dir,
174 const struct qstr *qstr, struct page *ipage)
175{
176 return security_inode_init_security(inode, dir, qstr,
177 &f2fs_initxattrs, ipage);
178}
179#endif
180
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900181const struct xattr_handler f2fs_xattr_user_handler = {
182 .prefix = XATTR_USER_PREFIX,
183 .flags = F2FS_XATTR_INDEX_USER,
184 .list = f2fs_xattr_generic_list,
185 .get = f2fs_xattr_generic_get,
186 .set = f2fs_xattr_generic_set,
187};
188
189const struct xattr_handler f2fs_xattr_trusted_handler = {
190 .prefix = XATTR_TRUSTED_PREFIX,
191 .flags = F2FS_XATTR_INDEX_TRUSTED,
192 .list = f2fs_xattr_generic_list,
193 .get = f2fs_xattr_generic_get,
194 .set = f2fs_xattr_generic_set,
195};
196
Jaegeuk Kim573ea5f2012-11-30 17:32:08 +0900197const struct xattr_handler f2fs_xattr_advise_handler = {
198 .prefix = F2FS_SYSTEM_ADVISE_PREFIX,
199 .flags = F2FS_XATTR_INDEX_ADVISE,
200 .list = f2fs_xattr_advise_list,
201 .get = f2fs_xattr_advise_get,
202 .set = f2fs_xattr_advise_set,
203};
204
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +0900205const struct xattr_handler f2fs_xattr_security_handler = {
206 .prefix = XATTR_SECURITY_PREFIX,
207 .flags = F2FS_XATTR_INDEX_SECURITY,
208 .list = f2fs_xattr_generic_list,
209 .get = f2fs_xattr_generic_get,
210 .set = f2fs_xattr_generic_set,
211};
212
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900213static const struct xattr_handler *f2fs_xattr_handler_map[] = {
214 [F2FS_XATTR_INDEX_USER] = &f2fs_xattr_user_handler,
215#ifdef CONFIG_F2FS_FS_POSIX_ACL
216 [F2FS_XATTR_INDEX_POSIX_ACL_ACCESS] = &f2fs_xattr_acl_access_handler,
217 [F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT] = &f2fs_xattr_acl_default_handler,
218#endif
219 [F2FS_XATTR_INDEX_TRUSTED] = &f2fs_xattr_trusted_handler,
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +0900220#ifdef CONFIG_F2FS_FS_SECURITY
221 [F2FS_XATTR_INDEX_SECURITY] = &f2fs_xattr_security_handler,
222#endif
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900223 [F2FS_XATTR_INDEX_ADVISE] = &f2fs_xattr_advise_handler,
224};
225
226const struct xattr_handler *f2fs_xattr_handlers[] = {
227 &f2fs_xattr_user_handler,
228#ifdef CONFIG_F2FS_FS_POSIX_ACL
229 &f2fs_xattr_acl_access_handler,
230 &f2fs_xattr_acl_default_handler,
231#endif
232 &f2fs_xattr_trusted_handler,
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +0900233#ifdef CONFIG_F2FS_FS_SECURITY
234 &f2fs_xattr_security_handler,
235#endif
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900236 &f2fs_xattr_advise_handler,
237 NULL,
238};
239
240static inline const struct xattr_handler *f2fs_xattr_handler(int name_index)
241{
242 const struct xattr_handler *handler = NULL;
243
244 if (name_index > 0 && name_index < ARRAY_SIZE(f2fs_xattr_handler_map))
245 handler = f2fs_xattr_handler_map[name_index];
246 return handler;
247}
248
249int f2fs_getxattr(struct inode *inode, int name_index, const char *name,
250 void *buffer, size_t buffer_size)
251{
252 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
253 struct f2fs_inode_info *fi = F2FS_I(inode);
254 struct f2fs_xattr_entry *entry;
255 struct page *page;
256 void *base_addr;
257 int error = 0, found = 0;
Leon Romanovsky9836b8b2012-12-27 19:55:46 +0200258 size_t value_len, name_len;
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900259
260 if (name == NULL)
261 return -EINVAL;
262 name_len = strlen(name);
263
264 if (!fi->i_xattr_nid)
265 return -ENODATA;
266
267 page = get_node_page(sbi, fi->i_xattr_nid);
Jason Hrycay1e03e382013-05-31 12:45:11 -0500268 if (IS_ERR(page))
269 return PTR_ERR(page);
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900270 base_addr = page_address(page);
271
272 list_for_each_xattr(entry, base_addr) {
273 if (entry->e_name_index != name_index)
274 continue;
275 if (entry->e_name_len != name_len)
276 continue;
277 if (!memcmp(entry->e_name, name, name_len)) {
278 found = 1;
279 break;
280 }
281 }
282 if (!found) {
283 error = -ENODATA;
284 goto cleanup;
285 }
286
287 value_len = le16_to_cpu(entry->e_value_size);
288
289 if (buffer && value_len > buffer_size) {
290 error = -ERANGE;
291 goto cleanup;
292 }
293
294 if (buffer) {
295 char *pval = entry->e_name + entry->e_name_len;
296 memcpy(buffer, pval, value_len);
297 }
298 error = value_len;
299
300cleanup:
301 f2fs_put_page(page, 1);
302 return error;
303}
304
305ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
306{
307 struct inode *inode = dentry->d_inode;
308 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
309 struct f2fs_inode_info *fi = F2FS_I(inode);
310 struct f2fs_xattr_entry *entry;
311 struct page *page;
312 void *base_addr;
313 int error = 0;
314 size_t rest = buffer_size;
315
316 if (!fi->i_xattr_nid)
317 return 0;
318
319 page = get_node_page(sbi, fi->i_xattr_nid);
Jason Hrycay1e03e382013-05-31 12:45:11 -0500320 if (IS_ERR(page))
321 return PTR_ERR(page);
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900322 base_addr = page_address(page);
323
324 list_for_each_xattr(entry, base_addr) {
325 const struct xattr_handler *handler =
326 f2fs_xattr_handler(entry->e_name_index);
327 size_t size;
328
329 if (!handler)
330 continue;
331
332 size = handler->list(dentry, buffer, rest, entry->e_name,
333 entry->e_name_len, handler->flags);
334 if (buffer && size > rest) {
335 error = -ERANGE;
336 goto cleanup;
337 }
338
339 if (buffer)
340 buffer += size;
341 rest -= size;
342 }
343 error = buffer_size - rest;
344cleanup:
345 f2fs_put_page(page, 1);
346 return error;
347}
348
349int f2fs_setxattr(struct inode *inode, int name_index, const char *name,
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +0900350 const void *value, size_t value_len, struct page *ipage)
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900351{
352 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
353 struct f2fs_inode_info *fi = F2FS_I(inode);
354 struct f2fs_xattr_header *header = NULL;
355 struct f2fs_xattr_entry *here, *last;
356 struct page *page;
357 void *base_addr;
Leon Romanovsky9836b8b2012-12-27 19:55:46 +0200358 int error, found, free, newsize;
359 size_t name_len;
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900360 char *pval;
Jaegeuk Kim39936832012-11-22 16:21:29 +0900361 int ilock;
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900362
363 if (name == NULL)
364 return -EINVAL;
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900365
366 if (value == NULL)
367 value_len = 0;
368
Namjae Jeon7c909772013-03-17 17:26:39 +0900369 name_len = strlen(name);
370
371 if (name_len > F2FS_NAME_LEN || value_len > MAX_VALUE_LEN)
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900372 return -ERANGE;
373
Jaegeuk Kim7d82db82013-01-11 13:10:49 +0900374 f2fs_balance_fs(sbi);
375
Jaegeuk Kim39936832012-11-22 16:21:29 +0900376 ilock = mutex_lock_op(sbi);
377
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900378 if (!fi->i_xattr_nid) {
379 /* Allocate new attribute block */
380 struct dnode_of_data dn;
381
382 if (!alloc_nid(sbi, &fi->i_xattr_nid)) {
Namjae Jeon7c909772013-03-17 17:26:39 +0900383 error = -ENOSPC;
384 goto exit;
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900385 }
386 set_new_dnode(&dn, inode, NULL, NULL, fi->i_xattr_nid);
387 mark_inode_dirty(inode);
388
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +0900389 page = new_node_page(&dn, XATTR_NODE_OFFSET, ipage);
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900390 if (IS_ERR(page)) {
391 alloc_nid_failed(sbi, fi->i_xattr_nid);
392 fi->i_xattr_nid = 0;
Namjae Jeon7c909772013-03-17 17:26:39 +0900393 error = PTR_ERR(page);
394 goto exit;
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900395 }
396
397 alloc_nid_done(sbi, fi->i_xattr_nid);
398 base_addr = page_address(page);
399 header = XATTR_HDR(base_addr);
400 header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC);
401 header->h_refcount = cpu_to_le32(1);
402 } else {
403 /* The inode already has an extended attribute block. */
404 page = get_node_page(sbi, fi->i_xattr_nid);
405 if (IS_ERR(page)) {
Namjae Jeon7c909772013-03-17 17:26:39 +0900406 error = PTR_ERR(page);
407 goto exit;
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900408 }
409
410 base_addr = page_address(page);
411 header = XATTR_HDR(base_addr);
412 }
413
414 if (le32_to_cpu(header->h_magic) != F2FS_XATTR_MAGIC) {
415 error = -EIO;
416 goto cleanup;
417 }
418
419 /* find entry with wanted name. */
420 found = 0;
421 list_for_each_xattr(here, base_addr) {
422 if (here->e_name_index != name_index)
423 continue;
424 if (here->e_name_len != name_len)
425 continue;
426 if (!memcmp(here->e_name, name, name_len)) {
427 found = 1;
428 break;
429 }
430 }
431
432 last = here;
433
434 while (!IS_XATTR_LAST_ENTRY(last))
435 last = XATTR_NEXT_ENTRY(last);
436
437 newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) +
438 name_len + value_len);
439
440 /* 1. Check space */
441 if (value) {
442 /* If value is NULL, it is remove operation.
443 * In case of update operation, we caculate free.
444 */
445 free = MIN_OFFSET - ((char *)last - (char *)header);
446 if (found)
447 free = free - ENTRY_SIZE(here);
448
449 if (free < newsize) {
450 error = -ENOSPC;
451 goto cleanup;
452 }
453 }
454
455 /* 2. Remove old entry */
456 if (found) {
457 /* If entry is found, remove old entry.
458 * If not found, remove operation is not needed.
459 */
460 struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);
461 int oldsize = ENTRY_SIZE(here);
462
463 memmove(here, next, (char *)last - (char *)next);
464 last = (struct f2fs_xattr_entry *)((char *)last - oldsize);
465 memset(last, 0, oldsize);
466 }
467
468 /* 3. Write new entry */
469 if (value) {
470 /* Before we come here, old entry is removed.
471 * We just write new entry. */
472 memset(last, 0, newsize);
473 last->e_name_index = name_index;
474 last->e_name_len = name_len;
475 memcpy(last->e_name, name, name_len);
476 pval = last->e_name + name_len;
477 memcpy(pval, value, value_len);
478 last->e_value_size = cpu_to_le16(value_len);
479 }
480
481 set_page_dirty(page);
482 f2fs_put_page(page, 1);
483
484 if (is_inode_flag_set(fi, FI_ACL_MODE)) {
485 inode->i_mode = fi->i_acl_mode;
486 inode->i_ctime = CURRENT_TIME;
487 clear_inode_flag(fi, FI_ACL_MODE);
488 }
Jaegeuk Kime518ff82013-08-09 14:46:15 +0900489
490 /* store checkpoint version for conducting checkpoint during fsync */
Jaegeuk Kimd71b5562013-08-09 15:03:21 +0900491 fi->xattr_ver = cur_cp_version(F2FS_CKPT(sbi));
Jaegeuk Kime518ff82013-08-09 14:46:15 +0900492
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +0900493 if (ipage)
494 update_inode(inode, ipage);
495 else
496 update_inode_page(inode);
Jaegeuk Kim39936832012-11-22 16:21:29 +0900497 mutex_unlock_op(sbi, ilock);
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900498
499 return 0;
500cleanup:
501 f2fs_put_page(page, 1);
Namjae Jeon7c909772013-03-17 17:26:39 +0900502exit:
Jaegeuk Kim39936832012-11-22 16:21:29 +0900503 mutex_unlock_op(sbi, ilock);
Jaegeuk Kimaf48b852012-11-02 17:12:17 +0900504 return error;
505}