mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 09:19:51 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
-----BEGIN PGP SIGNATURE-----
iHUEABYKAB0WIQRAhzRXHqcMeLMyaSiRxhvAZXjcogUCY+5NlQAKCRCRxhvAZXjc
orOaAP9i2h3OJy95nO2Fpde0Bt2UT+oulKCCcGlvXJ8/+TQpyQD/ZQq47gFQ0EAz
Br5NxeyGeecAb0lHpFz+CpLGsxMrMwQ=
=+BG5
-----END PGP SIGNATURE-----
Merge tag 'fs.idmapped.v6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/idmapping
Pull vfs idmapping updates from Christian Brauner:
- Last cycle we introduced the dedicated struct mnt_idmap type for
mount idmapping and the required infrastucture in 256c8aed2b
("fs:
introduce dedicated idmap type for mounts"). As promised in last
cycle's pull request message this converts everything to rely on
struct mnt_idmap.
Currently we still pass around the plain namespace that was attached
to a mount. This is in general pretty convenient but it makes it easy
to conflate namespaces that are relevant on the filesystem with
namespaces that are relevant on the mount level. Especially for
non-vfs developers without detailed knowledge in this area this was a
potential source for bugs.
This finishes the conversion. Instead of passing the plain namespace
around this updates all places that currently take a pointer to a
mnt_userns with a pointer to struct mnt_idmap.
Now that the conversion is done all helpers down to the really
low-level helpers only accept a struct mnt_idmap argument instead of
two namespace arguments.
Conflating mount and other idmappings will now cause the compiler to
complain loudly thus eliminating the possibility of any bugs. This
makes it impossible for filesystem developers to mix up mount and
filesystem idmappings as they are two distinct types and require
distinct helpers that cannot be used interchangeably.
Everything associated with struct mnt_idmap is moved into a single
separate file. With that change no code can poke around in struct
mnt_idmap. It can only be interacted with through dedicated helpers.
That means all filesystems are and all of the vfs is completely
oblivious to the actual implementation of idmappings.
We are now also able to extend struct mnt_idmap as we see fit. For
example, we can decouple it completely from namespaces for users that
don't require or don't want to use them at all. We can also extend
the concept of idmappings so we can cover filesystem specific
requirements.
In combination with the vfs{g,u}id_t work we finished in v6.2 this
makes this feature substantially more robust and thus difficult to
implement wrong by a given filesystem and also protects the vfs.
- Enable idmapped mounts for tmpfs and fulfill a longstanding request.
A long-standing request from users had been to make it possible to
create idmapped mounts for tmpfs. For example, to share the host's
tmpfs mount between multiple sandboxes. This is a prerequisite for
some advanced Kubernetes cases. Systemd also has a range of use-cases
to increase service isolation. And there are more users of this.
However, with all of the other work going on this was way down on the
priority list but luckily someone other than ourselves picked this
up.
As usual the patch is tiny as all the infrastructure work had been
done multiple kernel releases ago. In addition to all the tests that
we already have I requested that Rodrigo add a dedicated tmpfs
testsuite for idmapped mounts to xfstests. It is to be included into
xfstests during the v6.3 development cycle. This should add a slew of
additional tests.
* tag 'fs.idmapped.v6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/idmapping: (26 commits)
shmem: support idmapped mounts for tmpfs
fs: move mnt_idmap
fs: port vfs{g,u}id helpers to mnt_idmap
fs: port fs{g,u}id helpers to mnt_idmap
fs: port i_{g,u}id_into_vfs{g,u}id() to mnt_idmap
fs: port i_{g,u}id_{needs_}update() to mnt_idmap
quota: port to mnt_idmap
fs: port privilege checking helpers to mnt_idmap
fs: port inode_owner_or_capable() to mnt_idmap
fs: port inode_init_owner() to mnt_idmap
fs: port acl to mnt_idmap
fs: port xattr to mnt_idmap
fs: port ->permission() to pass mnt_idmap
fs: port ->fileattr_set() to pass mnt_idmap
fs: port ->set_acl() to pass mnt_idmap
fs: port ->get_acl() to pass mnt_idmap
fs: port ->tmpfile() to pass mnt_idmap
fs: port ->rename() to pass mnt_idmap
fs: port ->mknod() to pass mnt_idmap
fs: port ->mkdir() to pass mnt_idmap
...
514 lines
9.7 KiB
C
514 lines
9.7 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Copyright (C) 2021 Samsung Electronics Co., Ltd.
|
|
* Author(s): Namjae Jeon <linkinjeon@kernel.org>
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include "glob.h"
|
|
#include "ndr.h"
|
|
|
|
static inline char *ndr_get_field(struct ndr *n)
|
|
{
|
|
return n->data + n->offset;
|
|
}
|
|
|
|
static int try_to_realloc_ndr_blob(struct ndr *n, size_t sz)
|
|
{
|
|
char *data;
|
|
|
|
data = krealloc(n->data, n->offset + sz + 1024, GFP_KERNEL);
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
n->data = data;
|
|
n->length += 1024;
|
|
memset(n->data + n->offset, 0, 1024);
|
|
return 0;
|
|
}
|
|
|
|
static int ndr_write_int16(struct ndr *n, __u16 value)
|
|
{
|
|
if (n->length <= n->offset + sizeof(value)) {
|
|
int ret;
|
|
|
|
ret = try_to_realloc_ndr_blob(n, sizeof(value));
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
*(__le16 *)ndr_get_field(n) = cpu_to_le16(value);
|
|
n->offset += sizeof(value);
|
|
return 0;
|
|
}
|
|
|
|
static int ndr_write_int32(struct ndr *n, __u32 value)
|
|
{
|
|
if (n->length <= n->offset + sizeof(value)) {
|
|
int ret;
|
|
|
|
ret = try_to_realloc_ndr_blob(n, sizeof(value));
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
*(__le32 *)ndr_get_field(n) = cpu_to_le32(value);
|
|
n->offset += sizeof(value);
|
|
return 0;
|
|
}
|
|
|
|
static int ndr_write_int64(struct ndr *n, __u64 value)
|
|
{
|
|
if (n->length <= n->offset + sizeof(value)) {
|
|
int ret;
|
|
|
|
ret = try_to_realloc_ndr_blob(n, sizeof(value));
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
*(__le64 *)ndr_get_field(n) = cpu_to_le64(value);
|
|
n->offset += sizeof(value);
|
|
return 0;
|
|
}
|
|
|
|
static int ndr_write_bytes(struct ndr *n, void *value, size_t sz)
|
|
{
|
|
if (n->length <= n->offset + sz) {
|
|
int ret;
|
|
|
|
ret = try_to_realloc_ndr_blob(n, sz);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
memcpy(ndr_get_field(n), value, sz);
|
|
n->offset += sz;
|
|
return 0;
|
|
}
|
|
|
|
static int ndr_write_string(struct ndr *n, char *value)
|
|
{
|
|
size_t sz;
|
|
|
|
sz = strlen(value) + 1;
|
|
if (n->length <= n->offset + sz) {
|
|
int ret;
|
|
|
|
ret = try_to_realloc_ndr_blob(n, sz);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
memcpy(ndr_get_field(n), value, sz);
|
|
n->offset += sz;
|
|
n->offset = ALIGN(n->offset, 2);
|
|
return 0;
|
|
}
|
|
|
|
static int ndr_read_string(struct ndr *n, void *value, size_t sz)
|
|
{
|
|
int len;
|
|
|
|
if (n->offset + sz > n->length)
|
|
return -EINVAL;
|
|
|
|
len = strnlen(ndr_get_field(n), sz);
|
|
if (value)
|
|
memcpy(value, ndr_get_field(n), len);
|
|
len++;
|
|
n->offset += len;
|
|
n->offset = ALIGN(n->offset, 2);
|
|
return 0;
|
|
}
|
|
|
|
static int ndr_read_bytes(struct ndr *n, void *value, size_t sz)
|
|
{
|
|
if (n->offset + sz > n->length)
|
|
return -EINVAL;
|
|
|
|
if (value)
|
|
memcpy(value, ndr_get_field(n), sz);
|
|
n->offset += sz;
|
|
return 0;
|
|
}
|
|
|
|
static int ndr_read_int16(struct ndr *n, __u16 *value)
|
|
{
|
|
if (n->offset + sizeof(__u16) > n->length)
|
|
return -EINVAL;
|
|
|
|
if (value)
|
|
*value = le16_to_cpu(*(__le16 *)ndr_get_field(n));
|
|
n->offset += sizeof(__u16);
|
|
return 0;
|
|
}
|
|
|
|
static int ndr_read_int32(struct ndr *n, __u32 *value)
|
|
{
|
|
if (n->offset + sizeof(__u32) > n->length)
|
|
return -EINVAL;
|
|
|
|
if (value)
|
|
*value = le32_to_cpu(*(__le32 *)ndr_get_field(n));
|
|
n->offset += sizeof(__u32);
|
|
return 0;
|
|
}
|
|
|
|
static int ndr_read_int64(struct ndr *n, __u64 *value)
|
|
{
|
|
if (n->offset + sizeof(__u64) > n->length)
|
|
return -EINVAL;
|
|
|
|
if (value)
|
|
*value = le64_to_cpu(*(__le64 *)ndr_get_field(n));
|
|
n->offset += sizeof(__u64);
|
|
return 0;
|
|
}
|
|
|
|
int ndr_encode_dos_attr(struct ndr *n, struct xattr_dos_attrib *da)
|
|
{
|
|
char hex_attr[12] = {0};
|
|
int ret;
|
|
|
|
n->offset = 0;
|
|
n->length = 1024;
|
|
n->data = kzalloc(n->length, GFP_KERNEL);
|
|
if (!n->data)
|
|
return -ENOMEM;
|
|
|
|
if (da->version == 3) {
|
|
snprintf(hex_attr, 10, "0x%x", da->attr);
|
|
ret = ndr_write_string(n, hex_attr);
|
|
} else {
|
|
ret = ndr_write_string(n, "");
|
|
}
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int16(n, da->version);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int32(n, da->version);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int32(n, da->flags);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int32(n, da->attr);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (da->version == 3) {
|
|
ret = ndr_write_int32(n, da->ea_size);
|
|
if (ret)
|
|
return ret;
|
|
ret = ndr_write_int64(n, da->size);
|
|
if (ret)
|
|
return ret;
|
|
ret = ndr_write_int64(n, da->alloc_size);
|
|
} else {
|
|
ret = ndr_write_int64(n, da->itime);
|
|
}
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int64(n, da->create_time);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (da->version == 3)
|
|
ret = ndr_write_int64(n, da->change_time);
|
|
return ret;
|
|
}
|
|
|
|
int ndr_decode_dos_attr(struct ndr *n, struct xattr_dos_attrib *da)
|
|
{
|
|
char hex_attr[12];
|
|
unsigned int version2;
|
|
int ret;
|
|
|
|
n->offset = 0;
|
|
ret = ndr_read_string(n, hex_attr, sizeof(hex_attr));
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_read_int16(n, &da->version);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (da->version != 3 && da->version != 4) {
|
|
ksmbd_debug(VFS, "v%d version is not supported\n", da->version);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = ndr_read_int32(n, &version2);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (da->version != version2) {
|
|
ksmbd_debug(VFS, "ndr version mismatched(version: %d, version2: %d)\n",
|
|
da->version, version2);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = ndr_read_int32(n, NULL);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_read_int32(n, &da->attr);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (da->version == 4) {
|
|
ret = ndr_read_int64(n, &da->itime);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_read_int64(n, &da->create_time);
|
|
} else {
|
|
ret = ndr_read_int32(n, NULL);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_read_int64(n, NULL);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_read_int64(n, NULL);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_read_int64(n, &da->create_time);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_read_int64(n, NULL);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ndr_encode_posix_acl_entry(struct ndr *n, struct xattr_smb_acl *acl)
|
|
{
|
|
int i, ret;
|
|
|
|
ret = ndr_write_int32(n, acl->count);
|
|
if (ret)
|
|
return ret;
|
|
|
|
n->offset = ALIGN(n->offset, 8);
|
|
ret = ndr_write_int32(n, acl->count);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int32(n, 0);
|
|
if (ret)
|
|
return ret;
|
|
|
|
for (i = 0; i < acl->count; i++) {
|
|
n->offset = ALIGN(n->offset, 8);
|
|
ret = ndr_write_int16(n, acl->entries[i].type);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int16(n, acl->entries[i].type);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (acl->entries[i].type == SMB_ACL_USER) {
|
|
n->offset = ALIGN(n->offset, 8);
|
|
ret = ndr_write_int64(n, acl->entries[i].uid);
|
|
} else if (acl->entries[i].type == SMB_ACL_GROUP) {
|
|
n->offset = ALIGN(n->offset, 8);
|
|
ret = ndr_write_int64(n, acl->entries[i].gid);
|
|
}
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* push permission */
|
|
ret = ndr_write_int32(n, acl->entries[i].perm);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ndr_encode_posix_acl(struct ndr *n,
|
|
struct mnt_idmap *idmap,
|
|
struct inode *inode,
|
|
struct xattr_smb_acl *acl,
|
|
struct xattr_smb_acl *def_acl)
|
|
{
|
|
unsigned int ref_id = 0x00020000;
|
|
int ret;
|
|
vfsuid_t vfsuid;
|
|
vfsgid_t vfsgid;
|
|
|
|
n->offset = 0;
|
|
n->length = 1024;
|
|
n->data = kzalloc(n->length, GFP_KERNEL);
|
|
if (!n->data)
|
|
return -ENOMEM;
|
|
|
|
if (acl) {
|
|
/* ACL ACCESS */
|
|
ret = ndr_write_int32(n, ref_id);
|
|
ref_id += 4;
|
|
} else {
|
|
ret = ndr_write_int32(n, 0);
|
|
}
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (def_acl) {
|
|
/* DEFAULT ACL ACCESS */
|
|
ret = ndr_write_int32(n, ref_id);
|
|
ref_id += 4;
|
|
} else {
|
|
ret = ndr_write_int32(n, 0);
|
|
}
|
|
if (ret)
|
|
return ret;
|
|
|
|
vfsuid = i_uid_into_vfsuid(idmap, inode);
|
|
ret = ndr_write_int64(n, from_kuid(&init_user_ns, vfsuid_into_kuid(vfsuid)));
|
|
if (ret)
|
|
return ret;
|
|
vfsgid = i_gid_into_vfsgid(idmap, inode);
|
|
ret = ndr_write_int64(n, from_kgid(&init_user_ns, vfsgid_into_kgid(vfsgid)));
|
|
if (ret)
|
|
return ret;
|
|
ret = ndr_write_int32(n, inode->i_mode);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (acl) {
|
|
ret = ndr_encode_posix_acl_entry(n, acl);
|
|
if (def_acl && !ret)
|
|
ret = ndr_encode_posix_acl_entry(n, def_acl);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ndr_encode_v4_ntacl(struct ndr *n, struct xattr_ntacl *acl)
|
|
{
|
|
unsigned int ref_id = 0x00020004;
|
|
int ret;
|
|
|
|
n->offset = 0;
|
|
n->length = 2048;
|
|
n->data = kzalloc(n->length, GFP_KERNEL);
|
|
if (!n->data)
|
|
return -ENOMEM;
|
|
|
|
ret = ndr_write_int16(n, acl->version);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int32(n, acl->version);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int16(n, 2);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int32(n, ref_id);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* push hash type and hash 64bytes */
|
|
ret = ndr_write_int16(n, acl->hash_type);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_bytes(n, acl->hash, XATTR_SD_HASH_SIZE);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_bytes(n, acl->desc, acl->desc_len);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_int64(n, acl->current_time);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_write_bytes(n, acl->posix_acl_hash, XATTR_SD_HASH_SIZE);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* push ndr for security descriptor */
|
|
ret = ndr_write_bytes(n, acl->sd_buf, acl->sd_size);
|
|
return ret;
|
|
}
|
|
|
|
int ndr_decode_v4_ntacl(struct ndr *n, struct xattr_ntacl *acl)
|
|
{
|
|
unsigned int version2;
|
|
int ret;
|
|
|
|
n->offset = 0;
|
|
ret = ndr_read_int16(n, &acl->version);
|
|
if (ret)
|
|
return ret;
|
|
if (acl->version != 4) {
|
|
ksmbd_debug(VFS, "v%d version is not supported\n", acl->version);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = ndr_read_int32(n, &version2);
|
|
if (ret)
|
|
return ret;
|
|
if (acl->version != version2) {
|
|
ksmbd_debug(VFS, "ndr version mismatched(version: %d, version2: %d)\n",
|
|
acl->version, version2);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Read Level */
|
|
ret = ndr_read_int16(n, NULL);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* Read Ref Id */
|
|
ret = ndr_read_int32(n, NULL);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_read_int16(n, &acl->hash_type);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ndr_read_bytes(n, acl->hash, XATTR_SD_HASH_SIZE);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ndr_read_bytes(n, acl->desc, 10);
|
|
if (strncmp(acl->desc, "posix_acl", 9)) {
|
|
pr_err("Invalid acl description : %s\n", acl->desc);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Read Time */
|
|
ret = ndr_read_int64(n, NULL);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* Read Posix ACL hash */
|
|
ret = ndr_read_bytes(n, acl->posix_acl_hash, XATTR_SD_HASH_SIZE);
|
|
if (ret)
|
|
return ret;
|
|
|
|
acl->sd_size = n->length - n->offset;
|
|
acl->sd_buf = kzalloc(acl->sd_size, GFP_KERNEL);
|
|
if (!acl->sd_buf)
|
|
return -ENOMEM;
|
|
|
|
ret = ndr_read_bytes(n, acl->sd_buf, acl->sd_size);
|
|
return ret;
|
|
}
|