2018-09-12 04:16:07 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2012-11-29 08:28:09 +04:00
|
|
|
/*
|
2012-11-02 12:12:17 +04:00
|
|
|
* fs/f2fs/xattr.c
|
|
|
|
*
|
|
|
|
* Copyright (c) 2012 Samsung Electronics Co., Ltd.
|
|
|
|
* http://www.samsung.com/
|
|
|
|
*
|
|
|
|
* Portions of this code from linux/fs/ext2/xattr.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
|
|
|
|
*
|
|
|
|
* Fix by Harrison Xing <harrison@mountainviewdata.com>.
|
|
|
|
* Extended attributes for symlinks and special files added per
|
|
|
|
* suggestion of Luka Renko <luka.renko@hermes.si>.
|
|
|
|
* xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
|
|
|
|
* Red Hat Inc.
|
|
|
|
*/
|
|
|
|
#include <linux/rwsem.h>
|
|
|
|
#include <linux/f2fs_fs.h>
|
2013-06-03 14:46:19 +04:00
|
|
|
#include <linux/security.h>
|
2013-12-20 17:16:45 +04:00
|
|
|
#include <linux/posix_acl_xattr.h>
|
2012-11-02 12:12:17 +04:00
|
|
|
#include "f2fs.h"
|
|
|
|
#include "xattr.h"
|
2019-07-22 12:57:05 +03:00
|
|
|
#include "segment.h"
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2020-02-25 13:17:10 +03:00
|
|
|
static void *xattr_alloc(struct f2fs_sb_info *sbi, int size, bool *is_inline)
|
|
|
|
{
|
|
|
|
if (likely(size == sbi->inline_xattr_slab_size)) {
|
|
|
|
*is_inline = true;
|
|
|
|
return kmem_cache_zalloc(sbi->inline_xattr_slab, GFP_NOFS);
|
|
|
|
}
|
|
|
|
*is_inline = false;
|
|
|
|
return f2fs_kzalloc(sbi, size, GFP_NOFS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void xattr_free(struct f2fs_sb_info *sbi, void *xattr_addr,
|
|
|
|
bool is_inline)
|
|
|
|
{
|
|
|
|
if (is_inline)
|
|
|
|
kmem_cache_free(sbi->inline_xattr_slab, xattr_addr);
|
|
|
|
else
|
|
|
|
kvfree(xattr_addr);
|
|
|
|
}
|
|
|
|
|
2015-10-04 20:18:51 +03:00
|
|
|
static int f2fs_xattr_generic_get(const struct xattr_handler *handler,
|
2016-04-11 03:48:24 +03:00
|
|
|
struct dentry *unused, struct inode *inode,
|
|
|
|
const char *name, void *buffer, size_t size)
|
2012-11-02 12:12:17 +04:00
|
|
|
{
|
2016-04-11 03:48:24 +03:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2015-10-04 20:18:51 +03:00
|
|
|
switch (handler->flags) {
|
2012-11-02 12:12:17 +04:00
|
|
|
case F2FS_XATTR_INDEX_USER:
|
|
|
|
if (!test_opt(sbi, XATTR_USER))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
case F2FS_XATTR_INDEX_TRUSTED:
|
2013-06-03 14:46:19 +04:00
|
|
|
case F2FS_XATTR_INDEX_SECURITY:
|
|
|
|
break;
|
2012-11-02 12:12:17 +04:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2016-04-11 03:48:24 +03:00
|
|
|
return f2fs_getxattr(inode, handler->flags, name,
|
2015-10-04 20:18:51 +03:00
|
|
|
buffer, size, NULL);
|
2012-11-02 12:12:17 +04:00
|
|
|
}
|
|
|
|
|
2015-10-04 20:18:51 +03:00
|
|
|
static int f2fs_xattr_generic_set(const struct xattr_handler *handler,
|
2016-05-27 17:19:30 +03:00
|
|
|
struct dentry *unused, struct inode *inode,
|
|
|
|
const char *name, const void *value,
|
2015-10-04 20:18:51 +03:00
|
|
|
size_t size, int flags)
|
2012-11-02 12:12:17 +04:00
|
|
|
{
|
2016-05-27 17:19:30 +03:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2015-10-04 20:18:51 +03:00
|
|
|
switch (handler->flags) {
|
2012-11-02 12:12:17 +04:00
|
|
|
case F2FS_XATTR_INDEX_USER:
|
|
|
|
if (!test_opt(sbi, XATTR_USER))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
case F2FS_XATTR_INDEX_TRUSTED:
|
2013-06-03 14:46:19 +04:00
|
|
|
case F2FS_XATTR_INDEX_SECURITY:
|
|
|
|
break;
|
2012-11-02 12:12:17 +04:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2016-05-27 17:19:30 +03:00
|
|
|
return f2fs_setxattr(inode, handler->flags, name,
|
2014-04-23 07:23:14 +04:00
|
|
|
value, size, NULL, flags);
|
2012-11-02 12:12:17 +04:00
|
|
|
}
|
|
|
|
|
2015-12-02 16:44:43 +03:00
|
|
|
static bool f2fs_xattr_user_list(struct dentry *dentry)
|
2012-11-30 12:32:08 +04:00
|
|
|
{
|
2015-12-02 16:44:43 +03:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
|
|
|
|
|
|
|
|
return test_opt(sbi, XATTR_USER);
|
|
|
|
}
|
2012-11-30 12:32:08 +04:00
|
|
|
|
2015-12-02 16:44:43 +03:00
|
|
|
static bool f2fs_xattr_trusted_list(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
return capable(CAP_SYS_ADMIN);
|
2012-11-30 12:32:08 +04:00
|
|
|
}
|
|
|
|
|
2015-10-04 20:18:51 +03:00
|
|
|
static int f2fs_xattr_advise_get(const struct xattr_handler *handler,
|
2016-04-11 03:48:24 +03:00
|
|
|
struct dentry *unused, struct inode *inode,
|
|
|
|
const char *name, void *buffer, size_t size)
|
2012-11-30 12:32:08 +04:00
|
|
|
{
|
f2fs: avoid NULL pointer dereference in f2fs_xattr_advise_get
We will encounter oops by executing below command.
getfattr -n system.advise /mnt/f2fs/file
Killed
message log:
BUG: unable to handle kernel NULL pointer dereference at (null)
IP: [<f8b54d69>] f2fs_xattr_advise_get+0x29/0x40 [f2fs]
*pdpt = 00000000319b7001 *pde = 0000000000000000
Oops: 0002 [#1] SMP
Modules linked in: f2fs(O) snd_intel8x0 snd_ac97_codec ac97_bus snd_pcm snd_seq_midi snd_seq_midi_event snd_rawmidi snd_seq joydev
snd_seq_device snd_timer bnep snd rfcomm microcode bluetooth soundcore i2c_piix4 mac_hid serio_raw parport_pc ppdev lp parport
binfmt_misc hid_generic psmouse usbhid hid e1000 [last unloaded: f2fs]
CPU: 3 PID: 3134 Comm: getfattr Tainted: G O 4.0.0-rc1 #6
Hardware name: innotek GmbH VirtualBox/VirtualBox, BIOS VirtualBox 12/01/2006
task: f3a71b60 ti: f19a6000 task.ti: f19a6000
EIP: 0060:[<f8b54d69>] EFLAGS: 00010246 CPU: 3
EIP is at f2fs_xattr_advise_get+0x29/0x40 [f2fs]
EAX: 00000000 EBX: f19a7e71 ECX: 00000000 EDX: f8b5b467
ESI: 00000000 EDI: f2008570 EBP: f19a7e14 ESP: f19a7e08
DS: 007b ES: 007b FS: 00d8 GS: 0033 SS: 0068
CR0: 80050033 CR2: 00000000 CR3: 319b8000 CR4: 000007f0
Stack:
f8b5a634 c0cbb580 00000000 f19a7e34 c1193850 00000000 00000007 f19a7e71
f19a7e64 c0cbb580 c1193810 f19a7e50 c1193c00 00000000 00000000 00000000
c0cbb580 00000000 f19a7f70 c1194097 00000000 00000000 00000000 74737973
Call Trace:
[<c1193850>] generic_getxattr+0x40/0x50
[<c1193810>] ? xattr_resolve_name+0x80/0x80
[<c1193c00>] vfs_getxattr+0x70/0xa0
[<c1194097>] getxattr+0x87/0x190
[<c11801d7>] ? path_lookupat+0x57/0x5f0
[<c11819d2>] ? putname+0x32/0x50
[<c116653a>] ? kmem_cache_alloc+0x2a/0x130
[<c11819d2>] ? putname+0x32/0x50
[<c11819d2>] ? putname+0x32/0x50
[<c11819d2>] ? putname+0x32/0x50
[<c11827f9>] ? user_path_at_empty+0x49/0x70
[<c118283f>] ? user_path_at+0x1f/0x30
[<c11941e7>] path_getxattr+0x47/0x80
[<c11948e7>] SyS_getxattr+0x27/0x30
[<c163f748>] sysenter_do_call+0x12/0x12
Code: 66 90 55 89 e5 57 56 53 66 66 66 66 90 8b 78 20 89 d3 ba 67 b4 b5 f8 89 d8 89 ce e8 42 7c 7b c8 85 c0 75 16 0f b6 87 44 01 00
00 <88> 06 b8 01 00 00 00 5b 5e 5f 5d c3 8d 76 00 b8 ea ff ff ff eb
EIP: [<f8b54d69>] f2fs_xattr_advise_get+0x29/0x40 [f2fs] SS:ESP 0068:f19a7e08
CR2: 0000000000000000
---[ end trace 860260654f1f416a ]---
The reason is that in getfattr there are two steps which is indicated by strace info:
1) try to lookup and get size of specified xattr.
2) get value of the extented attribute.
strace info:
getxattr("/mnt/f2fs/file", "system.advise", 0x0, 0) = 1
getxattr("/mnt/f2fs/file", "system.advise", "\x00", 256) = 1
For the first step, getfattr may pass a NULL pointer in @value and zero in @size
as parameters for ->getxattr, but we access this @value pointer directly without
checking whether the pointer is valid or not in f2fs_xattr_advise_get, so the
oops occurs.
This patch fixes this issue by verifying @value pointer before using.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-03-23 05:36:15 +03:00
|
|
|
if (buffer)
|
|
|
|
*((char *)buffer) = F2FS_I(inode)->i_advise;
|
2012-11-30 12:32:08 +04:00
|
|
|
return sizeof(char);
|
|
|
|
}
|
|
|
|
|
2015-10-04 20:18:51 +03:00
|
|
|
static int f2fs_xattr_advise_set(const struct xattr_handler *handler,
|
2016-05-27 17:19:30 +03:00
|
|
|
struct dentry *unused, struct inode *inode,
|
|
|
|
const char *name, const void *value,
|
2015-10-04 20:18:51 +03:00
|
|
|
size_t size, int flags)
|
2012-11-30 12:32:08 +04:00
|
|
|
{
|
2018-07-19 18:57:54 +03:00
|
|
|
unsigned char old_advise = F2FS_I(inode)->i_advise;
|
|
|
|
unsigned char new_advise;
|
|
|
|
|
2012-11-30 12:32:08 +04:00
|
|
|
if (!inode_owner_or_capable(inode))
|
|
|
|
return -EPERM;
|
|
|
|
if (value == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2018-07-19 18:57:54 +03:00
|
|
|
new_advise = *(char *)value;
|
|
|
|
if (new_advise & ~FADVISE_MODIFIABLE_BITS)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
new_advise = new_advise & FADVISE_MODIFIABLE_BITS;
|
|
|
|
new_advise |= old_advise & ~FADVISE_MODIFIABLE_BITS;
|
|
|
|
|
|
|
|
F2FS_I(inode)->i_advise = new_advise;
|
2016-10-14 21:51:23 +03:00
|
|
|
f2fs_mark_inode_dirty_sync(inode, true);
|
2012-11-30 12:32:08 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-03 14:46:19 +04:00
|
|
|
#ifdef CONFIG_F2FS_FS_SECURITY
|
|
|
|
static int f2fs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
|
|
|
|
void *page)
|
|
|
|
{
|
|
|
|
const struct xattr *xattr;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
for (xattr = xattr_array; xattr->name != NULL; xattr++) {
|
2014-06-01 18:24:30 +04:00
|
|
|
err = f2fs_setxattr(inode, F2FS_XATTR_INDEX_SECURITY,
|
2013-06-03 14:46:19 +04:00
|
|
|
xattr->name, xattr->value,
|
2014-04-23 07:23:14 +04:00
|
|
|
xattr->value_len, (struct page *)page, 0);
|
2013-06-03 14:46:19 +04:00
|
|
|
if (err < 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int f2fs_init_security(struct inode *inode, struct inode *dir,
|
|
|
|
const struct qstr *qstr, struct page *ipage)
|
|
|
|
{
|
|
|
|
return security_inode_init_security(inode, dir, qstr,
|
|
|
|
&f2fs_initxattrs, ipage);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-11-02 12:12:17 +04:00
|
|
|
const struct xattr_handler f2fs_xattr_user_handler = {
|
|
|
|
.prefix = XATTR_USER_PREFIX,
|
|
|
|
.flags = F2FS_XATTR_INDEX_USER,
|
2015-12-02 16:44:43 +03:00
|
|
|
.list = f2fs_xattr_user_list,
|
2012-11-02 12:12:17 +04:00
|
|
|
.get = f2fs_xattr_generic_get,
|
|
|
|
.set = f2fs_xattr_generic_set,
|
|
|
|
};
|
|
|
|
|
|
|
|
const struct xattr_handler f2fs_xattr_trusted_handler = {
|
|
|
|
.prefix = XATTR_TRUSTED_PREFIX,
|
|
|
|
.flags = F2FS_XATTR_INDEX_TRUSTED,
|
2015-12-02 16:44:43 +03:00
|
|
|
.list = f2fs_xattr_trusted_list,
|
2012-11-02 12:12:17 +04:00
|
|
|
.get = f2fs_xattr_generic_get,
|
|
|
|
.set = f2fs_xattr_generic_set,
|
|
|
|
};
|
|
|
|
|
2012-11-30 12:32:08 +04:00
|
|
|
const struct xattr_handler f2fs_xattr_advise_handler = {
|
2015-12-02 16:44:36 +03:00
|
|
|
.name = F2FS_SYSTEM_ADVISE_NAME,
|
2012-11-30 12:32:08 +04:00
|
|
|
.flags = F2FS_XATTR_INDEX_ADVISE,
|
2020-07-24 11:55:28 +03:00
|
|
|
.get = f2fs_xattr_advise_get,
|
|
|
|
.set = f2fs_xattr_advise_set,
|
2012-11-30 12:32:08 +04:00
|
|
|
};
|
|
|
|
|
2013-06-03 14:46:19 +04:00
|
|
|
const struct xattr_handler f2fs_xattr_security_handler = {
|
|
|
|
.prefix = XATTR_SECURITY_PREFIX,
|
|
|
|
.flags = F2FS_XATTR_INDEX_SECURITY,
|
|
|
|
.get = f2fs_xattr_generic_get,
|
|
|
|
.set = f2fs_xattr_generic_set,
|
|
|
|
};
|
|
|
|
|
2012-11-02 12:12:17 +04:00
|
|
|
static const struct xattr_handler *f2fs_xattr_handler_map[] = {
|
|
|
|
[F2FS_XATTR_INDEX_USER] = &f2fs_xattr_user_handler,
|
|
|
|
#ifdef CONFIG_F2FS_FS_POSIX_ACL
|
2013-12-20 17:16:45 +04:00
|
|
|
[F2FS_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
|
|
|
|
[F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
|
2012-11-02 12:12:17 +04:00
|
|
|
#endif
|
|
|
|
[F2FS_XATTR_INDEX_TRUSTED] = &f2fs_xattr_trusted_handler,
|
2013-06-03 14:46:19 +04:00
|
|
|
#ifdef CONFIG_F2FS_FS_SECURITY
|
|
|
|
[F2FS_XATTR_INDEX_SECURITY] = &f2fs_xattr_security_handler,
|
|
|
|
#endif
|
2012-11-02 12:12:17 +04:00
|
|
|
[F2FS_XATTR_INDEX_ADVISE] = &f2fs_xattr_advise_handler,
|
|
|
|
};
|
|
|
|
|
|
|
|
const struct xattr_handler *f2fs_xattr_handlers[] = {
|
|
|
|
&f2fs_xattr_user_handler,
|
|
|
|
#ifdef CONFIG_F2FS_FS_POSIX_ACL
|
2013-12-20 17:16:45 +04:00
|
|
|
&posix_acl_access_xattr_handler,
|
|
|
|
&posix_acl_default_xattr_handler,
|
2012-11-02 12:12:17 +04:00
|
|
|
#endif
|
|
|
|
&f2fs_xattr_trusted_handler,
|
2013-06-03 14:46:19 +04:00
|
|
|
#ifdef CONFIG_F2FS_FS_SECURITY
|
|
|
|
&f2fs_xattr_security_handler,
|
|
|
|
#endif
|
2012-11-02 12:12:17 +04:00
|
|
|
&f2fs_xattr_advise_handler,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2014-04-23 07:17:25 +04:00
|
|
|
static inline const struct xattr_handler *f2fs_xattr_handler(int index)
|
2012-11-02 12:12:17 +04:00
|
|
|
{
|
|
|
|
const struct xattr_handler *handler = NULL;
|
|
|
|
|
2014-04-23 07:17:25 +04:00
|
|
|
if (index > 0 && index < ARRAY_SIZE(f2fs_xattr_handler_map))
|
|
|
|
handler = f2fs_xattr_handler_map[index];
|
2012-11-02 12:12:17 +04:00
|
|
|
return handler;
|
|
|
|
}
|
|
|
|
|
2019-04-11 11:26:46 +03:00
|
|
|
static struct f2fs_xattr_entry *__find_xattr(void *base_addr,
|
|
|
|
void *last_base_addr, int index,
|
|
|
|
size_t len, const char *name)
|
2013-08-13 05:13:55 +04:00
|
|
|
{
|
|
|
|
struct f2fs_xattr_entry *entry;
|
|
|
|
|
|
|
|
list_for_each_xattr(entry, base_addr) {
|
2019-04-11 11:26:46 +03:00
|
|
|
if ((void *)(entry) + sizeof(__u32) > last_base_addr ||
|
|
|
|
(void *)XATTR_NEXT_ENTRY(entry) > last_base_addr)
|
|
|
|
return NULL;
|
|
|
|
|
2014-04-23 07:17:25 +04:00
|
|
|
if (entry->e_name_index != index)
|
2013-08-13 05:13:55 +04:00
|
|
|
continue;
|
2014-04-23 07:17:25 +04:00
|
|
|
if (entry->e_name_len != len)
|
2013-08-13 05:13:55 +04:00
|
|
|
continue;
|
2014-04-23 07:17:25 +04:00
|
|
|
if (!memcmp(entry->e_name, name, len))
|
2013-08-13 05:13:55 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
f2fs: support flexible inline xattr size
Now, in product, more and more features based on file encryption were
introduced, their demand of xattr space is increasing, however, inline
xattr has fixed-size of 200 bytes, once inline xattr space is full, new
increased xattr data would occupy additional xattr block which may bring
us more space usage and performance regression during persisting.
In order to resolve above issue, it's better to expand inline xattr size
flexibly according to user's requirement.
So this patch introduces new filesystem feature 'flexible inline xattr',
and new mount option 'inline_xattr_size=%u', once mkfs enables the
feature, we can use the option to make f2fs supporting flexible inline
xattr size.
To support this feature, we add extra attribute i_inline_xattr_size in
inode layout, indicating that how many space inline xattr borrows from
block address mapping space in inode layout, by this, we can easily
locate and store flexible-sized inline xattr data in inode.
Inode disk layout:
+----------------------+
| .i_mode |
| ... |
| .i_ext |
+----------------------+
| .i_extra_isize |
| .i_inline_xattr_size |-----------+
| ... | |
+----------------------+ |
| .i_addr | |
| - block address or | |
| - inline data | |
+----------------------+<---+ v
| inline xattr | +---inline xattr range
+----------------------+<---+
| .i_nid |
+----------------------+
| node_footer |
| (nid, ino, offset) |
+----------------------+
Note that, we have to cnosider backward compatibility which reserved
inline_data space, 200 bytes, all the time, reported by Sheng Yong.
Previous inline data or directory always reserved 200 bytes in inode layout,
even if inline_xattr is disabled. In order to keep inline_dentry's structure
for backward compatibility, we get the space back only from inline_data.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Reported-by: Sheng Yong <shengyong1@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2017-09-06 16:59:50 +03:00
|
|
|
static struct f2fs_xattr_entry *__find_inline_xattr(struct inode *inode,
|
|
|
|
void *base_addr, void **last_addr, int index,
|
|
|
|
size_t len, const char *name)
|
2017-01-24 15:39:51 +03:00
|
|
|
{
|
|
|
|
struct f2fs_xattr_entry *entry;
|
f2fs: support flexible inline xattr size
Now, in product, more and more features based on file encryption were
introduced, their demand of xattr space is increasing, however, inline
xattr has fixed-size of 200 bytes, once inline xattr space is full, new
increased xattr data would occupy additional xattr block which may bring
us more space usage and performance regression during persisting.
In order to resolve above issue, it's better to expand inline xattr size
flexibly according to user's requirement.
So this patch introduces new filesystem feature 'flexible inline xattr',
and new mount option 'inline_xattr_size=%u', once mkfs enables the
feature, we can use the option to make f2fs supporting flexible inline
xattr size.
To support this feature, we add extra attribute i_inline_xattr_size in
inode layout, indicating that how many space inline xattr borrows from
block address mapping space in inode layout, by this, we can easily
locate and store flexible-sized inline xattr data in inode.
Inode disk layout:
+----------------------+
| .i_mode |
| ... |
| .i_ext |
+----------------------+
| .i_extra_isize |
| .i_inline_xattr_size |-----------+
| ... | |
+----------------------+ |
| .i_addr | |
| - block address or | |
| - inline data | |
+----------------------+<---+ v
| inline xattr | +---inline xattr range
+----------------------+<---+
| .i_nid |
+----------------------+
| node_footer |
| (nid, ino, offset) |
+----------------------+
Note that, we have to cnosider backward compatibility which reserved
inline_data space, 200 bytes, all the time, reported by Sheng Yong.
Previous inline data or directory always reserved 200 bytes in inode layout,
even if inline_xattr is disabled. In order to keep inline_dentry's structure
for backward compatibility, we get the space back only from inline_data.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Reported-by: Sheng Yong <shengyong1@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2017-09-06 16:59:50 +03:00
|
|
|
unsigned int inline_size = inline_xattr_size(inode);
|
2019-03-05 14:32:26 +03:00
|
|
|
void *max_addr = base_addr + inline_size;
|
2017-01-24 15:39:51 +03:00
|
|
|
|
|
|
|
list_for_each_xattr(entry, base_addr) {
|
2019-03-05 14:32:26 +03:00
|
|
|
if ((void *)entry + sizeof(__u32) > max_addr ||
|
|
|
|
(void *)XATTR_NEXT_ENTRY(entry) > max_addr) {
|
2017-01-24 15:39:51 +03:00
|
|
|
*last_addr = entry;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (entry->e_name_index != index)
|
|
|
|
continue;
|
|
|
|
if (entry->e_name_len != len)
|
|
|
|
continue;
|
|
|
|
if (!memcmp(entry->e_name, name, len))
|
|
|
|
break;
|
|
|
|
}
|
2019-03-05 14:32:26 +03:00
|
|
|
|
|
|
|
/* inline xattr header or entry across max inline xattr size */
|
|
|
|
if (IS_XATTR_LAST_ENTRY(entry) &&
|
|
|
|
(void *)entry + sizeof(__u32) > max_addr) {
|
|
|
|
*last_addr = entry;
|
|
|
|
return NULL;
|
|
|
|
}
|
2017-01-24 15:39:51 +03:00
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
2017-09-04 13:58:02 +03:00
|
|
|
static int read_inline_xattr(struct inode *inode, struct page *ipage,
|
|
|
|
void *txattr_addr)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
|
|
|
unsigned int inline_size = inline_xattr_size(inode);
|
|
|
|
struct page *page = NULL;
|
|
|
|
void *inline_addr;
|
|
|
|
|
|
|
|
if (ipage) {
|
f2fs: support flexible inline xattr size
Now, in product, more and more features based on file encryption were
introduced, their demand of xattr space is increasing, however, inline
xattr has fixed-size of 200 bytes, once inline xattr space is full, new
increased xattr data would occupy additional xattr block which may bring
us more space usage and performance regression during persisting.
In order to resolve above issue, it's better to expand inline xattr size
flexibly according to user's requirement.
So this patch introduces new filesystem feature 'flexible inline xattr',
and new mount option 'inline_xattr_size=%u', once mkfs enables the
feature, we can use the option to make f2fs supporting flexible inline
xattr size.
To support this feature, we add extra attribute i_inline_xattr_size in
inode layout, indicating that how many space inline xattr borrows from
block address mapping space in inode layout, by this, we can easily
locate and store flexible-sized inline xattr data in inode.
Inode disk layout:
+----------------------+
| .i_mode |
| ... |
| .i_ext |
+----------------------+
| .i_extra_isize |
| .i_inline_xattr_size |-----------+
| ... | |
+----------------------+ |
| .i_addr | |
| - block address or | |
| - inline data | |
+----------------------+<---+ v
| inline xattr | +---inline xattr range
+----------------------+<---+
| .i_nid |
+----------------------+
| node_footer |
| (nid, ino, offset) |
+----------------------+
Note that, we have to cnosider backward compatibility which reserved
inline_data space, 200 bytes, all the time, reported by Sheng Yong.
Previous inline data or directory always reserved 200 bytes in inode layout,
even if inline_xattr is disabled. In order to keep inline_dentry's structure
for backward compatibility, we get the space back only from inline_data.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Reported-by: Sheng Yong <shengyong1@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2017-09-06 16:59:50 +03:00
|
|
|
inline_addr = inline_xattr_addr(inode, ipage);
|
2017-09-04 13:58:02 +03:00
|
|
|
} else {
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
page = f2fs_get_node_page(sbi, inode->i_ino);
|
2017-09-04 13:58:02 +03:00
|
|
|
if (IS_ERR(page))
|
|
|
|
return PTR_ERR(page);
|
|
|
|
|
f2fs: support flexible inline xattr size
Now, in product, more and more features based on file encryption were
introduced, their demand of xattr space is increasing, however, inline
xattr has fixed-size of 200 bytes, once inline xattr space is full, new
increased xattr data would occupy additional xattr block which may bring
us more space usage and performance regression during persisting.
In order to resolve above issue, it's better to expand inline xattr size
flexibly according to user's requirement.
So this patch introduces new filesystem feature 'flexible inline xattr',
and new mount option 'inline_xattr_size=%u', once mkfs enables the
feature, we can use the option to make f2fs supporting flexible inline
xattr size.
To support this feature, we add extra attribute i_inline_xattr_size in
inode layout, indicating that how many space inline xattr borrows from
block address mapping space in inode layout, by this, we can easily
locate and store flexible-sized inline xattr data in inode.
Inode disk layout:
+----------------------+
| .i_mode |
| ... |
| .i_ext |
+----------------------+
| .i_extra_isize |
| .i_inline_xattr_size |-----------+
| ... | |
+----------------------+ |
| .i_addr | |
| - block address or | |
| - inline data | |
+----------------------+<---+ v
| inline xattr | +---inline xattr range
+----------------------+<---+
| .i_nid |
+----------------------+
| node_footer |
| (nid, ino, offset) |
+----------------------+
Note that, we have to cnosider backward compatibility which reserved
inline_data space, 200 bytes, all the time, reported by Sheng Yong.
Previous inline data or directory always reserved 200 bytes in inode layout,
even if inline_xattr is disabled. In order to keep inline_dentry's structure
for backward compatibility, we get the space back only from inline_data.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Reported-by: Sheng Yong <shengyong1@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2017-09-06 16:59:50 +03:00
|
|
|
inline_addr = inline_xattr_addr(inode, page);
|
2017-09-04 13:58:02 +03:00
|
|
|
}
|
|
|
|
memcpy(txattr_addr, inline_addr, inline_size);
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-09-04 13:58:03 +03:00
|
|
|
static int read_xattr_block(struct inode *inode, void *txattr_addr)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
|
|
|
nid_t xnid = F2FS_I(inode)->i_xattr_nid;
|
|
|
|
unsigned int inline_size = inline_xattr_size(inode);
|
|
|
|
struct page *xpage;
|
|
|
|
void *xattr_addr;
|
|
|
|
|
|
|
|
/* The inode already has an extended attribute block. */
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
xpage = f2fs_get_node_page(sbi, xnid);
|
2017-09-04 13:58:03 +03:00
|
|
|
if (IS_ERR(xpage))
|
|
|
|
return PTR_ERR(xpage);
|
|
|
|
|
|
|
|
xattr_addr = page_address(xpage);
|
|
|
|
memcpy(txattr_addr + inline_size, xattr_addr, VALID_XATTR_BLOCK_SIZE);
|
|
|
|
f2fs_put_page(xpage, 1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-24 15:39:51 +03:00
|
|
|
static int lookup_all_xattrs(struct inode *inode, struct page *ipage,
|
|
|
|
unsigned int index, unsigned int len,
|
|
|
|
const char *name, struct f2fs_xattr_entry **xe,
|
2020-02-25 13:17:10 +03:00
|
|
|
void **base_addr, int *base_size,
|
|
|
|
bool *is_inline)
|
2017-01-24 15:39:51 +03:00
|
|
|
{
|
2019-04-11 11:26:46 +03:00
|
|
|
void *cur_addr, *txattr_addr, *last_txattr_addr;
|
|
|
|
void *last_addr = NULL;
|
2017-01-24 15:39:51 +03:00
|
|
|
nid_t xnid = F2FS_I(inode)->i_xattr_nid;
|
2017-03-23 08:38:25 +03:00
|
|
|
unsigned int inline_size = inline_xattr_size(inode);
|
2017-01-24 15:39:51 +03:00
|
|
|
int err = 0;
|
|
|
|
|
2019-04-11 11:26:46 +03:00
|
|
|
if (!xnid && !inline_size)
|
2017-01-24 15:39:51 +03:00
|
|
|
return -ENODATA;
|
|
|
|
|
2020-02-14 12:44:11 +03:00
|
|
|
*base_size = XATTR_SIZE(inode) + XATTR_PADDING_SIZE;
|
2020-02-25 13:17:10 +03:00
|
|
|
txattr_addr = xattr_alloc(F2FS_I_SB(inode), *base_size, is_inline);
|
2017-01-24 15:39:51 +03:00
|
|
|
if (!txattr_addr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2020-02-14 12:44:11 +03:00
|
|
|
last_txattr_addr = (void *)txattr_addr + XATTR_SIZE(inode);
|
2019-04-11 11:26:46 +03:00
|
|
|
|
2017-01-24 15:39:51 +03:00
|
|
|
/* read from inline xattr */
|
|
|
|
if (inline_size) {
|
2017-09-04 13:58:02 +03:00
|
|
|
err = read_inline_xattr(inode, ipage, txattr_addr);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
2017-01-24 15:39:51 +03:00
|
|
|
|
f2fs: support flexible inline xattr size
Now, in product, more and more features based on file encryption were
introduced, their demand of xattr space is increasing, however, inline
xattr has fixed-size of 200 bytes, once inline xattr space is full, new
increased xattr data would occupy additional xattr block which may bring
us more space usage and performance regression during persisting.
In order to resolve above issue, it's better to expand inline xattr size
flexibly according to user's requirement.
So this patch introduces new filesystem feature 'flexible inline xattr',
and new mount option 'inline_xattr_size=%u', once mkfs enables the
feature, we can use the option to make f2fs supporting flexible inline
xattr size.
To support this feature, we add extra attribute i_inline_xattr_size in
inode layout, indicating that how many space inline xattr borrows from
block address mapping space in inode layout, by this, we can easily
locate and store flexible-sized inline xattr data in inode.
Inode disk layout:
+----------------------+
| .i_mode |
| ... |
| .i_ext |
+----------------------+
| .i_extra_isize |
| .i_inline_xattr_size |-----------+
| ... | |
+----------------------+ |
| .i_addr | |
| - block address or | |
| - inline data | |
+----------------------+<---+ v
| inline xattr | +---inline xattr range
+----------------------+<---+
| .i_nid |
+----------------------+
| node_footer |
| (nid, ino, offset) |
+----------------------+
Note that, we have to cnosider backward compatibility which reserved
inline_data space, 200 bytes, all the time, reported by Sheng Yong.
Previous inline data or directory always reserved 200 bytes in inode layout,
even if inline_xattr is disabled. In order to keep inline_dentry's structure
for backward compatibility, we get the space back only from inline_data.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Reported-by: Sheng Yong <shengyong1@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2017-09-06 16:59:50 +03:00
|
|
|
*xe = __find_inline_xattr(inode, txattr_addr, &last_addr,
|
2017-01-24 15:39:51 +03:00
|
|
|
index, len, name);
|
2018-12-27 06:54:07 +03:00
|
|
|
if (*xe) {
|
|
|
|
*base_size = inline_size;
|
2017-01-24 15:39:51 +03:00
|
|
|
goto check;
|
2018-12-27 06:54:07 +03:00
|
|
|
}
|
2017-01-24 15:39:51 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* read from xattr node block */
|
|
|
|
if (xnid) {
|
2017-09-04 13:58:03 +03:00
|
|
|
err = read_xattr_block(inode, txattr_addr);
|
|
|
|
if (err)
|
2017-01-24 15:39:51 +03:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (last_addr)
|
|
|
|
cur_addr = XATTR_HDR(last_addr) - 1;
|
|
|
|
else
|
|
|
|
cur_addr = txattr_addr;
|
|
|
|
|
2019-04-11 11:26:46 +03:00
|
|
|
*xe = __find_xattr(cur_addr, last_txattr_addr, index, len, name);
|
|
|
|
if (!*xe) {
|
2019-06-20 06:36:15 +03:00
|
|
|
f2fs_err(F2FS_I_SB(inode), "inode (%lu) has corrupted xattr",
|
|
|
|
inode->i_ino);
|
|
|
|
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
|
2019-06-20 06:36:14 +03:00
|
|
|
err = -EFSCORRUPTED;
|
2019-04-11 11:26:46 +03:00
|
|
|
goto out;
|
|
|
|
}
|
2017-01-24 15:39:51 +03:00
|
|
|
check:
|
|
|
|
if (IS_XATTR_LAST_ENTRY(*xe)) {
|
|
|
|
err = -ENODATA;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
*base_addr = txattr_addr;
|
|
|
|
return 0;
|
|
|
|
out:
|
2020-02-25 13:17:10 +03:00
|
|
|
xattr_free(F2FS_I_SB(inode), txattr_addr, *is_inline);
|
2017-01-24 15:39:51 +03:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-09-18 18:30:04 +03:00
|
|
|
static int read_all_xattrs(struct inode *inode, struct page *ipage,
|
|
|
|
void **base_addr)
|
2013-08-14 16:57:27 +04:00
|
|
|
{
|
|
|
|
struct f2fs_xattr_header *header;
|
2017-03-23 08:38:25 +03:00
|
|
|
nid_t xnid = F2FS_I(inode)->i_xattr_nid;
|
|
|
|
unsigned int size = VALID_XATTR_BLOCK_SIZE;
|
|
|
|
unsigned int inline_size = inline_xattr_size(inode);
|
2013-08-14 16:57:27 +04:00
|
|
|
void *txattr_addr;
|
2016-09-18 18:30:04 +03:00
|
|
|
int err;
|
2013-08-14 16:57:27 +04:00
|
|
|
|
2017-11-30 14:28:17 +03:00
|
|
|
txattr_addr = f2fs_kzalloc(F2FS_I_SB(inode),
|
|
|
|
inline_size + size + XATTR_PADDING_SIZE, GFP_NOFS);
|
2013-08-14 16:57:27 +04:00
|
|
|
if (!txattr_addr)
|
2016-09-18 18:30:04 +03:00
|
|
|
return -ENOMEM;
|
2013-08-14 16:57:27 +04:00
|
|
|
|
|
|
|
/* read from inline xattr */
|
|
|
|
if (inline_size) {
|
2017-09-04 13:58:02 +03:00
|
|
|
err = read_inline_xattr(inode, ipage, txattr_addr);
|
|
|
|
if (err)
|
|
|
|
goto fail;
|
2013-08-14 16:57:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* read from xattr node block */
|
2017-03-23 08:38:25 +03:00
|
|
|
if (xnid) {
|
2017-09-04 13:58:03 +03:00
|
|
|
err = read_xattr_block(inode, txattr_addr);
|
|
|
|
if (err)
|
2013-08-14 16:57:27 +04:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
header = XATTR_HDR(txattr_addr);
|
|
|
|
|
|
|
|
/* never been allocated xattrs */
|
|
|
|
if (le32_to_cpu(header->h_magic) != F2FS_XATTR_MAGIC) {
|
|
|
|
header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC);
|
|
|
|
header->h_refcount = cpu_to_le32(1);
|
|
|
|
}
|
2016-09-18 18:30:04 +03:00
|
|
|
*base_addr = txattr_addr;
|
|
|
|
return 0;
|
2013-08-14 16:57:27 +04:00
|
|
|
fail:
|
2019-03-05 12:52:33 +03:00
|
|
|
kvfree(txattr_addr);
|
2016-09-18 18:30:04 +03:00
|
|
|
return err;
|
2013-08-14 16:57:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
|
|
|
|
void *txattr_addr, struct page *ipage)
|
|
|
|
{
|
2014-09-03 02:31:18 +04:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2017-03-23 08:38:25 +03:00
|
|
|
size_t inline_size = inline_xattr_size(inode);
|
2017-10-17 01:05:16 +03:00
|
|
|
struct page *in_page = NULL;
|
2013-08-14 16:57:27 +04:00
|
|
|
void *xattr_addr;
|
2017-10-17 01:05:16 +03:00
|
|
|
void *inline_addr = NULL;
|
2013-08-14 16:57:27 +04:00
|
|
|
struct page *xpage;
|
|
|
|
nid_t new_nid = 0;
|
2017-10-17 01:05:16 +03:00
|
|
|
int err = 0;
|
2013-08-14 16:57:27 +04:00
|
|
|
|
|
|
|
if (hsize > inline_size && !F2FS_I(inode)->i_xattr_nid)
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
if (!f2fs_alloc_nid(sbi, &new_nid))
|
2013-08-14 16:57:27 +04:00
|
|
|
return -ENOSPC;
|
|
|
|
|
|
|
|
/* write to inline xattr */
|
|
|
|
if (inline_size) {
|
|
|
|
if (ipage) {
|
f2fs: support flexible inline xattr size
Now, in product, more and more features based on file encryption were
introduced, their demand of xattr space is increasing, however, inline
xattr has fixed-size of 200 bytes, once inline xattr space is full, new
increased xattr data would occupy additional xattr block which may bring
us more space usage and performance regression during persisting.
In order to resolve above issue, it's better to expand inline xattr size
flexibly according to user's requirement.
So this patch introduces new filesystem feature 'flexible inline xattr',
and new mount option 'inline_xattr_size=%u', once mkfs enables the
feature, we can use the option to make f2fs supporting flexible inline
xattr size.
To support this feature, we add extra attribute i_inline_xattr_size in
inode layout, indicating that how many space inline xattr borrows from
block address mapping space in inode layout, by this, we can easily
locate and store flexible-sized inline xattr data in inode.
Inode disk layout:
+----------------------+
| .i_mode |
| ... |
| .i_ext |
+----------------------+
| .i_extra_isize |
| .i_inline_xattr_size |-----------+
| ... | |
+----------------------+ |
| .i_addr | |
| - block address or | |
| - inline data | |
+----------------------+<---+ v
| inline xattr | +---inline xattr range
+----------------------+<---+
| .i_nid |
+----------------------+
| node_footer |
| (nid, ino, offset) |
+----------------------+
Note that, we have to cnosider backward compatibility which reserved
inline_data space, 200 bytes, all the time, reported by Sheng Yong.
Previous inline data or directory always reserved 200 bytes in inode layout,
even if inline_xattr is disabled. In order to keep inline_dentry's structure
for backward compatibility, we get the space back only from inline_data.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Reported-by: Sheng Yong <shengyong1@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2017-09-06 16:59:50 +03:00
|
|
|
inline_addr = inline_xattr_addr(inode, ipage);
|
2013-08-14 16:57:27 +04:00
|
|
|
} else {
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
in_page = f2fs_get_node_page(sbi, inode->i_ino);
|
2017-10-17 01:05:16 +03:00
|
|
|
if (IS_ERR(in_page)) {
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
f2fs_alloc_nid_failed(sbi, new_nid);
|
2017-10-17 01:05:16 +03:00
|
|
|
return PTR_ERR(in_page);
|
2013-08-14 16:57:27 +04:00
|
|
|
}
|
2017-10-17 01:05:16 +03:00
|
|
|
inline_addr = inline_xattr_addr(inode, in_page);
|
2013-08-14 16:57:27 +04:00
|
|
|
}
|
|
|
|
|
2017-10-17 01:05:16 +03:00
|
|
|
f2fs_wait_on_page_writeback(ipage ? ipage : in_page,
|
2018-12-25 12:43:42 +03:00
|
|
|
NODE, true, true);
|
2013-08-14 16:57:27 +04:00
|
|
|
/* no need to use xattr node block */
|
|
|
|
if (hsize <= inline_size) {
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
err = f2fs_truncate_xattr_node(inode);
|
|
|
|
f2fs_alloc_nid_failed(sbi, new_nid);
|
2017-10-17 01:05:16 +03:00
|
|
|
if (err) {
|
|
|
|
f2fs_put_page(in_page, 1);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
memcpy(inline_addr, txattr_addr, inline_size);
|
|
|
|
set_page_dirty(ipage ? ipage : in_page);
|
|
|
|
goto in_page_out;
|
2013-08-14 16:57:27 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* write to xattr node block */
|
|
|
|
if (F2FS_I(inode)->i_xattr_nid) {
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
xpage = f2fs_get_node_page(sbi, F2FS_I(inode)->i_xattr_nid);
|
2013-08-14 16:57:27 +04:00
|
|
|
if (IS_ERR(xpage)) {
|
2017-12-29 04:47:19 +03:00
|
|
|
err = PTR_ERR(xpage);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
f2fs_alloc_nid_failed(sbi, new_nid);
|
2017-10-17 01:05:16 +03:00
|
|
|
goto in_page_out;
|
2013-08-14 16:57:27 +04:00
|
|
|
}
|
2014-09-03 02:52:58 +04:00
|
|
|
f2fs_bug_on(sbi, new_nid);
|
2018-12-25 12:43:42 +03:00
|
|
|
f2fs_wait_on_page_writeback(xpage, NODE, true, true);
|
2013-08-14 16:57:27 +04:00
|
|
|
} else {
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, new_nid);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
xpage = f2fs_new_node_page(&dn, XATTR_NODE_OFFSET);
|
2013-08-14 16:57:27 +04:00
|
|
|
if (IS_ERR(xpage)) {
|
2017-12-29 04:47:19 +03:00
|
|
|
err = PTR_ERR(xpage);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
f2fs_alloc_nid_failed(sbi, new_nid);
|
2017-10-17 01:05:16 +03:00
|
|
|
goto in_page_out;
|
2013-08-14 16:57:27 +04:00
|
|
|
}
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
f2fs_alloc_nid_done(sbi, new_nid);
|
2013-08-14 16:57:27 +04:00
|
|
|
}
|
|
|
|
xattr_addr = page_address(xpage);
|
2017-10-17 01:05:16 +03:00
|
|
|
|
|
|
|
if (inline_size)
|
|
|
|
memcpy(inline_addr, txattr_addr, inline_size);
|
2017-03-23 08:38:26 +03:00
|
|
|
memcpy(xattr_addr, txattr_addr + inline_size, VALID_XATTR_BLOCK_SIZE);
|
2017-10-17 01:05:16 +03:00
|
|
|
|
|
|
|
if (inline_size)
|
|
|
|
set_page_dirty(ipage ? ipage : in_page);
|
2013-08-14 16:57:27 +04:00
|
|
|
set_page_dirty(xpage);
|
|
|
|
|
2017-10-17 01:05:16 +03:00
|
|
|
f2fs_put_page(xpage, 1);
|
|
|
|
in_page_out:
|
|
|
|
f2fs_put_page(in_page, 1);
|
|
|
|
return err;
|
2013-08-14 16:57:27 +04:00
|
|
|
}
|
|
|
|
|
2014-04-23 07:17:25 +04:00
|
|
|
int f2fs_getxattr(struct inode *inode, int index, const char *name,
|
2014-10-14 06:42:53 +04:00
|
|
|
void *buffer, size_t buffer_size, struct page *ipage)
|
2012-11-02 12:12:17 +04:00
|
|
|
{
|
2017-01-24 15:39:51 +03:00
|
|
|
struct f2fs_xattr_entry *entry = NULL;
|
2013-08-13 05:13:55 +04:00
|
|
|
int error = 0;
|
2017-01-24 15:39:51 +03:00
|
|
|
unsigned int size, len;
|
|
|
|
void *base_addr = NULL;
|
2018-12-27 06:54:07 +03:00
|
|
|
int base_size;
|
2020-02-25 13:17:10 +03:00
|
|
|
bool is_inline;
|
2012-11-02 12:12:17 +04:00
|
|
|
|
|
|
|
if (name == NULL)
|
|
|
|
return -EINVAL;
|
2014-04-23 07:17:25 +04:00
|
|
|
|
|
|
|
len = strlen(name);
|
|
|
|
if (len > F2FS_NAME_LEN)
|
2014-03-22 10:59:45 +04:00
|
|
|
return -ERANGE;
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2017-09-07 05:40:54 +03:00
|
|
|
down_read(&F2FS_I(inode)->i_xattr_sem);
|
2017-01-24 15:39:51 +03:00
|
|
|
error = lookup_all_xattrs(inode, ipage, index, len, name,
|
2020-02-25 13:17:10 +03:00
|
|
|
&entry, &base_addr, &base_size, &is_inline);
|
2017-09-07 05:40:54 +03:00
|
|
|
up_read(&F2FS_I(inode)->i_xattr_sem);
|
2016-09-18 18:30:04 +03:00
|
|
|
if (error)
|
|
|
|
return error;
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2014-04-23 07:17:25 +04:00
|
|
|
size = le16_to_cpu(entry->e_value_size);
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2014-04-23 07:17:25 +04:00
|
|
|
if (buffer && size > buffer_size) {
|
2012-11-02 12:12:17 +04:00
|
|
|
error = -ERANGE;
|
2017-01-24 15:39:51 +03:00
|
|
|
goto out;
|
2012-11-02 12:12:17 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (buffer) {
|
|
|
|
char *pval = entry->e_name + entry->e_name_len;
|
2018-12-27 06:54:07 +03:00
|
|
|
|
|
|
|
if (base_size - (pval - (char *)base_addr) < size) {
|
|
|
|
error = -ERANGE;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-04-23 07:17:25 +04:00
|
|
|
memcpy(buffer, pval, size);
|
2012-11-02 12:12:17 +04:00
|
|
|
}
|
2014-04-23 07:17:25 +04:00
|
|
|
error = size;
|
2017-01-24 15:39:51 +03:00
|
|
|
out:
|
2020-02-25 13:17:10 +03:00
|
|
|
xattr_free(F2FS_I_SB(inode), base_addr, is_inline);
|
2012-11-02 12:12:17 +04:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
|
|
|
|
{
|
2015-03-18 01:25:59 +03:00
|
|
|
struct inode *inode = d_inode(dentry);
|
2012-11-02 12:12:17 +04:00
|
|
|
struct f2fs_xattr_entry *entry;
|
2019-10-18 09:56:22 +03:00
|
|
|
void *base_addr, *last_base_addr;
|
2012-11-02 12:12:17 +04:00
|
|
|
int error = 0;
|
|
|
|
size_t rest = buffer_size;
|
|
|
|
|
2017-09-07 05:40:54 +03:00
|
|
|
down_read(&F2FS_I(inode)->i_xattr_sem);
|
2016-09-18 18:30:04 +03:00
|
|
|
error = read_all_xattrs(inode, NULL, &base_addr);
|
2017-09-07 05:40:54 +03:00
|
|
|
up_read(&F2FS_I(inode)->i_xattr_sem);
|
2016-09-18 18:30:04 +03:00
|
|
|
if (error)
|
|
|
|
return error;
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2020-02-14 12:44:11 +03:00
|
|
|
last_base_addr = (void *)base_addr + XATTR_SIZE(inode);
|
2019-10-18 09:56:22 +03:00
|
|
|
|
2012-11-02 12:12:17 +04:00
|
|
|
list_for_each_xattr(entry, base_addr) {
|
|
|
|
const struct xattr_handler *handler =
|
|
|
|
f2fs_xattr_handler(entry->e_name_index);
|
2015-12-02 16:44:43 +03:00
|
|
|
const char *prefix;
|
|
|
|
size_t prefix_len;
|
2012-11-02 12:12:17 +04:00
|
|
|
size_t size;
|
|
|
|
|
2019-10-18 09:56:22 +03:00
|
|
|
if ((void *)(entry) + sizeof(__u32) > last_base_addr ||
|
|
|
|
(void *)XATTR_NEXT_ENTRY(entry) > last_base_addr) {
|
|
|
|
f2fs_err(F2FS_I_SB(inode), "inode (%lu) has corrupted xattr",
|
|
|
|
inode->i_ino);
|
|
|
|
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
|
|
|
|
error = -EFSCORRUPTED;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2015-12-02 16:44:43 +03:00
|
|
|
if (!handler || (handler->list && !handler->list(dentry)))
|
2012-11-02 12:12:17 +04:00
|
|
|
continue;
|
|
|
|
|
2019-01-25 15:11:39 +03:00
|
|
|
prefix = xattr_prefix(handler);
|
2015-12-02 16:44:43 +03:00
|
|
|
prefix_len = strlen(prefix);
|
|
|
|
size = prefix_len + entry->e_name_len + 1;
|
|
|
|
if (buffer) {
|
|
|
|
if (size > rest) {
|
|
|
|
error = -ERANGE;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
memcpy(buffer, prefix, prefix_len);
|
|
|
|
buffer += prefix_len;
|
|
|
|
memcpy(buffer, entry->e_name, entry->e_name_len);
|
|
|
|
buffer += entry->e_name_len;
|
|
|
|
*buffer++ = 0;
|
2012-11-02 12:12:17 +04:00
|
|
|
}
|
|
|
|
rest -= size;
|
|
|
|
}
|
|
|
|
error = buffer_size - rest;
|
|
|
|
cleanup:
|
2019-03-05 12:52:33 +03:00
|
|
|
kvfree(base_addr);
|
2012-11-02 12:12:17 +04:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-02-25 14:23:27 +03:00
|
|
|
static bool f2fs_xattr_value_same(struct f2fs_xattr_entry *entry,
|
|
|
|
const void *value, size_t size)
|
|
|
|
{
|
|
|
|
void *pval = entry->e_name + entry->e_name_len;
|
2017-03-10 20:36:10 +03:00
|
|
|
|
|
|
|
return (le16_to_cpu(entry->e_value_size) == size) &&
|
|
|
|
!memcmp(pval, value, size);
|
2017-02-25 14:23:27 +03:00
|
|
|
}
|
|
|
|
|
2014-04-23 07:17:25 +04:00
|
|
|
static int __f2fs_setxattr(struct inode *inode, int index,
|
|
|
|
const char *name, const void *value, size_t size,
|
2014-04-23 07:23:14 +04:00
|
|
|
struct page *ipage, int flags)
|
2012-11-02 12:12:17 +04:00
|
|
|
{
|
|
|
|
struct f2fs_xattr_entry *here, *last;
|
2019-04-11 11:26:46 +03:00
|
|
|
void *base_addr, *last_base_addr;
|
2013-08-14 16:57:27 +04:00
|
|
|
int found, newsize;
|
2014-04-23 07:17:25 +04:00
|
|
|
size_t len;
|
2013-08-14 16:57:27 +04:00
|
|
|
__u32 new_hsize;
|
2016-06-28 02:27:59 +03:00
|
|
|
int error = 0;
|
2012-11-02 12:12:17 +04:00
|
|
|
|
|
|
|
if (name == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (value == NULL)
|
2014-04-23 07:17:25 +04:00
|
|
|
size = 0;
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2014-04-23 07:17:25 +04:00
|
|
|
len = strlen(name);
|
2013-03-17 12:26:39 +04:00
|
|
|
|
2015-07-13 12:45:19 +03:00
|
|
|
if (len > F2FS_NAME_LEN)
|
2012-11-02 12:12:17 +04:00
|
|
|
return -ERANGE;
|
|
|
|
|
2015-07-13 12:45:19 +03:00
|
|
|
if (size > MAX_VALUE_LEN(inode))
|
|
|
|
return -E2BIG;
|
|
|
|
|
2016-09-18 18:30:04 +03:00
|
|
|
error = read_all_xattrs(inode, ipage, &base_addr);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2020-02-14 12:44:11 +03:00
|
|
|
last_base_addr = (void *)base_addr + XATTR_SIZE(inode);
|
2019-04-11 11:26:46 +03:00
|
|
|
|
2012-11-02 12:12:17 +04:00
|
|
|
/* find entry with wanted name. */
|
2019-04-11 11:26:46 +03:00
|
|
|
here = __find_xattr(base_addr, last_base_addr, index, len, name);
|
|
|
|
if (!here) {
|
2019-06-20 06:36:15 +03:00
|
|
|
f2fs_err(F2FS_I_SB(inode), "inode (%lu) has corrupted xattr",
|
|
|
|
inode->i_ino);
|
|
|
|
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
|
2019-06-20 06:36:14 +03:00
|
|
|
error = -EFSCORRUPTED;
|
2019-04-11 11:26:46 +03:00
|
|
|
goto exit;
|
|
|
|
}
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2013-08-13 05:13:55 +04:00
|
|
|
found = IS_XATTR_LAST_ENTRY(here) ? 0 : 1;
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2017-02-25 14:23:27 +03:00
|
|
|
if (found) {
|
|
|
|
if ((flags & XATTR_CREATE)) {
|
|
|
|
error = -EEXIST;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2018-01-20 10:46:33 +03:00
|
|
|
if (value && f2fs_xattr_value_same(here, value, size))
|
2017-02-25 14:23:27 +03:00
|
|
|
goto exit;
|
|
|
|
} else if ((flags & XATTR_REPLACE)) {
|
2014-04-23 07:28:18 +04:00
|
|
|
error = -ENODATA;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
last = here;
|
2012-11-02 12:12:17 +04:00
|
|
|
while (!IS_XATTR_LAST_ENTRY(last))
|
|
|
|
last = XATTR_NEXT_ENTRY(last);
|
|
|
|
|
2014-04-23 07:17:25 +04:00
|
|
|
newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) + len + size);
|
2012-11-02 12:12:17 +04:00
|
|
|
|
|
|
|
/* 1. Check space */
|
|
|
|
if (value) {
|
2013-08-14 16:57:27 +04:00
|
|
|
int free;
|
|
|
|
/*
|
|
|
|
* If value is NULL, it is remove operation.
|
2014-08-06 18:22:50 +04:00
|
|
|
* In case of update operation, we calculate free.
|
2012-11-02 12:12:17 +04:00
|
|
|
*/
|
2013-08-14 16:57:27 +04:00
|
|
|
free = MIN_OFFSET(inode) - ((char *)last - (char *)base_addr);
|
2012-11-02 12:12:17 +04:00
|
|
|
if (found)
|
2013-10-29 10:17:05 +04:00
|
|
|
free = free + ENTRY_SIZE(here);
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2013-12-06 10:00:58 +04:00
|
|
|
if (unlikely(free < newsize)) {
|
2016-04-12 21:52:30 +03:00
|
|
|
error = -E2BIG;
|
2013-08-14 16:57:27 +04:00
|
|
|
goto exit;
|
2012-11-02 12:12:17 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 2. Remove old entry */
|
|
|
|
if (found) {
|
2013-08-14 16:57:27 +04:00
|
|
|
/*
|
|
|
|
* If entry is found, remove old entry.
|
2012-11-02 12:12:17 +04:00
|
|
|
* If not found, remove operation is not needed.
|
|
|
|
*/
|
|
|
|
struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);
|
|
|
|
int oldsize = ENTRY_SIZE(here);
|
|
|
|
|
|
|
|
memmove(here, next, (char *)last - (char *)next);
|
|
|
|
last = (struct f2fs_xattr_entry *)((char *)last - oldsize);
|
|
|
|
memset(last, 0, oldsize);
|
|
|
|
}
|
|
|
|
|
2013-08-14 16:57:27 +04:00
|
|
|
new_hsize = (char *)last - (char *)base_addr;
|
|
|
|
|
2012-11-02 12:12:17 +04:00
|
|
|
/* 3. Write new entry */
|
|
|
|
if (value) {
|
2013-08-14 16:57:27 +04:00
|
|
|
char *pval;
|
|
|
|
/*
|
|
|
|
* Before we come here, old entry is removed.
|
|
|
|
* We just write new entry.
|
|
|
|
*/
|
2014-04-23 07:17:25 +04:00
|
|
|
last->e_name_index = index;
|
|
|
|
last->e_name_len = len;
|
|
|
|
memcpy(last->e_name, name, len);
|
|
|
|
pval = last->e_name + len;
|
|
|
|
memcpy(pval, value, size);
|
|
|
|
last->e_value_size = cpu_to_le16(size);
|
2013-08-14 16:57:27 +04:00
|
|
|
new_hsize += newsize;
|
2012-11-02 12:12:17 +04:00
|
|
|
}
|
|
|
|
|
2013-08-14 16:57:27 +04:00
|
|
|
error = write_all_xattrs(inode, new_hsize, base_addr, ipage);
|
|
|
|
if (error)
|
|
|
|
goto exit;
|
2012-11-02 12:12:17 +04:00
|
|
|
|
2016-05-20 20:13:22 +03:00
|
|
|
if (is_inode_flag_set(inode, FI_ACL_MODE)) {
|
|
|
|
inode->i_mode = F2FS_I(inode)->i_acl_mode;
|
2016-09-14 17:48:06 +03:00
|
|
|
inode->i_ctime = current_time(inode);
|
2016-05-20 20:13:22 +03:00
|
|
|
clear_inode_flag(inode, FI_ACL_MODE);
|
2012-11-02 12:12:17 +04:00
|
|
|
}
|
2015-04-21 01:19:06 +03:00
|
|
|
if (index == F2FS_XATTR_INDEX_ENCRYPTION &&
|
|
|
|
!strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT))
|
|
|
|
f2fs_set_encrypted_inode(inode);
|
2016-10-14 21:51:23 +03:00
|
|
|
f2fs_mark_inode_dirty_sync(inode, true);
|
2016-08-30 04:23:45 +03:00
|
|
|
if (!error && S_ISDIR(inode->i_mode))
|
|
|
|
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_CP);
|
2013-03-17 12:26:39 +04:00
|
|
|
exit:
|
2019-03-05 12:52:33 +03:00
|
|
|
kvfree(base_addr);
|
2012-11-02 12:12:17 +04:00
|
|
|
return error;
|
|
|
|
}
|
2013-09-25 00:49:23 +04:00
|
|
|
|
2014-04-23 07:17:25 +04:00
|
|
|
int f2fs_setxattr(struct inode *inode, int index, const char *name,
|
|
|
|
const void *value, size_t size,
|
2014-04-23 07:23:14 +04:00
|
|
|
struct page *ipage, int flags)
|
2013-09-25 00:49:23 +04:00
|
|
|
{
|
2014-09-03 02:31:18 +04:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2013-09-25 00:49:23 +04:00
|
|
|
int err;
|
|
|
|
|
2019-07-22 12:57:06 +03:00
|
|
|
if (unlikely(f2fs_cp_error(sbi)))
|
|
|
|
return -EIO;
|
2019-08-23 12:58:36 +03:00
|
|
|
if (!f2fs_is_checkpoint_ready(sbi))
|
|
|
|
return -ENOSPC;
|
2019-07-22 12:57:05 +03:00
|
|
|
|
2017-10-24 00:50:15 +03:00
|
|
|
err = dquot_initialize(inode);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-29 19:20:41 +03:00
|
|
|
/* this case is only from f2fs_init_inode_metadata */
|
2014-06-01 18:24:30 +04:00
|
|
|
if (ipage)
|
|
|
|
return __f2fs_setxattr(inode, index, name, value,
|
|
|
|
size, ipage, flags);
|
2016-01-08 01:15:04 +03:00
|
|
|
f2fs_balance_fs(sbi, true);
|
2013-09-25 00:49:23 +04:00
|
|
|
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 14:08:30 +04:00
|
|
|
f2fs_lock_op(sbi);
|
2017-09-07 05:40:54 +03:00
|
|
|
down_write(&F2FS_I(inode)->i_xattr_sem);
|
2014-04-23 07:23:14 +04:00
|
|
|
err = __f2fs_setxattr(inode, index, name, value, size, ipage, flags);
|
2017-09-07 05:40:54 +03:00
|
|
|
up_write(&F2FS_I(inode)->i_xattr_sem);
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 14:08:30 +04:00
|
|
|
f2fs_unlock_op(sbi);
|
2013-09-25 00:49:23 +04:00
|
|
|
|
2016-01-09 03:57:48 +03:00
|
|
|
f2fs_update_time(sbi, REQ_TIME);
|
2013-09-25 00:49:23 +04:00
|
|
|
return err;
|
|
|
|
}
|
2020-02-25 13:17:10 +03:00
|
|
|
|
|
|
|
int f2fs_init_xattr_caches(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
dev_t dev = sbi->sb->s_bdev->bd_dev;
|
|
|
|
char slab_name[32];
|
|
|
|
|
|
|
|
sprintf(slab_name, "f2fs_xattr_entry-%u:%u", MAJOR(dev), MINOR(dev));
|
|
|
|
|
|
|
|
sbi->inline_xattr_slab_size = F2FS_OPTION(sbi).inline_xattr_size *
|
|
|
|
sizeof(__le32) + XATTR_PADDING_SIZE;
|
|
|
|
|
|
|
|
sbi->inline_xattr_slab = f2fs_kmem_cache_create(slab_name,
|
|
|
|
sbi->inline_xattr_slab_size);
|
|
|
|
if (!sbi->inline_xattr_slab)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void f2fs_destroy_xattr_caches(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
kmem_cache_destroy(sbi->inline_xattr_slab);
|
|
|
|
}
|