]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/f2fs/xattr.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
x86/static_call: Add out-of-line static call implementation
[mirror_ubuntu-jammy-kernel.git] / fs / f2fs / xattr.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * fs/f2fs/xattr.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 *
8 * Portions of this code from linux/fs/ext2/xattr.c
9 *
10 * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
11 *
12 * Fix by Harrison Xing <harrison@mountainviewdata.com>.
13 * Extended attributes for symlinks and special files added per
14 * suggestion of Luka Renko <luka.renko@hermes.si>.
15 * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
16 * Red Hat Inc.
17 */
18 #include <linux/rwsem.h>
19 #include <linux/f2fs_fs.h>
20 #include <linux/security.h>
21 #include <linux/posix_acl_xattr.h>
22 #include "f2fs.h"
23 #include "xattr.h"
24 #include "segment.h"
25
26 static void *xattr_alloc(struct f2fs_sb_info *sbi, int size, bool *is_inline)
27 {
28 if (likely(size == sbi->inline_xattr_slab_size)) {
29 *is_inline = true;
30 return kmem_cache_zalloc(sbi->inline_xattr_slab, GFP_NOFS);
31 }
32 *is_inline = false;
33 return f2fs_kzalloc(sbi, size, GFP_NOFS);
34 }
35
36 static void xattr_free(struct f2fs_sb_info *sbi, void *xattr_addr,
37 bool is_inline)
38 {
39 if (is_inline)
40 kmem_cache_free(sbi->inline_xattr_slab, xattr_addr);
41 else
42 kvfree(xattr_addr);
43 }
44
45 static int f2fs_xattr_generic_get(const struct xattr_handler *handler,
46 struct dentry *unused, struct inode *inode,
47 const char *name, void *buffer, size_t size)
48 {
49 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
50
51 switch (handler->flags) {
52 case F2FS_XATTR_INDEX_USER:
53 if (!test_opt(sbi, XATTR_USER))
54 return -EOPNOTSUPP;
55 break;
56 case F2FS_XATTR_INDEX_TRUSTED:
57 case F2FS_XATTR_INDEX_SECURITY:
58 break;
59 default:
60 return -EINVAL;
61 }
62 return f2fs_getxattr(inode, handler->flags, name,
63 buffer, size, NULL);
64 }
65
66 static int f2fs_xattr_generic_set(const struct xattr_handler *handler,
67 struct dentry *unused, struct inode *inode,
68 const char *name, const void *value,
69 size_t size, int flags)
70 {
71 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
72
73 switch (handler->flags) {
74 case F2FS_XATTR_INDEX_USER:
75 if (!test_opt(sbi, XATTR_USER))
76 return -EOPNOTSUPP;
77 break;
78 case F2FS_XATTR_INDEX_TRUSTED:
79 case F2FS_XATTR_INDEX_SECURITY:
80 break;
81 default:
82 return -EINVAL;
83 }
84 return f2fs_setxattr(inode, handler->flags, name,
85 value, size, NULL, flags);
86 }
87
88 static bool f2fs_xattr_user_list(struct dentry *dentry)
89 {
90 struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
91
92 return test_opt(sbi, XATTR_USER);
93 }
94
95 static bool f2fs_xattr_trusted_list(struct dentry *dentry)
96 {
97 return capable(CAP_SYS_ADMIN);
98 }
99
100 static int f2fs_xattr_advise_get(const struct xattr_handler *handler,
101 struct dentry *unused, struct inode *inode,
102 const char *name, void *buffer, size_t size)
103 {
104 if (buffer)
105 *((char *)buffer) = F2FS_I(inode)->i_advise;
106 return sizeof(char);
107 }
108
109 static int f2fs_xattr_advise_set(const struct xattr_handler *handler,
110 struct dentry *unused, struct inode *inode,
111 const char *name, const void *value,
112 size_t size, int flags)
113 {
114 unsigned char old_advise = F2FS_I(inode)->i_advise;
115 unsigned char new_advise;
116
117 if (!inode_owner_or_capable(inode))
118 return -EPERM;
119 if (value == NULL)
120 return -EINVAL;
121
122 new_advise = *(char *)value;
123 if (new_advise & ~FADVISE_MODIFIABLE_BITS)
124 return -EINVAL;
125
126 new_advise = new_advise & FADVISE_MODIFIABLE_BITS;
127 new_advise |= old_advise & ~FADVISE_MODIFIABLE_BITS;
128
129 F2FS_I(inode)->i_advise = new_advise;
130 f2fs_mark_inode_dirty_sync(inode, true);
131 return 0;
132 }
133
134 #ifdef CONFIG_F2FS_FS_SECURITY
135 static int f2fs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
136 void *page)
137 {
138 const struct xattr *xattr;
139 int err = 0;
140
141 for (xattr = xattr_array; xattr->name != NULL; xattr++) {
142 err = f2fs_setxattr(inode, F2FS_XATTR_INDEX_SECURITY,
143 xattr->name, xattr->value,
144 xattr->value_len, (struct page *)page, 0);
145 if (err < 0)
146 break;
147 }
148 return err;
149 }
150
151 int f2fs_init_security(struct inode *inode, struct inode *dir,
152 const struct qstr *qstr, struct page *ipage)
153 {
154 return security_inode_init_security(inode, dir, qstr,
155 &f2fs_initxattrs, ipage);
156 }
157 #endif
158
159 const struct xattr_handler f2fs_xattr_user_handler = {
160 .prefix = XATTR_USER_PREFIX,
161 .flags = F2FS_XATTR_INDEX_USER,
162 .list = f2fs_xattr_user_list,
163 .get = f2fs_xattr_generic_get,
164 .set = f2fs_xattr_generic_set,
165 };
166
167 const struct xattr_handler f2fs_xattr_trusted_handler = {
168 .prefix = XATTR_TRUSTED_PREFIX,
169 .flags = F2FS_XATTR_INDEX_TRUSTED,
170 .list = f2fs_xattr_trusted_list,
171 .get = f2fs_xattr_generic_get,
172 .set = f2fs_xattr_generic_set,
173 };
174
175 const struct xattr_handler f2fs_xattr_advise_handler = {
176 .name = F2FS_SYSTEM_ADVISE_NAME,
177 .flags = F2FS_XATTR_INDEX_ADVISE,
178 .get = f2fs_xattr_advise_get,
179 .set = f2fs_xattr_advise_set,
180 };
181
182 const struct xattr_handler f2fs_xattr_security_handler = {
183 .prefix = XATTR_SECURITY_PREFIX,
184 .flags = F2FS_XATTR_INDEX_SECURITY,
185 .get = f2fs_xattr_generic_get,
186 .set = f2fs_xattr_generic_set,
187 };
188
189 static const struct xattr_handler *f2fs_xattr_handler_map[] = {
190 [F2FS_XATTR_INDEX_USER] = &f2fs_xattr_user_handler,
191 #ifdef CONFIG_F2FS_FS_POSIX_ACL
192 [F2FS_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
193 [F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
194 #endif
195 [F2FS_XATTR_INDEX_TRUSTED] = &f2fs_xattr_trusted_handler,
196 #ifdef CONFIG_F2FS_FS_SECURITY
197 [F2FS_XATTR_INDEX_SECURITY] = &f2fs_xattr_security_handler,
198 #endif
199 [F2FS_XATTR_INDEX_ADVISE] = &f2fs_xattr_advise_handler,
200 };
201
202 const struct xattr_handler *f2fs_xattr_handlers[] = {
203 &f2fs_xattr_user_handler,
204 #ifdef CONFIG_F2FS_FS_POSIX_ACL
205 &posix_acl_access_xattr_handler,
206 &posix_acl_default_xattr_handler,
207 #endif
208 &f2fs_xattr_trusted_handler,
209 #ifdef CONFIG_F2FS_FS_SECURITY
210 &f2fs_xattr_security_handler,
211 #endif
212 &f2fs_xattr_advise_handler,
213 NULL,
214 };
215
216 static inline const struct xattr_handler *f2fs_xattr_handler(int index)
217 {
218 const struct xattr_handler *handler = NULL;
219
220 if (index > 0 && index < ARRAY_SIZE(f2fs_xattr_handler_map))
221 handler = f2fs_xattr_handler_map[index];
222 return handler;
223 }
224
225 static struct f2fs_xattr_entry *__find_xattr(void *base_addr,
226 void *last_base_addr, int index,
227 size_t len, const char *name)
228 {
229 struct f2fs_xattr_entry *entry;
230
231 list_for_each_xattr(entry, base_addr) {
232 if ((void *)(entry) + sizeof(__u32) > last_base_addr ||
233 (void *)XATTR_NEXT_ENTRY(entry) > last_base_addr)
234 return NULL;
235
236 if (entry->e_name_index != index)
237 continue;
238 if (entry->e_name_len != len)
239 continue;
240 if (!memcmp(entry->e_name, name, len))
241 break;
242 }
243 return entry;
244 }
245
246 static struct f2fs_xattr_entry *__find_inline_xattr(struct inode *inode,
247 void *base_addr, void **last_addr, int index,
248 size_t len, const char *name)
249 {
250 struct f2fs_xattr_entry *entry;
251 unsigned int inline_size = inline_xattr_size(inode);
252 void *max_addr = base_addr + inline_size;
253
254 list_for_each_xattr(entry, base_addr) {
255 if ((void *)entry + sizeof(__u32) > max_addr ||
256 (void *)XATTR_NEXT_ENTRY(entry) > max_addr) {
257 *last_addr = entry;
258 return NULL;
259 }
260 if (entry->e_name_index != index)
261 continue;
262 if (entry->e_name_len != len)
263 continue;
264 if (!memcmp(entry->e_name, name, len))
265 break;
266 }
267
268 /* inline xattr header or entry across max inline xattr size */
269 if (IS_XATTR_LAST_ENTRY(entry) &&
270 (void *)entry + sizeof(__u32) > max_addr) {
271 *last_addr = entry;
272 return NULL;
273 }
274 return entry;
275 }
276
277 static int read_inline_xattr(struct inode *inode, struct page *ipage,
278 void *txattr_addr)
279 {
280 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
281 unsigned int inline_size = inline_xattr_size(inode);
282 struct page *page = NULL;
283 void *inline_addr;
284
285 if (ipage) {
286 inline_addr = inline_xattr_addr(inode, ipage);
287 } else {
288 page = f2fs_get_node_page(sbi, inode->i_ino);
289 if (IS_ERR(page))
290 return PTR_ERR(page);
291
292 inline_addr = inline_xattr_addr(inode, page);
293 }
294 memcpy(txattr_addr, inline_addr, inline_size);
295 f2fs_put_page(page, 1);
296
297 return 0;
298 }
299
300 static int read_xattr_block(struct inode *inode, void *txattr_addr)
301 {
302 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
303 nid_t xnid = F2FS_I(inode)->i_xattr_nid;
304 unsigned int inline_size = inline_xattr_size(inode);
305 struct page *xpage;
306 void *xattr_addr;
307
308 /* The inode already has an extended attribute block. */
309 xpage = f2fs_get_node_page(sbi, xnid);
310 if (IS_ERR(xpage))
311 return PTR_ERR(xpage);
312
313 xattr_addr = page_address(xpage);
314 memcpy(txattr_addr + inline_size, xattr_addr, VALID_XATTR_BLOCK_SIZE);
315 f2fs_put_page(xpage, 1);
316
317 return 0;
318 }
319
320 static int lookup_all_xattrs(struct inode *inode, struct page *ipage,
321 unsigned int index, unsigned int len,
322 const char *name, struct f2fs_xattr_entry **xe,
323 void **base_addr, int *base_size,
324 bool *is_inline)
325 {
326 void *cur_addr, *txattr_addr, *last_txattr_addr;
327 void *last_addr = NULL;
328 nid_t xnid = F2FS_I(inode)->i_xattr_nid;
329 unsigned int inline_size = inline_xattr_size(inode);
330 int err = 0;
331
332 if (!xnid && !inline_size)
333 return -ENODATA;
334
335 *base_size = XATTR_SIZE(inode) + XATTR_PADDING_SIZE;
336 txattr_addr = xattr_alloc(F2FS_I_SB(inode), *base_size, is_inline);
337 if (!txattr_addr)
338 return -ENOMEM;
339
340 last_txattr_addr = (void *)txattr_addr + XATTR_SIZE(inode);
341
342 /* read from inline xattr */
343 if (inline_size) {
344 err = read_inline_xattr(inode, ipage, txattr_addr);
345 if (err)
346 goto out;
347
348 *xe = __find_inline_xattr(inode, txattr_addr, &last_addr,
349 index, len, name);
350 if (*xe) {
351 *base_size = inline_size;
352 goto check;
353 }
354 }
355
356 /* read from xattr node block */
357 if (xnid) {
358 err = read_xattr_block(inode, txattr_addr);
359 if (err)
360 goto out;
361 }
362
363 if (last_addr)
364 cur_addr = XATTR_HDR(last_addr) - 1;
365 else
366 cur_addr = txattr_addr;
367
368 *xe = __find_xattr(cur_addr, last_txattr_addr, index, len, name);
369 if (!*xe) {
370 f2fs_err(F2FS_I_SB(inode), "inode (%lu) has corrupted xattr",
371 inode->i_ino);
372 set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
373 err = -EFSCORRUPTED;
374 goto out;
375 }
376 check:
377 if (IS_XATTR_LAST_ENTRY(*xe)) {
378 err = -ENODATA;
379 goto out;
380 }
381
382 *base_addr = txattr_addr;
383 return 0;
384 out:
385 xattr_free(F2FS_I_SB(inode), txattr_addr, *is_inline);
386 return err;
387 }
388
389 static int read_all_xattrs(struct inode *inode, struct page *ipage,
390 void **base_addr)
391 {
392 struct f2fs_xattr_header *header;
393 nid_t xnid = F2FS_I(inode)->i_xattr_nid;
394 unsigned int size = VALID_XATTR_BLOCK_SIZE;
395 unsigned int inline_size = inline_xattr_size(inode);
396 void *txattr_addr;
397 int err;
398
399 txattr_addr = f2fs_kzalloc(F2FS_I_SB(inode),
400 inline_size + size + XATTR_PADDING_SIZE, GFP_NOFS);
401 if (!txattr_addr)
402 return -ENOMEM;
403
404 /* read from inline xattr */
405 if (inline_size) {
406 err = read_inline_xattr(inode, ipage, txattr_addr);
407 if (err)
408 goto fail;
409 }
410
411 /* read from xattr node block */
412 if (xnid) {
413 err = read_xattr_block(inode, txattr_addr);
414 if (err)
415 goto fail;
416 }
417
418 header = XATTR_HDR(txattr_addr);
419
420 /* never been allocated xattrs */
421 if (le32_to_cpu(header->h_magic) != F2FS_XATTR_MAGIC) {
422 header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC);
423 header->h_refcount = cpu_to_le32(1);
424 }
425 *base_addr = txattr_addr;
426 return 0;
427 fail:
428 kvfree(txattr_addr);
429 return err;
430 }
431
432 static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
433 void *txattr_addr, struct page *ipage)
434 {
435 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
436 size_t inline_size = inline_xattr_size(inode);
437 struct page *in_page = NULL;
438 void *xattr_addr;
439 void *inline_addr = NULL;
440 struct page *xpage;
441 nid_t new_nid = 0;
442 int err = 0;
443
444 if (hsize > inline_size && !F2FS_I(inode)->i_xattr_nid)
445 if (!f2fs_alloc_nid(sbi, &new_nid))
446 return -ENOSPC;
447
448 /* write to inline xattr */
449 if (inline_size) {
450 if (ipage) {
451 inline_addr = inline_xattr_addr(inode, ipage);
452 } else {
453 in_page = f2fs_get_node_page(sbi, inode->i_ino);
454 if (IS_ERR(in_page)) {
455 f2fs_alloc_nid_failed(sbi, new_nid);
456 return PTR_ERR(in_page);
457 }
458 inline_addr = inline_xattr_addr(inode, in_page);
459 }
460
461 f2fs_wait_on_page_writeback(ipage ? ipage : in_page,
462 NODE, true, true);
463 /* no need to use xattr node block */
464 if (hsize <= inline_size) {
465 err = f2fs_truncate_xattr_node(inode);
466 f2fs_alloc_nid_failed(sbi, new_nid);
467 if (err) {
468 f2fs_put_page(in_page, 1);
469 return err;
470 }
471 memcpy(inline_addr, txattr_addr, inline_size);
472 set_page_dirty(ipage ? ipage : in_page);
473 goto in_page_out;
474 }
475 }
476
477 /* write to xattr node block */
478 if (F2FS_I(inode)->i_xattr_nid) {
479 xpage = f2fs_get_node_page(sbi, F2FS_I(inode)->i_xattr_nid);
480 if (IS_ERR(xpage)) {
481 err = PTR_ERR(xpage);
482 f2fs_alloc_nid_failed(sbi, new_nid);
483 goto in_page_out;
484 }
485 f2fs_bug_on(sbi, new_nid);
486 f2fs_wait_on_page_writeback(xpage, NODE, true, true);
487 } else {
488 struct dnode_of_data dn;
489 set_new_dnode(&dn, inode, NULL, NULL, new_nid);
490 xpage = f2fs_new_node_page(&dn, XATTR_NODE_OFFSET);
491 if (IS_ERR(xpage)) {
492 err = PTR_ERR(xpage);
493 f2fs_alloc_nid_failed(sbi, new_nid);
494 goto in_page_out;
495 }
496 f2fs_alloc_nid_done(sbi, new_nid);
497 }
498 xattr_addr = page_address(xpage);
499
500 if (inline_size)
501 memcpy(inline_addr, txattr_addr, inline_size);
502 memcpy(xattr_addr, txattr_addr + inline_size, VALID_XATTR_BLOCK_SIZE);
503
504 if (inline_size)
505 set_page_dirty(ipage ? ipage : in_page);
506 set_page_dirty(xpage);
507
508 f2fs_put_page(xpage, 1);
509 in_page_out:
510 f2fs_put_page(in_page, 1);
511 return err;
512 }
513
514 int f2fs_getxattr(struct inode *inode, int index, const char *name,
515 void *buffer, size_t buffer_size, struct page *ipage)
516 {
517 struct f2fs_xattr_entry *entry = NULL;
518 int error = 0;
519 unsigned int size, len;
520 void *base_addr = NULL;
521 int base_size;
522 bool is_inline;
523
524 if (name == NULL)
525 return -EINVAL;
526
527 len = strlen(name);
528 if (len > F2FS_NAME_LEN)
529 return -ERANGE;
530
531 down_read(&F2FS_I(inode)->i_xattr_sem);
532 error = lookup_all_xattrs(inode, ipage, index, len, name,
533 &entry, &base_addr, &base_size, &is_inline);
534 up_read(&F2FS_I(inode)->i_xattr_sem);
535 if (error)
536 return error;
537
538 size = le16_to_cpu(entry->e_value_size);
539
540 if (buffer && size > buffer_size) {
541 error = -ERANGE;
542 goto out;
543 }
544
545 if (buffer) {
546 char *pval = entry->e_name + entry->e_name_len;
547
548 if (base_size - (pval - (char *)base_addr) < size) {
549 error = -ERANGE;
550 goto out;
551 }
552 memcpy(buffer, pval, size);
553 }
554 error = size;
555 out:
556 xattr_free(F2FS_I_SB(inode), base_addr, is_inline);
557 return error;
558 }
559
560 ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
561 {
562 struct inode *inode = d_inode(dentry);
563 struct f2fs_xattr_entry *entry;
564 void *base_addr, *last_base_addr;
565 int error = 0;
566 size_t rest = buffer_size;
567
568 down_read(&F2FS_I(inode)->i_xattr_sem);
569 error = read_all_xattrs(inode, NULL, &base_addr);
570 up_read(&F2FS_I(inode)->i_xattr_sem);
571 if (error)
572 return error;
573
574 last_base_addr = (void *)base_addr + XATTR_SIZE(inode);
575
576 list_for_each_xattr(entry, base_addr) {
577 const struct xattr_handler *handler =
578 f2fs_xattr_handler(entry->e_name_index);
579 const char *prefix;
580 size_t prefix_len;
581 size_t size;
582
583 if ((void *)(entry) + sizeof(__u32) > last_base_addr ||
584 (void *)XATTR_NEXT_ENTRY(entry) > last_base_addr) {
585 f2fs_err(F2FS_I_SB(inode), "inode (%lu) has corrupted xattr",
586 inode->i_ino);
587 set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
588 error = -EFSCORRUPTED;
589 goto cleanup;
590 }
591
592 if (!handler || (handler->list && !handler->list(dentry)))
593 continue;
594
595 prefix = xattr_prefix(handler);
596 prefix_len = strlen(prefix);
597 size = prefix_len + entry->e_name_len + 1;
598 if (buffer) {
599 if (size > rest) {
600 error = -ERANGE;
601 goto cleanup;
602 }
603 memcpy(buffer, prefix, prefix_len);
604 buffer += prefix_len;
605 memcpy(buffer, entry->e_name, entry->e_name_len);
606 buffer += entry->e_name_len;
607 *buffer++ = 0;
608 }
609 rest -= size;
610 }
611 error = buffer_size - rest;
612 cleanup:
613 kvfree(base_addr);
614 return error;
615 }
616
617 static bool f2fs_xattr_value_same(struct f2fs_xattr_entry *entry,
618 const void *value, size_t size)
619 {
620 void *pval = entry->e_name + entry->e_name_len;
621
622 return (le16_to_cpu(entry->e_value_size) == size) &&
623 !memcmp(pval, value, size);
624 }
625
626 static int __f2fs_setxattr(struct inode *inode, int index,
627 const char *name, const void *value, size_t size,
628 struct page *ipage, int flags)
629 {
630 struct f2fs_xattr_entry *here, *last;
631 void *base_addr, *last_base_addr;
632 int found, newsize;
633 size_t len;
634 __u32 new_hsize;
635 int error = 0;
636
637 if (name == NULL)
638 return -EINVAL;
639
640 if (value == NULL)
641 size = 0;
642
643 len = strlen(name);
644
645 if (len > F2FS_NAME_LEN)
646 return -ERANGE;
647
648 if (size > MAX_VALUE_LEN(inode))
649 return -E2BIG;
650
651 error = read_all_xattrs(inode, ipage, &base_addr);
652 if (error)
653 return error;
654
655 last_base_addr = (void *)base_addr + XATTR_SIZE(inode);
656
657 /* find entry with wanted name. */
658 here = __find_xattr(base_addr, last_base_addr, index, len, name);
659 if (!here) {
660 f2fs_err(F2FS_I_SB(inode), "inode (%lu) has corrupted xattr",
661 inode->i_ino);
662 set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
663 error = -EFSCORRUPTED;
664 goto exit;
665 }
666
667 found = IS_XATTR_LAST_ENTRY(here) ? 0 : 1;
668
669 if (found) {
670 if ((flags & XATTR_CREATE)) {
671 error = -EEXIST;
672 goto exit;
673 }
674
675 if (value && f2fs_xattr_value_same(here, value, size))
676 goto exit;
677 } else if ((flags & XATTR_REPLACE)) {
678 error = -ENODATA;
679 goto exit;
680 }
681
682 last = here;
683 while (!IS_XATTR_LAST_ENTRY(last))
684 last = XATTR_NEXT_ENTRY(last);
685
686 newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) + len + size);
687
688 /* 1. Check space */
689 if (value) {
690 int free;
691 /*
692 * If value is NULL, it is remove operation.
693 * In case of update operation, we calculate free.
694 */
695 free = MIN_OFFSET(inode) - ((char *)last - (char *)base_addr);
696 if (found)
697 free = free + ENTRY_SIZE(here);
698
699 if (unlikely(free < newsize)) {
700 error = -E2BIG;
701 goto exit;
702 }
703 }
704
705 /* 2. Remove old entry */
706 if (found) {
707 /*
708 * If entry is found, remove old entry.
709 * If not found, remove operation is not needed.
710 */
711 struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);
712 int oldsize = ENTRY_SIZE(here);
713
714 memmove(here, next, (char *)last - (char *)next);
715 last = (struct f2fs_xattr_entry *)((char *)last - oldsize);
716 memset(last, 0, oldsize);
717 }
718
719 new_hsize = (char *)last - (char *)base_addr;
720
721 /* 3. Write new entry */
722 if (value) {
723 char *pval;
724 /*
725 * Before we come here, old entry is removed.
726 * We just write new entry.
727 */
728 last->e_name_index = index;
729 last->e_name_len = len;
730 memcpy(last->e_name, name, len);
731 pval = last->e_name + len;
732 memcpy(pval, value, size);
733 last->e_value_size = cpu_to_le16(size);
734 new_hsize += newsize;
735 }
736
737 error = write_all_xattrs(inode, new_hsize, base_addr, ipage);
738 if (error)
739 goto exit;
740
741 if (is_inode_flag_set(inode, FI_ACL_MODE)) {
742 inode->i_mode = F2FS_I(inode)->i_acl_mode;
743 inode->i_ctime = current_time(inode);
744 clear_inode_flag(inode, FI_ACL_MODE);
745 }
746 if (index == F2FS_XATTR_INDEX_ENCRYPTION &&
747 !strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT))
748 f2fs_set_encrypted_inode(inode);
749 f2fs_mark_inode_dirty_sync(inode, true);
750 if (!error && S_ISDIR(inode->i_mode))
751 set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_CP);
752 exit:
753 kvfree(base_addr);
754 return error;
755 }
756
757 int f2fs_setxattr(struct inode *inode, int index, const char *name,
758 const void *value, size_t size,
759 struct page *ipage, int flags)
760 {
761 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
762 int err;
763
764 if (unlikely(f2fs_cp_error(sbi)))
765 return -EIO;
766 if (!f2fs_is_checkpoint_ready(sbi))
767 return -ENOSPC;
768
769 err = dquot_initialize(inode);
770 if (err)
771 return err;
772
773 /* this case is only from f2fs_init_inode_metadata */
774 if (ipage)
775 return __f2fs_setxattr(inode, index, name, value,
776 size, ipage, flags);
777 f2fs_balance_fs(sbi, true);
778
779 f2fs_lock_op(sbi);
780 down_write(&F2FS_I(inode)->i_xattr_sem);
781 err = __f2fs_setxattr(inode, index, name, value, size, ipage, flags);
782 up_write(&F2FS_I(inode)->i_xattr_sem);
783 f2fs_unlock_op(sbi);
784
785 f2fs_update_time(sbi, REQ_TIME);
786 return err;
787 }
788
789 int f2fs_init_xattr_caches(struct f2fs_sb_info *sbi)
790 {
791 dev_t dev = sbi->sb->s_bdev->bd_dev;
792 char slab_name[32];
793
794 sprintf(slab_name, "f2fs_xattr_entry-%u:%u", MAJOR(dev), MINOR(dev));
795
796 sbi->inline_xattr_slab_size = F2FS_OPTION(sbi).inline_xattr_size *
797 sizeof(__le32) + XATTR_PADDING_SIZE;
798
799 sbi->inline_xattr_slab = f2fs_kmem_cache_create(slab_name,
800 sbi->inline_xattr_slab_size);
801 if (!sbi->inline_xattr_slab)
802 return -ENOMEM;
803
804 return 0;
805 }
806
807 void f2fs_destroy_xattr_caches(struct f2fs_sb_info *sbi)
808 {
809 kmem_cache_destroy(sbi->inline_xattr_slab);
810 }
Ubuntu Jammy Linux kernel mirror