ARM64: DTS: Add rk3399-firefly uart4 device, node as /dev/ttyS1
[firefly-linux-kernel-4.4.55.git] / fs / f2fs / xattr.c
1 /*
2  * 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>
23 #include <linux/security.h>
24 #include <linux/posix_acl_xattr.h>
25 #include "f2fs.h"
26 #include "xattr.h"
27
28 static size_t f2fs_xattr_generic_list(const struct xattr_handler *handler,
29                 struct dentry *dentry, char *list, size_t list_size,
30                 const char *name, size_t len)
31 {
32         struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
33         int total_len, prefix_len;
34
35         switch (handler->flags) {
36         case F2FS_XATTR_INDEX_USER:
37                 if (!test_opt(sbi, XATTR_USER))
38                         return -EOPNOTSUPP;
39                 break;
40         case F2FS_XATTR_INDEX_TRUSTED:
41                 if (!capable(CAP_SYS_ADMIN))
42                         return -EPERM;
43                 break;
44         case F2FS_XATTR_INDEX_SECURITY:
45                 break;
46         default:
47                 return -EINVAL;
48         }
49
50         prefix_len = strlen(handler->prefix);
51         total_len = prefix_len + len + 1;
52         if (list && total_len <= list_size) {
53                 memcpy(list, handler->prefix, prefix_len);
54                 memcpy(list + prefix_len, name, len);
55                 list[prefix_len + len] = '\0';
56         }
57         return total_len;
58 }
59
60 static int f2fs_xattr_generic_get(const struct xattr_handler *handler,
61                 struct dentry *dentry, const char *name, void *buffer,
62                 size_t size)
63 {
64         struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
65
66         switch (handler->flags) {
67         case F2FS_XATTR_INDEX_USER:
68                 if (!test_opt(sbi, XATTR_USER))
69                         return -EOPNOTSUPP;
70                 break;
71         case F2FS_XATTR_INDEX_TRUSTED:
72                 if (!capable(CAP_SYS_ADMIN))
73                         return -EPERM;
74                 break;
75         case F2FS_XATTR_INDEX_SECURITY:
76                 break;
77         default:
78                 return -EINVAL;
79         }
80         if (strcmp(name, "") == 0)
81                 return -EINVAL;
82         return f2fs_getxattr(d_inode(dentry), handler->flags, name,
83                              buffer, size, NULL);
84 }
85
86 static int f2fs_xattr_generic_set(const struct xattr_handler *handler,
87                 struct dentry *dentry, const char *name, const void *value,
88                 size_t size, int flags)
89 {
90         struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
91
92         switch (handler->flags) {
93         case F2FS_XATTR_INDEX_USER:
94                 if (!test_opt(sbi, XATTR_USER))
95                         return -EOPNOTSUPP;
96                 break;
97         case F2FS_XATTR_INDEX_TRUSTED:
98                 if (!capable(CAP_SYS_ADMIN))
99                         return -EPERM;
100                 break;
101         case F2FS_XATTR_INDEX_SECURITY:
102                 break;
103         default:
104                 return -EINVAL;
105         }
106         if (strcmp(name, "") == 0)
107                 return -EINVAL;
108
109         return f2fs_setxattr(d_inode(dentry), handler->flags, name,
110                                         value, size, NULL, flags);
111 }
112
113 static size_t f2fs_xattr_advise_list(const struct xattr_handler *handler,
114                 struct dentry *dentry, char *list, size_t list_size,
115                 const char *name, size_t len)
116 {
117         const char *xname = F2FS_SYSTEM_ADVISE_PREFIX;
118         size_t size;
119
120         size = strlen(xname) + 1;
121         if (list && size <= list_size)
122                 memcpy(list, xname, size);
123         return size;
124 }
125
126 static int f2fs_xattr_advise_get(const struct xattr_handler *handler,
127                 struct dentry *dentry, const char *name, void *buffer,
128                 size_t size)
129 {
130         struct inode *inode = d_inode(dentry);
131
132         if (strcmp(name, "") != 0)
133                 return -EINVAL;
134
135         if (buffer)
136                 *((char *)buffer) = F2FS_I(inode)->i_advise;
137         return sizeof(char);
138 }
139
140 static int f2fs_xattr_advise_set(const struct xattr_handler *handler,
141                 struct dentry *dentry, const char *name, const void *value,
142                 size_t size, int flags)
143 {
144         struct inode *inode = d_inode(dentry);
145
146         if (strcmp(name, "") != 0)
147                 return -EINVAL;
148         if (!inode_owner_or_capable(inode))
149                 return -EPERM;
150         if (value == NULL)
151                 return -EINVAL;
152
153         F2FS_I(inode)->i_advise |= *(char *)value;
154         mark_inode_dirty(inode);
155         return 0;
156 }
157
158 #ifdef CONFIG_F2FS_FS_SECURITY
159 static int f2fs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
160                 void *page)
161 {
162         const struct xattr *xattr;
163         int err = 0;
164
165         for (xattr = xattr_array; xattr->name != NULL; xattr++) {
166                 err = f2fs_setxattr(inode, F2FS_XATTR_INDEX_SECURITY,
167                                 xattr->name, xattr->value,
168                                 xattr->value_len, (struct page *)page, 0);
169                 if (err < 0)
170                         break;
171         }
172         return err;
173 }
174
175 int f2fs_init_security(struct inode *inode, struct inode *dir,
176                                 const struct qstr *qstr, struct page *ipage)
177 {
178         return security_inode_init_security(inode, dir, qstr,
179                                 &f2fs_initxattrs, ipage);
180 }
181 #endif
182
183 const struct xattr_handler f2fs_xattr_user_handler = {
184         .prefix = XATTR_USER_PREFIX,
185         .flags  = F2FS_XATTR_INDEX_USER,
186         .list   = f2fs_xattr_generic_list,
187         .get    = f2fs_xattr_generic_get,
188         .set    = f2fs_xattr_generic_set,
189 };
190
191 const struct xattr_handler f2fs_xattr_trusted_handler = {
192         .prefix = XATTR_TRUSTED_PREFIX,
193         .flags  = F2FS_XATTR_INDEX_TRUSTED,
194         .list   = f2fs_xattr_generic_list,
195         .get    = f2fs_xattr_generic_get,
196         .set    = f2fs_xattr_generic_set,
197 };
198
199 const struct xattr_handler f2fs_xattr_advise_handler = {
200         .prefix = F2FS_SYSTEM_ADVISE_PREFIX,
201         .flags  = F2FS_XATTR_INDEX_ADVISE,
202         .list   = f2fs_xattr_advise_list,
203         .get    = f2fs_xattr_advise_get,
204         .set    = f2fs_xattr_advise_set,
205 };
206
207 const struct xattr_handler f2fs_xattr_security_handler = {
208         .prefix = XATTR_SECURITY_PREFIX,
209         .flags  = F2FS_XATTR_INDEX_SECURITY,
210         .list   = f2fs_xattr_generic_list,
211         .get    = f2fs_xattr_generic_get,
212         .set    = f2fs_xattr_generic_set,
213 };
214
215 static const struct xattr_handler *f2fs_xattr_handler_map[] = {
216         [F2FS_XATTR_INDEX_USER] = &f2fs_xattr_user_handler,
217 #ifdef CONFIG_F2FS_FS_POSIX_ACL
218         [F2FS_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
219         [F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
220 #endif
221         [F2FS_XATTR_INDEX_TRUSTED] = &f2fs_xattr_trusted_handler,
222 #ifdef CONFIG_F2FS_FS_SECURITY
223         [F2FS_XATTR_INDEX_SECURITY] = &f2fs_xattr_security_handler,
224 #endif
225         [F2FS_XATTR_INDEX_ADVISE] = &f2fs_xattr_advise_handler,
226 };
227
228 const struct xattr_handler *f2fs_xattr_handlers[] = {
229         &f2fs_xattr_user_handler,
230 #ifdef CONFIG_F2FS_FS_POSIX_ACL
231         &posix_acl_access_xattr_handler,
232         &posix_acl_default_xattr_handler,
233 #endif
234         &f2fs_xattr_trusted_handler,
235 #ifdef CONFIG_F2FS_FS_SECURITY
236         &f2fs_xattr_security_handler,
237 #endif
238         &f2fs_xattr_advise_handler,
239         NULL,
240 };
241
242 static inline const struct xattr_handler *f2fs_xattr_handler(int index)
243 {
244         const struct xattr_handler *handler = NULL;
245
246         if (index > 0 && index < ARRAY_SIZE(f2fs_xattr_handler_map))
247                 handler = f2fs_xattr_handler_map[index];
248         return handler;
249 }
250
251 static struct f2fs_xattr_entry *__find_xattr(void *base_addr, int index,
252                                         size_t len, const char *name)
253 {
254         struct f2fs_xattr_entry *entry;
255
256         list_for_each_xattr(entry, base_addr) {
257                 if (entry->e_name_index != index)
258                         continue;
259                 if (entry->e_name_len != len)
260                         continue;
261                 if (!memcmp(entry->e_name, name, len))
262                         break;
263         }
264         return entry;
265 }
266
267 static void *read_all_xattrs(struct inode *inode, struct page *ipage)
268 {
269         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
270         struct f2fs_xattr_header *header;
271         size_t size = PAGE_SIZE, inline_size = 0;
272         void *txattr_addr;
273
274         inline_size = inline_xattr_size(inode);
275
276         txattr_addr = kzalloc(inline_size + size, GFP_F2FS_ZERO);
277         if (!txattr_addr)
278                 return NULL;
279
280         /* read from inline xattr */
281         if (inline_size) {
282                 struct page *page = NULL;
283                 void *inline_addr;
284
285                 if (ipage) {
286                         inline_addr = inline_xattr_addr(ipage);
287                 } else {
288                         page = get_node_page(sbi, inode->i_ino);
289                         if (IS_ERR(page))
290                                 goto fail;
291                         inline_addr = inline_xattr_addr(page);
292                 }
293                 memcpy(txattr_addr, inline_addr, inline_size);
294                 f2fs_put_page(page, 1);
295         }
296
297         /* read from xattr node block */
298         if (F2FS_I(inode)->i_xattr_nid) {
299                 struct page *xpage;
300                 void *xattr_addr;
301
302                 /* The inode already has an extended attribute block. */
303                 xpage = get_node_page(sbi, F2FS_I(inode)->i_xattr_nid);
304                 if (IS_ERR(xpage))
305                         goto fail;
306
307                 xattr_addr = page_address(xpage);
308                 memcpy(txattr_addr + inline_size, xattr_addr, PAGE_SIZE);
309                 f2fs_put_page(xpage, 1);
310         }
311
312         header = XATTR_HDR(txattr_addr);
313
314         /* never been allocated xattrs */
315         if (le32_to_cpu(header->h_magic) != F2FS_XATTR_MAGIC) {
316                 header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC);
317                 header->h_refcount = cpu_to_le32(1);
318         }
319         return txattr_addr;
320 fail:
321         kzfree(txattr_addr);
322         return NULL;
323 }
324
325 static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
326                                 void *txattr_addr, struct page *ipage)
327 {
328         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
329         size_t inline_size = 0;
330         void *xattr_addr;
331         struct page *xpage;
332         nid_t new_nid = 0;
333         int err;
334
335         inline_size = inline_xattr_size(inode);
336
337         if (hsize > inline_size && !F2FS_I(inode)->i_xattr_nid)
338                 if (!alloc_nid(sbi, &new_nid))
339                         return -ENOSPC;
340
341         /* write to inline xattr */
342         if (inline_size) {
343                 struct page *page = NULL;
344                 void *inline_addr;
345
346                 if (ipage) {
347                         inline_addr = inline_xattr_addr(ipage);
348                         f2fs_wait_on_page_writeback(ipage, NODE);
349                 } else {
350                         page = get_node_page(sbi, inode->i_ino);
351                         if (IS_ERR(page)) {
352                                 alloc_nid_failed(sbi, new_nid);
353                                 return PTR_ERR(page);
354                         }
355                         inline_addr = inline_xattr_addr(page);
356                         f2fs_wait_on_page_writeback(page, NODE);
357                 }
358                 memcpy(inline_addr, txattr_addr, inline_size);
359                 f2fs_put_page(page, 1);
360
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);
365                         return err;
366                 }
367         }
368
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);
372                 if (IS_ERR(xpage)) {
373                         alloc_nid_failed(sbi, new_nid);
374                         return PTR_ERR(xpage);
375                 }
376                 f2fs_bug_on(sbi, new_nid);
377                 f2fs_wait_on_page_writeback(xpage, NODE);
378         } else {
379                 struct dnode_of_data dn;
380                 set_new_dnode(&dn, inode, NULL, NULL, new_nid);
381                 xpage = new_node_page(&dn, XATTR_NODE_OFFSET, ipage);
382                 if (IS_ERR(xpage)) {
383                         alloc_nid_failed(sbi, new_nid);
384                         return PTR_ERR(xpage);
385                 }
386                 alloc_nid_done(sbi, new_nid);
387         }
388
389         xattr_addr = page_address(xpage);
390         memcpy(xattr_addr, txattr_addr + inline_size, PAGE_SIZE -
391                                                 sizeof(struct node_footer));
392         set_page_dirty(xpage);
393         f2fs_put_page(xpage, 1);
394
395         /* need to checkpoint during fsync */
396         F2FS_I(inode)->xattr_ver = cur_cp_version(F2FS_CKPT(sbi));
397         return 0;
398 }
399
400 int f2fs_getxattr(struct inode *inode, int index, const char *name,
401                 void *buffer, size_t buffer_size, struct page *ipage)
402 {
403         struct f2fs_xattr_entry *entry;
404         void *base_addr;
405         int error = 0;
406         size_t size, len;
407
408         if (name == NULL)
409                 return -EINVAL;
410
411         len = strlen(name);
412         if (len > F2FS_NAME_LEN)
413                 return -ERANGE;
414
415         base_addr = read_all_xattrs(inode, ipage);
416         if (!base_addr)
417                 return -ENOMEM;
418
419         entry = __find_xattr(base_addr, index, len, name);
420         if (IS_XATTR_LAST_ENTRY(entry)) {
421                 error = -ENODATA;
422                 goto cleanup;
423         }
424
425         size = le16_to_cpu(entry->e_value_size);
426
427         if (buffer && size > buffer_size) {
428                 error = -ERANGE;
429                 goto cleanup;
430         }
431
432         if (buffer) {
433                 char *pval = entry->e_name + entry->e_name_len;
434                 memcpy(buffer, pval, size);
435         }
436         error = size;
437
438 cleanup:
439         kzfree(base_addr);
440         return error;
441 }
442
443 ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
444 {
445         struct inode *inode = d_inode(dentry);
446         struct f2fs_xattr_entry *entry;
447         void *base_addr;
448         int error = 0;
449         size_t rest = buffer_size;
450
451         base_addr = read_all_xattrs(inode, NULL);
452         if (!base_addr)
453                 return -ENOMEM;
454
455         list_for_each_xattr(entry, base_addr) {
456                 const struct xattr_handler *handler =
457                         f2fs_xattr_handler(entry->e_name_index);
458                 size_t size;
459
460                 if (!handler)
461                         continue;
462
463                 size = handler->list(handler, dentry, buffer, rest,
464                                      entry->e_name, entry->e_name_len);
465                 if (buffer && size > rest) {
466                         error = -ERANGE;
467                         goto cleanup;
468                 }
469
470                 if (buffer)
471                         buffer += size;
472                 rest -= size;
473         }
474         error = buffer_size - rest;
475 cleanup:
476         kzfree(base_addr);
477         return error;
478 }
479
480 static int __f2fs_setxattr(struct inode *inode, int index,
481                         const char *name, const void *value, size_t size,
482                         struct page *ipage, int flags)
483 {
484         struct f2fs_inode_info *fi = F2FS_I(inode);
485         struct f2fs_xattr_entry *here, *last;
486         void *base_addr;
487         int found, newsize;
488         size_t len;
489         __u32 new_hsize;
490         int error = -ENOMEM;
491
492         if (name == NULL)
493                 return -EINVAL;
494
495         if (value == NULL)
496                 size = 0;
497
498         len = strlen(name);
499
500         if (len > F2FS_NAME_LEN)
501                 return -ERANGE;
502
503         if (size > MAX_VALUE_LEN(inode))
504                 return -E2BIG;
505
506         base_addr = read_all_xattrs(inode, ipage);
507         if (!base_addr)
508                 goto exit;
509
510         /* find entry with wanted name. */
511         here = __find_xattr(base_addr, index, len, name);
512
513         found = IS_XATTR_LAST_ENTRY(here) ? 0 : 1;
514
515         if ((flags & XATTR_REPLACE) && !found) {
516                 error = -ENODATA;
517                 goto exit;
518         } else if ((flags & XATTR_CREATE) && found) {
519                 error = -EEXIST;
520                 goto exit;
521         }
522
523         last = here;
524         while (!IS_XATTR_LAST_ENTRY(last))
525                 last = XATTR_NEXT_ENTRY(last);
526
527         newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) + len + size);
528
529         /* 1. Check space */
530         if (value) {
531                 int free;
532                 /*
533                  * If value is NULL, it is remove operation.
534                  * In case of update operation, we calculate free.
535                  */
536                 free = MIN_OFFSET(inode) - ((char *)last - (char *)base_addr);
537                 if (found)
538                         free = free + ENTRY_SIZE(here);
539
540                 if (unlikely(free < newsize)) {
541                         error = -ENOSPC;
542                         goto exit;
543                 }
544         }
545
546         /* 2. Remove old entry */
547         if (found) {
548                 /*
549                  * If entry is found, remove old entry.
550                  * If not found, remove operation is not needed.
551                  */
552                 struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);
553                 int oldsize = ENTRY_SIZE(here);
554
555                 memmove(here, next, (char *)last - (char *)next);
556                 last = (struct f2fs_xattr_entry *)((char *)last - oldsize);
557                 memset(last, 0, oldsize);
558         }
559
560         new_hsize = (char *)last - (char *)base_addr;
561
562         /* 3. Write new entry */
563         if (value) {
564                 char *pval;
565                 /*
566                  * Before we come here, old entry is removed.
567                  * We just write new entry.
568                  */
569                 memset(last, 0, newsize);
570                 last->e_name_index = index;
571                 last->e_name_len = len;
572                 memcpy(last->e_name, name, len);
573                 pval = last->e_name + len;
574                 memcpy(pval, value, size);
575                 last->e_value_size = cpu_to_le16(size);
576                 new_hsize += newsize;
577         }
578
579         error = write_all_xattrs(inode, new_hsize, base_addr, ipage);
580         if (error)
581                 goto exit;
582
583         if (is_inode_flag_set(fi, FI_ACL_MODE)) {
584                 inode->i_mode = fi->i_acl_mode;
585                 inode->i_ctime = CURRENT_TIME;
586                 clear_inode_flag(fi, FI_ACL_MODE);
587         }
588         if (index == F2FS_XATTR_INDEX_ENCRYPTION &&
589                         !strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT))
590                 f2fs_set_encrypted_inode(inode);
591
592         if (ipage)
593                 update_inode(inode, ipage);
594         else
595                 update_inode_page(inode);
596 exit:
597         kzfree(base_addr);
598         return error;
599 }
600
601 int f2fs_setxattr(struct inode *inode, int index, const char *name,
602                                 const void *value, size_t size,
603                                 struct page *ipage, int flags)
604 {
605         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
606         int err;
607
608         /* this case is only from init_inode_metadata */
609         if (ipage)
610                 return __f2fs_setxattr(inode, index, name, value,
611                                                 size, ipage, flags);
612         f2fs_balance_fs(sbi);
613
614         f2fs_lock_op(sbi);
615         /* protect xattr_ver */
616         down_write(&F2FS_I(inode)->i_sem);
617         err = __f2fs_setxattr(inode, index, name, value, size, ipage, flags);
618         up_write(&F2FS_I(inode)->i_sem);
619         f2fs_unlock_op(sbi);
620
621         return err;
622 }