~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/f2fs/xattr.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 "f2fs.h"
 25 #include "xattr.h"
 26 
 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)
 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;
 47         case F2FS_XATTR_INDEX_SECURITY:
 48                 prefix = XATTR_SECURITY_PREFIX;
 49                 prefix_len = XATTR_SECURITY_PREFIX_LEN;
 50                 break;
 51         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);
 58                 memcpy(list + prefix_len, name, name_len);
 59                 list[prefix_len + name_len] = '\0';
 60         }
 61         return total_len;
 62 }
 63 
 64 static 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;
 78         case F2FS_XATTR_INDEX_SECURITY:
 79                 break;
 80         default:
 81                 return -EINVAL;
 82         }
 83         if (strcmp(name, "") == 0)
 84                 return -EINVAL;
 85         return f2fs_getxattr(dentry->d_inode, type, name, buffer, size);
 86 }
 87 
 88 static 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;
102         case F2FS_XATTR_INDEX_SECURITY:
103                 break;
104         default:
105                 return -EINVAL;
106         }
107         if (strcmp(name, "") == 0)
108                 return -EINVAL;
109 
110         return f2fs_setxattr(dentry->d_inode, type, name, value, size, NULL);
111 }
112 
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)
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 
128 static 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 
140 static 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 
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,
159                         struct page *ipage);
160 static int f2fs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
161                 void *page)
162 {
163         const struct xattr *xattr;
164         int err = 0;
165 
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);
170                 if (err < 0)
171                         break;
172         }
173         return err;
174 }
175 
176 int f2fs_init_security(struct inode *inode, struct inode *dir,
177                                 const struct qstr *qstr, struct page *ipage)
178 {
179         return security_inode_init_security(inode, dir, qstr,
180                                 &f2fs_initxattrs, ipage);
181 }
182 #endif
183 
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,
190 };
191 
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,
198 };
199 
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,
206 };
207 
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,
214 };
215 
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,
221 #endif
222         [F2FS_XATTR_INDEX_TRUSTED] = &f2fs_xattr_trusted_handler,
223 #ifdef CONFIG_F2FS_FS_SECURITY
224         [F2FS_XATTR_INDEX_SECURITY] = &f2fs_xattr_security_handler,
225 #endif
226         [F2FS_XATTR_INDEX_ADVISE] = &f2fs_xattr_advise_handler,
227 };
228 
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,
234 #endif
235         &f2fs_xattr_trusted_handler,
236 #ifdef CONFIG_F2FS_FS_SECURITY
237         &f2fs_xattr_security_handler,
238 #endif
239         &f2fs_xattr_advise_handler,
240         NULL,
241 };
242 
243 static inline const struct xattr_handler *f2fs_xattr_handler(int name_index)
244 {
245         const struct xattr_handler *handler = NULL;
246 
247         if (name_index > 0 && name_index < ARRAY_SIZE(f2fs_xattr_handler_map))
248                 handler = f2fs_xattr_handler_map[name_index];
249         return handler;
250 }
251 
252 static struct f2fs_xattr_entry *__find_xattr(void *base_addr, int name_index,
253                                         size_t name_len, const char *name)
254 {
255         struct f2fs_xattr_entry *entry;
256 
257         list_for_each_xattr(entry, base_addr) {
258                 if (entry->e_name_index != name_index)
259                         continue;
260                 if (entry->e_name_len != name_len)
261                         continue;
262                 if (!memcmp(entry->e_name, name, name_len))
263                         break;
264         }
265         return entry;
266 }
267 
268 static void *read_all_xattrs(struct inode *inode, struct page *ipage)
269 {
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;
273         void *txattr_addr;
274 
275         inline_size = inline_xattr_size(inode);
276 
277         txattr_addr = kzalloc(inline_size + size, GFP_KERNEL);
278         if (!txattr_addr)
279                 return NULL;
280 
281         /* read from inline xattr */
282         if (inline_size) {
283                 struct page *page = NULL;
284                 void *inline_addr;
285 
286                 if (ipage) {
287                         inline_addr = inline_xattr_addr(ipage);
288                 } else {
289                         page = get_node_page(sbi, inode->i_ino);
290                         if (IS_ERR(page))
291                                 goto fail;
292                         inline_addr = inline_xattr_addr(page);
293                 }
294                 memcpy(txattr_addr, inline_addr, inline_size);
295                 f2fs_put_page(page, 1);
296         }
297 
298         /* read from xattr node block */
299         if (F2FS_I(inode)->i_xattr_nid) {
300                 struct page *xpage;
301                 void *xattr_addr;
302 
303                 /* The inode already has an extended attribute block. */
304                 xpage = get_node_page(sbi, F2FS_I(inode)->i_xattr_nid);
305                 if (IS_ERR(xpage))
306                         goto fail;
307 
308                 xattr_addr = page_address(xpage);
309                 memcpy(txattr_addr + inline_size, xattr_addr, PAGE_SIZE);
310                 f2fs_put_page(xpage, 1);
311         }
312 
313         header = XATTR_HDR(txattr_addr);
314 
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);
319         }
320         return txattr_addr;
321 fail:
322         kzfree(txattr_addr);
323         return NULL;
324 }
325 
326 static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
327                                 void *txattr_addr, struct page *ipage)
328 {
329         struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
330         size_t inline_size = 0;
331         void *xattr_addr;
332         struct page *xpage;
333         nid_t new_nid = 0;
334         int err;
335 
336         inline_size = inline_xattr_size(inode);
337 
338         if (hsize > inline_size && !F2FS_I(inode)->i_xattr_nid)
339                 if (!alloc_nid(sbi, &new_nid))
340                         return -ENOSPC;
341 
342         /* write to inline xattr */
343         if (inline_size) {
344                 struct page *page = NULL;
345                 void *inline_addr;
346 
347                 if (ipage) {
348                         inline_addr = inline_xattr_addr(ipage);
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                 }
357                 memcpy(inline_addr, txattr_addr, inline_size);
358                 f2fs_put_page(page, 1);
359 
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);
364                         return err;
365                 }
366         }
367 
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);
371                 if (IS_ERR(xpage)) {
372                         alloc_nid_failed(sbi, new_nid);
373                         return PTR_ERR(xpage);
374                 }
375                 f2fs_bug_on(new_nid);
376         } else {
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);
380                 if (IS_ERR(xpage)) {
381                         alloc_nid_failed(sbi, new_nid);
382                         return PTR_ERR(xpage);
383                 }
384                 alloc_nid_done(sbi, new_nid);
385         }
386 
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);
392 
393         /* need to checkpoint during fsync */
394         F2FS_I(inode)->xattr_ver = cur_cp_version(F2FS_CKPT(sbi));
395         return 0;
396 }
397 
398 int f2fs_getxattr(struct inode *inode, int name_index, const char *name,
399                 void *buffer, size_t buffer_size)
400 {
401         struct f2fs_xattr_entry *entry;
402         void *base_addr;
403         int error = 0;
404         size_t value_len, name_len;
405 
406         if (name == NULL)
407                 return -EINVAL;
408         name_len = strlen(name);
409 
410         base_addr = read_all_xattrs(inode, NULL);
411         if (!base_addr)
412                 return -ENOMEM;
413 
414         entry = __find_xattr(base_addr, name_index, name_len, name);
415         if (IS_XATTR_LAST_ENTRY(entry)) {
416                 error = -ENODATA;
417                 goto cleanup;
418         }
419 
420         value_len = le16_to_cpu(entry->e_value_size);
421 
422         if (buffer && value_len > buffer_size) {
423                 error = -ERANGE;
424                 goto cleanup;
425         }
426 
427         if (buffer) {
428                 char *pval = entry->e_name + entry->e_name_len;
429                 memcpy(buffer, pval, value_len);
430         }
431         error = value_len;
432 
433 cleanup:
434         kzfree(base_addr);
435         return error;
436 }
437 
438 ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
439 {
440         struct inode *inode = dentry->d_inode;
441         struct f2fs_xattr_entry *entry;
442         void *base_addr;
443         int error = 0;
444         size_t rest = buffer_size;
445 
446         base_addr = read_all_xattrs(inode, NULL);
447         if (!base_addr)
448                 return -ENOMEM;
449 
450         list_for_each_xattr(entry, base_addr) {
451                 const struct xattr_handler *handler =
452                         f2fs_xattr_handler(entry->e_name_index);
453                 size_t size;
454 
455                 if (!handler)
456                         continue;
457 
458                 size = handler->list(dentry, buffer, rest, entry->e_name,
459                                 entry->e_name_len, handler->flags);
460                 if (buffer && size > rest) {
461                         error = -ERANGE;
462                         goto cleanup;
463                 }
464 
465                 if (buffer)
466                         buffer += size;
467                 rest -= size;
468         }
469         error = buffer_size - rest;
470 cleanup:
471         kzfree(base_addr);
472         return error;
473 }
474 
475 static int __f2fs_setxattr(struct inode *inode, int name_index,
476                         const char *name, const void *value, size_t value_len,
477                         struct page *ipage)
478 {
479         struct f2fs_inode_info *fi = F2FS_I(inode);
480         struct f2fs_xattr_entry *here, *last;
481         void *base_addr;
482         int found, newsize;
483         size_t name_len;
484         __u32 new_hsize;
485         int error = -ENOMEM;
486 
487         if (name == NULL)
488                 return -EINVAL;
489 
490         if (value == NULL)
491                 value_len = 0;
492 
493         name_len = strlen(name);
494 
495         if (name_len > F2FS_NAME_LEN || value_len > MAX_VALUE_LEN(inode))
496                 return -ERANGE;
497 
498         base_addr = read_all_xattrs(inode, ipage);
499         if (!base_addr)
500                 goto exit;
501 
502         /* find entry with wanted name. */
503         here = __find_xattr(base_addr, name_index, name_len, name);
504 
505         found = IS_XATTR_LAST_ENTRY(here) ? 0 : 1;
506         last = here;
507 
508         while (!IS_XATTR_LAST_ENTRY(last))
509                 last = XATTR_NEXT_ENTRY(last);
510 
511         newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) +
512                         name_len + value_len);
513 
514         /* 1. Check space */
515         if (value) {
516                 int free;
517                 /*
518                  * If value is NULL, it is remove operation.
519                  * In case of update operation, we caculate free.
520                  */
521                 free = MIN_OFFSET(inode) - ((char *)last - (char *)base_addr);
522                 if (found)
523                         free = free + ENTRY_SIZE(here);
524 
525                 if (free < newsize) {
526                         error = -ENOSPC;
527                         goto exit;
528                 }
529         }
530 
531         /* 2. Remove old entry */
532         if (found) {
533                 /*
534                  * If entry is found, remove old entry.
535                  * If not found, remove operation is not needed.
536                  */
537                 struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);
538                 int oldsize = ENTRY_SIZE(here);
539 
540                 memmove(here, next, (char *)last - (char *)next);
541                 last = (struct f2fs_xattr_entry *)((char *)last - oldsize);
542                 memset(last, 0, oldsize);
543         }
544 
545         new_hsize = (char *)last - (char *)base_addr;
546 
547         /* 3. Write new entry */
548         if (value) {
549                 char *pval;
550                 /*
551                  * Before we come here, old entry is removed.
552                  * We just write new entry.
553                  */
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;
562         }
563 
564         error = write_all_xattrs(inode, new_hsize, base_addr, ipage);
565         if (error)
566                 goto exit;
567 
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);
572         }
573 
574         if (ipage)
575                 update_inode(inode, ipage);
576         else
577                 update_inode_page(inode);
578 exit:
579         kzfree(base_addr);
580         return error;
581 }
582 
583 int f2fs_setxattr(struct inode *inode, int name_index, const char *name,
584                         const void *value, size_t value_len, struct page *ipage)
585 {
586         struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
587         int err;
588 
589         f2fs_balance_fs(sbi);
590 
591         f2fs_lock_op(sbi);
592         err = __f2fs_setxattr(inode, name_index, name, value, value_len, ipage);
593         f2fs_unlock_op(sbi);
594 
595         return err;
596 }
597 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp