nstree: listns()
Subsystems (27)
Christian Brauner
maintainerv4 cover nstree: listns()
Hey,
As announced a while ago this is the next step building on the nstree work from prior cycles. There's a bunch of fixes and semantic cleanups in here and a ton of tests.
Currently listns() is relying on active namespace reference counts which are introduced alongside this series.
While a namespace is on the namespace trees with a valid reference count it is possible to reopen it through a namespace file handle. This is all fine but has some issues that should be addressed.
On current kernels a namespace is visible to userspace in the following cases:
(1) The namespace is in use by a task.
(2) The namespace is persisted through a VFS object (namespace file descriptor or bind-mount).
Note that (2) only cares about direct persistence of the namespace itself not indirectly via e.g., file->f_cred file references or similar.
(3) The namespace is a hierarchical namespace type and is the parent of a single or multiple child namespaces.
Case (3) is interesting because it is possible that a parent namespace might not fulfill any of (1) or (2), i.e., is invisible to userspace but it may still be resurrected through the NS_GET_PARENT ioctl().
Currently namespace file handles allow much broader access to namespaces than what is currently possible via (1)-(3). The reason is that namespaces may remain pinned for completely internal reasons yet are inaccessible to userspace.
For example, a user namespace my remain pinned by get_cred() calls to stash the opener's credentials into file->f_cred. As it stands file handles allow to resurrect such a users namespace even though this should not be possible via (1)-(3). This is a fundamental uapi change that we shouldn't do if we don't have to.
Consider the following insane case: Various architectures support the CONFIG_MMU_LAZY_TLB_REFCOUNT option which uses lazy TLB destruction. When this option is set a userspace task's struct mm_struct may be used for kernel threads such as the idle task and will only be destroyed once the cpu's runqueue switches back to another task. But because of ptrace() permission checks struct mm_struct stashes the user namespace of the task that struct mm_struct originally belonged to. The kernel thread will take a reference on the struct mm_struct and thus pin it.
So on an idle system user namespaces can be persisted for arbitrary amounts of time which also means that they can be resurrected using namespace file handles. That makes no sense whatsoever. The problem is of course excarabted on large systems with a huge number of cpus.
To handle this nicely we introduce an active reference count which tracks (1)-(3). This is easy to do as all of these things are already managed centrally. Only (1)-(3) will count towards the active reference count and only namespaces which are active may be opened via namespace file handles.
The problem is that namespaces may be resurrected. Which means that they can become temporarily inactive and will be reactived some time later. Currently the only example of this is the SIOGCSKNS socket ioctl. The SIOCGSKNS ioctl allows to open a network namespace file descriptor based on a socket file descriptor.
If a socket is tied to a network namespace that subsequently becomes inactive but that socket is persisted by another process in another network namespace (e.g., via SCM_RIGHTS of pidfd_getfd()) then the SIOCGSKNS ioctl will resurrect this network namespace.
So calls to open_related_ns() and open_namespace() will end up resurrecting the corresponding namespace tree.
Note that the active reference count does not regulate the lifetime of the namespace itself. This is still done by the normal reference count. The active reference count can only be elevated if the regular reference count is elevated.
The active reference count also doesn't regulate the presence of a namespace on the namespace trees. It only regulates its visiblity to namespace file handles (and in later patches to listns()).
A namespace remains on the namespace trees from creation until its actual destruction. This will allow the kernel to always reach any namespace trivially and it will also enable subsystems like bpf to walk the namespace lists on the system for tracing or general introspection purposes.
Note that different namespaces have different visibility lifetimes on current kernels. While most namespace are immediately released when the last task using them exits, the user- and pid namespace are persisted and thus both remain accessible via /proc/<pid>/ns/<ns_type>.
The user namespace lifetime is aliged with struct cred and is only released through exit_creds(). However, it becomes inaccessible to userspace once the last task using it is reaped, i.e., when release_task() is called and all proc entries are flushed. Similarly, the pid namespace is also visible until the last task using it has been reaped and the associated pid numbers are freed.
The active reference counts of the user- and pid namespace are decremented once the task is reaped.
Based on the namespace trees and the active reference count, a new listns() system call that allows userspace to iterate through namespaces in the system. This provides a programmatic interface to discover and inspect namespaces, enhancing existing namespace apis.
Currently, there is no direct way for userspace to enumerate namespaces in the system. Applications must resort to scanning /proc/<pid>/ns/ across all processes, which is:
1. Inefficient - requires iterating over all processes
2. Incomplete - misses inactive namespaces that aren't attached to any running process but are kept alive by file descriptors, bind mounts, or parent namespace references
3. Permission-heavy - requires access to /proc for many processes
4. No ordering or ownership.
5. No filtering per namespace type: Must always iterate and check all namespaces.
The list goes on. The listns() system call solves these problems by providing direct kernel-level enumeration of namespaces. It is similar to listmount() but obviously tailored to namespaces.
/*
* @req: Pointer to struct ns_id_req specifying search parameters
* @ns_ids: User buffer to receive namespace IDs
* @nr_ns_ids: Size of ns_ids buffer (maximum number of IDs to return)
* @flags: Reserved for future use (must be 0)
*/ssize_t listns(const struct ns_id_req *req, u64 *ns_ids,
size_t nr_ns_ids, unsigned int flags);
Returns:
- On success: Number of namespace IDs written to ns_ids
- On error: Negative error code
/*
* @size: Structure size
* @ns_id: Starting point for iteration; use 0 for first call, then
* use the last returned ID for subsequent calls to paginate
* @ns_type: Bitmask of namespace types to include (from enum ns_type):
* 0: Return all namespace types
* MNT_NS: Mount namespaces
* NET_NS: Network namespaces
* USER_NS: User namespaces
* etc. Can be OR'd together
* @user_ns_id: Filter results to namespaces owned by this user namespace:
* 0: Return all namespaces (subject to permission checks)
* LISTNS_CURRENT_USER: Namespaces owned by caller's user namespace
* Other value: Namespaces owned by the specified user namespace ID
*/
struct ns_id_req {
__u32 size; /* sizeof(struct ns_id_req) */
__u32 spare; /* Reserved, must be 0 */
__u64 ns_id; /* Last seen namespace ID (for pagination) */
__u32 ns_type; /* Filter by namespace type(s) */
__u32 spare2; /* Reserved, must be 0 */
__u64 user_ns_id; /* Filter by owning user namespace */};
Example 1: List all namespaces
void list_all_namespaces(void)
{
struct ns_id_req req = {
.size = sizeof(req),
.ns_id = 0, /* Start from beginning */
.ns_type = 0, /* All types */
.user_ns_id = 0, /* All user namespaces */
};
uint64_t ids[100];
ssize_t ret;
printf("All namespaces in the system:\n");
do {
ret = listns(&req, ids, 100, 0);
if (ret < 0) {
perror("listns");
break;
}
for (ssize_t i = 0; i < ret; i++)
printf(" Namespace ID: %llu\n", (unsigned long long)ids[i]);
/* Continue from last seen ID */
if (ret > 0)
req.ns_id = ids[ret - 1];
} while (ret == 100); /* Buffer was full, more may exist */
}Example 2 : List network namespaces only
void list_network_namespaces(void)
{
struct ns_id_req req = {
.size = sizeof(req),
.ns_id = 0,
.ns_type = NET_NS, /* Only network namespaces */
.user_ns_id = 0,
};
uint64_t ids[100];
ssize_t ret;
ret = listns(&req, ids, 100, 0);
if (ret < 0) {
perror("listns");
return;
}
printf("Network namespaces: %zd found\n", ret);
for (ssize_t i = 0; i < ret; i++)
printf(" netns ID: %llu\n", (unsigned long long)ids[i]);
}Example 3 : List namespaces owned by current user namespace
void list_owned_namespaces(void)
{
struct ns_id_req req = {
.size = sizeof(req),
.ns_id = 0,
.ns_type = 0, /* All types */
.user_ns_id = LISTNS_CURRENT_USER, /* Current userns */
};
uint64_t ids[100];
ssize_t ret;
ret = listns(&req, ids, 100, 0);
if (ret < 0) {
perror("listns");
return;
}
printf("Namespaces owned by my user namespace: %zd\n", ret);
for (ssize_t i = 0; i < ret; i++)
printf(" ns ID: %llu\n", (unsigned long long)ids[i]);
}Example 4 : List multiple namespace types
void list_network_and_mount_namespaces(void)
{
struct ns_id_req req = {
.size = sizeof(req),
.ns_id = 0,
.ns_type = NET_NS | MNT_NS, /* Network and mount */
.user_ns_id = 0,
};
uint64_t ids[100];
ssize_t ret;
ret = listns(&req, ids, 100, 0);
printf("Network and mount namespaces: %zd found\n", ret);
}Example 5 : Pagination through large namespace sets
void list_all_with_pagination(void)
{
struct ns_id_req req = {
.size = sizeof(req),
.ns_id = 0,
.ns_type = 0,
.user_ns_id = 0,
};
uint64_t ids[50];
size_t total = 0;
ssize_t ret;
printf("Enumerating all namespaces with pagination:\n");
while (1) {
ret = listns(&req, ids, 50, 0);
if (ret < 0) {
perror("listns");
break;
}
if (ret == 0)
break; /* No more namespaces */
total += ret;
printf(" Batch: %zd namespaces\n", ret);
/* Last ID in this batch becomes start of next batch */
req.ns_id = ids[ret - 1];
if (ret < 50)
break; /* Partial batch = end of results */
}
printf("Total: %zu namespaces\n", total);
}listns() respects namespace isolation and capabilities:
(1) Global listing (user_ns_id = 0):
- Requires CAP_SYS_ADMIN in the namespace's owning user namespace
- OR the namespace must be in the caller's namespace context (e.g., a namespace the caller is currently using)
- User namespaces additionally allow listing if the caller has CAP_SYS_ADMIN in that user namespace itself
(2) Owner-filtered listing (user_ns_id != 0):
- Requires CAP_SYS_ADMIN in the specified owner user namespace
- OR the namespace must be in the caller's namespace context
- This allows unprivileged processes to enumerate namespaces they own
(3) Visibility:
- Only "active" namespaces are listed
- A namespace is active if it has a non-zero __ns_ref_active count
- This includes namespaces used by running processes, held by open file descriptors, or kept active by bind mounts
- Inactive namespaces (kept alive only by internal kernel references) are not visible via listns()
Signed-off-by Christian Brauner <[email protected]>
---
Changes in v4:
- Fold __ns_ref_active_get_owner() into __ns_tree_add_raw() as suggested
by Thomas.
- Don't use kvmalloc() instead use put_user() directly as suggested by
Arnd.
- Various minor documentation fixes.
- Unify various codepaths in the listns() implementation.
- Link to v3: https://patch.msgid.link/20251024-work-namespace-nstree-listns-v3-0-b6241981b72b@kernel.org
Changes in v3:
- Expanded test-suite.
- Moved active reference count tracking for task-attached namespaces to
dedicated helpers.
- Fixed active reference count leaks when creating a new process fails.
- Allow to be rescheduled when walking a a long namespace list.
- Grab reference count when accessing a namespace when walking the list.
- Link to v2: https://patch.msgid.link/20251022-work-namespace-nstree-listns-v2-0-71a588572371@kernel.org
Changes in v2:
- Fully implement the active reference count.
- Fix various minor issues.
- Expand the testsuite to test complex resurrection scenarios due to SIOCGSKNS.
- Currently each task takes an active reference on the user namespace as
credentials can be persisted for a very long time and completely
arbitrary reasons but we don't want to tie the lifetime of a user
namespace being visible to userspace to the existence of some
credentials being stashed somewhere. We want to tie it to it being
in-use by actual tasks or vfs objects and then go away. There might be
more clever ways of doing this but for now this is good enough.
- TODO: Add detailed tests for multi-threaded namespace sharing.
- Link to v1: https://patch.msgid.link/20251021-work-namespace-nstree-listns-v1-0-ad44261a8a5b@kernel.org
---
Christian Brauner (72):
libfs: allow to specify s_d_flags
nsfs: use inode_just_drop()
nsfs: raise DCACHE_DONTCACHE explicitly
pidfs: raise DCACHE_DONTCACHE explicitly
nsfs: raise SB_I_NODEV and SB_I_NOEXEC
cgroup: add cgroup namespace to tree after owner is set
nstree: simplify return
ns: initialize ns_list_node for initial namespaces
ns: add __ns_ref_read()
ns: rename to exit_nsproxy_namespaces()
ns: add active reference count
ns: use anonymous struct to group list member
nstree: introduce a unified tree
nstree: allow lookup solely based on inode
nstree: assign fixed ids to the initial namespaces
nstree: maintain list of owned namespaces
nstree: simplify rbtree comparison helpers
nstree: add unified namespace list
nstree: add listns()
arch: hookup listns() system call
nsfs: update tools header
selftests/filesystems: remove CLONE_NEWPIDNS from setup_userns() helper selftests/namespaces: first active reference count tests selftests/namespaces: second active reference count tests selftests/namespaces: third active reference count tests selftests/namespaces: fourth active reference count tests selftests/namespaces: fifth active reference count tests selftests/namespaces: sixth active reference count tests selftests/namespaces: seventh active reference count tests selftests/namespaces: eigth active reference count tests selftests/namespaces: ninth active reference count tests selftests/namespaces: tenth active reference count tests selftests/namespaces: eleventh active reference count tests selftests/namespaces: twelth active reference count tests selftests/namespaces: thirteenth active reference count tests selftests/namespaces: fourteenth active reference count tests selftests/namespaces: fifteenth active reference count tests selftests/namespaces: add listns() wrapper selftests/namespaces: first listns() test selftests/namespaces: second listns() test selftests/namespaces: third listns() test selftests/namespaces: fourth listns() test selftests/namespaces: fifth listns() test selftests/namespaces: sixth listns() test selftests/namespaces: seventh listns() test selftests/namespaces: eigth listns() test selftests/namespaces: ninth listns() test selftests/namespaces: first listns() permission test selftests/namespaces: second listns() permission test selftests/namespaces: third listns() permission test selftests/namespaces: fourth listns() permission test selftests/namespaces: fifth listns() permission test selftests/namespaces: sixth listns() permission test selftests/namespaces: seventh listns() permission test selftests/namespaces: first inactive namespace resurrection test selftests/namespaces: second inactive namespace resurrection test selftests/namespaces: third inactive namespace resurrection test selftests/namespaces: fourth inactive namespace resurrection test selftests/namespaces: fifth inactive namespace resurrection test selftests/namespaces: sixth inactive namespace resurrection test selftests/namespaces: seventh inactive namespace resurrection test selftests/namespaces: eigth inactive namespace resurrection test selftests/namespaces: ninth inactive namespace resurrection test selftests/namespaces: tenth inactive namespace resurrection test selftests/namespaces: eleventh inactive namespace resurrection test selftests/namespaces: twelth inactive namespace resurrection test selftests/namespace: first threaded active reference count test selftests/namespace: second threaded active reference count test selftests/namespace: third threaded active reference count test selftests/namespace: commit_creds() active reference tests selftests/namespace: add stress test
selftests/namespace: test listns() pagination
arch/alpha/kernel/syscalls/syscall.tbl | 1 + arch/arm/tools/syscall.tbl | 1 + arch/arm64/tools/syscall_32.tbl | 1 + arch/m68k/kernel/syscalls/syscall.tbl | 1 + arch/microblaze/kernel/syscalls/syscall.tbl | 1 + arch/mips/kernel/syscalls/syscall_n32.tbl | 1 + arch/mips/kernel/syscalls/syscall_n64.tbl | 1 + arch/mips/kernel/syscalls/syscall_o32.tbl | 1 + arch/parisc/kernel/syscalls/syscall.tbl | 1 + arch/powerpc/kernel/syscalls/syscall.tbl | 1 + arch/s390/kernel/syscalls/syscall.tbl | 1 + arch/sh/kernel/syscalls/syscall.tbl | 1 + arch/sparc/kernel/syscalls/syscall.tbl | 1 + arch/x86/entry/syscalls/syscall_32.tbl | 1 + arch/x86/entry/syscalls/syscall_64.tbl | 1 + arch/xtensa/kernel/syscalls/syscall.tbl | 1 + fs/libfs.c | 1 + fs/namespace.c | 7 +- fs/nsfs.c | 94 +- fs/pidfs.c | 1 + include/linux/ns_common.h | 165 +- include/linux/nsfs.h | 3 + include/linux/nsproxy.h | 5 +- include/linux/nstree.h | 26 +- include/linux/pseudo_fs.h | 1 + include/linux/syscalls.h | 4 + include/linux/user_namespace.h | 4 +- include/uapi/asm-generic/unistd.h | 4 +- include/uapi/linux/nsfs.h | 58 + init/version-timestamp.c | 5 + ipc/msgutil.c | 5 + kernel/cgroup/cgroup.c | 11 +- kernel/cgroup/namespace.c | 2 +- kernel/cred.c | 6 + kernel/exit.c | 3 +- kernel/fork.c | 3 +- kernel/nscommon.c | 220 +- kernel/nsproxy.c | 25 +- kernel/nstree.c | 610 ++++- kernel/pid.c | 10 + kernel/time/namespace.c | 5 + kernel/user.c | 5 + net/core/net_namespace.c | 2 +- scripts/syscall.tbl | 1 + tools/include/uapi/linux/nsfs.h | 70 + tools/testing/selftests/filesystems/utils.c | 2 +- tools/testing/selftests/namespaces/.gitignore | 7 + tools/testing/selftests/namespaces/Makefile | 20 +- .../selftests/namespaces/cred_change_test.c | 814 ++++++ .../selftests/namespaces/listns_pagination_bug.c | 138 + .../selftests/namespaces/listns_permissions_test.c | 759 ++++++ tools/testing/selftests/namespaces/listns_test.c | 679 +++++ .../selftests/namespaces/ns_active_ref_test.c | 2672 ++++++++++++++++++++ .../testing/selftests/namespaces/siocgskns_test.c | 1824 +++++++++++++ tools/testing/selftests/namespaces/stress_test.c | 626 +++++ tools/testing/selftests/namespaces/wrappers.h | 35 + 56 files changed, 8879 insertions(+), 69 deletions(-)
---
base-commit: 3a8660878839faadb4f1a6dd72c3179c1df56787
change-id: 20251020-work-namespace-nstree-listns-9fd71518515c
Christian Brauner
maintainerPATCH v4 1/72 libfs: allow to specify s_d_flags
Make it possible for pseudo filesystems to specify default dentry flags.
Signed-off-by Christian Brauner <[email protected]>
--- fs/libfs.c | 1 + include/linux/pseudo_fs.h | 1 + 2 files changed, 2 insertions(+)
fs/libfs.c +1 -0
@@ -680,6 +680,7 @@ static int pseudo_fs_fill_super(struct super_block *s, struct fs_context *fc) s->s_export_op = ctx->eops; s->s_xattr = ctx->xattr; s->s_time_gran =1 ; + s->s_d_flags |= ctx->s_d_flags; root =new_inode (s);if (!root)return -ENOMEM ;
include/linux/pseudo_fs.h +1 -0
@@ -9,6 +9,7 @@ struct pseudo_fs_context {const struct xattr_handler *const *xattr;const struct dentry_operations *dops;unsigned long magic; +unsigned int s_d_flags; }; struct pseudo_fs_context *init_pseudo(struct fs_context *fc,
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 2/72 nsfs: use inode_just_drop()
In reply to Christian BraunerCurrently nsfs uses the default inode_generic_drop() fallback which drops the inode when it's unlinked or when it's unhashed. Since nsfs never hashes inodes that always amounts to dropping the inode.
But that's just annoying to have to reason through every time we look at this code. Switch to inode_just_drop() which always drops the inode explicitly. This also aligns the behavior with pidfs which does the same.
Signed-off-by Christian Brauner <[email protected]>
--- fs/nsfs.c | 1 + 1 file changed, 1 insertion(+)
fs/nsfs.c +1 -0
@@ -408,6 +408,7 @@ static const struct super_operations nsfs_ops = { .statfs = simple_statfs, .evict_inode = nsfs_evict, .show_path = nsfs_show_path, + .drop_inode = inode_just_drop, };static int nsfs_init_inode (struct inode *inode,void *data)
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 3/72 nsfs: raise DCACHE_DONTCACHE explicitly
In reply to Christian BraunerWhile nsfs dentries are never hashed and thus retain_dentry() will never consider them for placing them on the LRU it isn't great to always have to go and remember that. Raise DCACHE_DONTCACHE explicitly as a visual marker that dentries aren't kept but freed immediately instead.
Signed-off-by Christian Brauner <[email protected]>
--- fs/nsfs.c | 1 + 1 file changed, 1 insertion(+)
fs/nsfs.c +1 -0
@@ -589,6 +589,7 @@ static int nsfs_init_fs_context(struct fs_context *fc)struct pseudo_fs_context *ctx =init_pseudo (fc,NSFS_MAGIC );if (!ctx)return -ENOMEM ; + ctx->s_d_flags |=DCACHE_DONTCACHE ; ctx->ops = &nsfs_ops; ctx->eops = &nsfs_export_operations; ctx->dops = &ns_dentry_operations;
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 4/72 pidfs: raise DCACHE_DONTCACHE explicitly
In reply to Christian BraunerWhile pidfs dentries are never hashed and thus retain_dentry() will never consider them for placing them on the LRU it isn't great to always have to go and remember that. Raise DCACHE_DONTCACHE explicitly as a visual marker that dentries aren't kept but freed immediately instead.
Signed-off-by Christian Brauner <[email protected]>
--- fs/pidfs.c | 1 + 1 file changed, 1 insertion(+)
fs/pidfs.c +1 -0
@@ -1022,6 +1022,7 @@ static int pidfs_init_fs_context(struct fs_context *fc) fc->s_iflags |=SB_I_NOEXEC ; fc->s_iflags |=SB_I_NODEV ; + ctx->s_d_flags |=DCACHE_DONTCACHE ; ctx->ops = &pidfs_sops; ctx->eops = &pidfs_export_operations; ctx->dops = &pidfs_dentry_operations;
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 5/72 nsfs: raise SB_I_NODEV and SB_I_NOEXEC
In reply to Christian BraunerThere's zero need for nsfs to allow device nodes or execution.
Signed-off-by Christian Brauner <[email protected]>
--- fs/nsfs.c | 1 + 1 file changed, 1 insertion(+)
fs/nsfs.c +1 -0
@@ -589,6 +589,7 @@ static int nsfs_init_fs_context(struct fs_context *fc)struct pseudo_fs_context *ctx =init_pseudo (fc,NSFS_MAGIC );if (!ctx)return -ENOMEM ; + fc->s_iflags |=SB_I_NOEXEC |SB_I_NODEV ; ctx->s_d_flags |=DCACHE_DONTCACHE ; ctx->ops = &nsfs_ops; ctx->eops = &nsfs_export_operations;
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 6/72 cgroup: add cgroup namespace to tree after owner is set
In reply to Christian BraunerOtherwise we trip VFS_WARN_ON_ONC() in __ns_tree_add_raw().
Fixes 7c6059398533 ("cgroup: support ns lookup")
Signed-off-by Christian Brauner <[email protected]>
--- kernel/cgroup/namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/cgroup/namespace.c +1 -1
@@ -30,7 +30,6 @@ static struct cgroup_namespace *alloc_cgroup_ns(void) ret =ns_common_init (new_ns);if (ret)return ERR_PTR (ret); -ns_tree_add (new_ns);return no_free_ptr (new_ns); }
@@ -86,6 +85,7 @@ struct cgroup_namespace *copy_cgroup_ns(u64 flags, new_ns->ucounts = ucounts; new_ns->root_cset = cset; +ns_tree_add (new_ns);return new_ns; }
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 7/72 nstree: simplify return
In reply to Christian Braunernode_to_ns() checks for NULL and the assert isn't really helpful and will have to be dropped later anyway.
Signed-off-by Christian Brauner <[email protected]>
--- kernel/nstree.c | 5 ----- 1 file changed, 5 deletions(-)
kernel/nstree.c +0 -5
@@ -194,11 +194,6 @@ struct ns_common *ns_tree_lookup_rcu(u64 ns_id, int ns_type)break ; }while (read_seqretry (&ns_tree->ns_tree_lock, seq)); -if (!node) -return NULL ; - -VFS_WARN_ON_ONCE (node_to_ns (node)->ns_type != ns_type); -return node_to_ns (node); }
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 8/72 ns: initialize ns_list_node for initial namespaces
In reply to Christian BraunerMake sure that the list is always initialized for initial namespaces.
Fixes 885fc8ac0a4d ("nstree: make iterator generic")
Signed-off-by Christian Brauner <[email protected]>
--- fs/namespace.c | 1 + init/version-timestamp.c | 1 + ipc/msgutil.c | 1 + kernel/cgroup/cgroup.c | 1 + kernel/pid.c | 1 + kernel/time/namespace.c | 1 + kernel/user.c | 1 + 7 files changed, 7 insertions(+)
fs/namespace.c +1 -0
@@ -5993,6 +5993,7 @@ struct mnt_namespace init_mnt_ns = { .passive = REFCOUNT_INIT(1), .mounts = RB_ROOT, .poll = __WAIT_QUEUE_HEAD_INITIALIZER(init_mnt_ns.poll), + .ns.ns_list_node = LIST_HEAD_INIT(init_mnt_ns.ns.ns_list_node), };static void __init init_mount_tree (void )
init/version-timestamp.c +1 -0
@@ -20,6 +20,7 @@ struct uts_namespace init_uts_ns = { }, .user_ns = &init_user_ns, .ns.inum = ns_init_inum(&init_uts_ns), + .ns.ns_list_node = LIST_HEAD_INIT(init_uts_ns.ns.ns_list_node),#ifdef CONFIG_UTS_NS .ns.ops = &utsns_operations,#endif
ipc/msgutil.c +1 -0
@@ -30,6 +30,7 @@ struct ipc_namespace init_ipc_ns = { .ns.__ns_ref = REFCOUNT_INIT(1), .user_ns = &init_user_ns, .ns.inum = ns_init_inum(&init_ipc_ns), + .ns.ns_list_node = LIST_HEAD_INIT(init_ipc_ns.ns.ns_list_node),#ifdef CONFIG_IPC_NS .ns.ops = &ipcns_operations,#endif
kernel/cgroup/cgroup.c +1 -0
@@ -256,6 +256,7 @@ struct cgroup_namespace init_cgroup_ns = { .ns.inum = ns_init_inum(&init_cgroup_ns), .root_cset = &init_css_set, .ns.ns_type = ns_common_type(&init_cgroup_ns), + .ns.ns_list_node = LIST_HEAD_INIT(init_cgroup_ns.ns.ns_list_node), };static struct file_system_type cgroup2_fs_type;
kernel/pid.c +1 -0
@@ -78,6 +78,7 @@ struct pid_namespace init_pid_ns = { .child_reaper = &init_task, .user_ns = &init_user_ns, .ns.inum = ns_init_inum(&init_pid_ns), + .ns.ns_list_node = LIST_HEAD_INIT(init_pid_ns.ns.ns_list_node),#ifdef CONFIG_PID_NS .ns.ops = &pidns_operations,#endif
kernel/time/namespace.c +1 -0
@@ -484,6 +484,7 @@ struct time_namespace init_time_ns = { .ns.inum = ns_init_inum(&init_time_ns), .ns.ops = &timens_operations, .frozen_offsets = true, + .ns.ns_list_node = LIST_HEAD_INIT(init_time_ns.ns.ns_list_node), };void __init time_ns_init (void )
kernel/user.c +1 -0
@@ -70,6 +70,7 @@ struct user_namespace init_user_ns = { .owner = GLOBAL_ROOT_UID, .group = GLOBAL_ROOT_GID, .ns.inum = ns_init_inum(&init_user_ns), + .ns.ns_list_node = LIST_HEAD_INIT(init_user_ns.ns.ns_list_node),#ifdef CONFIG_USER_NS .ns.ops = &userns_operations,#endif
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 9/72 ns: add __ns_ref_read()
In reply to Christian BraunerImplement ns_ref_read() the same way as ns_ref_{get,put}(). No point in making that any more special or different from the other helpers.
Signed-off-by Christian Brauner <[email protected]>
--- include/linux/ns_common.h | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
include/linux/ns_common.h +6 -1
@@ -143,7 +143,12 @@ static __always_inline __must_check bool __ns_ref_get(struct ns_common *ns)return refcount_inc_not_zero (&ns->__ns_ref); } -#define ns_ref_read (__ns) refcount_read(&to_ns_common((__ns))->__ns_ref) +static __always_inline __must_check int __ns_ref_read(const struct ns_common *ns) +{ +return refcount_read (&ns->__ns_ref); +} + +#define ns_ref_read (__ns) __ns_ref_read(to_ns_common((__ns)))#define ns_ref_inc (__ns) refcount_inc(&to_ns_common((__ns))->__ns_ref)#define ns_ref_get (__ns) __ns_ref_get(to_ns_common((__ns)))#define ns_ref_put (__ns) __ns_ref_put(to_ns_common((__ns)))
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 10/72 ns: rename to exit_nsproxy_namespaces()
In reply to Christian BraunerThe current naming is very misleading as this really isn't exiting all of the task's namespaces. It is only exiting the namespaces that hang of off nsproxy. Reflect that in the name.
Signed-off-by Christian Brauner <[email protected]>
--- include/linux/nsproxy.h | 2 +- kernel/cgroup/cgroup.c | 6 +++--- kernel/exit.c | 2 +- kernel/fork.c | 2 +- kernel/nsproxy.c | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-)
include/linux/nsproxy.h +1 -1
@@ -93,7 +93,7 @@ static inline struct cred *nsset_cred(struct nsset *set)*/ int copy_namespaces (u64 flags,struct task_struct *tsk); -void exit_task_namespaces (struct task_struct *tsk); +void exit_nsproxy_namespaces (struct task_struct *tsk);void switch_task_namespaces (struct task_struct *tsk,struct nsproxy *new);int exec_task_namespaces (void );void free_nsproxy (struct nsproxy *ns);
kernel/cgroup/cgroup.c +3 -3
@@ -1523,9 +1523,9 @@ static struct cgroup *current_cgns_cgroup_dfl(void) }else {/* * NOTE: This function may be called from bpf_cgroup_from_id() -* on a task which has already passed exit_task_namespaces() and -* nsproxy == NULL. Fall back to cgrp_dfl_root which will make all -* cgroups visible for lookups. +* on a task which has already passed exit_nsproxy_namespaces() +* and nsproxy == NULL. Fall back to cgrp_dfl_root which will +* make all cgroups visible for lookups. */ return &cgrp_dfl_root.cgrp; }
kernel/exit.c +1 -1
@@ -962,7 +962,7 @@ void __noreturn do_exit(long code)exit_fs (tsk);if (group_dead)disassociate_ctty (1 ); -exit_task_namespaces (tsk); +exit_nsproxy_namespaces (tsk);exit_task_work (tsk);exit_thread (tsk);
kernel/fork.c +1 -1
@@ -2453,7 +2453,7 @@ __latent_entropy struct task_struct *copy_process(if (p->io_context)exit_io_context (p); bad_fork_cleanup_namespaces: -exit_task_namespaces (p); +exit_nsproxy_namespaces (p); bad_fork_cleanup_mm:if (p->mm) {mm_clear_owner (p->mm, p);
kernel/nsproxy.c +1 -1
@@ -241,7 +241,7 @@ void switch_task_namespaces(struct task_struct *p, struct nsproxy *new)put_nsproxy (ns); } -void exit_task_namespaces (struct task_struct *p) +void exit_nsproxy_namespaces (struct task_struct *p) {switch_task_namespaces (p,NULL ); }
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 11/72 ns: add active reference count
In reply to Christian BraunerThe namespace tree is, among other things, currently used to support file handles for namespaces. When a namespace is created it is placed on the namespace trees and when it is destroyed it is removed from the namespace trees.
While a namespace is on the namespace trees with a valid reference count it is possible to reopen it through a namespace file handle. This is all fine but has some issues that should be addressed.
On current kernels a namespace is visible to userspace in the following cases:
(1) The namespace is in use by a task.
(2) The namespace is persisted through a VFS object (namespace file descriptor or bind-mount).
Note that (2) only cares about direct persistence of the namespace itself not indirectly via e.g., file->f_cred file references or similar.
(3) The namespace is a hierarchical namespace type and is the parent of a single or multiple child namespaces.
Case (3) is interesting because it is possible that a parent namespace might not fulfill any of (1) or (2), i.e., is invisible to userspace but it may still be resurrected through the NS_GET_PARENT ioctl().
Currently namespace file handles allow much broader access to namespaces than what is currently possible via (1)-(3). The reason is that namespaces may remain pinned for completely internal reasons yet are inaccessible to userspace.
For example, a user namespace my remain pinned by get_cred() calls to stash the opener's credentials into file->f_cred. As it stands file handles allow to resurrect such a users namespace even though this should not be possible via (1)-(3). This is a fundamental uapi change that we shouldn't do if we don't have to.
Consider the following insane case: Various architectures support the CONFIG_MMU_LAZY_TLB_REFCOUNT option which uses lazy TLB destruction. When this option is set a userspace task's struct mm_struct may be used for kernel threads such as the idle task and will only be destroyed once the cpu's runqueue switches back to another task. But because of ptrace() permission checks struct mm_struct stashes the user namespace of the task that struct mm_struct originally belonged to. The kernel thread will take a reference on the struct mm_struct and thus pin it.
So on an idle system user namespaces can be persisted for arbitrary amounts of time which also means that they can be resurrected using namespace file handles. That makes no sense whatsoever. The problem is of course excarabted on large systems with a huge number of cpus.
To handle this nicely we introduce an active reference count which tracks (1)-(3). This is easy to do as all of these things are already managed centrally. Only (1)-(3) will count towards the active reference count and only namespaces which are active may be opened via namespace file handles.
The problem is that namespaces may be resurrected. Which means that they can become temporarily inactive and will be reactived some time later. Currently the only example of this is the SIOGCSKNS socket ioctl. The SIOCGSKNS ioctl allows to open a network namespace file descriptor based on a socket file descriptor.
If a socket is tied to a network namespace that subsequently becomes inactive but that socket is persisted by another process in another network namespace (e.g., via SCM_RIGHTS of pidfd_getfd()) then the SIOCGSKNS ioctl will resurrect this network namespace.
So calls to open_related_ns() and open_namespace() will end up resurrecting the corresponding namespace tree.
Note that the active reference count does not regulate the lifetime of the namespace itself. This is still done by the normal reference count. The active reference count can only be elevated if the regular reference count is elevated.
The active reference count also doesn't regulate the presence of a namespace on the namespace trees. It only regulates its visiblity to namespace file handles (and in later patches to listns()).
A namespace remains on the namespace trees from creation until its actual destruction. This will allow the kernel to always reach any namespace trivially and it will also enable subsystems like bpf to walk the namespace lists on the system for tracing or general introspection purposes.
Note that different namespaces have different visibility lifetimes on current kernels. While most namespace are immediately released when the last task using them exits, the user- and pid namespace are persisted and thus both remain accessible via /proc/<pid>/ns/<ns_type>.
The user namespace lifetime is aliged with struct cred and is only released through exit_creds(). However, it becomes inaccessible to userspace once the last task using it is reaped, i.e., when release_task() is called and all proc entries are flushed. Similarly, the pid namespace is also visible until the last task using it has been reaped and the associated pid numbers are freed.
The active reference counts of the user- and pid namespace are decremented once the task is reaped.
Signed-off-by Christian Brauner <[email protected]>
--- fs/namespace.c | 1 + fs/nsfs.c | 48 ++++++++++- include/linux/ns_common.h | 140 +++++++++++++++++++++++++++++- include/linux/nsfs.h | 3 + include/linux/nsproxy.h | 3 + init/version-timestamp.c | 1 + ipc/msgutil.c | 1 + kernel/cgroup/cgroup.c | 1 + kernel/cred.c | 6 ++ kernel/exit.c | 1 + kernel/fork.c | 1 + kernel/nscommon.c | 214 +++++++++++++++++++++++++++++++++++++++++++++- kernel/nsproxy.c | 23 +++++ kernel/nstree.c | 8 ++ kernel/pid.c | 6 ++ kernel/time/namespace.c | 1 + kernel/user.c | 1 + 17 files changed, 455 insertions(+), 4 deletions(-)
fs/namespace.c +1 -0
@@ -5989,6 +5989,7 @@ struct mnt_namespace init_mnt_ns = { .ns.ops = &mntns_operations, .user_ns = &init_user_ns, .ns.__ns_ref = REFCOUNT_INIT(1), + .ns.__ns_ref_active = ATOMIC_INIT(1), .ns.ns_type = ns_common_type(&init_mnt_ns), .passive = REFCOUNT_INIT(1), .mounts = RB_ROOT,
fs/nsfs.c +47 -1
69 lines not on this page · raw message
include/linux/ns_common.h +138 -2
181 lines not on this page · raw message
include/linux/nsfs.h +3 -0
@@ -37,4 +37,7 @@ void nsfs_init(void);#define current_in_namespace (__ns) (__current_namespace_from_type(__ns) == __ns) +void nsproxy_ns_active_get (struct nsproxy *ns); +void nsproxy_ns_active_put (struct nsproxy *ns); +#endif /* _LINUX_NSFS_H */
include/linux/nsproxy.h +3 -0
@@ -93,7 +93,10 @@ static inline struct cred *nsset_cred(struct nsset *set)*/ int copy_namespaces (u64 flags,struct task_struct *tsk); +void switch_cred_namespaces (const struct cred *old,const struct cred *new);void exit_nsproxy_namespaces (struct task_struct *tsk); +void get_cred_namespaces (struct task_struct *tsk); +void exit_cred_namespaces (struct task_struct *tsk);void switch_task_namespaces (struct task_struct *tsk,struct nsproxy *new);int exec_task_namespaces (void );void free_nsproxy (struct nsproxy *ns);
init/version-timestamp.c +1 -0
@@ -10,6 +10,7 @@struct uts_namespace init_uts_ns = { .ns.ns_type =ns_common_type (&init_uts_ns), .ns.__ns_ref =REFCOUNT_INIT (2 ), + .ns.__ns_ref_active =ATOMIC_INIT (1 ), .name = { .sysname =UTS_SYSNAME , .nodename =UTS_NODENAME ,
ipc/msgutil.c +1 -0
@@ -28,6 +28,7 @@ DEFINE_SPINLOCK(mq_lock);*/ struct ipc_namespace init_ipc_ns = { .ns.__ns_ref =REFCOUNT_INIT (1 ), + .ns.__ns_ref_active =ATOMIC_INIT (1 ), .user_ns = &init_user_ns, .ns.inum =ns_init_inum (&init_ipc_ns), .ns.ns_list_node =LIST_HEAD_INIT (init_ipc_ns.ns.ns_list_node),
kernel/cgroup/cgroup.c +1 -0
@@ -251,6 +251,7 @@ bool cgroup_enable_per_threadgroup_rwsem __read_mostly;/* cgroup namespace for init task */ struct cgroup_namespace init_cgroup_ns = { .ns.__ns_ref =REFCOUNT_INIT (2 ), + .ns.__ns_ref_active =ATOMIC_INIT (1 ), .user_ns = &init_user_ns, .ns.ops = &cgroupns_operations, .ns.inum =ns_init_inum (&init_cgroup_ns),
kernel/cred.c +6 -0
@@ -306,6 +306,7 @@ int copy_creds(struct task_struct *p, u64 clone_flags)kdebug ("share_creds(%p{%ld})" , p->cred,atomic_long_read (&p->cred->usage));inc_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 ); +get_cred_namespaces (p);return 0 ; }
@@ -343,6 +344,8 @@ int copy_creds(struct task_struct *p, u64 clone_flags) p->cred = p->real_cred =get_cred (new);inc_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 ); +get_cred_namespaces (p); +return 0 ; error_put:
@@ -435,10 +438,13 @@ int commit_creds(struct cred *new)*/ if (new->user != old->user || new->user_ns != old->user_ns)inc_rlimit_ucounts (new->ucounts,UCOUNT_RLIMIT_NPROC ,1 ); +rcu_assign_pointer (task->real_cred, new);rcu_assign_pointer (task->cred, new);if (new->user != old->user || new->user_ns != old->user_ns)dec_rlimit_ucounts (old->ucounts,UCOUNT_RLIMIT_NPROC ,1 ); +if (new->user_ns != old->user_ns) +switch_cred_namespaces (old, new);/* send notifications */ if (!uid_eq(new->uid, old->uid) ||
kernel/exit.c +1 -0
@@ -291,6 +291,7 @@ void release_task(struct task_struct *p)write_unlock_irq (&tasklist_lock);/* @thread_pid can't go away until free_pids() below */ proc_flush_pid (thread_pid); +exit_cred_namespaces (p);add_device_randomness (&p->se.sum_exec_runtime,sizeof (p->se.sum_exec_runtime));free_pids (post.pids);
kernel/fork.c +1 -0
@@ -2487,6 +2487,7 @@ __latent_entropy struct task_struct *copy_process(delayacct_tsk_free (p); bad_fork_cleanup_count:dec_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 ); +exit_cred_namespaces (p);exit_creds (p); bad_fork_free:WRITE_ONCE (p->__state,TASK_DEAD );
kernel/nscommon.c +213 -1
235 lines not on this page · raw message
kernel/nsproxy.c +23 -0
@@ -26,6 +26,7 @@#include <linux/syscalls.h> #include <linux/cgroup.h> #include <linux/perf_event.h> +#include <linux/nstree.h> static struct kmem_cache *nsproxy_cachep;
@@ -179,12 +180,15 @@ int copy_namespaces(u64 flags, struct task_struct *tsk)if ((flags &CLONE_VM ) ==0 )timens_on_fork (new_ns, tsk); +nsproxy_ns_active_get (new_ns); tsk->nsproxy = new_ns;return 0 ; }void free_nsproxy (struct nsproxy *ns) { +nsproxy_ns_active_put (ns); +put_mnt_ns (ns->mnt_ns);put_uts_ns (ns->uts_ns);put_ipc_ns (ns->ipc_ns);
@@ -232,6 +236,9 @@ void switch_task_namespaces(struct task_struct *p, struct nsproxy *new)might_sleep (); +if (new) +nsproxy_ns_active_get (new); +task_lock (p); ns = p->nsproxy; p->nsproxy = new;
@@ -246,6 +253,22 @@ void exit_nsproxy_namespaces(struct task_struct *p)switch_task_namespaces (p,NULL ); } +void switch_cred_namespaces (const struct cred *old,const struct cred *new) +{ +ns_ref_active_get (new->user_ns); +ns_ref_active_put (old->user_ns); +} + +void get_cred_namespaces (struct task_struct *tsk) +{ +ns_ref_active_get (tsk->real_cred->user_ns); +} + +void exit_cred_namespaces (struct task_struct *tsk) +{ +ns_ref_active_put (tsk->real_cred->user_ns); +} +int exec_task_namespaces (void ) {struct task_struct *tsk = current;
kernel/nstree.c +8 -0
@@ -122,6 +122,14 @@ void __ns_tree_add_raw(struct ns_common *ns, struct ns_tree *ns_tree)write_sequnlock (&ns_tree->ns_tree_lock);VFS_WARN_ON_ONCE (node); + +/* +* Take an active reference on the owner namespace. This ensures +* that the owner remains visible while any of its child namespaces +* are active. For init namespaces this is a no-op as ns_owner() +* returns NULL for namespaces owned by init_user_ns. +*/ +__ns_ref_active_get_owner (ns); }void __ns_tree_remove (struct ns_common *ns,struct ns_tree *ns_tree)
kernel/pid.c +6 -0
@@ -72,6 +72,7 @@ static int pid_max_max = PID_MAX_LIMIT;*/ struct pid_namespace init_pid_ns = { .ns.__ns_ref =REFCOUNT_INIT (2 ), + .ns.__ns_ref_active =ATOMIC_INIT (1 ), .idr =IDR_INIT (init_pid_ns.idr), .pid_allocated =PIDNS_ADDING , .level =0 ,
@@ -118,9 +119,13 @@ static void delayed_put_pid(struct rcu_head *rhp)void free_pid (struct pid *pid) {int i; +struct pid_namespace *active_ns;lockdep_assert_not_held (&tasklist_lock); + active_ns = pid->numbers[pid->level].ns; +ns_ref_active_put (active_ns); +spin_lock (&pidmap_lock);for (i =0 ; i <= pid->level; i++) {struct upid *upid = pid->numbers + i;
@@ -284,6 +289,7 @@ struct pid *alloc_pid(struct pid_namespace *ns, pid_t *set_tid, }spin_unlock (&pidmap_lock);idr_preload_end (); +ns_ref_active_get (ns);return pid;
kernel/time/namespace.c +1 -0
@@ -480,6 +480,7 @@ const struct proc_ns_operations timens_for_children_operations = {struct time_namespace init_time_ns = { .ns.ns_type =ns_common_type (&init_time_ns), .ns.__ns_ref =REFCOUNT_INIT (3 ), + .ns.__ns_ref_active =ATOMIC_INIT (1 ), .user_ns = &init_user_ns, .ns.inum =ns_init_inum (&init_time_ns), .ns.ops = &timens_operations,
kernel/user.c +1 -0
@@ -67,6 +67,7 @@ struct user_namespace init_user_ns = { }, .ns.ns_type = ns_common_type(&init_user_ns), .ns.__ns_ref = REFCOUNT_INIT(3), + .ns.__ns_ref_active = ATOMIC_INIT(1), .owner = GLOBAL_ROOT_UID, .group = GLOBAL_ROOT_GID, .ns.inum = ns_init_inum(&init_user_ns),
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 12/72 ns: use anonymous struct to group list member
In reply to Christian BraunerMake it easier to spot that they belong together conceptually.
Signed-off-by Christian Brauner <[email protected]>
--- include/linux/ns_common.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
include/linux/ns_common.h +4 -2
@@ -109,8 +109,10 @@ struct ns_common {union {struct {u64 ns_id; -struct rb_node ns_tree_node; -struct list_head ns_list_node; +struct /* per type rbtree and list */ { +struct rb_node ns_tree_node; +struct list_head ns_list_node; + };atomic_t __ns_ref_active;/* do not use directly */ };struct rcu_head ns_rcu;
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 13/72 nstree: introduce a unified tree
In reply to Christian BraunerThis will allow userspace to lookup and stat a namespace simply by its identifier without having to know what type of namespace it is.
Signed-off-by Christian Brauner <[email protected]>
--- include/linux/ns_common.h | 4 ++ kernel/nscommon.c | 1 + kernel/nstree.c | 114 ++++++++++++++++++++++++++++++++++++---------- 3 files changed, 95 insertions(+), 24 deletions(-)
include/linux/ns_common.h +4 -0
@@ -109,6 +109,10 @@ struct ns_common { union { struct { u64 ns_id; + struct /* global namespace rbtree and list */ { + struct rb_node ns_unified_tree_node; + struct list_head ns_unified_list_node; + }; struct /* per type rbtree and list */ { struct rb_node ns_tree_node; struct list_head ns_list_node;
kernel/nscommon.c +1 -0
@@ -61,6 +61,7 @@ int __ns_common_init(struct ns_common *ns, u32 ns_type, const struct proc_ns_ope ns->ns_id =0 ; ns->ns_type = ns_type;RB_CLEAR_NODE (&ns->ns_tree_node); +RB_CLEAR_NODE (&ns->ns_unified_tree_node);INIT_LIST_HEAD (&ns->ns_list_node);#ifdef CONFIG_DEBUG_VFS
kernel/nstree.c +90 -24
238 lines not on this page · raw message
Signature · 1 line
2.47.3
kernel test robot
build botRe: [PATCH v4 13/72] nstree: introduce a unified tree
kernel test robot noticed the following build errors:
Hi Christian,
kernel test robot noticed the following build errors:
[auto build test ERROR on 3a8660878839faadb4f1a6dd72c3179c1df56787]
url: https://github.com/intel-lab-lkp/linux/commits/Christian-Brauner/libfs-allow-to-specify-s_d_flags/20251029-205841 base: 3a8660878839faadb4f1a6dd72c3179c1df56787 patch link: https://lore.kernel.org/r/20251029-work-namespace-nstree-listns-v4-13-2e6f823ebdc0%40kernel.org patch subject: [PATCH v4 13/72] nstree: introduce a unified tree config: loongarch-allnoconfig (https://download.01.org/0day-ci/archive/20251029/[email protected]/config) compiler: clang version 22.0.0git (https://github.com/llvm/llvm-project d1c086e82af239b245fe8d7832f2753436634990) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20251029/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
>> kernel/nstree.c:170:43: error: no member named 'type' in 'struct ns_tree'
170 | VFS_WARN_ON_ONCE(ns->ns_type != ns_tree->type);
| ~~~~~~~ ^
kernel/nstree.c:297:93: error: no member named 'type' in 'struct ns_tree'
297 | VFS_WARN_ON_ONCE(list_entry_rcu(list, struct ns_common, ns_list_node)->ns_type != ns_tree->type);
| ~~~~~~~ ^
2 errors generated.
vim +170 kernel/nstree.c
885fc8ac0a4dc70 Christian Brauner 2025-09-12 165
885fc8ac0a4dc70 Christian Brauner 2025-09-12 166 void __ns_tree_remove(struct ns_common *ns, struct ns_tree *ns_tree)
885fc8ac0a4dc70 Christian Brauner 2025-09-12 167 {
885fc8ac0a4dc70 Christian Brauner 2025-09-12 168 VFS_WARN_ON_ONCE(RB_EMPTY_NODE(&ns->ns_tree_node));
885fc8ac0a4dc70 Christian Brauner 2025-09-12 169 VFS_WARN_ON_ONCE(list_empty(&ns->ns_list_node));
4055526d35746ce Christian Brauner 2025-09-24 @170 VFS_WARN_ON_ONCE(ns->ns_type != ns_tree->type);
885fc8ac0a4dc70 Christian Brauner 2025-09-12 171
01da9c6ec4269ba Christian Brauner 2025-10-29 172 write_seqlock(&ns_tree_lock);
885fc8ac0a4dc70 Christian Brauner 2025-09-12 173 rb_erase(&ns->ns_tree_node, &ns_tree->ns_tree);
01da9c6ec4269ba Christian Brauner 2025-10-29 174 rb_erase(&ns->ns_unified_tree_node, &ns_unified_tree);
885fc8ac0a4dc70 Christian Brauner 2025-09-12 175 list_bidir_del_rcu(&ns->ns_list_node);
885fc8ac0a4dc70 Christian Brauner 2025-09-12 176 RB_CLEAR_NODE(&ns->ns_tree_node);
01da9c6ec4269ba Christian Brauner 2025-10-29 177 write_sequnlock(&ns_tree_lock);
885fc8ac0a4dc70 Christian Brauner 2025-09-12 178 }
885fc8ac0a4dc70 Christian Brauner 2025-09-12 179 EXPORT_SYMBOL_GPL(__ns_tree_remove);
885fc8ac0a4dc70 Christian Brauner 2025-09-12 180 Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
kernel test robot
build botRe: [PATCH v4 13/72] nstree: introduce a unified tree
In reply to Christian Braunerkernel test robot noticed the following build errors:
Hi Christian,
kernel test robot noticed the following build errors:
[auto build test ERROR on 3a8660878839faadb4f1a6dd72c3179c1df56787]
url: https://github.com/intel-lab-lkp/linux/commits/Christian-Brauner/libfs-allow-to-specify-s_d_flags/20251029-205841 base: 3a8660878839faadb4f1a6dd72c3179c1df56787 patch link: https://lore.kernel.org/r/20251029-work-namespace-nstree-listns-v4-13-2e6f823ebdc0%40kernel.org patch subject: [PATCH v4 13/72] nstree: introduce a unified tree config: m68k-allnoconfig (https://download.01.org/0day-ci/archive/20251029/[email protected]/config) compiler: m68k-linux-gcc (GCC) 15.1.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20251029/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
In file included from include/linux/init.h:5,
from include/linux/printk.h:6,
from include/asm-generic/bug.h:22,
from arch/m68k/include/asm/bug.h:32,
from include/linux/bug.h:5,
from include/linux/thread_info.h:13,
from include/asm-generic/preempt.h:5,
from ./arch/m68k/include/generated/asm/preempt.h:1,
from include/linux/preempt.h:79,
from arch/m68k/include/asm/irqflags.h:6,
from include/linux/irqflags.h:18,
from arch/m68k/include/asm/atomic.h:6,
from include/linux/atomic.h:7,
from include/linux/refcount.h:104,
from include/linux/ns_common.h:5,
from include/linux/nstree.h:5,
from kernel/nstree.c:3:
kernel/nstree.c: In function '__ns_tree_remove':
>> kernel/nstree.c:170:48: error: 'struct ns_tree' has no member named 'type'
170 | VFS_WARN_ON_ONCE(ns->ns_type != ns_tree->type);
| ^~
include/linux/build_bug.h:30:63: note: in definition of macro 'BUILD_BUG_ON_INVALID'
30 | #define BUILD_BUG_ON_INVALID(e) ((void)(sizeof((__force long)(e))))
| ^
kernel/nstree.c:170:9: note: in expansion of macro 'VFS_WARN_ON_ONCE'
170 | VFS_WARN_ON_ONCE(ns->ns_type != ns_tree->type);
| ^~~~~~~~~~~~~~~~
kernel/nstree.c: In function '__ns_tree_adjoined_rcu':
kernel/nstree.c:297:98: error: 'struct ns_tree' has no member named 'type'
297 | VFS_WARN_ON_ONCE(list_entry_rcu(list, struct ns_common, ns_list_node)->ns_type != ns_tree->type);
| ^~
include/linux/build_bug.h:30:63: note: in definition of macro 'BUILD_BUG_ON_INVALID'
30 | #define BUILD_BUG_ON_INVALID(e) ((void)(sizeof((__force long)(e))))
| ^
kernel/nstree.c:297:9: note: in expansion of macro 'VFS_WARN_ON_ONCE'
297 | VFS_WARN_ON_ONCE(list_entry_rcu(list, struct ns_common, ns_list_node)->ns_type != ns_tree->type);
| ^~~~~~~~~~~~~~~~vim +170 kernel/nstree.c
885fc8ac0a4dc7 Christian Brauner 2025-09-12 2
885fc8ac0a4dc7 Christian Brauner 2025-09-12 @3 #include <linux/nstree.h>
885fc8ac0a4dc7 Christian Brauner 2025-09-12 4 #include <linux/proc_ns.h>
885fc8ac0a4dc7 Christian Brauner 2025-09-12 5 #include <linux/vfsdebug.h>
885fc8ac0a4dc7 Christian Brauner 2025-09-12 6
01da9c6ec4269b Christian Brauner 2025-10-29 7 __cacheline_aligned_in_smp DEFINE_SEQLOCK(ns_tree_lock);
01da9c6ec4269b Christian Brauner 2025-10-29 8 static struct rb_root ns_unified_tree = RB_ROOT; /* protected by ns_tree_lock */
01da9c6ec4269b Christian Brauner 2025-10-29 9
10cdfcd37ade7c Christian Brauner 2025-09-24 10 /**
10cdfcd37ade7c Christian Brauner 2025-09-24 11 * struct ns_tree - Namespace tree
10cdfcd37ade7c Christian Brauner 2025-09-24 12 * @ns_tree: Rbtree of namespaces of a particular type
10cdfcd37ade7c Christian Brauner 2025-09-24 13 * @ns_list: Sequentially walkable list of all namespaces of this type
10cdfcd37ade7c Christian Brauner 2025-09-24 14 * @type: type of namespaces in this tree
10cdfcd37ade7c Christian Brauner 2025-09-24 15 */
10cdfcd37ade7c Christian Brauner 2025-09-24 16 struct ns_tree {
10cdfcd37ade7c Christian Brauner 2025-09-24 17 struct rb_root ns_tree;
10cdfcd37ade7c Christian Brauner 2025-09-24 18 struct list_head ns_list;
01da9c6ec4269b Christian Brauner 2025-10-29 19 #ifdef CONFIG_DEBUG_VFS
10cdfcd37ade7c Christian Brauner 2025-09-24 20 int type;
01da9c6ec4269b Christian Brauner 2025-10-29 21 #endif
10cdfcd37ade7c Christian Brauner 2025-09-24 22 };
10cdfcd37ade7c Christian Brauner 2025-09-24 23
885fc8ac0a4dc7 Christian Brauner 2025-09-12 24 struct ns_tree mnt_ns_tree = {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 25 .ns_tree = RB_ROOT,
885fc8ac0a4dc7 Christian Brauner 2025-09-12 26 .ns_list = LIST_HEAD_INIT(mnt_ns_tree.ns_list),
01da9c6ec4269b Christian Brauner 2025-10-29 27 #ifdef CONFIG_DEBUG_VFS
885fc8ac0a4dc7 Christian Brauner 2025-09-12 28 .type = CLONE_NEWNS,
01da9c6ec4269b Christian Brauner 2025-10-29 29 #endif
885fc8ac0a4dc7 Christian Brauner 2025-09-12 30 };
885fc8ac0a4dc7 Christian Brauner 2025-09-12 31
885fc8ac0a4dc7 Christian Brauner 2025-09-12 32 struct ns_tree net_ns_tree = {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 33 .ns_tree = RB_ROOT,
885fc8ac0a4dc7 Christian Brauner 2025-09-12 34 .ns_list = LIST_HEAD_INIT(net_ns_tree.ns_list),
01da9c6ec4269b Christian Brauner 2025-10-29 35 #ifdef CONFIG_DEBUG_VFS
885fc8ac0a4dc7 Christian Brauner 2025-09-12 36 .type = CLONE_NEWNET,
01da9c6ec4269b Christian Brauner 2025-10-29 37 #endif
885fc8ac0a4dc7 Christian Brauner 2025-09-12 38 };
885fc8ac0a4dc7 Christian Brauner 2025-09-12 39 EXPORT_SYMBOL_GPL(net_ns_tree);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 40
885fc8ac0a4dc7 Christian Brauner 2025-09-12 41 struct ns_tree uts_ns_tree = {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 42 .ns_tree = RB_ROOT,
885fc8ac0a4dc7 Christian Brauner 2025-09-12 43 .ns_list = LIST_HEAD_INIT(uts_ns_tree.ns_list),
01da9c6ec4269b Christian Brauner 2025-10-29 44 #ifdef CONFIG_DEBUG_VFS
885fc8ac0a4dc7 Christian Brauner 2025-09-12 45 .type = CLONE_NEWUTS,
01da9c6ec4269b Christian Brauner 2025-10-29 46 #endif
885fc8ac0a4dc7 Christian Brauner 2025-09-12 47 };
885fc8ac0a4dc7 Christian Brauner 2025-09-12 48
885fc8ac0a4dc7 Christian Brauner 2025-09-12 49 struct ns_tree user_ns_tree = {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 50 .ns_tree = RB_ROOT,
885fc8ac0a4dc7 Christian Brauner 2025-09-12 51 .ns_list = LIST_HEAD_INIT(user_ns_tree.ns_list),
01da9c6ec4269b Christian Brauner 2025-10-29 52 #ifdef CONFIG_DEBUG_VFS
885fc8ac0a4dc7 Christian Brauner 2025-09-12 53 .type = CLONE_NEWUSER,
01da9c6ec4269b Christian Brauner 2025-10-29 54 #endif
885fc8ac0a4dc7 Christian Brauner 2025-09-12 55 };
885fc8ac0a4dc7 Christian Brauner 2025-09-12 56
885fc8ac0a4dc7 Christian Brauner 2025-09-12 57 struct ns_tree ipc_ns_tree = {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 58 .ns_tree = RB_ROOT,
885fc8ac0a4dc7 Christian Brauner 2025-09-12 59 .ns_list = LIST_HEAD_INIT(ipc_ns_tree.ns_list),
01da9c6ec4269b Christian Brauner 2025-10-29 60 #ifdef CONFIG_DEBUG_VFS
885fc8ac0a4dc7 Christian Brauner 2025-09-12 61 .type = CLONE_NEWIPC,
01da9c6ec4269b Christian Brauner 2025-10-29 62 #endif
885fc8ac0a4dc7 Christian Brauner 2025-09-12 63 };
885fc8ac0a4dc7 Christian Brauner 2025-09-12 64
885fc8ac0a4dc7 Christian Brauner 2025-09-12 65 struct ns_tree pid_ns_tree = {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 66 .ns_tree = RB_ROOT,
885fc8ac0a4dc7 Christian Brauner 2025-09-12 67 .ns_list = LIST_HEAD_INIT(pid_ns_tree.ns_list),
01da9c6ec4269b Christian Brauner 2025-10-29 68 #ifdef CONFIG_DEBUG_VFS
885fc8ac0a4dc7 Christian Brauner 2025-09-12 69 .type = CLONE_NEWPID,
01da9c6ec4269b Christian Brauner 2025-10-29 70 #endif
885fc8ac0a4dc7 Christian Brauner 2025-09-12 71 };
885fc8ac0a4dc7 Christian Brauner 2025-09-12 72
885fc8ac0a4dc7 Christian Brauner 2025-09-12 73 struct ns_tree cgroup_ns_tree = {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 74 .ns_tree = RB_ROOT,
885fc8ac0a4dc7 Christian Brauner 2025-09-12 75 .ns_list = LIST_HEAD_INIT(cgroup_ns_tree.ns_list),
01da9c6ec4269b Christian Brauner 2025-10-29 76 #ifdef CONFIG_DEBUG_VFS
885fc8ac0a4dc7 Christian Brauner 2025-09-12 77 .type = CLONE_NEWCGROUP,
01da9c6ec4269b Christian Brauner 2025-10-29 78 #endif
885fc8ac0a4dc7 Christian Brauner 2025-09-12 79 };
885fc8ac0a4dc7 Christian Brauner 2025-09-12 80
885fc8ac0a4dc7 Christian Brauner 2025-09-12 81 struct ns_tree time_ns_tree = {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 82 .ns_tree = RB_ROOT,
885fc8ac0a4dc7 Christian Brauner 2025-09-12 83 .ns_list = LIST_HEAD_INIT(time_ns_tree.ns_list),
01da9c6ec4269b Christian Brauner 2025-10-29 84 #ifdef CONFIG_DEBUG_VFS
885fc8ac0a4dc7 Christian Brauner 2025-09-12 85 .type = CLONE_NEWTIME,
01da9c6ec4269b Christian Brauner 2025-10-29 86 #endif
885fc8ac0a4dc7 Christian Brauner 2025-09-12 87 };
885fc8ac0a4dc7 Christian Brauner 2025-09-12 88
885fc8ac0a4dc7 Christian Brauner 2025-09-12 89 DEFINE_COOKIE(namespace_cookie);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 90
885fc8ac0a4dc7 Christian Brauner 2025-09-12 91 static inline struct ns_common *node_to_ns(const struct rb_node *node)
885fc8ac0a4dc7 Christian Brauner 2025-09-12 92 {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 93 if (!node)
885fc8ac0a4dc7 Christian Brauner 2025-09-12 94 return NULL;
885fc8ac0a4dc7 Christian Brauner 2025-09-12 95 return rb_entry(node, struct ns_common, ns_tree_node);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 96 }
885fc8ac0a4dc7 Christian Brauner 2025-09-12 97
01da9c6ec4269b Christian Brauner 2025-10-29 98 static inline struct ns_common *node_to_ns_unified(const struct rb_node *node)
01da9c6ec4269b Christian Brauner 2025-10-29 99 {
01da9c6ec4269b Christian Brauner 2025-10-29 100 if (!node)
01da9c6ec4269b Christian Brauner 2025-10-29 101 return NULL;
01da9c6ec4269b Christian Brauner 2025-10-29 102 return rb_entry(node, struct ns_common, ns_unified_tree_node);
01da9c6ec4269b Christian Brauner 2025-10-29 103 }
01da9c6ec4269b Christian Brauner 2025-10-29 104
885fc8ac0a4dc7 Christian Brauner 2025-09-12 105 static inline int ns_cmp(struct rb_node *a, const struct rb_node *b)
885fc8ac0a4dc7 Christian Brauner 2025-09-12 106 {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 107 struct ns_common *ns_a = node_to_ns(a);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 108 struct ns_common *ns_b = node_to_ns(b);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 109 u64 ns_id_a = ns_a->ns_id;
885fc8ac0a4dc7 Christian Brauner 2025-09-12 110 u64 ns_id_b = ns_b->ns_id;
885fc8ac0a4dc7 Christian Brauner 2025-09-12 111
885fc8ac0a4dc7 Christian Brauner 2025-09-12 112 if (ns_id_a < ns_id_b)
885fc8ac0a4dc7 Christian Brauner 2025-09-12 113 return -1;
885fc8ac0a4dc7 Christian Brauner 2025-09-12 114 if (ns_id_a > ns_id_b)
885fc8ac0a4dc7 Christian Brauner 2025-09-12 115 return 1;
885fc8ac0a4dc7 Christian Brauner 2025-09-12 116 return 0;
885fc8ac0a4dc7 Christian Brauner 2025-09-12 117 }
885fc8ac0a4dc7 Christian Brauner 2025-09-12 118
01da9c6ec4269b Christian Brauner 2025-10-29 119 static inline int ns_cmp_unified(struct rb_node *a, const struct rb_node *b)
01da9c6ec4269b Christian Brauner 2025-10-29 120 {
01da9c6ec4269b Christian Brauner 2025-10-29 121 struct ns_common *ns_a = node_to_ns_unified(a);
01da9c6ec4269b Christian Brauner 2025-10-29 122 struct ns_common *ns_b = node_to_ns_unified(b);
01da9c6ec4269b Christian Brauner 2025-10-29 123 u64 ns_id_a = ns_a->ns_id;
01da9c6ec4269b Christian Brauner 2025-10-29 124 u64 ns_id_b = ns_b->ns_id;
01da9c6ec4269b Christian Brauner 2025-10-29 125
01da9c6ec4269b Christian Brauner 2025-10-29 126 if (ns_id_a < ns_id_b)
01da9c6ec4269b Christian Brauner 2025-10-29 127 return -1;
01da9c6ec4269b Christian Brauner 2025-10-29 128 if (ns_id_a > ns_id_b)
01da9c6ec4269b Christian Brauner 2025-10-29 129 return 1;
01da9c6ec4269b Christian Brauner 2025-10-29 130 return 0;
01da9c6ec4269b Christian Brauner 2025-10-29 131 }
01da9c6ec4269b Christian Brauner 2025-10-29 132
885fc8ac0a4dc7 Christian Brauner 2025-09-12 133 void __ns_tree_add_raw(struct ns_common *ns, struct ns_tree *ns_tree)
885fc8ac0a4dc7 Christian Brauner 2025-09-12 134 {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 135 struct rb_node *node, *prev;
885fc8ac0a4dc7 Christian Brauner 2025-09-12 136
885fc8ac0a4dc7 Christian Brauner 2025-09-12 137 VFS_WARN_ON_ONCE(!ns->ns_id);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 138
01da9c6ec4269b Christian Brauner 2025-10-29 139 write_seqlock(&ns_tree_lock);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 140
885fc8ac0a4dc7 Christian Brauner 2025-09-12 141 node = rb_find_add_rcu(&ns->ns_tree_node, &ns_tree->ns_tree, ns_cmp);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 142 /*
885fc8ac0a4dc7 Christian Brauner 2025-09-12 143 * If there's no previous entry simply add it after the
885fc8ac0a4dc7 Christian Brauner 2025-09-12 144 * head and if there is add it after the previous entry.
885fc8ac0a4dc7 Christian Brauner 2025-09-12 145 */
885fc8ac0a4dc7 Christian Brauner 2025-09-12 146 prev = rb_prev(&ns->ns_tree_node);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 147 if (!prev)
885fc8ac0a4dc7 Christian Brauner 2025-09-12 148 list_add_rcu(&ns->ns_list_node, &ns_tree->ns_list);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 149 else
885fc8ac0a4dc7 Christian Brauner 2025-09-12 150 list_add_rcu(&ns->ns_list_node, &node_to_ns(prev)->ns_list_node);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 151
01da9c6ec4269b Christian Brauner 2025-10-29 152 rb_find_add_rcu(&ns->ns_unified_tree_node, &ns_unified_tree, ns_cmp_unified);
01da9c6ec4269b Christian Brauner 2025-10-29 153 write_sequnlock(&ns_tree_lock);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 154
885fc8ac0a4dc7 Christian Brauner 2025-09-12 155 VFS_WARN_ON_ONCE(node);
cb9044bf715ece Christian Brauner 2025-10-29 156
cb9044bf715ece Christian Brauner 2025-10-29 157 /*
cb9044bf715ece Christian Brauner 2025-10-29 158 * Take an active reference on the owner namespace. This ensures
cb9044bf715ece Christian Brauner 2025-10-29 159 * that the owner remains visible while any of its child namespaces
cb9044bf715ece Christian Brauner 2025-10-29 160 * are active. For init namespaces this is a no-op as ns_owner()
cb9044bf715ece Christian Brauner 2025-10-29 161 * returns NULL for namespaces owned by init_user_ns.
cb9044bf715ece Christian Brauner 2025-10-29 162 */
cb9044bf715ece Christian Brauner 2025-10-29 163 __ns_ref_active_get_owner(ns);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 164 }
885fc8ac0a4dc7 Christian Brauner 2025-09-12 165
885fc8ac0a4dc7 Christian Brauner 2025-09-12 166 void __ns_tree_remove(struct ns_common *ns, struct ns_tree *ns_tree)
885fc8ac0a4dc7 Christian Brauner 2025-09-12 167 {
885fc8ac0a4dc7 Christian Brauner 2025-09-12 168 VFS_WARN_ON_ONCE(RB_EMPTY_NODE(&ns->ns_tree_node));
885fc8ac0a4dc7 Christian Brauner 2025-09-12 169 VFS_WARN_ON_ONCE(list_empty(&ns->ns_list_node));
4055526d35746c Christian Brauner 2025-09-24 @170 VFS_WARN_ON_ONCE(ns->ns_type != ns_tree->type);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 171
01da9c6ec4269b Christian Brauner 2025-10-29 172 write_seqlock(&ns_tree_lock);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 173 rb_erase(&ns->ns_tree_node, &ns_tree->ns_tree);
01da9c6ec4269b Christian Brauner 2025-10-29 174 rb_erase(&ns->ns_unified_tree_node, &ns_unified_tree);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 175 list_bidir_del_rcu(&ns->ns_list_node);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 176 RB_CLEAR_NODE(&ns->ns_tree_node);
01da9c6ec4269b Christian Brauner 2025-10-29 177 write_sequnlock(&ns_tree_lock);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 178 }
885fc8ac0a4dc7 Christian Brauner 2025-09-12 179 EXPORT_SYMBOL_GPL(__ns_tree_remove);
885fc8ac0a4dc7 Christian Brauner 2025-09-12 180 Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
Christian Brauner
maintainerPATCH v4 14/72 nstree: allow lookup solely based on inode
In reply to Christian BraunerThe namespace file handle struct nsfs_file_handle is uapi and userspace is expressly allowed to generate file handles without going through name_to_handle_at().
Allow userspace to generate a file handle where both the inode number and the namespace type are zero and just pass in the unique namespace id. The kernel uses the unified namespace tree to find the namespace and open the file handle.
When the kernel creates a file handle via name_to_handle_at() it will always fill in the type and the inode number allowing userspace to retrieve core information.
Signed-off-by Christian Brauner <[email protected]>
--- fs/nsfs.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/nsfs.c +2 -2
@@ -502,8 +502,8 @@ static struct dentry *nsfs_fh_to_dentry(struct super_block *sb, struct fid *fh,return NULL ;VFS_WARN_ON_ONCE (ns->ns_id != fid->ns_id); -VFS_WARN_ON_ONCE (ns->ns_type != fid->ns_type); -VFS_WARN_ON_ONCE (ns->inum != fid->ns_inum); +if (fid->ns_inum && (fid->ns_inum != ns->inum)) +return NULL ;/* * This is racy because we're not actually taking an
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 15/72 nstree: assign fixed ids to the initial namespaces
In reply to Christian BraunerThe initial set of namespace comes with fixed inode numbers making it easy for userspace to identify them solely based on that information. This has long preceeded anything here.
Similarly, let's assign fixed namespace ids for the initial namespaces.
Kill the cookie and use a sequentially increasing number. This has the nice side-effect that the owning user namespace will always have a namespace id that is smaller than any of it's descendant namespaces.
Signed-off-by Christian Brauner <[email protected]>
--- fs/namespace.c | 2 +- include/linux/nstree.h | 26 ++++++++++++++++++++++---- include/uapi/linux/nsfs.h | 14 ++++++++++++++ kernel/nstree.c | 13 ++++++++----- net/core/net_namespace.c | 2 +- 5 files changed, 46 insertions(+), 11 deletions(-)
fs/namespace.c +1 -1
@@ -4094,7 +4094,7 @@ static struct mnt_namespace *alloc_mnt_ns(struct user_namespace *user_ns, bool areturn ERR_PTR (ret); }if (!anon) -ns_tree_gen_id (&new_ns->ns); +ns_tree_gen_id (new_ns);refcount_set (&new_ns->passive,1 ); new_ns->mounts =RB_ROOT ;init_waitqueue_head (&new_ns->poll);
include/linux/nstree.h +22 -4
@@ -8,6 +8,7 @@#include <linux/seqlock.h> #include <linux/rculist.h> #include <linux/cookie.h> +#include <uapi/linux/nsfs.h> extern struct ns_tree cgroup_ns_tree;extern struct ns_tree ipc_ns_tree;
@@ -29,7 +30,22 @@ extern struct ns_tree uts_ns_tree; struct user_namespace *: &(user_ns_tree), \ struct uts_namespace *: &(uts_ns_tree)) -u64 ns_tree_gen_id (struct ns_common *ns); +#define ns_init_id (__ns) \ + _Generic((__ns), \ + struct cgroup_namespace *: CGROUP_NS_INIT_ID, \ + struct ipc_namespace *: IPC_NS_INIT_ID, \ + struct mnt_namespace *: MNT_NS_INIT_ID, \ + struct net *: NET_NS_INIT_ID, \ + struct pid_namespace *: PID_NS_INIT_ID, \ + struct time_namespace *: TIME_NS_INIT_ID, \ + struct user_namespace *: USER_NS_INIT_ID, \ + struct uts_namespace *: UTS_NS_INIT_ID) + +#define ns_tree_gen_id (__ns) \ + __ns_tree_gen_id(to_ns_common(__ns), \ + (((__ns) == ns_init_ns(__ns)) ? ns_init_id(__ns) : 0)) + +u64 __ns_tree_gen_id (struct ns_common *ns,u64 id);void __ns_tree_add_raw (struct ns_common *ns,struct ns_tree *ns_tree);void __ns_tree_remove (struct ns_common *ns,struct ns_tree *ns_tree);struct ns_common *ns_tree_lookup_rcu (u64 ns_id,int ns_type);
@@ -37,9 +53,9 @@ struct ns_common *__ns_tree_adjoined_rcu(struct ns_common *ns,struct ns_tree *ns_tree, bool previous); -static inline void __ns_tree_add (struct ns_common *ns,struct ns_tree *ns_tree) +static inline void __ns_tree_add (struct ns_common *ns,struct ns_tree *ns_tree,u64 id) { -ns_tree_gen_id (ns); +__ns_tree_gen_id (ns, id);__ns_tree_add_raw (ns, ns_tree); }
@@ -59,7 +75,9 @@ static inline void __ns_tree_add(struct ns_common *ns, struct ns_tree *ns_tree)* This function assigns a new id to the namespace and adds it to the * appropriate namespace tree and list. */ -#define ns_tree_add (__ns) __ns_tree_add(to_ns_common(__ns), to_ns_tree(__ns)) +#define ns_tree_add (__ns) \ + __ns_tree_add(to_ns_common(__ns), to_ns_tree(__ns), \ + (((__ns) == ns_init_ns(__ns)) ? ns_init_id(__ns) : 0))/** * ns_tree_remove - Remove a namespace from a namespace tree
include/uapi/linux/nsfs.h +14 -0
@@ -67,4 +67,18 @@ struct nsfs_file_handle {#define NSFS_FILE_HANDLE_SIZE_VER0 16/* sizeof first published struct */ #define NSFS_FILE_HANDLE_SIZE_LATEST sizeof(struct nsfs_file_handle)/* sizeof latest published struct */ +enum init_ns_id { +IPC_NS_INIT_ID =1ULL , +UTS_NS_INIT_ID =2ULL , +USER_NS_INIT_ID =3ULL , +PID_NS_INIT_ID =4ULL , +CGROUP_NS_INIT_ID =5ULL , +TIME_NS_INIT_ID =6ULL , +NET_NS_INIT_ID =7ULL , +MNT_NS_INIT_ID =8ULL , +#ifdef __KERNEL__ +NS_LAST_INIT_ID =MNT_NS_INIT_ID , +#endif +}; +#endif /* __LINUX_NSFS_H */
kernel/nstree.c +8 -5
@@ -86,8 +86,6 @@ struct ns_tree time_ns_tree = {#endif }; -DEFINE_COOKIE (namespace_cookie); -static inline struct ns_common *node_to_ns (const struct rb_node *node) {if (!node)
@@ -302,15 +300,20 @@ struct ns_common *__ns_tree_adjoined_rcu(struct ns_common *ns,/** * ns_tree_gen_id - generate a new namespace id * @ns: namespace to generate id for +* @id: if non-zero, this is the initial namespace and this is a fixed id * * Generates a new namespace id and assigns it to the namespace. All * namespaces types share the same id space and thus can be compared * directly. IOW, when two ids of two namespace are equal, they are * identical. */ -u64 ns_tree_gen_id (struct ns_common *ns) +u64 __ns_tree_gen_id (struct ns_common *ns,u64 id) { -guard (preempt)(); - ns->ns_id =gen_cookie_next (&namespace_cookie); +static atomic64_t namespace_cookie =ATOMIC64_INIT (NS_LAST_INIT_ID +1 ); + +if (id) + ns->ns_id = id; +else + ns->ns_id =atomic64_inc_return (&namespace_cookie);return ns->ns_id; }
net/core/net_namespace.c +1 -1
@@ -439,7 +439,7 @@ static __net_init int setup_net(struct net *net)LIST_HEAD (net_exit_list);int error =0 ; - net->net_cookie =ns_tree_gen_id (&net->ns); + net->net_cookie =ns_tree_gen_id (net);list_for_each_entry (ops, &pernet_list, list) { error =ops_init (ops, net);
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 16/72 nstree: maintain list of owned namespaces
In reply to Christian BraunerThe namespace tree doesn't express the ownership concept of namespace appropriately. Maintain a list of directly owned namespaces per user namespace. This will allow userspace and the kernel to use the listns() system call to walk the namespace tree by owning user namespace. The rbtree is used to find the relevant namespace entry point which allows to continue iteration and the owner list can be used to walk the tree completely lock free.
Signed-off-by Christian Brauner <[email protected]>
--- fs/namespace.c | 2 ++ include/linux/ns_common.h | 6 +++++ init/version-timestamp.c | 2 ++ ipc/msgutil.c | 2 ++ kernel/cgroup/cgroup.c | 2 ++ kernel/nscommon.c | 4 +++ kernel/nstree.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++- kernel/pid.c | 2 ++ kernel/time/namespace.c | 2 ++ kernel/user.c | 2 ++ 10 files changed, 91 insertions(+), 1 deletion(-)
fs/namespace.c +2 -0
@@ -5995,6 +5995,8 @@ struct mnt_namespace init_mnt_ns = { .mounts = RB_ROOT, .poll = __WAIT_QUEUE_HEAD_INITIALIZER(init_mnt_ns.poll), .ns.ns_list_node = LIST_HEAD_INIT(init_mnt_ns.ns.ns_list_node), + .ns.ns_owner_entry = LIST_HEAD_INIT(init_mnt_ns.ns.ns_owner_entry), + .ns.ns_owner = LIST_HEAD_INIT(init_mnt_ns.ns.ns_owner), };static void __init init_mount_tree (void )
include/linux/ns_common.h +6 -0
@@ -117,6 +117,12 @@ struct ns_common {struct rb_node ns_tree_node;struct list_head ns_list_node; }; +struct /* namespace ownership rbtree and list */ { +struct rb_root ns_owner_tree;/* rbtree of namespaces owned by this namespace */ +struct list_head ns_owner;/* list of namespaces owned by this namespace */ +struct rb_node ns_owner_tree_node;/* node in the owner namespace's rbtree */ +struct list_head ns_owner_entry;/* node in the owner namespace's ns_owned list */ + };atomic_t __ns_ref_active;/* do not use directly */ };struct rcu_head ns_rcu;
init/version-timestamp.c +2 -0
@@ -22,6 +22,8 @@ struct uts_namespace init_uts_ns = { .user_ns = &init_user_ns, .ns.inum = ns_init_inum(&init_uts_ns), .ns.ns_list_node = LIST_HEAD_INIT(init_uts_ns.ns.ns_list_node), + .ns.ns_owner_entry = LIST_HEAD_INIT(init_uts_ns.ns.ns_owner_entry), + .ns.ns_owner = LIST_HEAD_INIT(init_uts_ns.ns.ns_owner),#ifdef CONFIG_UTS_NS .ns.ops = &utsns_operations,#endif
ipc/msgutil.c +2 -0
@@ -32,6 +32,8 @@ struct ipc_namespace init_ipc_ns = { .user_ns = &init_user_ns, .ns.inum = ns_init_inum(&init_ipc_ns), .ns.ns_list_node = LIST_HEAD_INIT(init_ipc_ns.ns.ns_list_node), + .ns.ns_owner_entry = LIST_HEAD_INIT(init_ipc_ns.ns.ns_owner_entry), + .ns.ns_owner = LIST_HEAD_INIT(init_ipc_ns.ns.ns_owner),#ifdef CONFIG_IPC_NS .ns.ops = &ipcns_operations,#endif
kernel/cgroup/cgroup.c +2 -0
@@ -258,6 +258,8 @@ struct cgroup_namespace init_cgroup_ns = { .root_cset = &init_css_set, .ns.ns_type = ns_common_type(&init_cgroup_ns), .ns.ns_list_node = LIST_HEAD_INIT(init_cgroup_ns.ns.ns_list_node), + .ns.ns_owner_entry = LIST_HEAD_INIT(init_cgroup_ns.ns.ns_owner_entry), + .ns.ns_owner = LIST_HEAD_INIT(init_cgroup_ns.ns.ns_owner), };static struct file_system_type cgroup2_fs_type;
kernel/nscommon.c +4 -0
@@ -62,7 +62,11 @@ int __ns_common_init(struct ns_common *ns, u32 ns_type, const struct proc_ns_ope ns->ns_type = ns_type;RB_CLEAR_NODE (&ns->ns_tree_node);RB_CLEAR_NODE (&ns->ns_unified_tree_node); +RB_CLEAR_NODE (&ns->ns_owner_tree_node);INIT_LIST_HEAD (&ns->ns_list_node); + ns->ns_owner_tree =RB_ROOT ; +INIT_LIST_HEAD (&ns->ns_owner); +INIT_LIST_HEAD (&ns->ns_owner_entry);#ifdef CONFIG_DEBUG_VFS ns_debug (ns, ops);
kernel/nstree.c +67 -1
111 lines not on this page · raw message
kernel/pid.c +2 -0
@@ -80,6 +80,8 @@ struct pid_namespace init_pid_ns = { .user_ns = &init_user_ns, .ns.inum = ns_init_inum(&init_pid_ns), .ns.ns_list_node = LIST_HEAD_INIT(init_pid_ns.ns.ns_list_node), + .ns.ns_owner_entry = LIST_HEAD_INIT(init_pid_ns.ns.ns_owner_entry), + .ns.ns_owner = LIST_HEAD_INIT(init_pid_ns.ns.ns_owner),#ifdef CONFIG_PID_NS .ns.ops = &pidns_operations,#endif
kernel/time/namespace.c +2 -0
@@ -484,6 +484,8 @@ struct time_namespace init_time_ns = { .user_ns = &init_user_ns, .ns.inum = ns_init_inum(&init_time_ns), .ns.ops = &timens_operations, + .ns.ns_owner_entry = LIST_HEAD_INIT(init_time_ns.ns.ns_owner_entry), + .ns.ns_owner = LIST_HEAD_INIT(init_time_ns.ns.ns_owner), .frozen_offsets = true, .ns.ns_list_node = LIST_HEAD_INIT(init_time_ns.ns.ns_list_node), };
kernel/user.c +2 -0
@@ -72,6 +72,8 @@ struct user_namespace init_user_ns = { .group = GLOBAL_ROOT_GID, .ns.inum = ns_init_inum(&init_user_ns), .ns.ns_list_node = LIST_HEAD_INIT(init_user_ns.ns.ns_list_node), + .ns.ns_owner_entry = LIST_HEAD_INIT(init_user_ns.ns.ns_owner_entry), + .ns.ns_owner = LIST_HEAD_INIT(init_user_ns.ns.ns_owner),#ifdef CONFIG_USER_NS .ns.ops = &userns_operations,#endif
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 17/72 nstree: simplify rbtree comparison helpers
In reply to Christian BraunerThey all do the same basic thing.
Signed-off-by Christian Brauner <[email protected]>
--- kernel/nstree.c | 40 +++++++++++----------------------------- 1 file changed, 11 insertions(+), 29 deletions(-)
kernel/nstree.c +11 -29
@@ -109,46 +109,28 @@ static inline struct ns_common *node_to_ns_owner(const struct rb_node *node) return rb_entry(node, struct ns_common, ns_owner_tree_node); } -static inline int ns_cmp (struct rb_node *a,const struct rb_node *b) +static int ns_id_cmp (u64 id_a,u64 id_b) { -struct ns_common *ns_a =node_to_ns (a); -struct ns_common *ns_b =node_to_ns (b); -u64 ns_id_a = ns_a->ns_id; -u64 ns_id_b = ns_b->ns_id; - -if (ns_id_a < ns_id_b) +if (id_a < id_b)return -1 ; -if (ns_id_a > ns_id_b) +if (id_a > id_b)return 1 ;return 0 ; } -static inline int ns_cmp_unified (struct rb_node *a,const struct rb_node *b) +static int ns_cmp (struct rb_node *a,const struct rb_node *b) { -struct ns_common *ns_a =node_to_ns_unified (a); -struct ns_common *ns_b =node_to_ns_unified (b); -u64 ns_id_a = ns_a->ns_id; -u64 ns_id_b = ns_b->ns_id; - -if (ns_id_a < ns_id_b) -return -1 ; -if (ns_id_a > ns_id_b) -return 1 ; -return 0 ; +return ns_id_cmp (node_to_ns (a)->ns_id,node_to_ns (b)->ns_id); } -static inline int ns_cmp_owner (struct rb_node *a,const struct rb_node *b) +static int ns_cmp_unified (struct rb_node *a,const struct rb_node *b) { -struct ns_common *ns_a =node_to_ns_owner (a); -struct ns_common *ns_b =node_to_ns_owner (b); -u64 ns_id_a = ns_a->ns_id; -u64 ns_id_b = ns_b->ns_id; +return ns_id_cmp (node_to_ns_unified (a)->ns_id,node_to_ns_unified (b)->ns_id); +} -if (ns_id_a < ns_id_b) -return -1 ; -if (ns_id_a > ns_id_b) -return 1 ; -return 0 ; +static int ns_cmp_owner (struct rb_node *a,const struct rb_node *b) +{ +return ns_id_cmp (node_to_ns_owner (a)->ns_id,node_to_ns_owner (b)->ns_id); }void __ns_tree_add_raw (struct ns_common *ns,struct ns_tree *ns_tree)
Signature · 1 line
2.47.3
Re: [PATCH v4 17/72] nstree: simplify rbtree comparison helpers
Quoted 59 lines · Christian Brauner
They all do the same basic thing.
Signed-off-by Christian Brauner <[email protected]>--- kernel/nstree.c | 40 +++++++++++----------------------------- 1 file changed, 11 insertions(+), 29 deletions(-)kernel/nstree.c +8
-25@@ -109,46 +109,28 @@ static inline struct ns_common *node_to_ns_owner(const struct rb_node *node) return rb_entry(node, struct ns_common, ns_owner_tree_node); } -static inline int ns_cmp (struct rb_node *a,const struct rb_node *b) +static int ns_id_cmp (u64 id_a,u64 id_b) { -struct ns_common *ns_a =node_to_ns (a); -struct ns_common *ns_b =node_to_ns (b); -u64 ns_id_a = ns_a->ns_id; -u64 ns_id_b = ns_b->ns_id; - -if (ns_id_a < ns_id_b) +if (id_a < id_b)return -1 ; -if (ns_id_a > ns_id_b) +if (id_a > id_b)return 1 ;return 0 ; } -static inline int ns_cmp_unified (struct rb_node *a,const struct rb_node *b) +static int ns_cmp (struct rb_node *a,const struct rb_node *b) { -struct ns_common *ns_a =node_to_ns_unified (a); -struct ns_common *ns_b =node_to_ns_unified (b); -u64 ns_id_a = ns_a->ns_id; -u64 ns_id_b = ns_b->ns_id; - -if (ns_id_a < ns_id_b) -return -1 ; -if (ns_id_a > ns_id_b) -return 1 ; -return 0 ; +return ns_id_cmp (node_to_ns (a)->ns_id,node_to_ns (b)->ns_id); } -static inline int ns_cmp_owner (struct rb_node *a,const struct rb_node *b) +static int ns_cmp_unified (struct rb_node *a,const struct rb_node *b) { -struct ns_common *ns_a =node_to_ns_owner (a); -struct ns_common *ns_b =node_to_ns_owner (b); -u64 ns_id_a = ns_a->ns_id; -u64 ns_id_b = ns_b->ns_id; +return ns_id_cmp (node_to_ns_unified (a)->ns_id,node_to_ns_unified (b)->ns_id); +} -if (ns_id_a < ns_id_b)
kernel/nstree.c static inline struct ns_common *node_to_ns_owner(const struct rb_node *node) · line 136
Quoted 10 lines
kernel/nstree.c +3
-4-return -1 ; -if (ns_id_a > ns_id_b) -return 1 ; -return 0 ; +static int ns_cmp_owner (struct rb_node *a,const struct rb_node *b) +{ +return ns_id_cmp (node_to_ns_owner (a)->ns_id,node_to_ns_owner (b)->ns_id); }void __ns_tree_add_raw (struct ns_common *ns,struct ns_tree *ns_tree)
Reviewed-by Jeff Layton <[email protected]>
Christian Brauner
maintainerPATCH v4 18/72 nstree: add unified namespace list
In reply to Christian BraunerAllow to walk the unified namespace list completely locklessly.
Signed-off-by Christian Brauner <[email protected]>
--- fs/namespace.c | 1 + init/version-timestamp.c | 1 + ipc/msgutil.c | 1 + kernel/cgroup/cgroup.c | 1 + kernel/nscommon.c | 1 + kernel/nstree.c | 13 ++++++++++++- kernel/pid.c | 1 + kernel/time/namespace.c | 1 + kernel/user.c | 1 + 9 files changed, 20 insertions(+), 1 deletion(-)
fs/namespace.c +1 -0
@@ -5995,6 +5995,7 @@ struct mnt_namespace init_mnt_ns = { .mounts = RB_ROOT, .poll = __WAIT_QUEUE_HEAD_INITIALIZER(init_mnt_ns.poll), .ns.ns_list_node = LIST_HEAD_INIT(init_mnt_ns.ns.ns_list_node), + .ns.ns_unified_list_node = LIST_HEAD_INIT(init_mnt_ns.ns.ns_unified_list_node), .ns.ns_owner_entry = LIST_HEAD_INIT(init_mnt_ns.ns.ns_owner_entry), .ns.ns_owner = LIST_HEAD_INIT(init_mnt_ns.ns.ns_owner), };
init/version-timestamp.c +1 -0
@@ -22,6 +22,7 @@ struct uts_namespace init_uts_ns = { .user_ns = &init_user_ns, .ns.inum = ns_init_inum(&init_uts_ns), .ns.ns_list_node = LIST_HEAD_INIT(init_uts_ns.ns.ns_list_node), + .ns.ns_unified_list_node = LIST_HEAD_INIT(init_uts_ns.ns.ns_unified_list_node), .ns.ns_owner_entry = LIST_HEAD_INIT(init_uts_ns.ns.ns_owner_entry), .ns.ns_owner =LIST_HEAD_INIT (init_uts_ns.ns.ns_owner), #ifdef CONFIG_UTS_NS
ipc/msgutil.c +1 -0
@@ -32,6 +32,7 @@ struct ipc_namespace init_ipc_ns = { .user_ns = &init_user_ns, .ns.inum = ns_init_inum(&init_ipc_ns), .ns.ns_list_node = LIST_HEAD_INIT(init_ipc_ns.ns.ns_list_node), + .ns.ns_unified_list_node = LIST_HEAD_INIT(init_ipc_ns.ns.ns_unified_list_node), .ns.ns_owner_entry = LIST_HEAD_INIT(init_ipc_ns.ns.ns_owner_entry), .ns.ns_owner =LIST_HEAD_INIT (init_ipc_ns.ns.ns_owner), #ifdef CONFIG_IPC_NS
kernel/cgroup/cgroup.c +1 -0
@@ -258,6 +258,7 @@ struct cgroup_namespace init_cgroup_ns = { .root_cset = &init_css_set, .ns.ns_type = ns_common_type(&init_cgroup_ns), .ns.ns_list_node = LIST_HEAD_INIT(init_cgroup_ns.ns.ns_list_node), + .ns.ns_unified_list_node = LIST_HEAD_INIT(init_cgroup_ns.ns.ns_unified_list_node), .ns.ns_owner_entry = LIST_HEAD_INIT(init_cgroup_ns.ns.ns_owner_entry), .ns.ns_owner = LIST_HEAD_INIT(init_cgroup_ns.ns.ns_owner), };
kernel/nscommon.c +1 -0
@@ -64,6 +64,7 @@ int __ns_common_init(struct ns_common *ns, u32 ns_type, const struct proc_ns_opeRB_CLEAR_NODE (&ns->ns_unified_tree_node);RB_CLEAR_NODE (&ns->ns_owner_tree_node);INIT_LIST_HEAD (&ns->ns_list_node); +INIT_LIST_HEAD (&ns->ns_unified_list_node); ns->ns_owner_tree =RB_ROOT ;INIT_LIST_HEAD (&ns->ns_owner);INIT_LIST_HEAD (&ns->ns_owner_entry);
kernel/nstree.c +12 -1
@@ -8,6 +8,7 @@__cacheline_aligned_in_smp DEFINE_SEQLOCK (ns_tree_lock );static struct rb_root ns_unified_tree =RB_ROOT ;/* protected by ns_tree_lock */ +static LIST_HEAD (ns_unified_list);/* protected by ns_tree_lock */ /** * struct ns_tree - Namespace tree
@@ -154,7 +155,13 @@ void __ns_tree_add_raw(struct ns_common *ns, struct ns_tree *ns_tree)else list_add_rcu (&ns->ns_list_node, &node_to_ns (prev)->ns_list_node); +/* Add to unified tree and list */ rb_find_add_rcu (&ns->ns_unified_tree_node, &ns_unified_tree, ns_cmp_unified); + prev =rb_prev (&ns->ns_unified_tree_node); +if (!prev) +list_add_rcu (&ns->ns_unified_list_node, &ns_unified_list); +else +list_add_rcu (&ns->ns_unified_list_node, &node_to_ns_unified (prev)->ns_unified_list_node);if (ops) {struct user_namespace *user_ns;
@@ -203,11 +210,15 @@ void __ns_tree_remove(struct ns_common *ns, struct ns_tree *ns_tree)write_seqlock (&ns_tree_lock);rb_erase (&ns->ns_tree_node, &ns_tree->ns_tree); -rb_erase (&ns->ns_unified_tree_node, &ns_unified_tree);RB_CLEAR_NODE (&ns->ns_tree_node);list_bidir_del_rcu (&ns->ns_list_node); +rb_erase (&ns->ns_unified_tree_node, &ns_unified_tree); +RB_CLEAR_NODE (&ns->ns_unified_tree_node); + +list_bidir_del_rcu (&ns->ns_unified_list_node); +/* Remove from owner's rbtree if this namespace has an owner */ if (ops) { user_ns = ops->owner (ns);
kernel/pid.c +1 -0
@@ -80,6 +80,7 @@ struct pid_namespace init_pid_ns = { .user_ns = &init_user_ns, .ns.inum = ns_init_inum(&init_pid_ns), .ns.ns_list_node = LIST_HEAD_INIT(init_pid_ns.ns.ns_list_node), + .ns.ns_unified_list_node = LIST_HEAD_INIT(init_pid_ns.ns.ns_unified_list_node), .ns.ns_owner_entry = LIST_HEAD_INIT(init_pid_ns.ns.ns_owner_entry), .ns.ns_owner =LIST_HEAD_INIT (init_pid_ns.ns.ns_owner), #ifdef CONFIG_PID_NS
kernel/time/namespace.c +1 -0
@@ -488,6 +488,7 @@ struct time_namespace init_time_ns = { .ns.ns_owner = LIST_HEAD_INIT(init_time_ns.ns.ns_owner), .frozen_offsets = true, .ns.ns_list_node = LIST_HEAD_INIT(init_time_ns.ns.ns_list_node), + .ns.ns_unified_list_node = LIST_HEAD_INIT(init_time_ns.ns.ns_unified_list_node), };void __init time_ns_init (void )
kernel/user.c +1 -0
@@ -72,6 +72,7 @@ struct user_namespace init_user_ns = { .group = GLOBAL_ROOT_GID, .ns.inum = ns_init_inum(&init_user_ns), .ns.ns_list_node = LIST_HEAD_INIT(init_user_ns.ns.ns_list_node), + .ns.ns_unified_list_node = LIST_HEAD_INIT(init_user_ns.ns.ns_unified_list_node), .ns.ns_owner_entry = LIST_HEAD_INIT(init_user_ns.ns.ns_owner_entry), .ns.ns_owner =LIST_HEAD_INIT (init_user_ns.ns.ns_owner), #ifdef CONFIG_USER_NS
Signature · 1 line
2.47.3
Re: [PATCH v4 18/72] nstree: add unified namespace list
Christian!
kernel/time/namespace.c struct time_namespace init_time_ns = { · line 491
Quoted 7 lines · Christian Brauner
kernel/time/namespace.c +1
-0@@ -488,6 +488,7 @@ struct time_namespace init_time_ns = { .ns.ns_owner = LIST_HEAD_INIT(init_time_ns.ns.ns_owner), .frozen_offsets = true, .ns.ns_list_node = LIST_HEAD_INIT(init_time_ns.ns.ns_list_node), + .ns.ns_unified_list_node = LIST_HEAD_INIT(init_time_ns.ns.ns_unified_list_node),
Sorry that I did not catch that earlier, but
1) this screws up the proper tabular struct initializer
2) the churn of touching every compile time struct each time you add a new field and add the same stupid initialization to each of them can be avoided, when you do something like the uncompiled below. You get the idea.
Thanks,
tglx
--- fs/namespace.c | 9 +-------- include/linux/ns_common.h | 12 ++++++++++++ init/version-timestamp.c | 9 +-------- ipc/msgutil.c | 9 +-------- kernel/pid.c | 8 +------- kernel/time/namespace.c | 9 +-------- kernel/user.c | 9 +-------- 7 files changed, 18 insertions(+), 47 deletions(-)
fs/namespace.c +1 -8
@@ -5985,19 +5985,12 @@ SYSCALL_DEFINE4(listmount, const struct }struct mnt_namespace init_mnt_ns = { - .ns.inum =ns_init_inum (&init_mnt_ns), + .ns =NS_COMMON_INIT (init_mnt_ns,1 ,1 ), .ns.ops = &mntns_operations, .user_ns = &init_user_ns, - .ns.__ns_ref =REFCOUNT_INIT (1 ), - .ns.__ns_ref_active =ATOMIC_INIT (1 ), - .ns.ns_type =ns_common_type (&init_mnt_ns), .passive =REFCOUNT_INIT (1 ), .mounts =RB_ROOT , .poll =__WAIT_QUEUE_HEAD_INITIALIZER (init_mnt_ns.poll), - .ns.ns_list_node =LIST_HEAD_INIT (init_mnt_ns.ns.ns_list_node), - .ns.ns_unified_list_node =LIST_HEAD_INIT (init_mnt_ns.ns.ns_unified_list_node), - .ns.ns_owner_entry =LIST_HEAD_INIT (init_mnt_ns.ns.ns_owner_entry), - .ns.ns_owner =LIST_HEAD_INIT (init_mnt_ns.ns.ns_owner), };static void __init init_mount_tree (void )
include/linux/ns_common.h +12 -0
@@ -129,6 +129,18 @@ struct ns_common { }; }; +#define NS_COMMON_INIT (nsname, refs, active) \ +{ \ + .ns_type = ns_common_type(&nsname), \ + .inum = ns_init_inum(&nsname), \ + .__ns_ref = REFCOUNT_INIT(refs), \ + .__ns_ref_active = ATOMIC_INIT(active), \ + .ns_list_node = LIST_HEAD_INIT(nsname.ns.ns_list_node), \ + .ns_unified_list_node = LIST_HEAD_INIT(nsname.ns.ns_unified_list_node), \ + .ns_owner_entry = LIST_HEAD_INIT(nsname.ns.ns_owner_entry), \ + .ns_owner = LIST_HEAD_INIT(nsname.ns.ns_owner), \ +} +int __ns_common_init (struct ns_common *ns,u32 ns_type,const struct proc_ns_operations *ops,int inum);void __ns_common_free (struct ns_common *ns);
init/version-timestamp.c +1 -8
@@ -8,9 +8,7 @@#include <linux/utsname.h> struct uts_namespace init_uts_ns = { - .ns.ns_type =ns_common_type (&init_uts_ns), - .ns.__ns_ref =REFCOUNT_INIT (2 ), - .ns.__ns_ref_active =ATOMIC_INIT (1 ), + .ns =NS_COMMON_INIT (init_uts_ns,2 ,1 ), .name = { .sysname =UTS_SYSNAME , .nodename =UTS_NODENAME ,
@@ -20,11 +18,6 @@ struct uts_namespace init_uts_ns = { .domainname = UTS_DOMAINNAME, }, .user_ns = &init_user_ns, - .ns.inum = ns_init_inum(&init_uts_ns), - .ns.ns_list_node = LIST_HEAD_INIT(init_uts_ns.ns.ns_list_node), - .ns.ns_unified_list_node = LIST_HEAD_INIT(init_uts_ns.ns.ns_unified_list_node), - .ns.ns_owner_entry = LIST_HEAD_INIT(init_uts_ns.ns.ns_owner_entry), - .ns.ns_owner = LIST_HEAD_INIT(init_uts_ns.ns.ns_owner),#ifdef CONFIG_UTS_NS .ns.ops = &utsns_operations,#endif
ipc/msgutil.c +1 -8
@@ -27,18 +27,11 @@ DEFINE_SPINLOCK(mq_lock);* and not CONFIG_IPC_NS. */ struct ipc_namespace init_ipc_ns = { - .ns.__ns_ref =REFCOUNT_INIT (1 ), - .ns.__ns_ref_active =ATOMIC_INIT (1 ), + .ns =NS_COMMON_INIT (init_ipc_ns,1 ,1 ), .user_ns = &init_user_ns, - .ns.inum =ns_init_inum (&init_ipc_ns), - .ns.ns_list_node =LIST_HEAD_INIT (init_ipc_ns.ns.ns_list_node), - .ns.ns_unified_list_node =LIST_HEAD_INIT (init_ipc_ns.ns.ns_unified_list_node), - .ns.ns_owner_entry =LIST_HEAD_INIT (init_ipc_ns.ns.ns_owner_entry), - .ns.ns_owner =LIST_HEAD_INIT (init_ipc_ns.ns.ns_owner), #ifdef CONFIG_IPC_NS .ns.ops = &ipcns_operations, #endif - .ns.ns_type =ns_common_type (&init_ipc_ns), };struct msg_msgseg {
kernel/pid.c +1 -7
@@ -71,18 +71,12 @@ static int pid_max_max = PID_MAX_LIMIT;* the scheme scales to up to 4 million PIDs, runtime. */ struct pid_namespace init_pid_ns = { - .ns.__ns_ref =REFCOUNT_INIT (2 ), - .ns.__ns_ref_active =ATOMIC_INIT (1 ), + .ns =NS_COMMON_INIT (init_pid_ns,2 ,1 ), .idr =IDR_INIT (init_pid_ns.idr), .pid_allocated =PIDNS_ADDING , .level =0 , .child_reaper = &init_task, .user_ns = &init_user_ns, - .ns.inum =ns_init_inum (&init_pid_ns), - .ns.ns_list_node =LIST_HEAD_INIT (init_pid_ns.ns.ns_list_node), - .ns.ns_unified_list_node =LIST_HEAD_INIT (init_pid_ns.ns.ns_unified_list_node), - .ns.ns_owner_entry =LIST_HEAD_INIT (init_pid_ns.ns.ns_owner_entry), - .ns.ns_owner =LIST_HEAD_INIT (init_pid_ns.ns.ns_owner), #ifdef CONFIG_PID_NS .ns.ops = &pidns_operations, #endif
kernel/time/namespace.c +1 -8
@@ -478,17 +478,10 @@ const struct proc_ns_operations timens_f };struct time_namespace init_time_ns = { - .ns.ns_type =ns_common_type (&init_time_ns), - .ns.__ns_ref =REFCOUNT_INIT (3 ), - .ns.__ns_ref_active =ATOMIC_INIT (1 ), + .ns =NS_COMMON_INIT (init_time_ns,3 ,1 ), .user_ns = &init_user_ns, - .ns.inum =ns_init_inum (&init_time_ns), .ns.ops = &timens_operations, - .ns.ns_owner_entry =LIST_HEAD_INIT (init_time_ns.ns.ns_owner_entry), - .ns.ns_owner =LIST_HEAD_INIT (init_time_ns.ns.ns_owner), .frozen_offsets = true, - .ns.ns_list_node =LIST_HEAD_INIT (init_time_ns.ns.ns_list_node), - .ns.ns_unified_list_node =LIST_HEAD_INIT (init_time_ns.ns.ns_unified_list_node), };void __init time_ns_init (void )
kernel/user.c +1 -8
@@ -65,16 +65,9 @@ struct user_namespace init_user_ns = { .nr_extents = 1, }, }, - .ns.ns_type = ns_common_type(&init_user_ns), - .ns.__ns_ref = REFCOUNT_INIT(3), - .ns.__ns_ref_active = ATOMIC_INIT(1), + .ns = NS_COMMON_INIT(init_user_ns, 3, 1), .owner = GLOBAL_ROOT_UID, .group = GLOBAL_ROOT_GID, - .ns.inum = ns_init_inum(&init_user_ns), - .ns.ns_list_node = LIST_HEAD_INIT(init_user_ns.ns.ns_list_node), - .ns.ns_unified_list_node = LIST_HEAD_INIT(init_user_ns.ns.ns_unified_list_node), - .ns.ns_owner_entry = LIST_HEAD_INIT(init_user_ns.ns.ns_owner_entry), - .ns.ns_owner =LIST_HEAD_INIT (init_user_ns.ns.ns_owner),#ifdef CONFIG_USER_NS .ns.ops = &userns_operations,#endif
Christian Brauner
maintainerRe: [PATCH v4 18/72] nstree: add unified namespace list
Quoted 13 lines · Thomas Gleixner
Christian!
kernel/time/namespace.c struct time_namespace init_time_ns = { · line 491
Quoted 7 lines · Christian Brauner
kernel/time/namespace.c +1
-0@@ -488,6 +488,7 @@ struct time_namespace init_time_ns = { .ns.ns_owner = LIST_HEAD_INIT(init_time_ns.ns.ns_owner), .frozen_offsets = true, .ns.ns_list_node = LIST_HEAD_INIT(init_time_ns.ns.ns_list_node), + .ns.ns_unified_list_node = LIST_HEAD_INIT(init_time_ns.ns.ns_unified_list_node),Sorry that I did not catch that earlier, but
Quoted 8 lines
1) this screws up the proper tabular struct initializer
2) the churn of touching every compile time struct each time you add a new field and add the same stupid initialization to each of them can be avoided, when you do something like the uncompiled below. You get the idea.
Thanks,
Nice! I'm stealing that and I'll slap a Suggested-by for you on it. Thanks!
Quoted 166 lines
tglx
--- fs/namespace.c | 9 +-------- include/linux/ns_common.h | 12 ++++++++++++ init/version-timestamp.c | 9 +-------- ipc/msgutil.c | 9 +-------- kernel/pid.c | 8 +------- kernel/time/namespace.c | 9 +-------- kernel/user.c | 9 +-------- 7 files changed, 18 insertions(+), 47 deletions(-)fs/namespace.c +1
-8@@ -5985,19 +5985,12 @@ SYSCALL_DEFINE4(listmount, const struct }struct mnt_namespace init_mnt_ns = { - .ns.inum =ns_init_inum (&init_mnt_ns), + .ns =NS_COMMON_INIT (init_mnt_ns,1 ,1 ), .ns.ops = &mntns_operations, .user_ns = &init_user_ns, - .ns.__ns_ref =REFCOUNT_INIT (1 ), - .ns.__ns_ref_active =ATOMIC_INIT (1 ), - .ns.ns_type =ns_common_type (&init_mnt_ns), .passive =REFCOUNT_INIT (1 ), .mounts =RB_ROOT , .poll =__WAIT_QUEUE_HEAD_INITIALIZER (init_mnt_ns.poll), - .ns.ns_list_node =LIST_HEAD_INIT (init_mnt_ns.ns.ns_list_node), - .ns.ns_unified_list_node =LIST_HEAD_INIT (init_mnt_ns.ns.ns_unified_list_node), - .ns.ns_owner_entry =LIST_HEAD_INIT (init_mnt_ns.ns.ns_owner_entry), - .ns.ns_owner =LIST_HEAD_INIT (init_mnt_ns.ns.ns_owner), };static void __init init_mount_tree (void )include/linux/ns_common.h +12
-0@@ -129,6 +129,18 @@ struct ns_common { }; }; +#define NS_COMMON_INIT (nsname, refs, active) \ +{ \ + .ns_type = ns_common_type(&nsname), \ + .inum = ns_init_inum(&nsname), \ + .__ns_ref = REFCOUNT_INIT(refs), \ + .__ns_ref_active = ATOMIC_INIT(active), \ + .ns_list_node = LIST_HEAD_INIT(nsname.ns.ns_list_node), \ + .ns_unified_list_node = LIST_HEAD_INIT(nsname.ns.ns_unified_list_node), \ + .ns_owner_entry = LIST_HEAD_INIT(nsname.ns.ns_owner_entry), \ + .ns_owner = LIST_HEAD_INIT(nsname.ns.ns_owner), \ +} +int __ns_common_init (struct ns_common *ns,u32 ns_type,const struct proc_ns_operations *ops,int inum);void __ns_common_free (struct ns_common *ns);init/version-timestamp.c +1
-8@@ -8,9 +8,7 @@#include <linux/utsname.h> struct uts_namespace init_uts_ns = { - .ns.ns_type =ns_common_type (&init_uts_ns), - .ns.__ns_ref =REFCOUNT_INIT (2 ), - .ns.__ns_ref_active =ATOMIC_INIT (1 ), + .ns =NS_COMMON_INIT (init_uts_ns,2 ,1 ), .name = { .sysname =UTS_SYSNAME , .nodename =UTS_NODENAME ,@@ -20,11 +18,6 @@ struct uts_namespace init_uts_ns = { .domainname = UTS_DOMAINNAME, }, .user_ns = &init_user_ns, - .ns.inum = ns_init_inum(&init_uts_ns), - .ns.ns_list_node = LIST_HEAD_INIT(init_uts_ns.ns.ns_list_node), - .ns.ns_unified_list_node = LIST_HEAD_INIT(init_uts_ns.ns.ns_unified_list_node), - .ns.ns_owner_entry = LIST_HEAD_INIT(init_uts_ns.ns.ns_owner_entry), - .ns.ns_owner = LIST_HEAD_INIT(init_uts_ns.ns.ns_owner),#ifdef CONFIG_UTS_NS .ns.ops = &utsns_operations,#endif ipc/msgutil.c +1
-8@@ -27,18 +27,11 @@ DEFINE_SPINLOCK(mq_lock);* and not CONFIG_IPC_NS. */ struct ipc_namespace init_ipc_ns = { - .ns.__ns_ref =REFCOUNT_INIT (1 ), - .ns.__ns_ref_active =ATOMIC_INIT (1 ), + .ns =NS_COMMON_INIT (init_ipc_ns,1 ,1 ), .user_ns = &init_user_ns, - .ns.inum =ns_init_inum (&init_ipc_ns), - .ns.ns_list_node =LIST_HEAD_INIT (init_ipc_ns.ns.ns_list_node), - .ns.ns_unified_list_node =LIST_HEAD_INIT (init_ipc_ns.ns.ns_unified_list_node), - .ns.ns_owner_entry =LIST_HEAD_INIT (init_ipc_ns.ns.ns_owner_entry), - .ns.ns_owner =LIST_HEAD_INIT (init_ipc_ns.ns.ns_owner), #ifdef CONFIG_IPC_NS .ns.ops = &ipcns_operations, #endif - .ns.ns_type =ns_common_type (&init_ipc_ns), };struct msg_msgseg {kernel/pid.c +1
-7@@ -71,18 +71,12 @@ static int pid_max_max = PID_MAX_LIMIT;* the scheme scales to up to 4 million PIDs, runtime. */ struct pid_namespace init_pid_ns = { - .ns.__ns_ref =REFCOUNT_INIT (2 ), - .ns.__ns_ref_active =ATOMIC_INIT (1 ), + .ns =NS_COMMON_INIT (init_pid_ns,2 ,1 ), .idr =IDR_INIT (init_pid_ns.idr), .pid_allocated =PIDNS_ADDING , .level =0 , .child_reaper = &init_task, .user_ns = &init_user_ns, - .ns.inum =ns_init_inum (&init_pid_ns), - .ns.ns_list_node =LIST_HEAD_INIT (init_pid_ns.ns.ns_list_node), - .ns.ns_unified_list_node =LIST_HEAD_INIT (init_pid_ns.ns.ns_unified_list_node), - .ns.ns_owner_entry =LIST_HEAD_INIT (init_pid_ns.ns.ns_owner_entry), - .ns.ns_owner =LIST_HEAD_INIT (init_pid_ns.ns.ns_owner), #ifdef CONFIG_PID_NS .ns.ops = &pidns_operations, #endifkernel/time/namespace.c +1
-8@@ -478,17 +478,10 @@ const struct proc_ns_operations timens_f };struct time_namespace init_time_ns = { - .ns.ns_type =ns_common_type (&init_time_ns), - .ns.__ns_ref =REFCOUNT_INIT (3 ), - .ns.__ns_ref_active =ATOMIC_INIT (1 ), + .ns =NS_COMMON_INIT (init_time_ns,3 ,1 ), .user_ns = &init_user_ns, - .ns.inum =ns_init_inum (&init_time_ns), .ns.ops = &timens_operations, - .ns.ns_owner_entry =LIST_HEAD_INIT (init_time_ns.ns.ns_owner_entry), - .ns.ns_owner =LIST_HEAD_INIT (init_time_ns.ns.ns_owner), .frozen_offsets = true, - .ns.ns_list_node =LIST_HEAD_INIT (init_time_ns.ns.ns_list_node), - .ns.ns_unified_list_node =LIST_HEAD_INIT (init_time_ns.ns.ns_unified_list_node), };void __init time_ns_init (void )kernel/user.c +1
-8@@ -65,16 +65,9 @@ struct user_namespace init_user_ns = { .nr_extents = 1, }, }, - .ns.ns_type = ns_common_type(&init_user_ns), - .ns.__ns_ref = REFCOUNT_INIT(3), - .ns.__ns_ref_active = ATOMIC_INIT(1), + .ns = NS_COMMON_INIT(init_user_ns, 3, 1), .owner = GLOBAL_ROOT_UID, .group = GLOBAL_ROOT_GID, - .ns.inum = ns_init_inum(&init_user_ns), - .ns.ns_list_node = LIST_HEAD_INIT(init_user_ns.ns.ns_list_node), - .ns.ns_unified_list_node = LIST_HEAD_INIT(init_user_ns.ns.ns_unified_list_node), - .ns.ns_owner_entry = LIST_HEAD_INIT(init_user_ns.ns.ns_owner_entry), - .ns.ns_owner =LIST_HEAD_INIT (init_user_ns.ns.ns_owner),#ifdef CONFIG_USER_NS .ns.ops = &userns_operations,#endif
Christian Brauner
maintainerPATCH v4 19/72 nstree: add listns()
In reply to Christian BraunerAdd a new listns() system call that allows userspace to iterate through namespaces in the system. This provides a programmatic interface to discover and inspect namespaces, enhancing existing namespace apis.
Currently, there is no direct way for userspace to enumerate namespaces in the system. Applications must resort to scanning /proc/<pid>/ns/ across all processes, which is:
1. Inefficient - requires iterating over all processes
2. Incomplete - misses inactive namespaces that aren't attached to any running process but are kept alive by file descriptors, bind mounts, or parent namespace references
3. Permission-heavy - requires access to /proc for many processes
4. No ordering or ownership.
5. No filtering per namespace type: Must always iterate and check all namespaces.
The list goes on. The listns() system call solves these problems by providing direct kernel-level enumeration of namespaces. It is similar to listmount() but obviously tailored to namespaces.
/*
* @req: Pointer to struct ns_id_req specifying search parameters
* @ns_ids: User buffer to receive namespace IDs
* @nr_ns_ids: Size of ns_ids buffer (maximum number of IDs to return)
* @flags: Reserved for future use (must be 0)
*/ssize_t listns(const struct ns_id_req *req, u64 *ns_ids,
size_t nr_ns_ids, unsigned int flags);
Returns:
- On success: Number of namespace IDs written to ns_ids
- On error: Negative error code
/*
* @size: Structure size
* @ns_id: Starting point for iteration; use 0 for first call, then
* use the last returned ID for subsequent calls to paginate
* @ns_type: Bitmask of namespace types to include (from enum ns_type):
* 0: Return all namespace types
* MNT_NS: Mount namespaces
* NET_NS: Network namespaces
* USER_NS: User namespaces
* etc. Can be OR'd together
* @user_ns_id: Filter results to namespaces owned by this user namespace:
* 0: Return all namespaces (subject to permission checks)
* LISTNS_CURRENT_USER: Namespaces owned by caller's user namespace
* Other value: Namespaces owned by the specified user namespace ID
*/
struct ns_id_req {
__u32 size; /* sizeof(struct ns_id_req) */
__u32 spare; /* Reserved, must be 0 */
__u64 ns_id; /* Last seen namespace ID (for pagination) */
__u32 ns_type; /* Filter by namespace type(s) */
__u32 spare2; /* Reserved, must be 0 */
__u64 user_ns_id; /* Filter by owning user namespace */};
Example 1: List all namespaces
void list_all_namespaces(void)
{
struct ns_id_req req = {
.size = sizeof(req),
.ns_id = 0, /* Start from beginning */
.ns_type = 0, /* All types */
.user_ns_id = 0, /* All user namespaces */
};
uint64_t ids[100];
ssize_t ret;
printf("All namespaces in the system:\n");
do {
ret = listns(&req, ids, 100, 0);
if (ret < 0) {
perror("listns");
break;
}
for (ssize_t i = 0; i < ret; i++)
printf(" Namespace ID: %llu\n", (unsigned long long)ids[i]);
/* Continue from last seen ID */
if (ret > 0)
req.ns_id = ids[ret - 1];
} while (ret == 100); /* Buffer was full, more may exist */
}Example 2: List network namespaces only
void list_network_namespaces(void)
{
struct ns_id_req req = {
.size = sizeof(req),
.ns_id = 0,
.ns_type = NET_NS, /* Only network namespaces */
.user_ns_id = 0,
};
uint64_t ids[100];
ssize_t ret;
ret = listns(&req, ids, 100, 0);
if (ret < 0) {
perror("listns");
return;
}
printf("Network namespaces: %zd found\n", ret);
for (ssize_t i = 0; i < ret; i++)
printf(" netns ID: %llu\n", (unsigned long long)ids[i]);
}Example 3: List namespaces owned by current user namespace
void list_owned_namespaces(void)
{
struct ns_id_req req = {
.size = sizeof(req),
.ns_id = 0,
.ns_type = 0, /* All types */
.user_ns_id = LISTNS_CURRENT_USER, /* Current userns */
};
uint64_t ids[100];
ssize_t ret;
ret = listns(&req, ids, 100, 0);
if (ret < 0) {
perror("listns");
return;
}
printf("Namespaces owned by my user namespace: %zd\n", ret);
for (ssize_t i = 0; i < ret; i++)
printf(" ns ID: %llu\n", (unsigned long long)ids[i]);
}Example 4: List multiple namespace types
void list_network_and_mount_namespaces(void)
{
struct ns_id_req req = {
.size = sizeof(req),
.ns_id = 0,
.ns_type = NET_NS | MNT_NS, /* Network and mount */
.user_ns_id = 0,
};
uint64_t ids[100];
ssize_t ret;
ret = listns(&req, ids, 100, 0);
printf("Network and mount namespaces: %zd found\n", ret);
}Example 5: Pagination through large namespace sets
void list_all_with_pagination(void)
{
struct ns_id_req req = {
.size = sizeof(req),
.ns_id = 0,
.ns_type = 0,
.user_ns_id = 0,
};
uint64_t ids[50];
size_t total = 0;
ssize_t ret;
printf("Enumerating all namespaces with pagination:\n");
while (1) {
ret = listns(&req, ids, 50, 0);
if (ret < 0) {
perror("listns");
break;
}
if (ret == 0)
break; /* No more namespaces */
total += ret;
printf(" Batch: %zd namespaces\n", ret);
/* Last ID in this batch becomes start of next batch */
req.ns_id = ids[ret - 1];
if (ret < 50)
break; /* Partial batch = end of results */
}
printf("Total: %zu namespaces\n", total);
}Permission Model
listns() respects namespace isolation and capabilities:
(1) Global listing (user_ns_id = 0):
- Requires CAP_SYS_ADMIN in the namespace's owning user namespace
- OR the namespace must be in the caller's namespace context (e.g., a namespace the caller is currently using)
- User namespaces additionally allow listing if the caller has CAP_SYS_ADMIN in that user namespace itself
(2) Owner-filtered listing (user_ns_id != 0):
- Requires CAP_SYS_ADMIN in the specified owner user namespace
- OR the namespace must be in the caller's namespace context
- This allows unprivileged processes to enumerate namespaces they own
(3) Visibility:
- Only "active" namespaces are listed
- A namespace is active if it has a non-zero __ns_ref_active count
- This includes namespaces used by running processes, held by open file descriptors, or kept active by bind mounts
- Inactive namespaces (kept alive only by internal kernel references) are not visible via listns()
Signed-off-by Christian Brauner <[email protected]>
--- fs/nsfs.c | 39 ++++ include/linux/ns_common.h | 2 + include/linux/syscalls.h | 4 + include/linux/user_namespace.h | 4 +- include/uapi/linux/nsfs.h | 44 +++++ kernel/nscommon.c | 2 +- kernel/nstree.c | 397 +++++++++++++++++++++++++++++++++++++++++ 7 files changed, 489 insertions(+), 3 deletions(-)
fs/nsfs.c +39 -0
@@ -471,6 +471,45 @@ static int nsfs_encode_fh(struct inode *inode, u32 *fh, int *max_len,return FILEID_NSFS ; } +bool is_current_namespace (struct ns_common *ns) +{ +switch (ns->ns_type) { +#ifdef CONFIG_CGROUPS +case CLONE_NEWCGROUP : +return current_in_namespace (to_cg_ns (ns)); +#endif +#ifdef CONFIG_IPC_NS +case CLONE_NEWIPC : +return current_in_namespace (to_ipc_ns (ns)); +#endif +case CLONE_NEWNS : +return current_in_namespace (to_mnt_ns (ns)); +#ifdef CONFIG_NET_NS +case CLONE_NEWNET : +return current_in_namespace (to_net_ns (ns)); +#endif +#ifdef CONFIG_PID_NS +case CLONE_NEWPID : +return current_in_namespace (to_pid_ns (ns)); +#endif +#ifdef CONFIG_TIME_NS +case CLONE_NEWTIME : +return current_in_namespace (to_time_ns (ns)); +#endif +#ifdef CONFIG_USER_NS +case CLONE_NEWUSER : +return current_in_namespace (to_user_ns (ns)); +#endif +#ifdef CONFIG_UTS_NS +case CLONE_NEWUTS : +return current_in_namespace (to_uts_ns (ns)); +#endif +default : +VFS_WARN_ON_ONCE (true); +return false; + } +} +static struct dentry *nsfs_fh_to_dentry (struct super_block *sb,struct fid *fh,int fh_len,int fh_type) {
include/linux/ns_common.h +2 -0
@@ -129,8 +129,10 @@ struct ns_common { }; }; +bool is_current_namespace (struct ns_common *ns);int __ns_common_init (struct ns_common *ns,u32 ns_type,const struct proc_ns_operations *ops,int inum);void __ns_common_free (struct ns_common *ns); +struct ns_common *__must_check ns_owner (struct ns_common *ns); static __always_inline bool is_initial_namespace(struct ns_common *ns) {
include/linux/syscalls.h +4 -0
@@ -77,6 +77,7 @@ struct cachestat_range;struct cachestat ;struct statmount ;struct mnt_id_req ; +struct ns_id_req ;struct xattr_args ;struct file_attr ;
@@ -437,6 +438,9 @@ asmlinkage long sys_statmount(const struct mnt_id_req __user *req,asmlinkage long sys_listmount (const struct mnt_id_req __user *req,u64 __user *mnt_ids,size_t nr_mnt_ids,unsigned int flags); +asmlinkage long sys_listns (const struct ns_id_req __user *req, +u64 __user *ns_ids,size_t nr_ns_ids, +unsigned int flags);asmlinkage long sys_truncate (const char __user *path,long length);asmlinkage long sys_ftruncate (unsigned int fd,off_t length);#if BITS_PER_LONG ==32
include/linux/user_namespace.h +2 -2
@@ -166,13 +166,13 @@ static inline void set_userns_rlimit_max(struct user_namespace *ns, ns->rlimit_max[type] = max <=LONG_MAX ? max :LONG_MAX ; } -#ifdef CONFIG_USER_NS -static inline struct user_namespace *to_user_ns (struct ns_common *ns) { return container_of(ns, struct user_namespace, ns); } +#ifdef CONFIG_USER_NS +static inline struct user_namespace *get_user_ns (struct user_namespace *ns) {if (ns)
include/uapi/linux/nsfs.h +44 -0
48 lines not on this page · raw message
kernel/nscommon.c +1 -1
@@ -97,7 +97,7 @@ void __ns_common_free(struct ns_common *ns)proc_free_inum (ns->inum); } -static struct ns_common *ns_owner (struct ns_common *ns) +struct ns_common *__must_check ns_owner (struct ns_common *ns) {struct user_namespace *owner;
kernel/nstree.c +397 -0
406 lines not on this page · raw message
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 20/72 arch: hookup listns() system call
In reply to Christian BraunerAdd the listns() system call to all architectures.
Signed-off-by Christian Brauner <[email protected]>
--- arch/alpha/kernel/syscalls/syscall.tbl | 1 + arch/arm/tools/syscall.tbl | 1 + arch/arm64/tools/syscall_32.tbl | 1 + arch/m68k/kernel/syscalls/syscall.tbl | 1 + arch/microblaze/kernel/syscalls/syscall.tbl | 1 + arch/mips/kernel/syscalls/syscall_n32.tbl | 1 + arch/mips/kernel/syscalls/syscall_n64.tbl | 1 + arch/mips/kernel/syscalls/syscall_o32.tbl | 1 + arch/parisc/kernel/syscalls/syscall.tbl | 1 + arch/powerpc/kernel/syscalls/syscall.tbl | 1 + arch/s390/kernel/syscalls/syscall.tbl | 1 + arch/sh/kernel/syscalls/syscall.tbl | 1 + arch/sparc/kernel/syscalls/syscall.tbl | 1 + arch/x86/entry/syscalls/syscall_32.tbl | 1 + arch/x86/entry/syscalls/syscall_64.tbl | 1 + arch/xtensa/kernel/syscalls/syscall.tbl | 1 + include/uapi/asm-generic/unistd.h | 4 +++- scripts/syscall.tbl | 1 + 18 files changed, 20 insertions(+), 1 deletion(-)
arch/alpha/kernel/syscalls/syscall.tbl +1 -0
@@ -509,3 +509,4 @@ 577 common open_tree_attr sys_open_tree_attr 578 common file_getattr sys_file_getattr 579 common file_setattr sys_file_setattr +580 common listns sys_listns
arch/arm/tools/syscall.tbl +1 -0
@@ -484,3 +484,4 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns
arch/arm64/tools/syscall_32.tbl +1 -0
@@ -481,3 +481,4 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns
arch/m68k/kernel/syscalls/syscall.tbl +1 -0
@@ -469,3 +469,4 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns
arch/microblaze/kernel/syscalls/syscall.tbl +1 -0
@@ -475,3 +475,4 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns
arch/mips/kernel/syscalls/syscall_n32.tbl +1 -0
@@ -408,3 +408,4 @@ 467 n32 open_tree_attr sys_open_tree_attr 468 n32 file_getattr sys_file_getattr 469 n32 file_setattr sys_file_setattr +470 n32 listns sys_listns
arch/mips/kernel/syscalls/syscall_n64.tbl +1 -0
@@ -384,3 +384,4 @@ 467 n64 open_tree_attr sys_open_tree_attr 468 n64 file_getattr sys_file_getattr 469 n64 file_setattr sys_file_setattr +470 n64 listns sys_listns
arch/mips/kernel/syscalls/syscall_o32.tbl +1 -0
@@ -457,3 +457,4 @@ 467 o32 open_tree_attr sys_open_tree_attr 468 o32 file_getattr sys_file_getattr 469 o32 file_setattr sys_file_setattr +470 o32 listns sys_listns
arch/parisc/kernel/syscalls/syscall.tbl +1 -0
@@ -468,3 +468,4 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns
arch/powerpc/kernel/syscalls/syscall.tbl +1 -0
@@ -560,3 +560,4 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns
arch/s390/kernel/syscalls/syscall.tbl +1 -0
@@ -472,3 +472,4 @@ 467 common open_tree_attr sys_open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr sys_file_setattr +470 common listns sys_listns sys_listns
arch/sh/kernel/syscalls/syscall.tbl +1 -0
@@ -473,3 +473,4 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns
arch/sparc/kernel/syscalls/syscall.tbl +1 -0
@@ -515,3 +515,4 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns
arch/x86/entry/syscalls/syscall_32.tbl +1 -0
@@ -475,3 +475,4 @@ 467 i386 open_tree_attr sys_open_tree_attr 468 i386 file_getattr sys_file_getattr 469 i386 file_setattr sys_file_setattr +470 i386 listns sys_listns
arch/x86/entry/syscalls/syscall_64.tbl +1 -0
@@ -394,6 +394,7 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns # # Due to a historical design error, certain syscalls are numbered differently
arch/xtensa/kernel/syscalls/syscall.tbl +1 -0
@@ -440,3 +440,4 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns
include/uapi/asm-generic/unistd.h +3 -1
@@ -857,9 +857,11 @@ __SYSCALL(__NR_open_tree_attr, sys_open_tree_attr) __SYSCALL(__NR_file_getattr, sys_file_getattr)#define __NR_file_setattr 469 __SYSCALL(__NR_file_setattr, sys_file_setattr) +#define __NR_listns 470 +__SYSCALL(__NR_listns, sys_listns)#undef __NR_syscalls -#define __NR_syscalls 470 +#define __NR_syscalls 471/* * 32 bit systems traditionally used different
scripts/syscall.tbl +1 -0
@@ -410,3 +410,4 @@ 467 common open_tree_attr sys_open_tree_attr 468 common file_getattr sys_file_getattr 469 common file_setattr sys_file_setattr +470 common listns sys_listns
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 21/72 nsfs: update tools header
In reply to Christian BraunerEnsure all the new uapi bits are visible for the selftests.
Signed-off-by Christian Brauner <[email protected]>
--- tools/include/uapi/linux/nsfs.h | 70 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+)
tools/include/uapi/linux/nsfs.h +70 -0
@@ -53,6 +53,76 @@ enum init_ns_ino {TIME_NS_INIT_INO =0xEFFFFFFAU ,NET_NS_INIT_INO =0xEFFFFFF9U ,MNT_NS_INIT_INO =0xEFFFFFF8U , +#ifdef __KERNEL__ + MNT_NS_ANON_INO = 0xEFFFFFF7U, +#endif }; +struct nsfs_file_handle { +__u64 ns_id; +__u32 ns_type; +__u32 ns_inum; +}; + +#define NSFS_FILE_HANDLE_SIZE_VER0 16/* sizeof first published struct */ +#define NSFS_FILE_HANDLE_SIZE_LATEST sizeof(struct nsfs_file_handle)/* sizeof latest published struct */ + +enum init_ns_id { +IPC_NS_INIT_ID =1ULL , +UTS_NS_INIT_ID =2ULL , +USER_NS_INIT_ID =3ULL , +PID_NS_INIT_ID =4ULL , +CGROUP_NS_INIT_ID =5ULL , +TIME_NS_INIT_ID =6ULL , +NET_NS_INIT_ID =7ULL , +MNT_NS_INIT_ID =8ULL , +#ifdef __KERNEL__ +NS_LAST_INIT_ID =MNT_NS_INIT_ID , +#endif +}; + +enum ns_type { +TIME_NS = (1ULL <<7 ),/* CLONE_NEWTIME */ +MNT_NS = (1ULL <<17 ),/* CLONE_NEWNS */ +CGROUP_NS = (1ULL <<25 ),/* CLONE_NEWCGROUP */ +UTS_NS = (1ULL <<26 ),/* CLONE_NEWUTS */ +IPC_NS = (1ULL <<27 ),/* CLONE_NEWIPC */ +USER_NS = (1ULL <<28 ),/* CLONE_NEWUSER */ +PID_NS = (1ULL <<29 ),/* CLONE_NEWPID */ +NET_NS = (1ULL <<30 ),/* CLONE_NEWNET */ +}; + +/** +* struct ns_id_req - namespace ID request structure +* @size: size of this structure +* @spare: reserved for future use +* @filter: filter mask +* @ns_id: last namespace id +* @user_ns_id: owning user namespace ID +* +* Structure for passing namespace ID and miscellaneous parameters to +* statns(2) and listns(2). +* +* For statns(2) @param represents the request mask. +* For listns(2) @param represents the last listed mount id (or zero). +*/ +struct ns_id_req { +__u32 size; +__u32 spare; +__u64 ns_id; +struct /* listns */ { +__u32 ns_type; +__u32 spare2; +__u64 user_ns_id; + }; +}; + +/* +* Special @user_ns_id value that can be passed to listns() +*/ +#define LISTNS_CURRENT_USER 0xffffffffffffffff/* Caller's userns */ + +/* List of all ns_id_req versions. */ +#define NS_ID_REQ_SIZE_VER0 32/* sizeof first published struct */ +#endif /* __LINUX_NSFS_H */
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 22/72 selftests/filesystems: remove CLONE_NEWPIDNS from setup_userns() helper
In reply to Christian BraunerThis is effectively unused and doesn't really server any purpose after having reviewed all of the tests that rely on it.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/filesystems/utils.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
tools/testing/selftests/filesystems/utils.c +1 -1
@@ -487,7 +487,7 @@ int setup_userns(void)uid_t uid =getuid ();gid_t gid =getgid (); - ret =unshare (CLONE_NEWNS |CLONE_NEWUSER |CLONE_NEWPID ); + ret =unshare (CLONE_NEWNS |CLONE_NEWUSER );if (ret) {ksft_exit_fail_msg ("unsharing mountns and userns: %s\n" ,strerror (errno));
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 23/72 selftests/namespaces: first active reference count tests
In reply to Christian BraunerTest that initial namespaces can be reopened via file handle. Initial namespaces should always have a ref count of one from boot.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/.gitignore | 1 + tools/testing/selftests/namespaces/Makefile | 5 +- .../selftests/namespaces/ns_active_ref_test.c | 74 ++++++++++++++++++++++ 3 files changed, 79 insertions(+), 1 deletion(-)
tools/testing/selftests/namespaces/.gitignore +1 -0
@@ -1,3 +1,4 @@ nsid_test file_handle_test init_ino_test +ns_active_ref_test
tools/testing/selftests/namespaces/Makefile +4 -1
@@ -1,7 +1,10 @@ # SPDX-License-Identifier: GPL-2.0-only CFLAGS += -Wall -O0 -g $(KHDR_INCLUDES) $(TOOLS_INCLUDES) +LDLIBS += -lcap -TEST_GEN_PROGS := nsid_test file_handle_test init_ino_test +TEST_GEN_PROGS := nsid_test file_handle_test init_ino_test ns_active_ref_test include ../lib.mk +$(OUTPUT)/ns_active_ref_test: ../filesystems/utils.c +
tools/testing/selftests/namespaces/ns_active_ref_test.c new file +74 -0
74 lines not on this page · raw message
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 24/72 selftests/namespaces: second active reference count tests
In reply to Christian BraunerTest namespace lifecycle: create a namespace in a child process, get a file handle while it's active, then try to reopen after the process exits (namespace becomes inactive).
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 81 ++++++++++++++++++++++ 1 file changed, 81 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +81 -0
@@ -71,4 +71,85 @@ TEST(init_ns_always_active)free (handle); } +/* +* Test namespace lifecycle: create a namespace in a child process, +* get a file handle while it's active, then try to reopen after +* the process exits (namespace becomes inactive). +*/ +TEST (ns_inactive_after_exit) +{ +struct file_handle *handle; +int mount_id; +int ret; +int fd; +int pipefd[2 ]; +pid_t pid; +int status; +char buf[sizeof (*handle) +MAX_HANDLE_SZ ]; + +/* Create pipe for passing file handle from child */ +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child process */ +close (pipefd[0 ]); + +/* Create new network namespace */ + ret =unshare (CLONE_NEWNET ); +if (ret <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Open our new namespace */ + fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Get file handle for the namespace */ + handle = (struct file_handle *)buf; + handle->handle_bytes =MAX_HANDLE_SZ ; + ret =name_to_handle_at (fd,"" , handle, &mount_id,AT_EMPTY_PATH ); +close (fd); + +if (ret <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Send handle to parent */ +write (pipefd[1 ], buf,sizeof (*handle) + handle->handle_bytes); +close (pipefd[1 ]); + +/* Exit - namespace should become inactive */ +exit (0 ); + } + +/* Parent process */ +close (pipefd[1 ]); + +/* Read file handle from child */ + ret =read (pipefd[0 ], buf,sizeof (buf)); +close (pipefd[0 ]); + +/* Wait for child to exit */ +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +ASSERT_GT (ret,0 ); + handle = (struct file_handle *)buf; + +/* Try to reopen namespace - should fail with ENOENT since it's inactive */ + fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_LT (fd,0 ); +/* Should fail with ENOENT (namespace inactive) or ESTALE */ +ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 25/72 selftests/namespaces: third active reference count tests
In reply to Christian BraunerTest that a namespace remains active while a process is using it, even after the creating process exits.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 124 +++++++++++++++++++++ 1 file changed, 124 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +124 -0
@@ -152,4 +152,128 @@ TEST(ns_inactive_after_exit)ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); } +/* +* Test that a namespace remains active while a process is using it, +* even after the creating process exits. +*/ +TEST (ns_active_with_multiple_processes) +{ +struct file_handle *handle; +int mount_id; +int ret; +int fd; +int pipefd[2 ]; +int syncpipe[2 ]; +pid_t pid1, pid2; +int status; +char buf[sizeof (*handle) +MAX_HANDLE_SZ ]; +char sync_byte; + +/* Create pipes for communication */ +ASSERT_EQ (pipe (pipefd),0 ); +ASSERT_EQ (pipe (syncpipe),0 ); + + pid1 =fork (); +ASSERT_GE (pid1,0 ); + +if (pid1 ==0 ) { +/* First child - creates namespace */ +close (pipefd[0 ]); +close (syncpipe[1 ]); + +/* Create new network namespace */ + ret =unshare (CLONE_NEWNET ); +if (ret <0 ) { +close (pipefd[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } + +/* Open and get handle */ + fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (fd <0 ) { +close (pipefd[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } + + handle = (struct file_handle *)buf; + handle->handle_bytes =MAX_HANDLE_SZ ; + ret =name_to_handle_at (fd,"" , handle, &mount_id,AT_EMPTY_PATH ); +close (fd); + +if (ret <0 ) { +close (pipefd[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } + +/* Send handle to parent */ +write (pipefd[1 ], buf,sizeof (*handle) + handle->handle_bytes); +close (pipefd[1 ]); + +/* Wait for signal before exiting */ +read (syncpipe[0 ], &sync_byte,1 ); +close (syncpipe[0 ]); +exit (0 ); + } + +/* Parent reads handle */ +close (pipefd[1 ]); + ret =read (pipefd[0 ], buf,sizeof (buf)); +close (pipefd[0 ]); +ASSERT_GT (ret,0 ); + + handle = (struct file_handle *)buf; + +/* Create second child that will keep namespace active */ + pid2 =fork (); +ASSERT_GE (pid2,0 ); + +if (pid2 ==0 ) { +/* Second child - reopens the namespace */ +close (syncpipe[0 ]); +close (syncpipe[1 ]); + +/* Open the namespace via handle */ + fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +if (fd <0 ) { +exit (1 ); + } + +/* Join the namespace */ + ret =setns (fd,CLONE_NEWNET ); +close (fd); +if (ret <0 ) { +exit (1 ); + } + +/* Sleep to keep namespace active */ +sleep (1 ); +exit (0 ); + } + +/* Let second child enter the namespace */ +usleep (100000 );/* 100ms */ + +/* Signal first child to exit */ +close (syncpipe[0 ]); + sync_byte ='X' ; +write (syncpipe[1 ], &sync_byte,1 ); +close (syncpipe[1 ]); + +/* Wait for first child */ +waitpid (pid1, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); + +/* Namespace should still be active because second child is using it */ + fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_GE (fd,0 ); +close (fd); + +/* Wait for second child */ +waitpid (pid2, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 26/72 selftests/namespaces: fourth active reference count tests
In reply to Christian BraunerTest user namespace active ref tracking via credential lifecycle.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 90 ++++++++++++++++++++++ 1 file changed, 90 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +90 -0
@@ -276,4 +276,94 @@ TEST(ns_active_with_multiple_processes)ASSERT_TRUE (WIFEXITED (status)); } +/* +* Test user namespace active ref tracking via credential lifecycle +*/ +TEST (userns_active_ref_lifecycle) +{ +struct file_handle *handle; +int mount_id; +int ret; +int fd; +int pipefd[2 ]; +pid_t pid; +int status; +char buf[sizeof (*handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child process */ +close (pipefd[0 ]); + +/* Create new user namespace */ + ret =unshare (CLONE_NEWUSER ); +if (ret <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Set up uid/gid mappings */ +int uid_map_fd =open ("/proc/self/uid_map" ,O_WRONLY ); +int gid_map_fd =open ("/proc/self/gid_map" ,O_WRONLY ); +int setgroups_fd =open ("/proc/self/setgroups" ,O_WRONLY ); + +if (uid_map_fd >=0 && gid_map_fd >=0 && setgroups_fd >=0 ) { +write (setgroups_fd,"deny" ,4 ); +close (setgroups_fd); + +char mapping[64 ]; +snprintf (mapping,sizeof (mapping),"0 %d 1" ,getuid ()); +write (uid_map_fd, mapping,strlen (mapping)); +close (uid_map_fd); + +snprintf (mapping,sizeof (mapping),"0 %d 1" ,getgid ()); +write (gid_map_fd, mapping,strlen (mapping)); +close (gid_map_fd); + } + +/* Get file handle */ + fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + + handle = (struct file_handle *)buf; + handle->handle_bytes =MAX_HANDLE_SZ ; + ret =name_to_handle_at (fd,"" , handle, &mount_id,AT_EMPTY_PATH ); +close (fd); + +if (ret <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Send handle to parent */ +write (pipefd[1 ], buf,sizeof (*handle) + handle->handle_bytes); +close (pipefd[1 ]); +exit (0 ); + } + +/* Parent */ +close (pipefd[1 ]); + ret =read (pipefd[0 ], buf,sizeof (buf)); +close (pipefd[0 ]); + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +ASSERT_GT (ret,0 ); + handle = (struct file_handle *)buf; + +/* Namespace should be inactive after all tasks exit */ + fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_LT (fd,0 ); +ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 27/72 selftests/namespaces: fifth active reference count tests
In reply to Christian BraunerTest PID namespace active ref tracking
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 82 ++++++++++++++++++++++ 1 file changed, 82 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +82 -0
@@ -366,4 +366,86 @@ TEST(userns_active_ref_lifecycle)ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); } +/* +* Test PID namespace active ref tracking +*/ +TEST (pidns_active_ref_lifecycle) +{ +struct file_handle *handle; +int mount_id; +int ret; +int fd; +int pipefd[2 ]; +pid_t pid; +int status; +char buf[sizeof (*handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child process */ +close (pipefd[0 ]); + +/* Create new PID namespace */ + ret =unshare (CLONE_NEWPID ); +if (ret <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Fork to actually enter the PID namespace */ +pid_t child =fork (); +if (child <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +if (child ==0 ) { +/* Grandchild - in new PID namespace */ + fd =open ("/proc/self/ns/pid" ,O_RDONLY ); +if (fd <0 ) { +exit (1 ); + } + + handle = (struct file_handle *)buf; + handle->handle_bytes =MAX_HANDLE_SZ ; + ret =name_to_handle_at (fd,"" , handle, &mount_id,AT_EMPTY_PATH ); +close (fd); + +if (ret <0 ) { +exit (1 ); + } + +/* Send handle to grandparent */ +write (pipefd[1 ], buf,sizeof (*handle) + handle->handle_bytes); +close (pipefd[1 ]); +exit (0 ); + } + +/* Wait for grandchild */ +waitpid (child,NULL ,0 ); +exit (0 ); + } + +/* Parent */ +close (pipefd[1 ]); + ret =read (pipefd[0 ], buf,sizeof (buf)); +close (pipefd[0 ]); + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +ASSERT_GT (ret,0 ); + handle = (struct file_handle *)buf; + +/* Namespace should be inactive after all processes exit */ + fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_LT (fd,0 ); +ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 28/72 selftests/namespaces: sixth active reference count tests
In reply to Christian BraunerTest that an open file descriptor keeps a namespace active. Even after the creating process exits, the namespace should remain active as long as an fd is held open.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 155 +++++++++++++++++++++ 1 file changed, 155 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +155 -0
@@ -448,4 +448,159 @@ TEST(pidns_active_ref_lifecycle)ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); } +/* +* Test that an open file descriptor keeps a namespace active. +* Even after the creating process exits, the namespace should remain +* active as long as an fd is held open. +*/ +TEST (ns_fd_keeps_active) +{ +struct file_handle *handle; +int mount_id; +int ret; +int nsfd; +int pipe_child_ready[2 ]; +int pipe_parent_ready[2 ]; +pid_t pid; +int status; +char buf[sizeof (*handle) +MAX_HANDLE_SZ ]; +char sync_byte; +char proc_path[64 ]; + +ASSERT_EQ (pipe (pipe_child_ready),0 ); +ASSERT_EQ (pipe (pipe_parent_ready),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child process */ +close (pipe_child_ready[0 ]); +close (pipe_parent_ready[1 ]); + +TH_LOG ("Child: creating new network namespace" ); + +/* Create new network namespace */ + ret =unshare (CLONE_NEWNET ); +if (ret <0 ) { +TH_LOG ("Child: unshare(CLONE_NEWNET) failed: %s" ,strerror (errno)); +close (pipe_child_ready[1 ]); +close (pipe_parent_ready[0 ]); +exit (1 ); + } + +TH_LOG ("Child: network namespace created successfully" ); + +/* Get file handle for the namespace */ + nsfd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (nsfd <0 ) { +TH_LOG ("Child: failed to open /proc/self/ns/net: %s" ,strerror (errno)); +close (pipe_child_ready[1 ]); +close (pipe_parent_ready[0 ]); +exit (1 ); + } + +TH_LOG ("Child: opened namespace fd %d" , nsfd); + + handle = (struct file_handle *)buf; + handle->handle_bytes =MAX_HANDLE_SZ ; + ret =name_to_handle_at (nsfd,"" , handle, &mount_id,AT_EMPTY_PATH ); +close (nsfd); + +if (ret <0 ) { +TH_LOG ("Child: name_to_handle_at failed: %s" ,strerror (errno)); +close (pipe_child_ready[1 ]); +close (pipe_parent_ready[0 ]); +exit (1 ); + } + +TH_LOG ("Child: got file handle (bytes=%u)" , handle->handle_bytes); + +/* Send file handle to parent */ + ret =write (pipe_child_ready[1 ], buf,sizeof (*handle) + handle->handle_bytes); +TH_LOG ("Child: sent %d bytes of file handle to parent" , ret); +close (pipe_child_ready[1 ]); + +/* Wait for parent to open the fd */ +TH_LOG ("Child: waiting for parent to open fd" ); + ret =read (pipe_parent_ready[0 ], &sync_byte,1 ); +close (pipe_parent_ready[0 ]); + +TH_LOG ("Child: parent signaled (read %d bytes), exiting now" , ret); +/* Exit - namespace should stay active because parent holds fd */ +exit (0 ); + } + +/* Parent process */ +close (pipe_child_ready[1 ]); +close (pipe_parent_ready[0 ]); + +TH_LOG ("Parent: reading file handle from child" ); + +/* Read file handle from child */ + ret =read (pipe_child_ready[0 ], buf,sizeof (buf)); +close (pipe_child_ready[0 ]); +ASSERT_GT (ret,0 ); + handle = (struct file_handle *)buf; + +TH_LOG ("Parent: received %d bytes, handle size=%u" , ret, handle->handle_bytes); + +/* Open the child's namespace while it's still alive */ +snprintf (proc_path,sizeof (proc_path),"/proc/%d/ns/net" , pid); +TH_LOG ("Parent: opening child's namespace at %s" , proc_path); + nsfd =open (proc_path,O_RDONLY ); +if (nsfd <0 ) { +TH_LOG ("Parent: failed to open %s: %s" , proc_path,strerror (errno)); +close (pipe_parent_ready[1 ]); +kill (pid,SIGKILL ); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to open child's namespace" ); + } + +TH_LOG ("Parent: opened child's namespace, got fd %d" , nsfd); + +/* Signal child that we have the fd */ + sync_byte ='G' ; +write (pipe_parent_ready[1 ], &sync_byte,1 ); +close (pipe_parent_ready[1 ]); +TH_LOG ("Parent: signaled child that we have the fd" ); + +/* Wait for child to exit */ +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +TH_LOG ("Child exited, parent holds fd %d to namespace" , nsfd); + +/* +* Namespace should still be ACTIVE because we hold an fd. +* We should be able to reopen it via file handle. +*/ +TH_LOG ("Attempting to reopen namespace via file handle (should succeed - fd held)" ); +int fd2 =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_GE (fd2,0 ); + +TH_LOG ("Successfully reopened namespace via file handle, got fd %d" , fd2); + +/* Verify it's the same namespace */ +struct stat st1, st2; +ASSERT_EQ (fstat (nsfd, &st1),0 ); +ASSERT_EQ (fstat (fd2, &st2),0 ); +TH_LOG ("Namespace inodes: nsfd=%lu, fd2=%lu" , st1.st_ino, st2.st_ino); +ASSERT_EQ (st1.st_ino, st2.st_ino); +close (fd2); + +/* Now close the fd - namespace should become inactive */ +TH_LOG ("Closing fd %d - namespace should become inactive" , nsfd); +close (nsfd); + +/* Now reopening should fail - namespace is inactive */ +TH_LOG ("Attempting to reopen namespace via file handle (should fail - inactive)" ); + fd2 =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_LT (fd2,0 ); +/* Should fail with ENOENT (inactive) or ESTALE (gone) */ +TH_LOG ("Reopen failed as expected: %s (errno=%d)" ,strerror (errno), errno); +ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 29/72 selftests/namespaces: seventh active reference count tests
In reply to Christian BraunerTest hierarchical active reference propagation.
When a child namespace is active, its owning user namespace should also be active automatically due to hierarchical active reference propagation. This ensures parents are always reachable when children are active.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 222 +++++++++++++++++++++ 1 file changed, 222 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +222 -0
@@ -20,6 +20,10 @@#define FD_NSFS_ROOT -10003/* Root of the nsfs filesystem */ #endif +#ifndef FILEID_NSFS +#define FILEID_NSFS 0xf1 +#endif +/* * Test that initial namespaces can be reopened via file handle. * Initial namespaces should have active ref count of 1 from boot.
@@ -603,4 +607,222 @@ TEST(ns_fd_keeps_active)ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); } +/* +* Test hierarchical active reference propagation. +* When a child namespace is active, its owning user namespace should also +* be active automatically due to hierarchical active reference propagation. +* This ensures parents are always reachable when children are active. +*/ +TEST (ns_parent_always_reachable) +{ +struct file_handle *parent_handle, *child_handle; +int ret; +int child_nsfd; +int pipefd[2 ]; +pid_t pid; +int status; +__u64 parent_id, child_id; +char parent_buf[sizeof (*parent_handle) +MAX_HANDLE_SZ ]; +char child_buf[sizeof (*child_handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child process */ +close (pipefd[0 ]); + +TH_LOG ("Child: creating parent user namespace and setting up mappings" ); + +/* Create parent user namespace with mappings */ + ret =setup_userns (); +if (ret <0 ) { +TH_LOG ("Child: setup_userns() for parent failed: %s" ,strerror (errno)); +close (pipefd[1 ]); +exit (1 ); + } + +TH_LOG ("Child: parent user namespace created, now uid=%d gid=%d" ,getuid (),getgid ()); + +/* Get namespace ID for parent user namespace */ +int parent_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (parent_fd <0 ) { +TH_LOG ("Child: failed to open parent /proc/self/ns/user: %s" ,strerror (errno)); +close (pipefd[1 ]); +exit (1 ); + } + +TH_LOG ("Child: opened parent userns fd %d" , parent_fd); + +if (ioctl (parent_fd,NS_GET_ID , &parent_id) <0 ) { +TH_LOG ("Child: NS_GET_ID for parent failed: %s" ,strerror (errno)); +close (parent_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (parent_fd); + +TH_LOG ("Child: got parent namespace ID %llu" , (unsigned long long )parent_id); + +/* Create child user namespace within parent */ +TH_LOG ("Child: creating nested child user namespace" ); + ret =setup_userns (); +if (ret <0 ) { +TH_LOG ("Child: setup_userns() for child failed: %s" ,strerror (errno)); +close (pipefd[1 ]); +exit (1 ); + } + +TH_LOG ("Child: nested child user namespace created, uid=%d gid=%d" ,getuid (),getgid ()); + +/* Get namespace ID for child user namespace */ +int child_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (child_fd <0 ) { +TH_LOG ("Child: failed to open child /proc/self/ns/user: %s" ,strerror (errno)); +close (pipefd[1 ]); +exit (1 ); + } + +TH_LOG ("Child: opened child userns fd %d" , child_fd); + +if (ioctl (child_fd,NS_GET_ID , &child_id) <0 ) { +TH_LOG ("Child: NS_GET_ID for child failed: %s" ,strerror (errno)); +close (child_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (child_fd); + +TH_LOG ("Child: got child namespace ID %llu" , (unsigned long long )child_id); + +/* Send both namespace IDs to parent */ +TH_LOG ("Child: sending both namespace IDs to parent" ); +write (pipefd[1 ], &parent_id,sizeof (parent_id)); +write (pipefd[1 ], &child_id,sizeof (child_id)); +close (pipefd[1 ]); + +TH_LOG ("Child: exiting - parent userns should become inactive" ); +/* Exit - parent user namespace should become inactive */ +exit (0 ); + } + +/* Parent process */ +close (pipefd[1 ]); + +TH_LOG ("Parent: reading both namespace IDs from child" ); + +/* Read both namespace IDs - fixed size, no parsing needed */ + ret =read (pipefd[0 ], &parent_id,sizeof (parent_id)); +if (ret !=sizeof (parent_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read parent namespace ID from child" ); + } + + ret =read (pipefd[0 ], &child_id,sizeof (child_id)); +close (pipefd[0 ]); +if (ret !=sizeof (child_id)) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read child namespace ID from child" ); + } + +TH_LOG ("Parent: received parent_id=%llu, child_id=%llu" , + (unsigned long long )parent_id, (unsigned long long )child_id); + +/* Construct file handles from namespace IDs */ + parent_handle = (struct file_handle *)parent_buf; + parent_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + parent_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *parent_fh = (struct nsfs_file_handle *)parent_handle->f_handle; + parent_fh->ns_id = parent_id; + parent_fh->ns_type =0 ; + parent_fh->ns_inum =0 ; + + child_handle = (struct file_handle *)child_buf; + child_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + child_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *child_fh = (struct nsfs_file_handle *)child_handle->f_handle; + child_fh->ns_id = child_id; + child_fh->ns_type =0 ; + child_fh->ns_inum =0 ; + +TH_LOG ("Parent: opening child namespace BEFORE child exits" ); + +/* Open child namespace while child is still alive to keep it active */ + child_nsfd =open_by_handle_at (FD_NSFS_ROOT , child_handle,O_RDONLY ); +if (child_nsfd <0 ) { +TH_LOG ("Failed to open child namespace: %s (errno=%d)" ,strerror (errno), errno); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to open child namespace" ); + } + +TH_LOG ("Opened child namespace fd %d" , child_nsfd); + +/* Now wait for child to exit */ +TH_LOG ("Parent: waiting for child to exit" ); +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +TH_LOG ("Child process exited, parent holds fd to child namespace" ); + +/* +* With hierarchical active reference propagation: +* Since the child namespace is active (parent process holds fd), +* the parent user namespace should ALSO be active automatically. +* This is because when we took an active reference on the child, +* it propagated up to the owning user namespace. +*/ +TH_LOG ("Attempting to reopen parent namespace (should SUCCEED - hierarchical propagation)" ); +int parent_fd =open_by_handle_at (FD_NSFS_ROOT , parent_handle,O_RDONLY ); +ASSERT_GE (parent_fd,0 ); + +TH_LOG ("SUCCESS: Parent namespace is active (fd=%d) due to active child" , parent_fd); + +/* Verify we can also get parent via NS_GET_USERNS */ +TH_LOG ("Verifying NS_GET_USERNS also works" ); +int parent_fd2 =ioctl (child_nsfd,NS_GET_USERNS ); +if (parent_fd2 <0 ) { +close (parent_fd); +close (child_nsfd); +TH_LOG ("NS_GET_USERNS failed: %s (errno=%d)" ,strerror (errno), errno); +SKIP (return,"NS_GET_USERNS not supported or failed" ); + } + +TH_LOG ("NS_GET_USERNS succeeded, got parent fd %d" , parent_fd2); + +/* Verify both methods give us the same namespace */ +struct stat st1, st2; +ASSERT_EQ (fstat (parent_fd, &st1),0 ); +ASSERT_EQ (fstat (parent_fd2, &st2),0 ); +TH_LOG ("Parent namespace inodes: parent_fd=%lu, parent_fd2=%lu" , st1.st_ino, st2.st_ino); +ASSERT_EQ (st1.st_ino, st2.st_ino); + +/* +* Close child fd - parent should remain active because we still +* hold direct references to it (parent_fd and parent_fd2). +*/ +TH_LOG ("Closing child fd - parent should remain active (direct refs held)" ); +close (child_nsfd); + +/* Parent should still be openable */ +TH_LOG ("Verifying parent still active via file handle" ); +int parent_fd3 =open_by_handle_at (FD_NSFS_ROOT , parent_handle,O_RDONLY ); +ASSERT_GE (parent_fd3,0 ); +close (parent_fd3); + +TH_LOG ("Closing all fds to parent namespace" ); +close (parent_fd); +close (parent_fd2); + +/* Both should now be inactive */ +TH_LOG ("Attempting to reopen parent (should fail - inactive, no refs)" ); + parent_fd =open_by_handle_at (FD_NSFS_ROOT , parent_handle,O_RDONLY ); +ASSERT_LT (parent_fd,0 ); +TH_LOG ("Parent inactive as expected: %s (errno=%d)" ,strerror (errno), errno); +ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 30/72 selftests/namespaces: eigth active reference count tests
In reply to Christian BraunerTest that bind mounts keep namespaces in the tree even when inactive
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 117 +++++++++++++++++++++ 1 file changed, 117 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +117 -0
@@ -825,4 +825,121 @@ TEST(ns_parent_always_reachable)ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); } +/* +* Test that bind mounts keep namespaces in the tree even when inactive +*/ +TEST (ns_bind_mount_keeps_in_tree) +{ +struct file_handle *handle; +int mount_id; +int ret; +int fd; +int pipefd[2 ]; +pid_t pid; +int status; +char buf[sizeof (*handle) +MAX_HANDLE_SZ ]; +char tmpfile[] ="/tmp/ns-test-XXXXXX" ; +int tmpfd; + +/* Create temporary file for bind mount */ + tmpfd =mkstemp (tmpfile); +if (tmpfd <0 ) { +SKIP (return,"Cannot create temporary file" ); + } +close (tmpfd); + +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child process */ +close (pipefd[0 ]); + +/* Unshare mount namespace and make mounts private to avoid propagation */ + ret =unshare (CLONE_NEWNS ); +if (ret <0 ) { +close (pipefd[1 ]); +unlink (tmpfile); +exit (1 ); + } + ret =mount (NULL ,"/" ,NULL ,MS_PRIVATE |MS_REC ,NULL ); +if (ret <0 ) { +close (pipefd[1 ]); +unlink (tmpfile); +exit (1 ); + } + +/* Create new network namespace */ + ret =unshare (CLONE_NEWNET ); +if (ret <0 ) { +close (pipefd[1 ]); +unlink (tmpfile); +exit (1 ); + } + +/* Bind mount the namespace */ + ret =mount ("/proc/self/ns/net" , tmpfile,NULL ,MS_BIND ,NULL ); +if (ret <0 ) { +close (pipefd[1 ]); +unlink (tmpfile); +exit (1 ); + } + +/* Get file handle */ + fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (fd <0 ) { +umount (tmpfile); +close (pipefd[1 ]); +unlink (tmpfile); +exit (1 ); + } + + handle = (struct file_handle *)buf; + handle->handle_bytes =MAX_HANDLE_SZ ; + ret =name_to_handle_at (fd,"" , handle, &mount_id,AT_EMPTY_PATH ); +close (fd); + +if (ret <0 ) { +umount (tmpfile); +close (pipefd[1 ]); +unlink (tmpfile); +exit (1 ); + } + +/* Send handle to parent */ +write (pipefd[1 ], buf,sizeof (*handle) + handle->handle_bytes); +close (pipefd[1 ]); +exit (0 ); + } + +/* Parent */ +close (pipefd[1 ]); + ret =read (pipefd[0 ], buf,sizeof (buf)); +close (pipefd[0 ]); + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +ASSERT_GT (ret,0 ); + handle = (struct file_handle *)buf; + +/* +* Namespace should be inactive but still in tree due to bind mount. +* Reopening should fail with ENOENT (inactive) not ESTALE (not in tree). +*/ + fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_LT (fd,0 ); +/* Should be ENOENT (inactive) since bind mount keeps it in tree */ +if (errno !=ENOENT && errno !=ESTALE ) { +TH_LOG ("Unexpected error: %d" , errno); + } + +/* Cleanup */ +umount (tmpfile); +unlink (tmpfile); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 31/72 selftests/namespaces: ninth active reference count tests
In reply to Christian BraunerTest multi-level hierarchy (3+ levels deep).
Grandparent → Parent → Child
When child is active, both parent AND grandparent should be active.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 164 +++++++++++++++++++++ 1 file changed, 164 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +164 -0
@@ -942,4 +942,168 @@ TEST(ns_bind_mount_keeps_in_tree)unlink (tmpfile); } +/* +* Test multi-level hierarchy (3+ levels deep). +* Grandparent → Parent → Child +* When child is active, both parent AND grandparent should be active. +*/ +TEST (ns_multilevel_hierarchy) +{ +struct file_handle *gp_handle, *p_handle, *c_handle; +int ret, pipefd[2 ]; +pid_t pid; +int status; +__u64 gp_id, p_id, c_id; +char gp_buf[sizeof (*gp_handle) +MAX_HANDLE_SZ ]; +char p_buf[sizeof (*p_handle) +MAX_HANDLE_SZ ]; +char c_buf[sizeof (*c_handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +close (pipefd[0 ]); + +/* Create grandparent user namespace */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int gp_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (gp_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (gp_fd,NS_GET_ID , &gp_id) <0 ) { +close (gp_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (gp_fd); + +/* Create parent user namespace */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int p_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (p_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (p_fd,NS_GET_ID , &p_id) <0 ) { +close (p_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (p_fd); + +/* Create child user namespace */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int c_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (c_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (c_fd,NS_GET_ID , &c_id) <0 ) { +close (c_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (c_fd); + +/* Send all three namespace IDs */ +write (pipefd[1 ], &gp_id,sizeof (gp_id)); +write (pipefd[1 ], &p_id,sizeof (p_id)); +write (pipefd[1 ], &c_id,sizeof (c_id)); +close (pipefd[1 ]); +exit (0 ); + } + +close (pipefd[1 ]); + +/* Read all three namespace IDs - fixed size, no parsing needed */ + ret =read (pipefd[0 ], &gp_id,sizeof (gp_id)); +if (ret !=sizeof (gp_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read grandparent namespace ID from child" ); + } + + ret =read (pipefd[0 ], &p_id,sizeof (p_id)); +if (ret !=sizeof (p_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read parent namespace ID from child" ); + } + + ret =read (pipefd[0 ], &c_id,sizeof (c_id)); +close (pipefd[0 ]); +if (ret !=sizeof (c_id)) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read child namespace ID from child" ); + } + +/* Construct file handles from namespace IDs */ + gp_handle = (struct file_handle *)gp_buf; + gp_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + gp_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *gp_fh = (struct nsfs_file_handle *)gp_handle->f_handle; + gp_fh->ns_id = gp_id; + gp_fh->ns_type =0 ; + gp_fh->ns_inum =0 ; + + p_handle = (struct file_handle *)p_buf; + p_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + p_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *p_fh = (struct nsfs_file_handle *)p_handle->f_handle; + p_fh->ns_id = p_id; + p_fh->ns_type =0 ; + p_fh->ns_inum =0 ; + + c_handle = (struct file_handle *)c_buf; + c_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + c_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *c_fh = (struct nsfs_file_handle *)c_handle->f_handle; + c_fh->ns_id = c_id; + c_fh->ns_type =0 ; + c_fh->ns_inum =0 ; + +/* Open child before process exits */ +int c_fd =open_by_handle_at (FD_NSFS_ROOT , c_handle,O_RDONLY ); +if (c_fd <0 ) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to open child namespace" ); + } + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* +* With 3-level hierarchy and child active: +* - Child is active (we hold fd) +* - Parent should be active (propagated from child) +* - Grandparent should be active (propagated from parent) +*/ +TH_LOG ("Testing parent active when child is active" ); +int p_fd =open_by_handle_at (FD_NSFS_ROOT , p_handle,O_RDONLY ); +ASSERT_GE (p_fd,0 ); + +TH_LOG ("Testing grandparent active when child is active" ); +int gp_fd =open_by_handle_at (FD_NSFS_ROOT , gp_handle,O_RDONLY ); +ASSERT_GE (gp_fd,0 ); + +close (c_fd); +close (p_fd); +close (gp_fd); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 32/72 selftests/namespaces: tenth active reference count tests
In reply to Christian BraunerTest multiple children sharing same parent. Parent should stay active as long as ANY child is active.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 170 +++++++++++++++++++++ 1 file changed, 170 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +170 -0
@@ -1106,4 +1106,174 @@ TEST(ns_multilevel_hierarchy)close (gp_fd); } +/* +* Test multiple children sharing same parent. +* Parent should stay active as long as ANY child is active. +*/ +TEST (ns_multiple_children_same_parent) +{ +struct file_handle *p_handle, *c1_handle, *c2_handle; +int ret, pipefd[2 ]; +pid_t pid; +int status; +__u64 p_id, c1_id, c2_id; +char p_buf[sizeof (*p_handle) +MAX_HANDLE_SZ ]; +char c1_buf[sizeof (*c1_handle) +MAX_HANDLE_SZ ]; +char c2_buf[sizeof (*c2_handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +close (pipefd[0 ]); + +/* Create parent user namespace */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int p_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (p_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (p_fd,NS_GET_ID , &p_id) <0 ) { +close (p_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (p_fd); + +/* Create first child user namespace */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int c1_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (c1_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (c1_fd,NS_GET_ID , &c1_id) <0 ) { +close (c1_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (c1_fd); + +/* Return to parent user namespace and create second child */ +/* We can't actually do this easily, so let's create a sibling namespace +* by creating a network namespace instead */ +if (unshare (CLONE_NEWNET ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int c2_fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (c2_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (c2_fd,NS_GET_ID , &c2_id) <0 ) { +close (c2_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (c2_fd); + +/* Send all namespace IDs */ +write (pipefd[1 ], &p_id,sizeof (p_id)); +write (pipefd[1 ], &c1_id,sizeof (c1_id)); +write (pipefd[1 ], &c2_id,sizeof (c2_id)); +close (pipefd[1 ]); +exit (0 ); + } + +close (pipefd[1 ]); + +/* Read all three namespace IDs - fixed size, no parsing needed */ + ret =read (pipefd[0 ], &p_id,sizeof (p_id)); +if (ret !=sizeof (p_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read parent namespace ID" ); + } + + ret =read (pipefd[0 ], &c1_id,sizeof (c1_id)); +if (ret !=sizeof (c1_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read first child namespace ID" ); + } + + ret =read (pipefd[0 ], &c2_id,sizeof (c2_id)); +close (pipefd[0 ]); +if (ret !=sizeof (c2_id)) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read second child namespace ID" ); + } + +/* Construct file handles from namespace IDs */ + p_handle = (struct file_handle *)p_buf; + p_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + p_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *p_fh = (struct nsfs_file_handle *)p_handle->f_handle; + p_fh->ns_id = p_id; + p_fh->ns_type =0 ; + p_fh->ns_inum =0 ; + + c1_handle = (struct file_handle *)c1_buf; + c1_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + c1_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *c1_fh = (struct nsfs_file_handle *)c1_handle->f_handle; + c1_fh->ns_id = c1_id; + c1_fh->ns_type =0 ; + c1_fh->ns_inum =0 ; + + c2_handle = (struct file_handle *)c2_buf; + c2_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + c2_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *c2_fh = (struct nsfs_file_handle *)c2_handle->f_handle; + c2_fh->ns_id = c2_id; + c2_fh->ns_type =0 ; + c2_fh->ns_inum =0 ; + +/* Open both children before process exits */ +int c1_fd =open_by_handle_at (FD_NSFS_ROOT , c1_handle,O_RDONLY ); +int c2_fd =open_by_handle_at (FD_NSFS_ROOT , c2_handle,O_RDONLY ); + +if (c1_fd <0 || c2_fd <0 ) { +if (c1_fd >=0 )close (c1_fd); +if (c2_fd >=0 )close (c2_fd); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to open child namespaces" ); + } + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* Parent should be active (both children active) */ +TH_LOG ("Both children active - parent should be active" ); +int p_fd =open_by_handle_at (FD_NSFS_ROOT , p_handle,O_RDONLY ); +ASSERT_GE (p_fd,0 ); +close (p_fd); + +/* Close first child - parent should STILL be active */ +TH_LOG ("Closing first child - parent should still be active" ); +close (c1_fd); + p_fd =open_by_handle_at (FD_NSFS_ROOT , p_handle,O_RDONLY ); +ASSERT_GE (p_fd,0 ); +close (p_fd); + +/* Close second child - NOW parent should become inactive */ +TH_LOG ("Closing second child - parent should become inactive" ); +close (c2_fd); + p_fd =open_by_handle_at (FD_NSFS_ROOT , p_handle,O_RDONLY ); +ASSERT_LT (p_fd,0 ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 33/72 selftests/namespaces: eleventh active reference count tests
In reply to Christian BraunerTest that different namespace types with same owner all contribute active references to the owning user namespace.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 171 +++++++++++++++++++++ 1 file changed, 171 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +171 -0
@@ -1276,4 +1276,175 @@ TEST(ns_multiple_children_same_parent)ASSERT_LT (p_fd,0 ); } +/* +* Test that different namespace types with same owner all contribute +* active references to the owning user namespace. +*/ +TEST (ns_different_types_same_owner) +{ +struct file_handle *u_handle, *n_handle, *ut_handle; +int ret, pipefd[2 ]; +pid_t pid; +int status; +__u64 u_id, n_id, ut_id; +char u_buf[sizeof (*u_handle) +MAX_HANDLE_SZ ]; +char n_buf[sizeof (*n_handle) +MAX_HANDLE_SZ ]; +char ut_buf[sizeof (*ut_handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +close (pipefd[0 ]); + +/* Create user namespace */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int u_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (u_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (u_fd,NS_GET_ID , &u_id) <0 ) { +close (u_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (u_fd); + +/* Create network namespace (owned by user namespace) */ +if (unshare (CLONE_NEWNET ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int n_fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (n_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (n_fd,NS_GET_ID , &n_id) <0 ) { +close (n_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (n_fd); + +/* Create UTS namespace (also owned by user namespace) */ +if (unshare (CLONE_NEWUTS ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int ut_fd =open ("/proc/self/ns/uts" ,O_RDONLY ); +if (ut_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (ut_fd,NS_GET_ID , &ut_id) <0 ) { +close (ut_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (ut_fd); + +/* Send all namespace IDs */ +write (pipefd[1 ], &u_id,sizeof (u_id)); +write (pipefd[1 ], &n_id,sizeof (n_id)); +write (pipefd[1 ], &ut_id,sizeof (ut_id)); +close (pipefd[1 ]); +exit (0 ); + } + +close (pipefd[1 ]); + +/* Read all three namespace IDs - fixed size, no parsing needed */ + ret =read (pipefd[0 ], &u_id,sizeof (u_id)); +if (ret !=sizeof (u_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read user namespace ID" ); + } + + ret =read (pipefd[0 ], &n_id,sizeof (n_id)); +if (ret !=sizeof (n_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read network namespace ID" ); + } + + ret =read (pipefd[0 ], &ut_id,sizeof (ut_id)); +close (pipefd[0 ]); +if (ret !=sizeof (ut_id)) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read UTS namespace ID" ); + } + +/* Construct file handles from namespace IDs */ + u_handle = (struct file_handle *)u_buf; + u_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + u_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *u_fh = (struct nsfs_file_handle *)u_handle->f_handle; + u_fh->ns_id = u_id; + u_fh->ns_type =0 ; + u_fh->ns_inum =0 ; + + n_handle = (struct file_handle *)n_buf; + n_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + n_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *n_fh = (struct nsfs_file_handle *)n_handle->f_handle; + n_fh->ns_id = n_id; + n_fh->ns_type =0 ; + n_fh->ns_inum =0 ; + + ut_handle = (struct file_handle *)ut_buf; + ut_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + ut_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *ut_fh = (struct nsfs_file_handle *)ut_handle->f_handle; + ut_fh->ns_id = ut_id; + ut_fh->ns_type =0 ; + ut_fh->ns_inum =0 ; + +/* Open both non-user namespaces before process exits */ +int n_fd =open_by_handle_at (FD_NSFS_ROOT , n_handle,O_RDONLY ); +int ut_fd =open_by_handle_at (FD_NSFS_ROOT , ut_handle,O_RDONLY ); + +if (n_fd <0 || ut_fd <0 ) { +if (n_fd >=0 )close (n_fd); +if (ut_fd >=0 )close (ut_fd); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to open namespaces" ); + } + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* +* Both network and UTS namespaces are active. +* User namespace should be active (gets 2 active refs). +*/ +TH_LOG ("Both net and uts active - user namespace should be active" ); +int u_fd =open_by_handle_at (FD_NSFS_ROOT , u_handle,O_RDONLY ); +ASSERT_GE (u_fd,0 ); +close (u_fd); + +/* Close network namespace - user namespace should STILL be active */ +TH_LOG ("Closing network ns - user ns should still be active (uts still active)" ); +close (n_fd); + u_fd =open_by_handle_at (FD_NSFS_ROOT , u_handle,O_RDONLY ); +ASSERT_GE (u_fd,0 ); +close (u_fd); + +/* Close UTS namespace - user namespace should become inactive */ +TH_LOG ("Closing uts ns - user ns should become inactive" ); +close (ut_fd); + u_fd =open_by_handle_at (FD_NSFS_ROOT , u_handle,O_RDONLY ); +ASSERT_LT (u_fd,0 ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 34/72 selftests/namespaces: twelth active reference count tests
In reply to Christian BraunerTest hierarchical propagation with deep namespace hierarchy.
Create: init_user_ns -> user_A -> user_B -> net_ns
When net_ns is active, both user_A and user_B should be active. This verifies the conditional recursion in __ns_ref_active_put() works.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 176 +++++++++++++++++++++ 1 file changed, 176 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +176 -0
@@ -1447,4 +1447,180 @@ TEST(ns_different_types_same_owner)ASSERT_LT (u_fd,0 ); } +/* +* Test hierarchical propagation with deep namespace hierarchy. +* Create: init_user_ns -> user_A -> user_B -> net_ns +* When net_ns is active, both user_A and user_B should be active. +* This verifies the conditional recursion in __ns_ref_active_put() works. +*/ +TEST (ns_deep_hierarchy_propagation) +{ +struct file_handle *ua_handle, *ub_handle, *net_handle; +int ret, pipefd[2 ]; +pid_t pid; +int status; +__u64 ua_id, ub_id, net_id; +char ua_buf[sizeof (*ua_handle) +MAX_HANDLE_SZ ]; +char ub_buf[sizeof (*ub_handle) +MAX_HANDLE_SZ ]; +char net_buf[sizeof (*net_handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +close (pipefd[0 ]); + +/* Create user_A -> user_B -> net hierarchy */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int ua_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (ua_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (ua_fd,NS_GET_ID , &ua_id) <0 ) { +close (ua_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (ua_fd); + +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int ub_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (ub_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (ub_fd,NS_GET_ID , &ub_id) <0 ) { +close (ub_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (ub_fd); + +if (unshare (CLONE_NEWNET ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int net_fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (net_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (net_fd,NS_GET_ID , &net_id) <0 ) { +close (net_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (net_fd); + +/* Send all three namespace IDs */ +write (pipefd[1 ], &ua_id,sizeof (ua_id)); +write (pipefd[1 ], &ub_id,sizeof (ub_id)); +write (pipefd[1 ], &net_id,sizeof (net_id)); +close (pipefd[1 ]); +exit (0 ); + } + +close (pipefd[1 ]); + +/* Read all three namespace IDs - fixed size, no parsing needed */ + ret =read (pipefd[0 ], &ua_id,sizeof (ua_id)); +if (ret !=sizeof (ua_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read user_A namespace ID" ); + } + + ret =read (pipefd[0 ], &ub_id,sizeof (ub_id)); +if (ret !=sizeof (ub_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read user_B namespace ID" ); + } + + ret =read (pipefd[0 ], &net_id,sizeof (net_id)); +close (pipefd[0 ]); +if (ret !=sizeof (net_id)) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read network namespace ID" ); + } + +/* Construct file handles from namespace IDs */ + ua_handle = (struct file_handle *)ua_buf; + ua_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + ua_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *ua_fh = (struct nsfs_file_handle *)ua_handle->f_handle; + ua_fh->ns_id = ua_id; + ua_fh->ns_type =0 ; + ua_fh->ns_inum =0 ; + + ub_handle = (struct file_handle *)ub_buf; + ub_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + ub_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *ub_fh = (struct nsfs_file_handle *)ub_handle->f_handle; + ub_fh->ns_id = ub_id; + ub_fh->ns_type =0 ; + ub_fh->ns_inum =0 ; + + net_handle = (struct file_handle *)net_buf; + net_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + net_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *net_fh = (struct nsfs_file_handle *)net_handle->f_handle; + net_fh->ns_id = net_id; + net_fh->ns_type =0 ; + net_fh->ns_inum =0 ; + +/* Open net_ns before child exits to keep it active */ +int net_fd =open_by_handle_at (FD_NSFS_ROOT , net_handle,O_RDONLY ); +if (net_fd <0 ) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to open network namespace" ); + } + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* With net_ns active, both user_A and user_B should be active */ +TH_LOG ("Testing user_B active (net_ns active causes propagation)" ); +int ub_fd =open_by_handle_at (FD_NSFS_ROOT , ub_handle,O_RDONLY ); +ASSERT_GE (ub_fd,0 ); + +TH_LOG ("Testing user_A active (propagated through user_B)" ); +int ua_fd =open_by_handle_at (FD_NSFS_ROOT , ua_handle,O_RDONLY ); +ASSERT_GE (ua_fd,0 ); + +/* Close net_ns - user_B should stay active (we hold direct ref) */ +TH_LOG ("Closing net_ns, user_B should remain active (direct ref held)" ); +close (net_fd); +int ub_fd2 =open_by_handle_at (FD_NSFS_ROOT , ub_handle,O_RDONLY ); +ASSERT_GE (ub_fd2,0 ); +close (ub_fd2); + +/* Close user_B - user_A should stay active (we hold direct ref) */ +TH_LOG ("Closing user_B, user_A should remain active (direct ref held)" ); +close (ub_fd); +int ua_fd2 =open_by_handle_at (FD_NSFS_ROOT , ua_handle,O_RDONLY ); +ASSERT_GE (ua_fd2,0 ); +close (ua_fd2); + +/* Close user_A - everything should become inactive */ +TH_LOG ("Closing user_A, all should become inactive" ); +close (ua_fd); + +/* All should now be inactive */ + ua_fd =open_by_handle_at (FD_NSFS_ROOT , ua_handle,O_RDONLY ); +ASSERT_LT (ua_fd,0 ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 35/72 selftests/namespaces: thirteenth active reference count tests
In reply to Christian BraunerTest that parent stays active as long as ANY child is active. Create parent user namespace with two child net namespaces. Parent should remain active until BOTH children are inactive.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 194 +++++++++++++++++++++ 1 file changed, 194 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +194 -0
@@ -1623,4 +1623,198 @@ TEST(ns_deep_hierarchy_propagation)ASSERT_LT (ua_fd,0 ); } +/* +* Test that parent stays active as long as ANY child is active. +* Create parent user namespace with two child net namespaces. +* Parent should remain active until BOTH children are inactive. +*/ +TEST (ns_parent_multiple_children_refcount) +{ +struct file_handle *parent_handle, *net1_handle, *net2_handle; +int ret, pipefd[2 ], syncpipe[2 ]; +pid_t pid; +int status; +__u64 p_id, n1_id, n2_id; +char p_buf[sizeof (*parent_handle) +MAX_HANDLE_SZ ]; +char n1_buf[sizeof (*net1_handle) +MAX_HANDLE_SZ ]; +char n2_buf[sizeof (*net2_handle) +MAX_HANDLE_SZ ]; +char sync_byte; + +ASSERT_EQ (pipe (pipefd),0 ); +ASSERT_EQ (pipe (syncpipe),0 ); + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +close (pipefd[0 ]); +close (syncpipe[1 ]); + +/* Create parent user namespace */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int p_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (p_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (p_fd,NS_GET_ID , &p_id) <0 ) { +close (p_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (p_fd); + +/* Create first network namespace */ +if (unshare (CLONE_NEWNET ) <0 ) { +close (pipefd[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } + +int n1_fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (n1_fd <0 ) { +close (pipefd[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } +if (ioctl (n1_fd,NS_GET_ID , &n1_id) <0 ) { +close (n1_fd); +close (pipefd[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } +/* Keep n1_fd open so first namespace stays active */ + +/* Create second network namespace */ +if (unshare (CLONE_NEWNET ) <0 ) { +close (n1_fd); +close (pipefd[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } + +int n2_fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (n2_fd <0 ) { +close (n1_fd); +close (pipefd[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } +if (ioctl (n2_fd,NS_GET_ID , &n2_id) <0 ) { +close (n1_fd); +close (n2_fd); +close (pipefd[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } +/* Keep both n1_fd and n2_fd open */ + +/* Send all namespace IDs */ +write (pipefd[1 ], &p_id,sizeof (p_id)); +write (pipefd[1 ], &n1_id,sizeof (n1_id)); +write (pipefd[1 ], &n2_id,sizeof (n2_id)); +close (pipefd[1 ]); + +/* Wait for parent to signal before exiting */ +read (syncpipe[0 ], &sync_byte,1 ); +close (syncpipe[0 ]); +exit (0 ); + } + +close (pipefd[1 ]); +close (syncpipe[0 ]); + +/* Read all three namespace IDs - fixed size, no parsing needed */ + ret =read (pipefd[0 ], &p_id,sizeof (p_id)); +if (ret !=sizeof (p_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read parent namespace ID" ); + } + + ret =read (pipefd[0 ], &n1_id,sizeof (n1_id)); +if (ret !=sizeof (n1_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read first network namespace ID" ); + } + + ret =read (pipefd[0 ], &n2_id,sizeof (n2_id)); +close (pipefd[0 ]); +if (ret !=sizeof (n2_id)) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read second network namespace ID" ); + } + +/* Construct file handles from namespace IDs */ + parent_handle = (struct file_handle *)p_buf; + parent_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + parent_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *p_fh = (struct nsfs_file_handle *)parent_handle->f_handle; + p_fh->ns_id = p_id; + p_fh->ns_type =0 ; + p_fh->ns_inum =0 ; + + net1_handle = (struct file_handle *)n1_buf; + net1_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + net1_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *n1_fh = (struct nsfs_file_handle *)net1_handle->f_handle; + n1_fh->ns_id = n1_id; + n1_fh->ns_type =0 ; + n1_fh->ns_inum =0 ; + + net2_handle = (struct file_handle *)n2_buf; + net2_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + net2_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *n2_fh = (struct nsfs_file_handle *)net2_handle->f_handle; + n2_fh->ns_id = n2_id; + n2_fh->ns_type =0 ; + n2_fh->ns_inum =0 ; + +/* Open both net namespaces while child is still alive */ +int n1_fd =open_by_handle_at (FD_NSFS_ROOT , net1_handle,O_RDONLY ); +int n2_fd =open_by_handle_at (FD_NSFS_ROOT , net2_handle,O_RDONLY ); +if (n1_fd <0 || n2_fd <0 ) { +if (n1_fd >=0 )close (n1_fd); +if (n2_fd >=0 )close (n2_fd); + sync_byte ='G' ; +write (syncpipe[1 ], &sync_byte,1 ); +close (syncpipe[1 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to open net namespaces" ); + } + +/* Signal child that we have opened the namespaces */ + sync_byte ='G' ; +write (syncpipe[1 ], &sync_byte,1 ); +close (syncpipe[1 ]); + +/* Wait for child to exit */ +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* Parent should be active (has 2 active children) */ +TH_LOG ("Both net namespaces active - parent should be active" ); +int p_fd =open_by_handle_at (FD_NSFS_ROOT , parent_handle,O_RDONLY ); +ASSERT_GE (p_fd,0 ); +close (p_fd); + +/* Close first net namespace - parent should STILL be active */ +TH_LOG ("Closing first net ns - parent should still be active" ); +close (n1_fd); + p_fd =open_by_handle_at (FD_NSFS_ROOT , parent_handle,O_RDONLY ); +ASSERT_GE (p_fd,0 ); +close (p_fd); + +/* Close second net namespace - parent should become inactive */ +TH_LOG ("Closing second net ns - parent should become inactive" ); +close (n2_fd); + p_fd =open_by_handle_at (FD_NSFS_ROOT , parent_handle,O_RDONLY ); +ASSERT_LT (p_fd,0 ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 36/72 selftests/namespaces: fourteenth active reference count tests
In reply to Christian BraunerTest that user namespace as a child also propagates correctly. Create user_A -> user_B, verify when user_B is active that user_A is also active. This is different from non-user namespace children.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 132 +++++++++++++++++++++ 1 file changed, 132 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +132 -0
@@ -1817,4 +1817,136 @@ TEST(ns_parent_multiple_children_refcount)ASSERT_LT (p_fd,0 ); } +/* +* Test that user namespace as a child also propagates correctly. +* Create user_A -> user_B, verify when user_B is active that user_A +* is also active. This is different from non-user namespace children. +*/ +TEST (ns_userns_child_propagation) +{ +struct file_handle *ua_handle, *ub_handle; +int ret, pipefd[2 ]; +pid_t pid; +int status; +__u64 ua_id, ub_id; +char ua_buf[sizeof (*ua_handle) +MAX_HANDLE_SZ ]; +char ub_buf[sizeof (*ub_handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +close (pipefd[0 ]); + +/* Create user_A */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int ua_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (ua_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (ua_fd,NS_GET_ID , &ua_id) <0 ) { +close (ua_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (ua_fd); + +/* Create user_B (child of user_A) */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int ub_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (ub_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (ub_fd,NS_GET_ID , &ub_id) <0 ) { +close (ub_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (ub_fd); + +/* Send both namespace IDs */ +write (pipefd[1 ], &ua_id,sizeof (ua_id)); +write (pipefd[1 ], &ub_id,sizeof (ub_id)); +close (pipefd[1 ]); +exit (0 ); + } + +close (pipefd[1 ]); + +/* Read both namespace IDs - fixed size, no parsing needed */ + ret =read (pipefd[0 ], &ua_id,sizeof (ua_id)); +if (ret !=sizeof (ua_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read user_A namespace ID" ); + } + + ret =read (pipefd[0 ], &ub_id,sizeof (ub_id)); +close (pipefd[0 ]); +if (ret !=sizeof (ub_id)) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read user_B namespace ID" ); + } + +/* Construct file handles from namespace IDs */ + ua_handle = (struct file_handle *)ua_buf; + ua_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + ua_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *ua_fh = (struct nsfs_file_handle *)ua_handle->f_handle; + ua_fh->ns_id = ua_id; + ua_fh->ns_type =0 ; + ua_fh->ns_inum =0 ; + + ub_handle = (struct file_handle *)ub_buf; + ub_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + ub_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *ub_fh = (struct nsfs_file_handle *)ub_handle->f_handle; + ub_fh->ns_id = ub_id; + ub_fh->ns_type =0 ; + ub_fh->ns_inum =0 ; + +/* Open user_B before child exits */ +int ub_fd =open_by_handle_at (FD_NSFS_ROOT , ub_handle,O_RDONLY ); +if (ub_fd <0 ) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to open user_B" ); + } + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* With user_B active, user_A should also be active */ +TH_LOG ("Testing user_A active when child user_B is active" ); +int ua_fd =open_by_handle_at (FD_NSFS_ROOT , ua_handle,O_RDONLY ); +ASSERT_GE (ua_fd,0 ); + +/* Close user_B */ +TH_LOG ("Closing user_B" ); +close (ub_fd); + +/* user_A should remain active (we hold direct ref) */ +int ua_fd2 =open_by_handle_at (FD_NSFS_ROOT , ua_handle,O_RDONLY ); +ASSERT_GE (ua_fd2,0 ); +close (ua_fd2); + +/* Close user_A - should become inactive */ +TH_LOG ("Closing user_A - should become inactive" ); +close (ua_fd); + + ua_fd =open_by_handle_at (FD_NSFS_ROOT , ua_handle,O_RDONLY ); +ASSERT_LT (ua_fd,0 ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 37/72 selftests/namespaces: fifteenth active reference count tests
In reply to Christian BraunerTest different namespace types (net, uts, ipc) all contributing active references to the same owning user namespace.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 164 +++++++++++++++++++++ 1 file changed, 164 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +164 -0
@@ -1949,4 +1949,168 @@ TEST(ns_userns_child_propagation)ASSERT_LT (ua_fd,0 ); } +/* +* Test different namespace types (net, uts, ipc) all contributing +* active references to the same owning user namespace. +*/ +TEST (ns_mixed_types_same_owner) +{ +struct file_handle *user_handle, *net_handle, *uts_handle; +int ret, pipefd[2 ]; +pid_t pid; +int status; +__u64 u_id, n_id, ut_id; +char u_buf[sizeof (*user_handle) +MAX_HANDLE_SZ ]; +char n_buf[sizeof (*net_handle) +MAX_HANDLE_SZ ]; +char ut_buf[sizeof (*uts_handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +close (pipefd[0 ]); + +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int u_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (u_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (u_fd,NS_GET_ID , &u_id) <0 ) { +close (u_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (u_fd); + +if (unshare (CLONE_NEWNET ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int n_fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (n_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (n_fd,NS_GET_ID , &n_id) <0 ) { +close (n_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (n_fd); + +if (unshare (CLONE_NEWUTS ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +int ut_fd =open ("/proc/self/ns/uts" ,O_RDONLY ); +if (ut_fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } +if (ioctl (ut_fd,NS_GET_ID , &ut_id) <0 ) { +close (ut_fd); +close (pipefd[1 ]); +exit (1 ); + } +close (ut_fd); + +/* Send all namespace IDs */ +write (pipefd[1 ], &u_id,sizeof (u_id)); +write (pipefd[1 ], &n_id,sizeof (n_id)); +write (pipefd[1 ], &ut_id,sizeof (ut_id)); +close (pipefd[1 ]); +exit (0 ); + } + +close (pipefd[1 ]); + +/* Read all three namespace IDs - fixed size, no parsing needed */ + ret =read (pipefd[0 ], &u_id,sizeof (u_id)); +if (ret !=sizeof (u_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read user namespace ID" ); + } + + ret =read (pipefd[0 ], &n_id,sizeof (n_id)); +if (ret !=sizeof (n_id)) { +close (pipefd[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read network namespace ID" ); + } + + ret =read (pipefd[0 ], &ut_id,sizeof (ut_id)); +close (pipefd[0 ]); +if (ret !=sizeof (ut_id)) { +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read UTS namespace ID" ); + } + +/* Construct file handles from namespace IDs */ + user_handle = (struct file_handle *)u_buf; + user_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + user_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *u_fh = (struct nsfs_file_handle *)user_handle->f_handle; + u_fh->ns_id = u_id; + u_fh->ns_type =0 ; + u_fh->ns_inum =0 ; + + net_handle = (struct file_handle *)n_buf; + net_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + net_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *n_fh = (struct nsfs_file_handle *)net_handle->f_handle; + n_fh->ns_id = n_id; + n_fh->ns_type =0 ; + n_fh->ns_inum =0 ; + + uts_handle = (struct file_handle *)ut_buf; + uts_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + uts_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *ut_fh = (struct nsfs_file_handle *)uts_handle->f_handle; + ut_fh->ns_id = ut_id; + ut_fh->ns_type =0 ; + ut_fh->ns_inum =0 ; + +/* Open both non-user namespaces */ +int n_fd =open_by_handle_at (FD_NSFS_ROOT , net_handle,O_RDONLY ); +int ut_fd =open_by_handle_at (FD_NSFS_ROOT , uts_handle,O_RDONLY ); +if (n_fd <0 || ut_fd <0 ) { +if (n_fd >=0 )close (n_fd); +if (ut_fd >=0 )close (ut_fd); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to open namespaces" ); + } + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* User namespace should be active (2 active children) */ +TH_LOG ("Both net and uts active - user ns should be active" ); +int u_fd =open_by_handle_at (FD_NSFS_ROOT , user_handle,O_RDONLY ); +ASSERT_GE (u_fd,0 ); +close (u_fd); + +/* Close net - user ns should STILL be active (uts still active) */ +TH_LOG ("Closing net - user ns should still be active" ); +close (n_fd); + u_fd =open_by_handle_at (FD_NSFS_ROOT , user_handle,O_RDONLY ); +ASSERT_GE (u_fd,0 ); +close (u_fd); + +/* Close uts - user ns should become inactive */ +TH_LOG ("Closing uts - user ns should become inactive" ); +close (ut_fd); + u_fd =open_by_handle_at (FD_NSFS_ROOT , user_handle,O_RDONLY ); +ASSERT_LT (u_fd,0 ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 38/72 selftests/namespaces: add listns() wrapper
In reply to Christian BraunerAdd a wrapper for the listns() system call.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/wrappers.h | 35 +++++++++++++++++++++++++++ 1 file changed, 35 insertions(+)
tools/testing/selftests/namespaces/wrappers.h new file +35 -0
@@ -0,0 +1,35 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <linux/nsfs.h> +#include <linux/types.h> +#include <sys/syscall.h> +#include <unistd.h> + +#ifndef __SELFTESTS_NAMESPACES_WRAPPERS_H__ +#define __SELFTESTS_NAMESPACES_WRAPPERS_H__ + +#ifndef __NR_listns +#if defined __alpha__ +#define __NR_listns 580 +#elif defined _MIPS_SIM +#if _MIPS_SIM == _MIPS_SIM_ABI32/* o32 */ +#define __NR_listns 4470 +#endif +#if _MIPS_SIM == _MIPS_SIM_NABI32/* n32 */ +#define __NR_listns 6470 +#endif +#if _MIPS_SIM == _MIPS_SIM_ABI64/* n64 */ +#define __NR_listns 5470 +#endif +#else +#define __NR_listns 470 +#endif +#endif + +static inline int sys_listns (const struct ns_id_req *req,__u64 *ns_ids, +size_t nr_ns_ids,unsigned int flags) +{ +return syscall (__NR_listns, req, ns_ids, nr_ns_ids, flags); +} + +#endif /* __SELFTESTS_NAMESPACES_WRAPPERS_H__ */
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 39/72 selftests/namespaces: first listns() test
In reply to Christian BraunerTest basic listns() functionality with the unified namespace tree. List all active namespaces globally.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/.gitignore | 1 + tools/testing/selftests/namespaces/Makefile | 3 +- tools/testing/selftests/namespaces/listns_test.c | 57 ++++++++++++++++++++++++ 3 files changed, 60 insertions(+), 1 deletion(-)
tools/testing/selftests/namespaces/.gitignore +1 -0
@@ -2,3 +2,4 @@ nsid_test file_handle_test init_ino_test ns_active_ref_test +listns_test
tools/testing/selftests/namespaces/Makefile +2 -1
@@ -2,9 +2,10 @@ CFLAGS += -Wall -O0 -g $(KHDR_INCLUDES) $(TOOLS_INCLUDES) LDLIBS += -lcap -TEST_GEN_PROGS := nsid_test file_handle_test init_ino_test ns_active_ref_test +TEST_GEN_PROGS := nsid_test file_handle_test init_ino_test ns_active_ref_test listns_test include ../lib.mk $(OUTPUT)/ns_active_ref_test: ../filesystems/utils.c +$(OUTPUT)/listns_test: ../filesystems/utils.c
tools/testing/selftests/namespaces/listns_test.c new file +57 -0
57 lines not on this page · raw message
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 40/72 selftests/namespaces: second listns() test
In reply to Christian Braunertest listns() with type filtering.
List only network namespaces.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/listns_test.c | 61 ++++++++++++++++++++++++ 1 file changed, 61 insertions(+)
tools/testing/selftests/namespaces/listns_test.c +61 -0
@@ -54,4 +54,65 @@ TEST(listns_basic_unified) } } +/* +* Test listns() with type filtering. +* List only network namespaces. +*/ +TEST (listns_filter_by_type) +{ +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =CLONE_NEWNET ,/* Only network namespaces */ + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 ns_ids[100 ]; +ssize_t ret; + + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +if (ret <0 ) { +if (errno ==ENOSYS ) +SKIP (return,"listns() not supported" ); +TH_LOG ("listns failed: %s (errno=%d)" ,strerror (errno), errno); +ASSERT_TRUE (false); + } +ASSERT_GE (ret,0 ); + +/* Should find at least init_net */ +ASSERT_GT (ret,0 ); +TH_LOG ("Found %zd active network namespaces" , ret); + +/* Verify we can open each namespace and it's actually a network namespace */ +for (ssize_t i =0 ; i < ret && i <5 ; i++) { +struct nsfs_file_handle nsfh = { + .ns_id = ns_ids[i], + .ns_type =CLONE_NEWNET , + .ns_inum =0 , + }; +struct file_handle *fh; +int fd; + + fh = (struct file_handle *)malloc (sizeof (*fh) +sizeof (nsfh)); +ASSERT_NE (fh,NULL ); + fh->handle_bytes =sizeof (nsfh); + fh->handle_type =0 ; +memcpy (fh->f_handle, &nsfh,sizeof (nsfh)); + + fd =open_by_handle_at (-10003 , fh,O_RDONLY ); +free (fh); + +if (fd >=0 ) { +int ns_type; +/* Verify it's a network namespace via ioctl */ + ns_type =ioctl (fd,NS_GET_NSTYPE ); +if (ns_type >=0 ) { +ASSERT_EQ (ns_type,CLONE_NEWNET ); + } +close (fd); + } + } +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 41/72 selftests/namespaces: third listns() test
In reply to Christian BraunerTest listns() pagination.
List namespaces in batches.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/listns_test.c | 53 ++++++++++++++++++++++++ 1 file changed, 53 insertions(+)
tools/testing/selftests/namespaces/listns_test.c +53 -0
@@ -115,4 +115,57 @@ TEST(listns_filter_by_type) } } +/* +* Test listns() pagination. +* List namespaces in batches. +*/ +TEST (listns_pagination) +{ +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =0 , + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 batch1[2 ], batch2[2 ]; +ssize_t ret1, ret2; + +/* Get first batch */ + ret1 =sys_listns (&req, batch1,ARRAY_SIZE (batch1),0 ); +if (ret1 <0 ) { +if (errno ==ENOSYS ) +SKIP (return,"listns() not supported" ); +TH_LOG ("listns failed: %s (errno=%d)" ,strerror (errno), errno); +ASSERT_TRUE (false); + } +ASSERT_GE (ret1,0 ); + +if (ret1 ==0 ) +SKIP (return,"No namespaces found" ); + +TH_LOG ("First batch: %zd namespaces" , ret1); + +/* Get second batch using last ID from first batch */ +if (ret1 ==ARRAY_SIZE (batch1)) { + req.ns_id = batch1[ret1 -1 ]; + ret2 =sys_listns (&req, batch2,ARRAY_SIZE (batch2),0 ); +ASSERT_GE (ret2,0 ); + +TH_LOG ("Second batch: %zd namespaces (after ns_id=%llu)" , + ret2, (unsigned long long )req.ns_id); + +/* If we got more results, verify IDs are monotonically increasing */ +if (ret2 >0 ) { +ASSERT_GT (batch2[0 ], batch1[ret1 -1 ]); +TH_LOG ("Pagination working: %llu > %llu" , + (unsigned long long )batch2[0 ], + (unsigned long long )batch1[ret1 -1 ]); + } + }else { +TH_LOG ("All namespaces fit in first batch" ); + } +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 42/72 selftests/namespaces: fourth listns() test
In reply to Christian BraunerTest listns() with LISTNS_CURRENT_USER.
List namespaces owned by current user namespace.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/listns_test.c | 33 ++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
tools/testing/selftests/namespaces/listns_test.c +33 -0
@@ -168,4 +168,37 @@ TEST(listns_pagination) } } +/* +* Test listns() with LISTNS_CURRENT_USER. +* List namespaces owned by current user namespace. +*/ +TEST (listns_current_user) +{ +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =0 , + .spare2 =0 , + .user_ns_id =LISTNS_CURRENT_USER , + }; +__u64 ns_ids[100 ]; +ssize_t ret; + + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +if (ret <0 ) { +if (errno ==ENOSYS ) +SKIP (return,"listns() not supported" ); +TH_LOG ("listns failed: %s (errno=%d)" ,strerror (errno), errno); +ASSERT_TRUE (false); + } +ASSERT_GE (ret,0 ); + +/* Should find at least the initial namespaces if we're in init_user_ns */ +TH_LOG ("Found %zd namespaces owned by current user namespace" , ret); + +for (ssize_t i =0 ; i < ret; i++) +TH_LOG (" [%zd] ns_id: %llu" , i, (unsigned long long )ns_ids[i]); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 43/72 selftests/namespaces: fifth listns() test
In reply to Christian BraunerTest that listns() only returns active namespaces. Create a namespace, let it become inactive, verify it's not listed.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/listns_test.c | 123 +++++++++++++++++++++++ 1 file changed, 123 insertions(+)
tools/testing/selftests/namespaces/listns_test.c +123 -0
@@ -201,4 +201,127 @@ TEST(listns_current_user)TH_LOG (" [%zd] ns_id: %llu" , i, (unsigned long long )ns_ids[i]); } +/* +* Test that listns() only returns active namespaces. +* Create a namespace, let it become inactive, verify it's not listed. +*/ +TEST (listns_only_active) +{ +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =CLONE_NEWNET , + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 ns_ids_before[100 ], ns_ids_after[100 ]; +ssize_t ret_before, ret_after; +int pipefd[2 ]; +pid_t pid; +__u64 new_ns_id =0 ; +int status; + +/* Get initial list */ + ret_before =sys_listns (&req, ns_ids_before,ARRAY_SIZE (ns_ids_before),0 ); +if (ret_before <0 ) { +if (errno ==ENOSYS ) +SKIP (return,"listns() not supported" ); +TH_LOG ("listns failed: %s (errno=%d)" ,strerror (errno), errno); +ASSERT_TRUE (false); + } +ASSERT_GE (ret_before,0 ); + +TH_LOG ("Before: %zd active network namespaces" , ret_before); + +/* Create a new namespace in a child process and get its ID */ +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +int fd; +__u64 ns_id; + +close (pipefd[0 ]); + +/* Create new network namespace */ +if (unshare (CLONE_NEWNET ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Get its ID */ + fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +if (ioctl (fd,NS_GET_ID , &ns_id) <0 ) { +close (fd); +close (pipefd[1 ]); +exit (1 ); + } +close (fd); + +/* Send ID to parent */ +write (pipefd[1 ], &ns_id,sizeof (ns_id)); +close (pipefd[1 ]); + +/* Keep namespace active briefly */ +usleep (100000 ); +exit (0 ); + } + +/* Parent reads the new namespace ID */ + { +int bytes; + +close (pipefd[1 ]); + bytes =read (pipefd[0 ], &new_ns_id,sizeof (new_ns_id)); +close (pipefd[0 ]); + +if (bytes ==sizeof (new_ns_id)) { +__u64 ns_ids_during[100 ]; +int ret_during; + +TH_LOG ("Child created namespace with ID %llu" , (unsigned long long )new_ns_id); + +/* List namespaces while child is still alive - should see new one */ + ret_during =sys_listns (&req, ns_ids_during,ARRAY_SIZE (ns_ids_during),0 ); +ASSERT_GE (ret_during,0 ); +TH_LOG ("During: %d active network namespaces" , ret_during); + +/* Should have more namespaces than before */ +ASSERT_GE (ret_during, ret_before); + } + } + +/* Wait for child to exit */ +waitpid (pid, &status,0 ); + +/* Give time for namespace to become inactive */ +usleep (100000 ); + +/* List namespaces after child exits - should not see new one */ + ret_after =sys_listns (&req, ns_ids_after,ARRAY_SIZE (ns_ids_after),0 ); +ASSERT_GE (ret_after,0 ); +TH_LOG ("After: %zd active network namespaces" , ret_after); + +/* Verify the new namespace ID is not in the after list */ +if (new_ns_id !=0 ) { +bool found = false; + +for (ssize_t i =0 ; i < ret_after; i++) { +if (ns_ids_after[i] == new_ns_id) { + found = true; +break ; + } + } +ASSERT_FALSE (found); + } +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 44/72 selftests/namespaces: sixth listns() test
In reply to Christian BraunerTest listns() with specific user namespace ID. Create a user namespace and list namespaces it owns.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/listns_test.c | 122 +++++++++++++++++++++++ 1 file changed, 122 insertions(+)
tools/testing/selftests/namespaces/listns_test.c +122 -0
@@ -9,6 +9,7 @@#include <string.h> #include <linux/nsfs.h> #include <sys/ioctl.h> +#include <sys/socket.h> #include <sys/stat.h> #include <sys/syscall.h> #include <sys/types.h>
@@ -324,4 +325,125 @@ TEST(listns_only_active) } } +/* +* Test listns() with specific user namespace ID. +* Create a user namespace and list namespaces it owns. +*/ +TEST (listns_specific_userns) +{ +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =0 , + .spare2 =0 , + .user_ns_id =0 ,/* Will be filled with created userns ID */ + }; +__u64 ns_ids[100 ]; +int sv[2 ]; +pid_t pid; +int status; +__u64 user_ns_id =0 ; +int bytes; +ssize_t ret; + +ASSERT_EQ (socketpair (AF_UNIX ,SOCK_STREAM ,0 , sv),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +int fd; +__u64 ns_id; +char buf; + +close (sv[0 ]); + +/* Create new user namespace */ +if (setup_userns () <0 ) { +close (sv[1 ]); +exit (1 ); + } + +/* Get user namespace ID */ + fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (fd <0 ) { +close (sv[1 ]); +exit (1 ); + } + +if (ioctl (fd,NS_GET_ID , &ns_id) <0 ) { +close (fd); +close (sv[1 ]); +exit (1 ); + } +close (fd); + +/* Send ID to parent */ +if (write (sv[1 ], &ns_id,sizeof (ns_id)) !=sizeof (ns_id)) { +close (sv[1 ]); +exit (1 ); + } + +/* Create some namespaces owned by this user namespace */ +unshare (CLONE_NEWNET ); +unshare (CLONE_NEWUTS ); + +/* Wait for parent signal */ +if (read (sv[1 ], &buf,1 ) !=1 ) { +close (sv[1 ]); +exit (1 ); + } +close (sv[1 ]); +exit (0 ); + } + +/* Parent */ +close (sv[1 ]); + bytes =read (sv[0 ], &user_ns_id,sizeof (user_ns_id)); + +if (bytes !=sizeof (user_ns_id)) { +close (sv[0 ]); +kill (pid,SIGKILL ); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to get user namespace ID from child" ); + } + +TH_LOG ("Child created user namespace with ID %llu" , (unsigned long long )user_ns_id); + +/* List namespaces owned by this user namespace */ + req.user_ns_id = user_ns_id; + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); + +if (ret <0 ) { +TH_LOG ("listns failed: %s (errno=%d)" ,strerror (errno), errno); +close (sv[0 ]); +kill (pid,SIGKILL ); +waitpid (pid,NULL ,0 ); +if (errno ==ENOSYS ) { +SKIP (return,"listns() not supported" ); + } +ASSERT_GE (ret,0 ); + } + +TH_LOG ("Found %zd namespaces owned by user namespace %llu" , ret, + (unsigned long long )user_ns_id); + +/* Should find at least the network and UTS namespaces we created */ +if (ret >0 ) { +for (ssize_t i =0 ; i < ret && i <10 ; i++) +TH_LOG (" [%zd] ns_id: %llu" , i, (unsigned long long )ns_ids[i]); + } + +/* Signal child to exit */ +if (write (sv[0 ],"X" ,1 ) !=1 ) { +close (sv[0 ]); +kill (pid,SIGKILL ); +waitpid (pid,NULL ,0 ); +ASSERT_TRUE (false); + } +close (sv[0 ]); +waitpid (pid, &status,0 ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 45/72 selftests/namespaces: seventh listns() test
In reply to Christian BraunerTest listns() with multiple namespace types filter.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/listns_test.c | 31 ++++++++++++++++++++++++ 1 file changed, 31 insertions(+)
tools/testing/selftests/namespaces/listns_test.c +31 -0
@@ -446,4 +446,35 @@ TEST(listns_specific_userns)waitpid (pid, &status,0 ); } +/* +* Test listns() with multiple namespace types filter. +*/ +TEST (listns_multiple_types) +{ +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =CLONE_NEWNET |CLONE_NEWUTS ,/* Network and UTS */ + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 ns_ids[100 ]; +ssize_t ret; + + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +if (ret <0 ) { +if (errno ==ENOSYS ) +SKIP (return,"listns() not supported" ); +TH_LOG ("listns failed: %s (errno=%d)" ,strerror (errno), errno); +ASSERT_TRUE (false); + } +ASSERT_GE (ret,0 ); + +TH_LOG ("Found %zd active network/UTS namespaces" , ret); + +for (ssize_t i =0 ; i < ret; i++) +TH_LOG (" [%zd] ns_id: %llu" , i, (unsigned long long )ns_ids[i]); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 46/72 selftests/namespaces: eigth listns() test
In reply to Christian BraunerTest that hierarchical active reference propagation keeps parent user namespaces visible in listns().
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/listns_test.c | 150 +++++++++++++++++++++++ 1 file changed, 150 insertions(+)
tools/testing/selftests/namespaces/listns_test.c +150 -0
@@ -477,4 +477,154 @@ TEST(listns_multiple_types)TH_LOG (" [%zd] ns_id: %llu" , i, (unsigned long long )ns_ids[i]); } +/* +* Test that hierarchical active reference propagation keeps parent +* user namespaces visible in listns(). +*/ +TEST (listns_hierarchical_visibility) +{ +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =CLONE_NEWUSER , + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 parent_ns_id =0 , child_ns_id =0 ; +int sv[2 ]; +pid_t pid; +int status; +int bytes; +__u64 ns_ids[100 ]; +ssize_t ret; +bool found_parent, found_child; + +ASSERT_EQ (socketpair (AF_UNIX ,SOCK_STREAM ,0 , sv),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +int fd; +char buf; + +close (sv[0 ]); + +/* Create parent user namespace */ +if (setup_userns () <0 ) { +close (sv[1 ]); +exit (1 ); + } + + fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (fd <0 ) { +close (sv[1 ]); +exit (1 ); + } + +if (ioctl (fd,NS_GET_ID , &parent_ns_id) <0 ) { +close (fd); +close (sv[1 ]); +exit (1 ); + } +close (fd); + +/* Create child user namespace */ +if (setup_userns () <0 ) { +close (sv[1 ]); +exit (1 ); + } + + fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (fd <0 ) { +close (sv[1 ]); +exit (1 ); + } + +if (ioctl (fd,NS_GET_ID , &child_ns_id) <0 ) { +close (fd); +close (sv[1 ]); +exit (1 ); + } +close (fd); + +/* Send both IDs to parent */ +if (write (sv[1 ], &parent_ns_id,sizeof (parent_ns_id)) !=sizeof (parent_ns_id)) { +close (sv[1 ]); +exit (1 ); + } +if (write (sv[1 ], &child_ns_id,sizeof (child_ns_id)) !=sizeof (child_ns_id)) { +close (sv[1 ]); +exit (1 ); + } + +/* Wait for parent signal */ +if (read (sv[1 ], &buf,1 ) !=1 ) { +close (sv[1 ]); +exit (1 ); + } +close (sv[1 ]); +exit (0 ); + } + +/* Parent */ +close (sv[1 ]); + +/* Read both namespace IDs */ + bytes =read (sv[0 ], &parent_ns_id,sizeof (parent_ns_id)); + bytes +=read (sv[0 ], &child_ns_id,sizeof (child_ns_id)); + +if (bytes != (int )(2 *sizeof (__u64))) { +close (sv[0 ]); +kill (pid,SIGKILL ); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to get namespace IDs from child" ); + } + +TH_LOG ("Parent user namespace ID: %llu" , (unsigned long long )parent_ns_id); +TH_LOG ("Child user namespace ID: %llu" , (unsigned long long )child_ns_id); + +/* List all user namespaces */ + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); + +if (ret <0 && errno ==ENOSYS ) { +close (sv[0 ]); +kill (pid,SIGKILL ); +waitpid (pid,NULL ,0 ); +SKIP (return,"listns() not supported" ); + } + +ASSERT_GE (ret,0 ); +TH_LOG ("Found %zd active user namespaces" , ret); + +/* Both parent and child should be visible (active due to child process) */ + found_parent = false; + found_child = false; +for (ssize_t i =0 ; i < ret; i++) { +if (ns_ids[i] == parent_ns_id) + found_parent = true; +if (ns_ids[i] == child_ns_id) + found_child = true; + } + +TH_LOG ("Parent namespace %s, child namespace %s" , + found_parent ?"found" :"NOT FOUND" , + found_child ?"found" :"NOT FOUND" ); + +ASSERT_TRUE (found_child); +/* With hierarchical propagation, parent should also be active */ +ASSERT_TRUE (found_parent); + +/* Signal child to exit */ +if (write (sv[0 ],"X" ,1 ) !=1 ) { +close (sv[0 ]); +kill (pid,SIGKILL ); +waitpid (pid,NULL ,0 ); +ASSERT_TRUE (false); + } +close (sv[0 ]); +waitpid (pid, &status,0 ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 47/72 selftests/namespaces: ninth listns() test
In reply to Christian BraunerTest error cases for listns().
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/listns_test.c | 49 ++++++++++++++++++++++++ 1 file changed, 49 insertions(+)
tools/testing/selftests/namespaces/listns_test.c +49 -0
@@ -627,4 +627,53 @@ TEST(listns_hierarchical_visibility)waitpid (pid, &status,0 ); } +/* +* Test error cases for listns(). +*/ +TEST (listns_error_cases) +{ +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =0 , + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 ns_ids[10 ]; +int ret; + +/* Test with invalid flags */ + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0xFFFF ); +if (errno ==ENOSYS ) { +/* listns() not supported, skip this check */ + }else { +ASSERT_LT (ret,0 ); +ASSERT_EQ (errno,EINVAL ); + } + +/* Test with NULL ns_ids array */ + ret =sys_listns (&req,NULL ,10 ,0 ); +ASSERT_LT (ret,0 ); + +/* Test with invalid spare field */ + req.spare =1 ; + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +if (errno ==ENOSYS ) { +/* listns() not supported, skip this check */ + }else { +ASSERT_LT (ret,0 ); +ASSERT_EQ (errno,EINVAL ); + } + req.spare =0 ; + +/* Test with huge nr_ns_ids */ + ret =sys_listns (&req, ns_ids,2000000 ,0 ); +if (errno ==ENOSYS ) { +/* listns() not supported, skip this check */ + }else { +ASSERT_LT (ret,0 ); + } +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 48/72 selftests/namespaces: first listns() permission test
In reply to Christian BraunerTest that unprivileged users can only see namespaces they're currently in. Create a namespace, drop privileges, verify we can only see our own namespaces.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/.gitignore | 1 + tools/testing/selftests/namespaces/Makefile | 3 +- .../selftests/namespaces/listns_permissions_test.c | 131 +++++++++++++++++++++ 3 files changed, 134 insertions(+), 1 deletion(-)
tools/testing/selftests/namespaces/.gitignore +1 -0
@@ -3,3 +3,4 @@ file_handle_test init_ino_test ns_active_ref_test listns_test +listns_permissions_test
tools/testing/selftests/namespaces/Makefile +2 -1
@@ -2,10 +2,11 @@ CFLAGS += -Wall -O0 -g $(KHDR_INCLUDES) $(TOOLS_INCLUDES) LDLIBS += -lcap -TEST_GEN_PROGS := nsid_test file_handle_test init_ino_test ns_active_ref_test listns_test +TEST_GEN_PROGS := nsid_test file_handle_test init_ino_test ns_active_ref_test listns_test listns_permissions_test include ../lib.mk $(OUTPUT)/ns_active_ref_test: ../filesystems/utils.c $(OUTPUT)/listns_test: ../filesystems/utils.c +$(OUTPUT)/listns_permissions_test: ../filesystems/utils.c
tools/testing/selftests/namespaces/listns_permissions_test.c new file +131 -0
131 lines not on this page · raw message
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 49/72 selftests/namespaces: second listns() permission test
In reply to Christian BraunerTest that users with CAP_SYS_ADMIN in a user namespace can see all namespaces owned by that user namespace.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/listns_permissions_test.c | 100 +++++++++++++++++++++ 1 file changed, 100 insertions(+)
tools/testing/selftests/namespaces/listns_permissions_test.c +100 -0
@@ -128,4 +128,104 @@ TEST(listns_unprivileged_current_only) unexpected_count); } +/* +* Test that users with CAP_SYS_ADMIN in a user namespace can see +* all namespaces owned by that user namespace. +*/ +TEST (listns_cap_sys_admin_in_userns) +{ +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =0 ,/* All types */ + .spare2 =0 , + .user_ns_id =0 ,/* Will be set to our created user namespace */ + }; +__u64 ns_ids[100 ]; +int pipefd[2 ]; +pid_t pid; +int status; +bool success; +ssize_t count; + +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +int fd; +__u64 userns_id; +ssize_t ret; +int min_expected; +bool success; + +close (pipefd[0 ]); + +/* Create user namespace - we'll have CAP_SYS_ADMIN in it */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Get the user namespace ID */ + fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +if (ioctl (fd,NS_GET_ID , &userns_id) <0 ) { +close (fd); +close (pipefd[1 ]); +exit (1 ); + } +close (fd); + +/* Create several namespaces owned by this user namespace */ +unshare (CLONE_NEWNET ); +unshare (CLONE_NEWUTS ); +unshare (CLONE_NEWIPC ); + +/* List namespaces owned by our user namespace */ + req.user_ns_id = userns_id; + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +if (ret <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* +* We have CAP_SYS_ADMIN in this user namespace, +* so we should see all namespaces owned by it. +* That includes: net, uts, ipc, and the user namespace itself. +*/ + min_expected =4 ; + success = (ret >= min_expected); + +write (pipefd[1 ], &success,sizeof (success)); +write (pipefd[1 ], &ret,sizeof (ret)); +close (pipefd[1 ]); +exit (0 ); + } + +/* Parent */ +close (pipefd[1 ]); + + success = false; + count =0 ; +read (pipefd[0 ], &success,sizeof (success)); +read (pipefd[0 ], &count,sizeof (count)); +close (pipefd[0 ]); + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +ASSERT_TRUE (success); +TH_LOG ("User with CAP_SYS_ADMIN saw %zd namespaces owned by their user namespace" , + count); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 50/72 selftests/namespaces: third listns() permission test
In reply to Christian BraunerTest that users cannot see namespaces from unrelated user namespaces. Create two sibling user namespaces, verify they can't see each other's owned namespaces.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/listns_permissions_test.c | 138 +++++++++++++++++++++ 1 file changed, 138 insertions(+)
tools/testing/selftests/namespaces/listns_permissions_test.c +138 -0
@@ -228,4 +228,142 @@ TEST(listns_cap_sys_admin_in_userns) count); } +/* +* Test that users cannot see namespaces from unrelated user namespaces. +* Create two sibling user namespaces, verify they can't see each other's +* owned namespaces. +*/ +TEST (listns_cannot_see_sibling_userns_namespaces) +{ +int pipefd[2 ]; +pid_t pid1, pid2; +int status; +__u64 netns_a_id; +int pipefd2[2 ]; +bool found_sibling_netns; + +ASSERT_EQ (pipe (pipefd),0 ); + +/* Fork first child - creates user namespace A */ + pid1 =fork (); +ASSERT_GE (pid1,0 ); + +if (pid1 ==0 ) { +int fd; +__u64 netns_a_id; +char buf; + +close (pipefd[0 ]); + +/* Create user namespace A */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Create network namespace owned by user namespace A */ +if (unshare (CLONE_NEWNET ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Get network namespace ID */ + fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +if (ioctl (fd,NS_GET_ID , &netns_a_id) <0 ) { +close (fd); +close (pipefd[1 ]); +exit (1 ); + } +close (fd); + +/* Send namespace ID to parent */ +write (pipefd[1 ], &netns_a_id,sizeof (netns_a_id)); + +/* Keep alive for sibling to check */ +read (pipefd[1 ], &buf,1 ); +close (pipefd[1 ]); +exit (0 ); + } + +/* Parent reads namespace A ID */ +close (pipefd[1 ]); + netns_a_id =0 ; +read (pipefd[0 ], &netns_a_id,sizeof (netns_a_id)); + +TH_LOG ("User namespace A created network namespace with ID %llu" , + (unsigned long long )netns_a_id); + +/* Fork second child - creates user namespace B */ +ASSERT_EQ (pipe (pipefd2),0 ); + + pid2 =fork (); +ASSERT_GE (pid2,0 ); + +if (pid2 ==0 ) { +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =CLONE_NEWNET , + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 ns_ids[100 ]; +ssize_t ret; +bool found_sibling_netns; + +close (pipefd[0 ]); +close (pipefd2[0 ]); + +/* Create user namespace B (sibling to A) */ +if (setup_userns () <0 ) { +close (pipefd2[1 ]); +exit (1 ); + } + +/* Try to list all network namespaces */ + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); + + found_sibling_netns = false; +if (ret >0 ) { +for (ssize_t i =0 ; i < ret; i++) { +if (ns_ids[i] == netns_a_id) { + found_sibling_netns = true; +break ; + } + } + } + +/* We should NOT see the sibling's network namespace */ +write (pipefd2[1 ], &found_sibling_netns,sizeof (found_sibling_netns)); +close (pipefd2[1 ]); +exit (0 ); + } + +/* Parent reads result from second child */ +close (pipefd2[1 ]); + found_sibling_netns = false; +read (pipefd2[0 ], &found_sibling_netns,sizeof (found_sibling_netns)); +close (pipefd2[0 ]); + +/* Signal first child to exit */ +close (pipefd[0 ]); + +/* Wait for both children */ +waitpid (pid2, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); + +waitpid (pid1, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); + +/* Second child should NOT have seen first child's namespace */ +ASSERT_FALSE (found_sibling_netns); +TH_LOG ("User namespace B correctly could not see sibling namespace A's network namespace" ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 51/72 selftests/namespaces: fourth listns() permission test
In reply to Christian BraunerTest permission checking with LISTNS_CURRENT_USER. Verify that listing with LISTNS_CURRENT_USER respects permissions.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/listns_permissions_test.c | 76 ++++++++++++++++++++++ 1 file changed, 76 insertions(+)
tools/testing/selftests/namespaces/listns_permissions_test.c +76 -0
@@ -366,4 +366,80 @@ TEST(listns_cannot_see_sibling_userns_namespaces)TH_LOG ("User namespace B correctly could not see sibling namespace A's network namespace" ); } +/* +* Test permission checking with LISTNS_CURRENT_USER. +* Verify that listing with LISTNS_CURRENT_USER respects permissions. +*/ +TEST (listns_current_user_permissions) +{ +int pipefd[2 ]; +pid_t pid; +int status; +bool success; +ssize_t count; + +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =0 , + .spare2 =0 , + .user_ns_id =LISTNS_CURRENT_USER , + }; +__u64 ns_ids[100 ]; +ssize_t ret; +bool success; + +close (pipefd[0 ]); + +/* Create user namespace */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Create some namespaces owned by this user namespace */ +if (unshare (CLONE_NEWNET ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +if (unshare (CLONE_NEWUTS ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* List with LISTNS_CURRENT_USER - should see our owned namespaces */ + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); + + success = (ret >=3 );/* At least user, net, uts */ +write (pipefd[1 ], &success,sizeof (success)); +write (pipefd[1 ], &ret,sizeof (ret)); +close (pipefd[1 ]); +exit (0 ); + } + +/* Parent */ +close (pipefd[1 ]); + + success = false; + count =0 ; +read (pipefd[0 ], &success,sizeof (success)); +read (pipefd[0 ], &count,sizeof (count)); +close (pipefd[0 ]); + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +ASSERT_TRUE (success); +TH_LOG ("LISTNS_CURRENT_USER returned %zd namespaces" , count); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 52/72 selftests/namespaces: fifth listns() permission test
In reply to Christian BraunerTest that CAP_SYS_ADMIN in parent user namespace allows seeing child user namespace's owned namespaces.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/listns_permissions_test.c | 119 +++++++++++++++++++++ 1 file changed, 119 insertions(+)
tools/testing/selftests/namespaces/listns_permissions_test.c +119 -0
@@ -442,4 +442,123 @@ TEST(listns_current_user_permissions)TH_LOG ("LISTNS_CURRENT_USER returned %zd namespaces" , count); } +/* +* Test that CAP_SYS_ADMIN in parent user namespace allows seeing +* child user namespace's owned namespaces. +*/ +TEST (listns_parent_userns_cap_sys_admin) +{ +int pipefd[2 ]; +pid_t pid; +int status; +bool found_child_userns; +ssize_t count; + +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +int fd; +__u64 parent_userns_id; +__u64 child_userns_id; +struct ns_id_req req; +__u64 ns_ids[100 ]; +ssize_t ret; +bool found_child_userns; + +close (pipefd[0 ]); + +/* Create parent user namespace - we have CAP_SYS_ADMIN in it */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Get parent user namespace ID */ + fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +if (ioctl (fd,NS_GET_ID , &parent_userns_id) <0 ) { +close (fd); +close (pipefd[1 ]); +exit (1 ); + } +close (fd); + +/* Create child user namespace */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Get child user namespace ID */ + fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +if (ioctl (fd,NS_GET_ID , &child_userns_id) <0 ) { +close (fd); +close (pipefd[1 ]); +exit (1 ); + } +close (fd); + +/* Create namespaces owned by child user namespace */ +if (unshare (CLONE_NEWNET ) <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* List namespaces owned by parent user namespace */ + req.size =sizeof (req); + req.spare =0 ; + req.ns_id =0 ; + req.ns_type =0 ; + req.spare2 =0 ; + req.user_ns_id = parent_userns_id; + + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); + +/* Should see child user namespace in the list */ + found_child_userns = false; +if (ret >0 ) { +for (ssize_t i =0 ; i < ret; i++) { +if (ns_ids[i] == child_userns_id) { + found_child_userns = true; +break ; + } + } + } + +write (pipefd[1 ], &found_child_userns,sizeof (found_child_userns)); +write (pipefd[1 ], &ret,sizeof (ret)); +close (pipefd[1 ]); +exit (0 ); + } + +/* Parent */ +close (pipefd[1 ]); + + found_child_userns = false; + count =0 ; +read (pipefd[0 ], &found_child_userns,sizeof (found_child_userns)); +read (pipefd[0 ], &count,sizeof (count)); +close (pipefd[0 ]); + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +ASSERT_TRUE (found_child_userns); +TH_LOG ("Process with CAP_SYS_ADMIN in parent user namespace saw child user namespace (total: %zd)" , + count); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 53/72 selftests/namespaces: sixth listns() permission test
In reply to Christian BraunerTest that we can see user namespaces we have CAP_SYS_ADMIN inside of. This is different from seeing namespaces owned by a user namespace.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/listns_permissions_test.c | 87 ++++++++++++++++++++++ 1 file changed, 87 insertions(+)
tools/testing/selftests/namespaces/listns_permissions_test.c +87 -0
@@ -561,4 +561,91 @@ TEST(listns_parent_userns_cap_sys_admin) count); } +/* +* Test that we can see user namespaces we have CAP_SYS_ADMIN inside of. +* This is different from seeing namespaces owned by a user namespace. +*/ +TEST (listns_cap_sys_admin_inside_userns) +{ +int pipefd[2 ]; +pid_t pid; +int status; +bool found_ours; + +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +int fd; +__u64 our_userns_id; +struct ns_id_req req; +__u64 ns_ids[100 ]; +ssize_t ret; +bool found_ours; + +close (pipefd[0 ]); + +/* Create user namespace - we have CAP_SYS_ADMIN inside it */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Get our user namespace ID */ + fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (fd <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +if (ioctl (fd,NS_GET_ID , &our_userns_id) <0 ) { +close (fd); +close (pipefd[1 ]); +exit (1 ); + } +close (fd); + +/* List all user namespaces globally */ + req.size =sizeof (req); + req.spare =0 ; + req.ns_id =0 ; + req.ns_type =CLONE_NEWUSER ; + req.spare2 =0 ; + req.user_ns_id =0 ; + + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); + +/* We should be able to see our own user namespace */ + found_ours = false; +if (ret >0 ) { +for (ssize_t i =0 ; i < ret; i++) { +if (ns_ids[i] == our_userns_id) { + found_ours = true; +break ; + } + } + } + +write (pipefd[1 ], &found_ours,sizeof (found_ours)); +close (pipefd[1 ]); +exit (0 ); + } + +/* Parent */ +close (pipefd[1 ]); + + found_ours = false; +read (pipefd[0 ], &found_ours,sizeof (found_ours)); +close (pipefd[0 ]); + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +ASSERT_TRUE (found_ours); +TH_LOG ("Process can see user namespace it has CAP_SYS_ADMIN inside of" ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 54/72 selftests/namespaces: seventh listns() permission test
In reply to Christian BraunerTest that dropping CAP_SYS_ADMIN restricts what we can see.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/listns_permissions_test.c | 108 +++++++++++++++++++++ 1 file changed, 108 insertions(+)
tools/testing/selftests/namespaces/listns_permissions_test.c +108 -0
@@ -648,4 +648,112 @@ TEST(listns_cap_sys_admin_inside_userns)TH_LOG ("Process can see user namespace it has CAP_SYS_ADMIN inside of" ); } +/* +* Test that dropping CAP_SYS_ADMIN restricts what we can see. +*/ +TEST (listns_drop_cap_sys_admin) +{ +cap_t caps; +cap_value_t cap_list[1 ] = {CAP_SYS_ADMIN }; + +/* This test needs to start with CAP_SYS_ADMIN */ + caps =cap_get_proc (); +if (!caps) { +SKIP (return,"Cannot get capabilities" ); + } + +cap_flag_value_t cap_val; +if (cap_get_flag (caps,CAP_SYS_ADMIN ,CAP_EFFECTIVE , &cap_val) <0 ) { +cap_free (caps); +SKIP (return,"Cannot check CAP_SYS_ADMIN" ); + } + +if (cap_val !=CAP_SET ) { +cap_free (caps); +SKIP (return,"Test needs CAP_SYS_ADMIN to start" ); + } +cap_free (caps); + +int pipefd[2 ]; +pid_t pid; +int status; +bool correct; +ssize_t count_before, count_after; + +ASSERT_EQ (pipe (pipefd),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =CLONE_NEWNET , + .spare2 =0 , + .user_ns_id =LISTNS_CURRENT_USER , + }; +__u64 ns_ids_before[100 ]; +ssize_t count_before; +__u64 ns_ids_after[100 ]; +ssize_t count_after; +bool correct; + +close (pipefd[0 ]); + +/* Create user namespace */ +if (setup_userns () <0 ) { +close (pipefd[1 ]); +exit (1 ); + } + +/* Count namespaces with CAP_SYS_ADMIN */ + count_before =sys_listns (&req, ns_ids_before,ARRAY_SIZE (ns_ids_before),0 ); + +/* Drop CAP_SYS_ADMIN */ + caps =cap_get_proc (); +if (caps) { +cap_set_flag (caps,CAP_EFFECTIVE ,1 , cap_list,CAP_CLEAR ); +cap_set_flag (caps,CAP_PERMITTED ,1 , cap_list,CAP_CLEAR ); +cap_set_proc (caps); +cap_free (caps); + } + +/* Ensure we can't regain the capability */ +prctl (PR_SET_NO_NEW_PRIVS ,1 ,0 ,0 ,0 ); + +/* Count namespaces without CAP_SYS_ADMIN */ + count_after =sys_listns (&req, ns_ids_after,ARRAY_SIZE (ns_ids_after),0 ); + +/* Without CAP_SYS_ADMIN, we should see same or fewer namespaces */ + correct = (count_after <= count_before); + +write (pipefd[1 ], &correct,sizeof (correct)); +write (pipefd[1 ], &count_before,sizeof (count_before)); +write (pipefd[1 ], &count_after,sizeof (count_after)); +close (pipefd[1 ]); +exit (0 ); + } + +/* Parent */ +close (pipefd[1 ]); + + correct = false; + count_before =0 ; + count_after =0 ; +read (pipefd[0 ], &correct,sizeof (correct)); +read (pipefd[0 ], &count_before,sizeof (count_before)); +read (pipefd[0 ], &count_after,sizeof (count_after)); +close (pipefd[0 ]); + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +ASSERT_TRUE (correct); +TH_LOG ("With CAP_SYS_ADMIN: %zd namespaces, without: %zd namespaces" , + count_before, count_after); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 55/72 selftests/namespaces: first inactive namespace resurrection test
In reply to Christian BraunerTest basic SIOCGSKNS functionality. Create a socket and verify SIOCGSKNS returns the correct network namespace.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/.gitignore | 1 + tools/testing/selftests/namespaces/Makefile | 9 ++- .../testing/selftests/namespaces/siocgskns_test.c | 72 ++++++++++++++++++++++ 3 files changed, 81 insertions(+), 1 deletion(-)
tools/testing/selftests/namespaces/.gitignore +1 -0
@@ -4,3 +4,4 @@ init_ino_test ns_active_ref_test listns_test listns_permissions_test +siocgskns_test
tools/testing/selftests/namespaces/Makefile +8 -1
@@ -2,11 +2,18 @@ CFLAGS += -Wall -O0 -g $(KHDR_INCLUDES) $(TOOLS_INCLUDES) LDLIBS += -lcap -TEST_GEN_PROGS := nsid_test file_handle_test init_ino_test ns_active_ref_test listns_test listns_permissions_test +TEST_GEN_PROGS := nsid_test \ + file_handle_test \ + init_ino_test \ + ns_active_ref_test \ + listns_test \ + listns_permissions_test \ + siocgskns_test include ../lib.mk $(OUTPUT)/ns_active_ref_test: ../filesystems/utils.c $(OUTPUT)/listns_test: ../filesystems/utils.c $(OUTPUT)/listns_permissions_test: ../filesystems/utils.c +$(OUTPUT)/siocgskns_test: ../filesystems/utils.c
tools/testing/selftests/namespaces/siocgskns_test.c new file +72 -0
72 lines not on this page · raw message
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 56/72 selftests/namespaces: second inactive namespace resurrection test
In reply to Christian BraunerTest that socket file descriptors keep network namespaces active. Create a network namespace, create a socket in it, then exit the namespace. The namespace should remain active while the socket FD is held.
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 126 +++++++++++++++++++++ 1 file changed, 126 insertions(+)
tools/testing/selftests/namespaces/siocgskns_test.c +126 -0
@@ -69,4 +69,130 @@ TEST(siocgskns_basic)close (current_netns_fd); } +/* +* Test that socket file descriptors keep network namespaces active. +* Create a network namespace, create a socket in it, then exit the namespace. +* The namespace should remain active while the socket FD is held. +*/ +TEST (siocgskns_keeps_netns_active) +{ +int sock_fd, netns_fd, test_fd; +int ipc_sockets[2 ]; +pid_t pid; +int status; +struct stat st; + +EXPECT_EQ (socketpair (AF_LOCAL ,SOCK_STREAM |SOCK_CLOEXEC ,0 , ipc_sockets),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child: create new netns and socket */ +close (ipc_sockets[0 ]); + +if (unshare (CLONE_NEWNET ) <0 ) { +TH_LOG ("unshare(CLONE_NEWNET) failed: %s" ,strerror (errno)); +close (ipc_sockets[1 ]); +exit (1 ); + } + +/* Create a socket in the new network namespace */ + sock_fd =socket (AF_INET ,SOCK_DGRAM ,0 ); +if (sock_fd <0 ) { +TH_LOG ("socket() failed: %s" ,strerror (errno)); +close (ipc_sockets[1 ]); +exit (1 ); + } + +/* Send socket FD to parent via SCM_RIGHTS */ +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ] = {'X' }; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); + cmsg->cmsg_level =SOL_SOCKET ; + cmsg->cmsg_type =SCM_RIGHTS ; + cmsg->cmsg_len =CMSG_LEN (sizeof (int )); +memcpy (CMSG_DATA (cmsg), &sock_fd,sizeof (int )); + +if (sendmsg (ipc_sockets[1 ], &msg,0 ) <0 ) { +close (sock_fd); +close (ipc_sockets[1 ]); +exit (1 ); + } + +close (sock_fd); +close (ipc_sockets[1 ]); +exit (0 ); + } + +/* Parent: receive socket FD */ +close (ipc_sockets[1 ]); + +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ]; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +ssize_t n =recvmsg (ipc_sockets[0 ], &msg,0 ); +close (ipc_sockets[0 ]); +ASSERT_EQ (n,1 ); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); +ASSERT_NE (cmsg,NULL ); +ASSERT_EQ (cmsg->cmsg_type,SCM_RIGHTS ); + +memcpy (&sock_fd,CMSG_DATA (cmsg),sizeof (int )); + +/* Wait for child to exit */ +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +if (WEXITSTATUS (status) !=0 ) + SKIP(close(sock_fd); return, "Child failed to create namespace"); + +/* Get network namespace from socket */ + netns_fd =ioctl (sock_fd,SIOCGSKNS ); +if (netns_fd <0 ) { +close (sock_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_fd,0 ); + } + +ASSERT_EQ (fstat (netns_fd, &st),0 ); + +/* +* Namespace should still be active because socket FD keeps it alive. +* Try to access it via /proc/self/fd/<fd>. +*/ +char path[64 ]; +snprintf (path,sizeof (path),"/proc/self/fd/%d" , netns_fd); + test_fd =open (path,O_RDONLY ); +ASSERT_GE (test_fd,0 ); +close (test_fd); +close (netns_fd); + +/* Close socket - namespace should become inactive */ +close (sock_fd); + +/* Try SIOCGSKNS again - should fail since socket is closed */ +ASSERT_LT (ioctl (sock_fd,SIOCGSKNS ),0 ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 57/72 selftests/namespaces: third inactive namespace resurrection test
In reply to Christian BraunerTest SIOCGSKNS with different socket types (TCP, UDP, RAW).
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 65 +++++++++++++++++++++- 1 file changed, 63 insertions(+), 2 deletions(-)
tools/testing/selftests/namespaces/siocgskns_test.c +63 -2
@@ -163,8 +163,7 @@ TEST(siocgskns_keeps_netns_active)/* Wait for child to exit */ waitpid (pid, &status,0 );ASSERT_TRUE (WIFEXITED (status)); -if (WEXITSTATUS (status) !=0 ) - SKIP(close(sock_fd); return, "Child failed to create namespace"); +ASSERT_EQ (WEXITSTATUS (status),0 );/* Get network namespace from socket */ netns_fd =ioctl (sock_fd,SIOCGSKNS );
@@ -195,4 +194,66 @@ TEST(siocgskns_keeps_netns_active)ASSERT_LT (ioctl (sock_fd,SIOCGSKNS ),0 ); } +/* +* Test SIOCGSKNS with different socket types (TCP, UDP, RAW). +*/ +TEST (siocgskns_socket_types) +{ +int sock_tcp, sock_udp, sock_raw; +int netns_tcp, netns_udp, netns_raw; +struct stat st_tcp, st_udp, st_raw; + +/* TCP socket */ + sock_tcp =socket (AF_INET ,SOCK_STREAM ,0 ); +ASSERT_GE (sock_tcp,0 ); + +/* UDP socket */ + sock_udp =socket (AF_INET ,SOCK_DGRAM ,0 ); +ASSERT_GE (sock_udp,0 ); + +/* RAW socket (may require privileges) */ + sock_raw =socket (AF_INET ,SOCK_RAW ,IPPROTO_ICMP ); +if (sock_raw <0 && (errno ==EPERM || errno ==EACCES )) { + sock_raw =-1 ;/* Skip raw socket test */ + } + +/* Test SIOCGSKNS on TCP */ + netns_tcp =ioctl (sock_tcp,SIOCGSKNS ); +if (netns_tcp <0 ) { +close (sock_tcp); +close (sock_udp); +if (sock_raw >=0 )close (sock_raw); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_tcp,0 ); + } + +/* Test SIOCGSKNS on UDP */ + netns_udp =ioctl (sock_udp,SIOCGSKNS ); +ASSERT_GE (netns_udp,0 ); + +/* Test SIOCGSKNS on RAW (if available) */ +if (sock_raw >=0 ) { + netns_raw =ioctl (sock_raw,SIOCGSKNS ); +ASSERT_GE (netns_raw,0 ); + } + +/* Verify all return the same network namespace */ +ASSERT_EQ (fstat (netns_tcp, &st_tcp),0 ); +ASSERT_EQ (fstat (netns_udp, &st_udp),0 ); +ASSERT_EQ (st_tcp.st_ino, st_udp.st_ino); + +if (sock_raw >=0 ) { +ASSERT_EQ (fstat (netns_raw, &st_raw),0 ); +ASSERT_EQ (st_tcp.st_ino, st_raw.st_ino); +close (netns_raw); +close (sock_raw); + } + +close (netns_tcp); +close (netns_udp); +close (sock_tcp); +close (sock_udp); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 58/72 selftests/namespaces: fourth inactive namespace resurrection test
In reply to Christian BraunerTest SIOCGSKNS across setns. Create a socket in netns A, switch to netns B, verify SIOCGSKNS still returns netns A.
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 51 ++++++++++++++++++++++ 1 file changed, 51 insertions(+)
tools/testing/selftests/namespaces/siocgskns_test.c +51 -0
@@ -256,4 +256,55 @@ TEST(siocgskns_socket_types)close (sock_udp); } +/* +* Test SIOCGSKNS across setns. +* Create a socket in netns A, switch to netns B, verify SIOCGSKNS still +* returns netns A. +*/ +TEST (siocgskns_across_setns) +{ +int sock_fd, netns_a_fd, netns_b_fd, result_fd; +struct stat st_a; + +/* Get current netns (A) */ + netns_a_fd =open ("/proc/self/ns/net" ,O_RDONLY ); +ASSERT_GE (netns_a_fd,0 ); +ASSERT_EQ (fstat (netns_a_fd, &st_a),0 ); + +/* Create socket in netns A */ + sock_fd =socket (AF_INET ,SOCK_STREAM ,0 ); +ASSERT_GE (sock_fd,0 ); + +/* Create new netns (B) */ +ASSERT_EQ (unshare (CLONE_NEWNET ),0 ); + + netns_b_fd =open ("/proc/self/ns/net" ,O_RDONLY ); +ASSERT_GE (netns_b_fd,0 ); + +/* Get netns from socket created in A */ + result_fd =ioctl (sock_fd,SIOCGSKNS ); +if (result_fd <0 ) { +close (sock_fd); +setns (netns_a_fd,CLONE_NEWNET ); +close (netns_a_fd); +close (netns_b_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (result_fd,0 ); + } + +/* Verify it still points to netns A */ +struct stat st_result_stat; +ASSERT_EQ (fstat (result_fd, &st_result_stat),0 ); +ASSERT_EQ (st_a.st_ino, st_result_stat.st_ino); + +close (result_fd); +close (sock_fd); +close (netns_b_fd); + +/* Restore original netns */ +ASSERT_EQ (setns (netns_a_fd,CLONE_NEWNET ),0 ); +close (netns_a_fd); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 59/72 selftests/namespaces: fifth inactive namespace resurrection test
In reply to Christian BraunerTest SIOCGSKNS fails on non-socket file descriptors.
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 26 ++++++++++++++++++++++ 1 file changed, 26 insertions(+)
tools/testing/selftests/namespaces/siocgskns_test.c +26 -0
@@ -307,4 +307,30 @@ TEST(siocgskns_across_setns)close (netns_a_fd); } +/* +* Test SIOCGSKNS fails on non-socket file descriptors. +*/ +TEST (siocgskns_non_socket) +{ +int fd; +int pipefd[2 ]; + +/* Test on regular file */ + fd =open ("/dev/null" ,O_RDONLY ); +ASSERT_GE (fd,0 ); + +ASSERT_LT (ioctl (fd,SIOCGSKNS ),0 ); +ASSERT_TRUE (errno ==ENOTTY || errno ==EINVAL ); +close (fd); + +/* Test on pipe */ +ASSERT_EQ (pipe (pipefd),0 ); + +ASSERT_LT (ioctl (pipefd[0 ],SIOCGSKNS ),0 ); +ASSERT_TRUE (errno ==ENOTTY || errno ==EINVAL ); + +close (pipefd[0 ]); +close (pipefd[1 ]); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 60/72 selftests/namespaces: sixth inactive namespace resurrection test
In reply to Christian BraunerTest multiple sockets keep the same network namespace active. Create multiple sockets, verify closing some doesn't affect others.
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 68 ++++++++++++++++++++++ 1 file changed, 68 insertions(+)
tools/testing/selftests/namespaces/siocgskns_test.c +68 -0
@@ -333,4 +333,72 @@ TEST(siocgskns_non_socket)close (pipefd[1 ]); } +/* +* Test multiple sockets keep the same network namespace active. +* Create multiple sockets, verify closing some doesn't affect others. +*/ +TEST (siocgskns_multiple_sockets) +{ +int socks[5 ]; +int netns_fds[5 ]; +int i; +struct stat st; +ino_t netns_ino; + +/* Create new network namespace */ +ASSERT_EQ (unshare (CLONE_NEWNET ),0 ); + +/* Create multiple sockets */ +for (i =0 ; i <5 ; i++) { + socks[i] =socket (AF_INET ,SOCK_STREAM ,0 ); +ASSERT_GE (socks[i],0 ); + } + +/* Get netns from all sockets */ +for (i =0 ; i <5 ; i++) { + netns_fds[i] =ioctl (socks[i],SIOCGSKNS ); +if (netns_fds[i] <0 ) { +int j; +for (j =0 ; j <= i; j++) { +close (socks[j]); +if (j < i && netns_fds[j] >=0 ) +close (netns_fds[j]); + } +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_fds[i],0 ); + } + } + +/* Verify all point to same netns */ +ASSERT_EQ (fstat (netns_fds[0 ], &st),0 ); + netns_ino = st.st_ino; + +for (i =1 ; i <5 ; i++) { +ASSERT_EQ (fstat (netns_fds[i], &st),0 ); +ASSERT_EQ (st.st_ino, netns_ino); + } + +/* Close some sockets */ +for (i =0 ; i <3 ; i++) { +close (socks[i]); + } + +/* Remaining netns FDs should still be valid */ +for (i =3 ; i <5 ; i++) { +char path[64 ]; +snprintf (path,sizeof (path),"/proc/self/fd/%d" , netns_fds[i]); +int test_fd =open (path,O_RDONLY ); +ASSERT_GE (test_fd,0 ); +close (test_fd); + } + +/* Cleanup */ +for (i =0 ; i <5 ; i++) { +if (i >=3 ) +close (socks[i]); +close (netns_fds[i]); + } +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 61/72 selftests/namespaces: seventh inactive namespace resurrection test
In reply to Christian BraunerTest socket keeps netns active after creating process exits. Verify that as long as the socket FD exists, the namespace remains active.
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 141 +++++++++++++++++++++ 1 file changed, 141 insertions(+)
tools/testing/selftests/namespaces/siocgskns_test.c +141 -0
@@ -401,4 +401,145 @@ TEST(siocgskns_multiple_sockets) } } +/* +* Test socket keeps netns active after creating process exits. +* Verify that as long as the socket FD exists, the namespace remains active. +*/ +TEST (siocgskns_netns_lifecycle) +{ +int sock_fd, netns_fd; +int ipc_sockets[2 ]; +int syncpipe[2 ]; +pid_t pid; +int status; +char sync_byte; +struct stat st; +ino_t netns_ino; + +EXPECT_EQ (socketpair (AF_LOCAL ,SOCK_STREAM |SOCK_CLOEXEC ,0 , ipc_sockets),0 ); + +ASSERT_EQ (pipe (syncpipe),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child */ +close (ipc_sockets[0 ]); +close (syncpipe[1 ]); + +if (unshare (CLONE_NEWNET ) <0 ) { +close (ipc_sockets[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } + + sock_fd =socket (AF_INET ,SOCK_STREAM ,0 ); +if (sock_fd <0 ) { +close (ipc_sockets[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } + +/* Send socket to parent */ +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ] = {'X' }; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); + cmsg->cmsg_level =SOL_SOCKET ; + cmsg->cmsg_type =SCM_RIGHTS ; + cmsg->cmsg_len =CMSG_LEN (sizeof (int )); +memcpy (CMSG_DATA (cmsg), &sock_fd,sizeof (int )); + +if (sendmsg (ipc_sockets[1 ], &msg,0 ) <0 ) { +close (sock_fd); +close (ipc_sockets[1 ]); +close (syncpipe[0 ]); +exit (1 ); + } + +close (sock_fd); +close (ipc_sockets[1 ]); + +/* Wait for parent signal */ +read (syncpipe[0 ], &sync_byte,1 ); +close (syncpipe[0 ]); +exit (0 ); + } + +/* Parent */ +close (ipc_sockets[1 ]); +close (syncpipe[0 ]); + +/* Receive socket FD */ +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ]; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +ssize_t n =recvmsg (ipc_sockets[0 ], &msg,0 ); +close (ipc_sockets[0 ]); +ASSERT_EQ (n,1 ); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); +ASSERT_NE (cmsg,NULL ); +memcpy (&sock_fd,CMSG_DATA (cmsg),sizeof (int )); + +/* Get netns from socket while child is alive */ + netns_fd =ioctl (sock_fd,SIOCGSKNS ); +if (netns_fd <0 ) { + sync_byte ='G' ; +write (syncpipe[1 ], &sync_byte,1 ); +close (syncpipe[1 ]); +close (sock_fd); +waitpid (pid,NULL ,0 ); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_fd,0 ); + } +ASSERT_EQ (fstat (netns_fd, &st),0 ); + netns_ino = st.st_ino; + +/* Signal child to exit */ + sync_byte ='G' ; +write (syncpipe[1 ], &sync_byte,1 ); +close (syncpipe[1 ]); + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); + +/* +* Socket FD should still keep namespace active even after +* the creating process exited. +*/ +int test_fd =ioctl (sock_fd,SIOCGSKNS ); +ASSERT_GE (test_fd,0 ); + +struct stat st_test; +ASSERT_EQ (fstat (test_fd, &st_test),0 ); +ASSERT_EQ (st_test.st_ino, netns_ino); + +close (test_fd); +close (netns_fd); + +/* Close socket - namespace should become inactive */ +close (sock_fd); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 62/72 selftests/namespaces: eigth inactive namespace resurrection test
In reply to Christian BraunerTest IPv6 sockets also work with SIOCGSKNS.
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 34 ++++++++++++++++++++++ 1 file changed, 34 insertions(+)
tools/testing/selftests/namespaces/siocgskns_test.c +34 -0
@@ -542,4 +542,38 @@ TEST(siocgskns_netns_lifecycle)close (sock_fd); } +/* +* Test IPv6 sockets also work with SIOCGSKNS. +*/ +TEST (siocgskns_ipv6) +{ +int sock_fd, netns_fd, current_netns_fd; +struct stat st1, st2; + +/* Create an IPv6 TCP socket */ + sock_fd =socket (AF_INET6 ,SOCK_STREAM ,0 ); +ASSERT_GE (sock_fd,0 ); + +/* Use SIOCGSKNS */ + netns_fd =ioctl (sock_fd,SIOCGSKNS ); +if (netns_fd <0 ) { +close (sock_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_fd,0 ); + } + +/* Verify it matches current namespace */ + current_netns_fd =open ("/proc/self/ns/net" ,O_RDONLY ); +ASSERT_GE (current_netns_fd,0 ); + +ASSERT_EQ (fstat (netns_fd, &st1),0 ); +ASSERT_EQ (fstat (current_netns_fd, &st2),0 ); +ASSERT_EQ (st1.st_ino, st2.st_ino); + +close (sock_fd); +close (netns_fd); +close (current_netns_fd); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 63/72 selftests/namespaces: ninth inactive namespace resurrection test
In reply to Christian BraunerTest that socket-kept netns appears in listns() output. Verify that a network namespace kept alive by a socket FD appears in listns() output even after the creating process exits, and that it disappears when the socket is closed.
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 203 +++++++++++++++++++++ 1 file changed, 203 insertions(+)
tools/testing/selftests/namespaces/siocgskns_test.c +203 -0
@@ -576,4 +576,207 @@ TEST(siocgskns_ipv6)close (current_netns_fd); } +/* +* Test that socket-kept netns appears in listns() output. +* Verify that a network namespace kept alive by a socket FD appears in +* listns() output even after the creating process exits, and that it +* disappears when the socket is closed. +*/ +TEST (siocgskns_listns_visibility) +{ +int sock_fd, netns_fd, owner_fd; +int ipc_sockets[2 ]; +pid_t pid; +int status; +__u64 netns_id, owner_id; +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =CLONE_NEWNET , + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 ns_ids[256 ]; +int ret, i; +bool found_netns = false; + +EXPECT_EQ (socketpair (AF_LOCAL ,SOCK_STREAM |SOCK_CLOEXEC ,0 , ipc_sockets),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child: create new netns and socket */ +close (ipc_sockets[0 ]); + +if (unshare (CLONE_NEWNET ) <0 ) { +close (ipc_sockets[1 ]); +exit (1 ); + } + + sock_fd =socket (AF_INET ,SOCK_DGRAM ,0 ); +if (sock_fd <0 ) { +close (ipc_sockets[1 ]); +exit (1 ); + } + +/* Send socket FD to parent via SCM_RIGHTS */ +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ] = {'X' }; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); + cmsg->cmsg_level =SOL_SOCKET ; + cmsg->cmsg_type =SCM_RIGHTS ; + cmsg->cmsg_len =CMSG_LEN (sizeof (int )); +memcpy (CMSG_DATA (cmsg), &sock_fd,sizeof (int )); + +if (sendmsg (ipc_sockets[1 ], &msg,0 ) <0 ) { +close (sock_fd); +close (ipc_sockets[1 ]); +exit (1 ); + } + +close (sock_fd); +close (ipc_sockets[1 ]); +exit (0 ); + } + +/* Parent: receive socket FD */ +close (ipc_sockets[1 ]); + +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ]; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +ssize_t n =recvmsg (ipc_sockets[0 ], &msg,0 ); +close (ipc_sockets[0 ]); +ASSERT_EQ (n,1 ); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); +ASSERT_NE (cmsg,NULL ); +memcpy (&sock_fd,CMSG_DATA (cmsg),sizeof (int )); + +/* Wait for child to exit */ +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* Get network namespace from socket */ + netns_fd =ioctl (sock_fd,SIOCGSKNS ); +if (netns_fd <0 ) { +close (sock_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_fd,0 ); + } + +/* Get namespace ID */ + ret =ioctl (netns_fd,NS_GET_ID , &netns_id); +if (ret <0 ) { +close (sock_fd); +close (netns_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"NS_GET_ID not supported" ); +ASSERT_EQ (ret,0 ); + } + +/* Get owner user namespace */ + owner_fd =ioctl (netns_fd,NS_GET_USERNS ); +if (owner_fd <0 ) { +close (sock_fd); +close (netns_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"NS_GET_USERNS not supported" ); +ASSERT_GE (owner_fd,0 ); + } + +/* Get owner namespace ID */ + ret =ioctl (owner_fd,NS_GET_ID , &owner_id); +if (ret <0 ) { +close (owner_fd); +close (sock_fd); +close (netns_fd); +ASSERT_EQ (ret,0 ); + } +close (owner_fd); + +/* Namespace should appear in listns() output */ + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +if (ret <0 ) { +close (sock_fd); +close (netns_fd); +if (errno ==ENOSYS ) +SKIP (return,"listns() not supported" ); +TH_LOG ("listns failed: %s" ,strerror (errno)); +ASSERT_GE (ret,0 ); + } + +/* Search for our network namespace in the list */ +for (i =0 ; i < ret; i++) { +if (ns_ids[i] == netns_id) { + found_netns = true; +break ; + } + } + +ASSERT_TRUE (found_netns); +TH_LOG ("Found netns %llu in listns() output (kept alive by socket)" , netns_id); + +/* Now verify with owner filtering */ + req.user_ns_id = owner_id; + found_netns = false; + + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +ASSERT_GE (ret,0 ); + +for (i =0 ; i < ret; i++) { +if (ns_ids[i] == netns_id) { + found_netns = true; +break ; + } + } + +ASSERT_TRUE (found_netns); +TH_LOG ("Found netns %llu owned by userns %llu" , netns_id, owner_id); + +/* Close socket - namespace should become inactive and disappear from listns() */ +close (sock_fd); +close (netns_fd); + +/* Verify it's no longer in listns() output */ + req.user_ns_id =0 ; + found_netns = false; + + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +ASSERT_GE (ret,0 ); + +for (i =0 ; i < ret; i++) { +if (ns_ids[i] == netns_id) { + found_netns = true; +break ; + } + } + +ASSERT_FALSE (found_netns); +TH_LOG ("Netns %llu correctly disappeared from listns() after socket closed" , netns_id); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 64/72 selftests/namespaces: tenth inactive namespace resurrection test
In reply to Christian BraunerTest that socket-kept netns can be reopened via file handle. Verify that a network namespace kept alive by a socket FD can be reopened using file handles even after the creating process exits.
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 195 +++++++++++++++++++++ 1 file changed, 195 insertions(+)
tools/testing/selftests/namespaces/siocgskns_test.c +195 -0
@@ -779,4 +779,199 @@ TEST(siocgskns_listns_visibility)TH_LOG ("Netns %llu correctly disappeared from listns() after socket closed" , netns_id); } +/* +* Test that socket-kept netns can be reopened via file handle. +* Verify that a network namespace kept alive by a socket FD can be +* reopened using file handles even after the creating process exits. +*/ +TEST (siocgskns_file_handle) +{ +int sock_fd, netns_fd, reopened_fd; +int ipc_sockets[2 ]; +pid_t pid; +int status; +struct stat st1, st2; +ino_t netns_ino; +__u64 netns_id; +struct file_handle *handle; +struct nsfs_file_handle *nsfs_fh; +int ret; + +/* Allocate file_handle structure for nsfs */ + handle =malloc (sizeof (struct file_handle ) +sizeof (struct nsfs_file_handle )); +ASSERT_NE (handle,NULL ); + handle->handle_bytes =sizeof (struct nsfs_file_handle ); + handle->handle_type =FILEID_NSFS ; + +EXPECT_EQ (socketpair (AF_LOCAL ,SOCK_STREAM |SOCK_CLOEXEC ,0 , ipc_sockets),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child: create new netns and socket */ +close (ipc_sockets[0 ]); + +if (unshare (CLONE_NEWNET ) <0 ) { +close (ipc_sockets[1 ]); +exit (1 ); + } + + sock_fd =socket (AF_INET ,SOCK_DGRAM ,0 ); +if (sock_fd <0 ) { +close (ipc_sockets[1 ]); +exit (1 ); + } + +/* Send socket FD to parent via SCM_RIGHTS */ +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ] = {'X' }; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); + cmsg->cmsg_level =SOL_SOCKET ; + cmsg->cmsg_type =SCM_RIGHTS ; + cmsg->cmsg_len =CMSG_LEN (sizeof (int )); +memcpy (CMSG_DATA (cmsg), &sock_fd,sizeof (int )); + +if (sendmsg (ipc_sockets[1 ], &msg,0 ) <0 ) { +close (sock_fd); +close (ipc_sockets[1 ]); +exit (1 ); + } + +close (sock_fd); +close (ipc_sockets[1 ]); +exit (0 ); + } + +/* Parent: receive socket FD */ +close (ipc_sockets[1 ]); + +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ]; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +ssize_t n =recvmsg (ipc_sockets[0 ], &msg,0 ); +close (ipc_sockets[0 ]); +ASSERT_EQ (n,1 ); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); +ASSERT_NE (cmsg,NULL ); +memcpy (&sock_fd,CMSG_DATA (cmsg),sizeof (int )); + +/* Wait for child to exit */ +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* Get network namespace from socket */ + netns_fd =ioctl (sock_fd,SIOCGSKNS ); +if (netns_fd <0 ) { +free (handle); +close (sock_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_fd,0 ); + } + +ASSERT_EQ (fstat (netns_fd, &st1),0 ); + netns_ino = st1.st_ino; + +/* Get namespace ID */ + ret =ioctl (netns_fd,NS_GET_ID , &netns_id); +if (ret <0 ) { +free (handle); +close (sock_fd); +close (netns_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"NS_GET_ID not supported" ); +ASSERT_EQ (ret,0 ); + } + +/* Construct file handle from namespace ID */ + nsfs_fh = (struct nsfs_file_handle *)handle->f_handle; + nsfs_fh->ns_id = netns_id; + nsfs_fh->ns_type =0 ;/* Type field not needed for reopening */ + nsfs_fh->ns_inum =0 ;/* Inum field not needed for reopening */ + +TH_LOG ("Constructed file handle for netns %lu (id=%llu)" , netns_ino, netns_id); + +/* Reopen namespace using file handle (while socket still keeps it alive) */ + reopened_fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +if (reopened_fd <0 ) { +free (handle); +close (sock_fd); +if (errno ==EOPNOTSUPP || errno ==ENOSYS || errno ==EBADF ) +SKIP (return,"open_by_handle_at with FD_NSFS_ROOT not supported" ); +TH_LOG ("open_by_handle_at failed: %s" ,strerror (errno)); +ASSERT_GE (reopened_fd,0 ); + } + +/* Verify it's the same namespace */ +ASSERT_EQ (fstat (reopened_fd, &st2),0 ); +ASSERT_EQ (st1.st_ino, st2.st_ino); +ASSERT_EQ (st1.st_dev, st2.st_dev); + +TH_LOG ("Successfully reopened netns %lu via file handle" , netns_ino); + +close (reopened_fd); + +/* Close the netns FD */ +close (netns_fd); + +/* Try to reopen via file handle - should fail since namespace is now inactive */ + reopened_fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_LT (reopened_fd,0 ); +TH_LOG ("Correctly failed to reopen inactive netns: %s" ,strerror (errno)); + +/* Get network namespace from socket */ + netns_fd =ioctl (sock_fd,SIOCGSKNS ); +if (netns_fd <0 ) { +free (handle); +close (sock_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_fd,0 ); + } + +/* Reopen namespace using file handle (while socket still keeps it alive) */ + reopened_fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +if (reopened_fd <0 ) { +free (handle); +close (sock_fd); +if (errno ==EOPNOTSUPP || errno ==ENOSYS || errno ==EBADF ) +SKIP (return,"open_by_handle_at with FD_NSFS_ROOT not supported" ); +TH_LOG ("open_by_handle_at failed: %s" ,strerror (errno)); +ASSERT_GE (reopened_fd,0 ); + } + +/* Verify it's the same namespace */ +ASSERT_EQ (fstat (reopened_fd, &st2),0 ); +ASSERT_EQ (st1.st_ino, st2.st_ino); +ASSERT_EQ (st1.st_dev, st2.st_dev); + +TH_LOG ("Successfully reopened netns %lu via file handle" , netns_ino); + +/* Close socket - namespace should become inactive */ +close (sock_fd); +free (handle); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 65/72 selftests/namespaces: eleventh inactive namespace resurrection test
In reply to Christian BraunerTest combined listns() and file handle operations with socket-kept netns. Create a netns, keep it alive with a socket, verify it appears in listns(), then reopen it via file handle obtained from listns() entry.
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 283 +++++++++++++++++++++ 1 file changed, 283 insertions(+)
tools/testing/selftests/namespaces/siocgskns_test.c +283 -0
@@ -974,4 +974,287 @@ TEST(siocgskns_file_handle)free (handle); } +/* +* Test combined listns() and file handle operations with socket-kept netns. +* Create a netns, keep it alive with a socket, verify it appears in listns(), +* then reopen it via file handle obtained from listns() entry. +*/ +TEST (siocgskns_listns_and_file_handle) +{ +int sock_fd, netns_fd, userns_fd, reopened_fd; +int ipc_sockets[2 ]; +pid_t pid; +int status; +struct stat st; +ino_t netns_ino; +__u64 netns_id, userns_id; +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =CLONE_NEWNET |CLONE_NEWUSER , + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 ns_ids[256 ]; +int ret, i; +bool found_netns = false, found_userns = false; +struct file_handle *handle; +struct nsfs_file_handle *nsfs_fh; + +/* Allocate file_handle structure for nsfs */ + handle =malloc (sizeof (struct file_handle ) +sizeof (struct nsfs_file_handle )); +ASSERT_NE (handle,NULL ); + handle->handle_bytes =sizeof (struct nsfs_file_handle ); + handle->handle_type =FILEID_NSFS ; + +EXPECT_EQ (socketpair (AF_LOCAL ,SOCK_STREAM |SOCK_CLOEXEC ,0 , ipc_sockets),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child: create new userns and netns with socket */ +close (ipc_sockets[0 ]); + +if (setup_userns () <0 ) { +close (ipc_sockets[1 ]); +exit (1 ); + } + +if (unshare (CLONE_NEWNET ) <0 ) { +close (ipc_sockets[1 ]); +exit (1 ); + } + + sock_fd =socket (AF_INET ,SOCK_DGRAM ,0 ); +if (sock_fd <0 ) { +close (ipc_sockets[1 ]); +exit (1 ); + } + +/* Send socket FD to parent via SCM_RIGHTS */ +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ] = {'X' }; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); + cmsg->cmsg_level =SOL_SOCKET ; + cmsg->cmsg_type =SCM_RIGHTS ; + cmsg->cmsg_len =CMSG_LEN (sizeof (int )); +memcpy (CMSG_DATA (cmsg), &sock_fd,sizeof (int )); + +if (sendmsg (ipc_sockets[1 ], &msg,0 ) <0 ) { +close (sock_fd); +close (ipc_sockets[1 ]); +exit (1 ); + } + +close (sock_fd); +close (ipc_sockets[1 ]); +exit (0 ); + } + +/* Parent: receive socket FD */ +close (ipc_sockets[1 ]); + +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ]; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +ssize_t n =recvmsg (ipc_sockets[0 ], &msg,0 ); +close (ipc_sockets[0 ]); +ASSERT_EQ (n,1 ); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); +ASSERT_NE (cmsg,NULL ); +memcpy (&sock_fd,CMSG_DATA (cmsg),sizeof (int )); + +/* Wait for child to exit */ +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* Get network namespace from socket */ + netns_fd =ioctl (sock_fd,SIOCGSKNS ); +if (netns_fd <0 ) { +free (handle); +close (sock_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_fd,0 ); + } + +ASSERT_EQ (fstat (netns_fd, &st),0 ); + netns_ino = st.st_ino; + +/* Get namespace ID */ + ret =ioctl (netns_fd,NS_GET_ID , &netns_id); +if (ret <0 ) { +free (handle); +close (sock_fd); +close (netns_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"NS_GET_ID not supported" ); +ASSERT_EQ (ret,0 ); + } + +/* Get owner user namespace */ + userns_fd =ioctl (netns_fd,NS_GET_USERNS ); +if (userns_fd <0 ) { +free (handle); +close (sock_fd); +close (netns_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"NS_GET_USERNS not supported" ); +ASSERT_GE (userns_fd,0 ); + } + +/* Get owner namespace ID */ + ret =ioctl (userns_fd,NS_GET_ID , &userns_id); +if (ret <0 ) { +close (userns_fd); +free (handle); +close (sock_fd); +close (netns_fd); +ASSERT_EQ (ret,0 ); + } +close (userns_fd); + +TH_LOG ("Testing netns %lu (id=%llu) owned by userns id=%llu" , netns_ino, netns_id, userns_id); + +/* Verify namespace appears in listns() */ + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +if (ret <0 ) { +free (handle); +close (sock_fd); +close (netns_fd); +if (errno ==ENOSYS ) +SKIP (return,"listns() not supported" ); +TH_LOG ("listns failed: %s" ,strerror (errno)); +ASSERT_GE (ret,0 ); + } + + found_netns = false; + found_userns = false; +for (i =0 ; i < ret; i++) { +if (ns_ids[i] == netns_id) + found_netns = true; +if (ns_ids[i] == userns_id) + found_userns = true; + } +ASSERT_TRUE (found_netns); +ASSERT_TRUE (found_userns); +TH_LOG ("Found netns %llu in listns() output" , netns_id); + +/* Construct file handle from namespace ID */ + nsfs_fh = (struct nsfs_file_handle *)handle->f_handle; + nsfs_fh->ns_id = netns_id; + nsfs_fh->ns_type =0 ; + nsfs_fh->ns_inum =0 ; + + reopened_fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +if (reopened_fd <0 ) { +free (handle); +close (sock_fd); +if (errno ==EOPNOTSUPP || errno ==ENOSYS || errno ==EBADF ) +SKIP (return,"open_by_handle_at with FD_NSFS_ROOT not supported" ); +TH_LOG ("open_by_handle_at failed: %s" ,strerror (errno)); +ASSERT_GE (reopened_fd,0 ); + } + +struct stat reopened_st; +ASSERT_EQ (fstat (reopened_fd, &reopened_st),0 ); +ASSERT_EQ (reopened_st.st_ino, netns_ino); + +TH_LOG ("Successfully reopened netns %lu via file handle (socket-kept)" , netns_ino); + +close (reopened_fd); +close (netns_fd); + +/* Try to reopen via file handle - should fail since namespace is now inactive */ + reopened_fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_LT (reopened_fd,0 ); +TH_LOG ("Correctly failed to reopen inactive netns: %s" ,strerror (errno)); + +/* Get network namespace from socket */ + netns_fd =ioctl (sock_fd,SIOCGSKNS ); +if (netns_fd <0 ) { +free (handle); +close (sock_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_fd,0 ); + } + +/* Verify namespace appears in listns() */ + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +if (ret <0 ) { +free (handle); +close (sock_fd); +close (netns_fd); +if (errno ==ENOSYS ) +SKIP (return,"listns() not supported" ); +TH_LOG ("listns failed: %s" ,strerror (errno)); +ASSERT_GE (ret,0 ); + } + + found_netns = false; + found_userns = false; +for (i =0 ; i < ret; i++) { +if (ns_ids[i] == netns_id) + found_netns = true; +if (ns_ids[i] == userns_id) + found_userns = true; + } +ASSERT_TRUE (found_netns); +ASSERT_TRUE (found_userns); +TH_LOG ("Found netns %llu in listns() output" , netns_id); + +close (netns_fd); + +/* Verify namespace appears in listns() */ + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +if (ret <0 ) { +free (handle); +close (sock_fd); +close (netns_fd); +if (errno ==ENOSYS ) +SKIP (return,"listns() not supported" ); +TH_LOG ("listns failed: %s" ,strerror (errno)); +ASSERT_GE (ret,0 ); + } + + found_netns = false; + found_userns = false; +for (i =0 ; i < ret; i++) { +if (ns_ids[i] == netns_id) + found_netns = true; +if (ns_ids[i] == userns_id) + found_userns = true; + } +ASSERT_FALSE (found_netns); +ASSERT_FALSE (found_userns); +TH_LOG ("Netns %llu correctly disappeared from listns() after socket closed" , netns_id); + +close (sock_fd); +free (handle); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 66/72 selftests/namespaces: twelth inactive namespace resurrection test
In reply to Christian BraunerTest multi-level namespace resurrection across three user namespace levels.
This test creates a complex namespace hierarchy with three levels of user namespaces and a network namespace at the deepest level. It verifies that the resurrection semantics work correctly when SIOCGSKNS is called on a socket from an inactive namespace tree, and that listns() and open_by_handle_at() correctly respect visibility rules.
Hierarchy after child processes exit (all with 0 active refcount):
net_L3A (0) <- Level 3 network namespace
|
+
userns_L3 (0) <- Level 3 user namespace
|
+
userns_L2 (0) <- Level 2 user namespace
|
+
userns_L1 (0) <- Level 1 user namespace
|
x
init_user_nsThe test verifies:
1. SIOCGSKNS on a socket from inactive net_L3A resurrects the entire chain
2. After resurrection, all namespaces are visible in listns()
3. Resurrected namespaces can be reopened via file handles
4. Closing the netns FD cascades down: the entire ownership chain (userns_L3 -> userns_L2 -> userns_L1) becomes inactive again
5. Inactive namespaces disappear from listns() and cannot be reopened
6. Calling SIOCGSKNS again on the same socket resurrects the tree again
7. After second resurrection, namespaces are visible and can be reopened
Signed-off-by Christian Brauner <[email protected]>
--- .../testing/selftests/namespaces/siocgskns_test.c | 564 +++++++++++++++++++++ 1 file changed, 564 insertions(+)
tools/testing/selftests/namespaces/siocgskns_test.c +564 -0
@@ -1257,4 +1257,568 @@ TEST(siocgskns_listns_and_file_handle)free (handle); } +/* +* Test multi-level namespace resurrection across three user namespace levels. +* +* This test creates a complex namespace hierarchy with three levels of user +* namespaces and a network namespace at the deepest level. It verifies that +* the resurrection semantics work correctly when SIOCGSKNS is called on a +* socket from an inactive namespace tree, and that listns() and +* open_by_handle_at() correctly respect visibility rules. +* +* Hierarchy after child processes exit (all with 0 active refcount): +* +* net_L3A (0) <- Level 3 network namespace +* | +* + +* userns_L3 (0) <- Level 3 user namespace +* | +* + +* userns_L2 (0) <- Level 2 user namespace +* | +* + +* userns_L1 (0) <- Level 1 user namespace +* | +* x +* init_user_ns +* +* The test verifies: +* 1. SIOCGSKNS on a socket from inactive net_L3A resurrects the entire chain +* 2. After resurrection, all namespaces are visible in listns() +* 3. Resurrected namespaces can be reopened via file handles +* 4. Closing the netns FD cascades down: the entire ownership chain +* (userns_L3 -> userns_L2 -> userns_L1) becomes inactive again +* 5. Inactive namespaces disappear from listns() and cannot be reopened +* 6. Calling SIOCGSKNS again on the same socket resurrects the tree again +* 7. After second resurrection, namespaces are visible and can be reopened +*/ +TEST (siocgskns_multilevel_resurrection) +{ +int ipc_sockets[2 ]; +pid_t pid_l1, pid_l2, pid_l3; +int status; + +/* Namespace file descriptors to be received from child */ +int sock_L3A_fd =-1 ; +int netns_L3A_fd =-1 ; +__u64 netns_L3A_id; +__u64 userns_L1_id, userns_L2_id, userns_L3_id; + +/* For listns() and file handle testing */ +struct ns_id_req req = { + .size =sizeof (req), + .spare =0 , + .ns_id =0 , + .ns_type =CLONE_NEWNET |CLONE_NEWUSER , + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 ns_ids[256 ]; +int ret, i; +struct file_handle *handle; +struct nsfs_file_handle *nsfs_fh; +int reopened_fd; + +/* Allocate file handle for testing */ + handle =malloc (sizeof (struct file_handle ) +sizeof (struct nsfs_file_handle )); +ASSERT_NE (handle,NULL ); + handle->handle_bytes =sizeof (struct nsfs_file_handle ); + handle->handle_type =FILEID_NSFS ; + +EXPECT_EQ (socketpair (AF_LOCAL ,SOCK_STREAM |SOCK_CLOEXEC ,0 , ipc_sockets),0 ); + +/* +* Fork level 1 child that creates userns_L1 +*/ + pid_l1 =fork (); +ASSERT_GE (pid_l1,0 ); + +if (pid_l1 ==0 ) { +/* Level 1 child */ +int ipc_L2[2 ]; +close (ipc_sockets[0 ]); + +/* Create userns_L1 */ +if (setup_userns () <0 ) { +close (ipc_sockets[1 ]); +exit (1 ); + } + +/* Create socketpair for communicating with L2 child */ +if (socketpair (AF_LOCAL ,SOCK_STREAM |SOCK_CLOEXEC ,0 , ipc_L2) <0 ) { +close (ipc_sockets[1 ]); +exit (1 ); + } + +/* +* Fork level 2 child that creates userns_L2 +*/ + pid_l2 =fork (); +if (pid_l2 <0 ) { +close (ipc_sockets[1 ]); +close (ipc_L2[0 ]); +close (ipc_L2[1 ]); +exit (1 ); + } + +if (pid_l2 ==0 ) { +/* Level 2 child */ +int ipc_L3[2 ]; +close (ipc_L2[0 ]); + +/* Create userns_L2 (nested inside userns_L1) */ +if (setup_userns () <0 ) { +close (ipc_L2[1 ]); +exit (1 ); + } + +/* Create socketpair for communicating with L3 child */ +if (socketpair (AF_LOCAL ,SOCK_STREAM |SOCK_CLOEXEC ,0 , ipc_L3) <0 ) { +close (ipc_L2[1 ]); +exit (1 ); + } + +/* +* Fork level 3 child that creates userns_L3 and network namespaces +*/ + pid_l3 =fork (); +if (pid_l3 <0 ) { +close (ipc_L2[1 ]); +close (ipc_L3[0 ]); +close (ipc_L3[1 ]); +exit (1 ); + } + +if (pid_l3 ==0 ) { +/* Level 3 child - the deepest level */ +int sock_fd; +close (ipc_L3[0 ]); + +/* Create userns_L3 (nested inside userns_L2) */ +if (setup_userns () <0 ) { +close (ipc_L3[1 ]); +exit (1 ); + } + +/* Create network namespace at level 3 */ +if (unshare (CLONE_NEWNET ) <0 ) { +close (ipc_L3[1 ]); +exit (1 ); + } + +/* Create socket in net_L3A */ + sock_fd =socket (AF_INET ,SOCK_DGRAM ,0 ); +if (sock_fd <0 ) { +close (ipc_L3[1 ]); +exit (1 ); + } + +/* Send socket FD to L2 parent */ +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ] = {'X' }; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); + cmsg->cmsg_level =SOL_SOCKET ; + cmsg->cmsg_type =SCM_RIGHTS ; + cmsg->cmsg_len =CMSG_LEN (sizeof (int )); +memcpy (CMSG_DATA (cmsg), &sock_fd,sizeof (int )); + +if (sendmsg (ipc_L3[1 ], &msg,0 ) <0 ) { +close (sock_fd); +close (ipc_L3[1 ]); +exit (1 ); + } + +close (sock_fd); +close (ipc_L3[1 ]); +exit (0 ); + } + +/* Level 2 child - receive from L3 and forward to L1 */ +close (ipc_L3[1 ]); + +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ]; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; +int received_fd; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +ssize_t n =recvmsg (ipc_L3[0 ], &msg,0 ); +close (ipc_L3[0 ]); + +if (n !=1 ) { +close (ipc_L2[1 ]); +waitpid (pid_l3,NULL ,0 ); +exit (1 ); + } + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); +if (!cmsg) { +close (ipc_L2[1 ]); +waitpid (pid_l3,NULL ,0 ); +exit (1 ); + } +memcpy (&received_fd,CMSG_DATA (cmsg),sizeof (int )); + +/* Wait for L3 child */ +waitpid (pid_l3,NULL ,0 ); + +/* Forward the socket FD to L1 parent */ +memset (&msg,0 ,sizeof (msg)); + buf[0 ] ='Y' ; + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + + cmsg =CMSG_FIRSTHDR (&msg); + cmsg->cmsg_level =SOL_SOCKET ; + cmsg->cmsg_type =SCM_RIGHTS ; + cmsg->cmsg_len =CMSG_LEN (sizeof (int )); +memcpy (CMSG_DATA (cmsg), &received_fd,sizeof (int )); + +if (sendmsg (ipc_L2[1 ], &msg,0 ) <0 ) { +close (received_fd); +close (ipc_L2[1 ]); +exit (1 ); + } + +close (received_fd); +close (ipc_L2[1 ]); +exit (0 ); + } + +/* Level 1 child - receive from L2 and forward to parent */ +close (ipc_L2[1 ]); + +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ]; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; +int received_fd; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +ssize_t n =recvmsg (ipc_L2[0 ], &msg,0 ); +close (ipc_L2[0 ]); + +if (n !=1 ) { +close (ipc_sockets[1 ]); +waitpid (pid_l2,NULL ,0 ); +exit (1 ); + } + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); +if (!cmsg) { +close (ipc_sockets[1 ]); +waitpid (pid_l2,NULL ,0 ); +exit (1 ); + } +memcpy (&received_fd,CMSG_DATA (cmsg),sizeof (int )); + +/* Wait for L2 child */ +waitpid (pid_l2,NULL ,0 ); + +/* Forward the socket FD to parent */ +memset (&msg,0 ,sizeof (msg)); + buf[0 ] ='Z' ; + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + + cmsg =CMSG_FIRSTHDR (&msg); + cmsg->cmsg_level =SOL_SOCKET ; + cmsg->cmsg_type =SCM_RIGHTS ; + cmsg->cmsg_len =CMSG_LEN (sizeof (int )); +memcpy (CMSG_DATA (cmsg), &received_fd,sizeof (int )); + +if (sendmsg (ipc_sockets[1 ], &msg,0 ) <0 ) { +close (received_fd); +close (ipc_sockets[1 ]); +exit (1 ); + } + +close (received_fd); +close (ipc_sockets[1 ]); +exit (0 ); + } + +/* Parent - receive the socket from the deepest level */ +close (ipc_sockets[1 ]); + +struct msghdr msg = {0 }; +struct iovec iov = {0 }; +char buf[1 ]; +char cmsg_buf[CMSG_SPACE (sizeof (int ))]; + + iov.iov_base = buf; + iov.iov_len =1 ; + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + msg.msg_control = cmsg_buf; + msg.msg_controllen =sizeof (cmsg_buf); + +ssize_t n =recvmsg (ipc_sockets[0 ], &msg,0 ); +close (ipc_sockets[0 ]); + +if (n !=1 ) { +free (handle); +waitpid (pid_l1,NULL ,0 ); +SKIP (return,"Failed to receive socket from child" ); + } + +struct cmsghdr *cmsg =CMSG_FIRSTHDR (&msg); +if (!cmsg) { +free (handle); +waitpid (pid_l1,NULL ,0 ); +SKIP (return,"Failed to receive socket from child" ); + } +memcpy (&sock_L3A_fd,CMSG_DATA (cmsg),sizeof (int )); + +/* Wait for L1 child */ +waitpid (pid_l1, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 ); + +/* +* At this point, all child processes have exited. The socket itself +* doesn't keep the namespace active - we need to call SIOCGSKNS which +* will resurrect the entire namespace tree by taking active references. +*/ + +/* Get network namespace from socket - this resurrects the tree */ + netns_L3A_fd =ioctl (sock_L3A_fd,SIOCGSKNS ); +if (netns_L3A_fd <0 ) { +free (handle); +close (sock_L3A_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"SIOCGSKNS not supported" ); +ASSERT_GE (netns_L3A_fd,0 ); + } + +/* Get namespace ID for net_L3A */ + ret =ioctl (netns_L3A_fd,NS_GET_ID , &netns_L3A_id); +if (ret <0 ) { +free (handle); +close (sock_L3A_fd); +close (netns_L3A_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"NS_GET_ID not supported" ); +ASSERT_EQ (ret,0 ); + } + +/* Get owner user namespace chain: userns_L3 -> userns_L2 -> userns_L1 */ +int userns_L3_fd =ioctl (netns_L3A_fd,NS_GET_USERNS ); +if (userns_L3_fd <0 ) { +free (handle); +close (sock_L3A_fd); +close (netns_L3A_fd); +if (errno ==ENOTTY || errno ==EINVAL ) +SKIP (return,"NS_GET_USERNS not supported" ); +ASSERT_GE (userns_L3_fd,0 ); + } + + ret =ioctl (userns_L3_fd,NS_GET_ID , &userns_L3_id); +ASSERT_EQ (ret,0 ); + +int userns_L2_fd =ioctl (userns_L3_fd,NS_GET_USERNS ); +ASSERT_GE (userns_L2_fd,0 ); + ret =ioctl (userns_L2_fd,NS_GET_ID , &userns_L2_id); +ASSERT_EQ (ret,0 ); + +int userns_L1_fd =ioctl (userns_L2_fd,NS_GET_USERNS ); +ASSERT_GE (userns_L1_fd,0 ); + ret =ioctl (userns_L1_fd,NS_GET_ID , &userns_L1_id); +ASSERT_EQ (ret,0 ); + +close (userns_L1_fd); +close (userns_L2_fd); +close (userns_L3_fd); + +TH_LOG ("Multi-level hierarchy: net_L3A (id=%llu) -> userns_L3 (id=%llu) -> userns_L2 (id=%llu) -> userns_L1 (id=%llu)" , + netns_L3A_id, userns_L3_id, userns_L2_id, userns_L1_id); + +/* +* Test 1: Verify net_L3A is visible in listns() after resurrection. +* The entire ownership chain should be resurrected and visible. +*/ + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +if (ret <0 ) { +free (handle); +close (sock_L3A_fd); +close (netns_L3A_fd); +if (errno ==ENOSYS ) +SKIP (return,"listns() not supported" ); +ASSERT_GE (ret,0 ); + } + +bool found_netns_L3A = false; +bool found_userns_L1 = false; +bool found_userns_L2 = false; +bool found_userns_L3 = false; + +for (i =0 ; i < ret; i++) { +if (ns_ids[i] == netns_L3A_id) + found_netns_L3A = true; +if (ns_ids[i] == userns_L1_id) + found_userns_L1 = true; +if (ns_ids[i] == userns_L2_id) + found_userns_L2 = true; +if (ns_ids[i] == userns_L3_id) + found_userns_L3 = true; + } + +ASSERT_TRUE (found_netns_L3A); +ASSERT_TRUE (found_userns_L1); +ASSERT_TRUE (found_userns_L2); +ASSERT_TRUE (found_userns_L3); +TH_LOG ("Resurrection verified: all namespaces in hierarchy visible in listns()" ); + +/* +* Test 2: Verify net_L3A can be reopened via file handle. +*/ + nsfs_fh = (struct nsfs_file_handle *)handle->f_handle; + nsfs_fh->ns_id = netns_L3A_id; + nsfs_fh->ns_type =0 ; + nsfs_fh->ns_inum =0 ; + + reopened_fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +if (reopened_fd <0 ) { +free (handle); +close (sock_L3A_fd); +close (netns_L3A_fd); +if (errno ==EOPNOTSUPP || errno ==ENOSYS || errno ==EBADF ) +SKIP (return,"open_by_handle_at with FD_NSFS_ROOT not supported" ); +TH_LOG ("open_by_handle_at failed: %s" ,strerror (errno)); +ASSERT_GE (reopened_fd,0 ); + } + +close (reopened_fd); +TH_LOG ("File handle test passed: net_L3A can be reopened" ); + +/* +* Test 3: Verify that when we close the netns FD (dropping the last +* active reference), the entire tree becomes inactive and disappears +* from listns(). The cascade goes: net_L3A drops -> userns_L3 drops -> +* userns_L2 drops -> userns_L1 drops. +*/ +close (netns_L3A_fd); + + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +ASSERT_GE (ret,0 ); + + found_netns_L3A = false; + found_userns_L1 = false; + found_userns_L2 = false; + found_userns_L3 = false; + +for (i =0 ; i < ret; i++) { +if (ns_ids[i] == netns_L3A_id) + found_netns_L3A = true; +if (ns_ids[i] == userns_L1_id) + found_userns_L1 = true; +if (ns_ids[i] == userns_L2_id) + found_userns_L2 = true; +if (ns_ids[i] == userns_L3_id) + found_userns_L3 = true; + } + +ASSERT_FALSE (found_netns_L3A); +ASSERT_FALSE (found_userns_L1); +ASSERT_FALSE (found_userns_L2); +ASSERT_FALSE (found_userns_L3); +TH_LOG ("Cascade test passed: all namespaces disappeared after netns FD closed" ); + +/* +* Test 4: Verify file handle no longer works for inactive namespace. +*/ + reopened_fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +if (reopened_fd >=0 ) { +close (reopened_fd); +free (handle); +ASSERT_TRUE (false);/* Should have failed */ + } +TH_LOG ("Inactive namespace correctly cannot be reopened via file handle" ); + +/* +* Test 5: Verify that calling SIOCGSKNS again resurrects the tree again. +* The socket is still valid, so we can call SIOCGSKNS on it to resurrect +* the namespace tree once more. +*/ + netns_L3A_fd =ioctl (sock_L3A_fd,SIOCGSKNS ); +ASSERT_GE (netns_L3A_fd,0 ); + +TH_LOG ("Called SIOCGSKNS again to resurrect the namespace tree" ); + +/* Verify the namespace tree is resurrected and visible in listns() */ + ret =sys_listns (&req, ns_ids,ARRAY_SIZE (ns_ids),0 ); +ASSERT_GE (ret,0 ); + + found_netns_L3A = false; + found_userns_L1 = false; + found_userns_L2 = false; + found_userns_L3 = false; + +for (i =0 ; i < ret; i++) { +if (ns_ids[i] == netns_L3A_id) + found_netns_L3A = true; +if (ns_ids[i] == userns_L1_id) + found_userns_L1 = true; +if (ns_ids[i] == userns_L2_id) + found_userns_L2 = true; +if (ns_ids[i] == userns_L3_id) + found_userns_L3 = true; + } + +ASSERT_TRUE (found_netns_L3A); +ASSERT_TRUE (found_userns_L1); +ASSERT_TRUE (found_userns_L2); +ASSERT_TRUE (found_userns_L3); +TH_LOG ("Second resurrection verified: all namespaces in hierarchy visible in listns() again" ); + +/* Verify we can reopen via file handle again */ + reopened_fd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +if (reopened_fd <0 ) { +free (handle); +close (sock_L3A_fd); +close (netns_L3A_fd); +TH_LOG ("open_by_handle_at failed after second resurrection: %s" ,strerror (errno)); +ASSERT_GE (reopened_fd,0 ); + } + +close (reopened_fd); +TH_LOG ("File handle test passed: net_L3A can be reopened after second resurrection" ); + +/* Final cleanup */ +close (sock_L3A_fd); +close (netns_L3A_fd); +free (handle); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 67/72 selftests/namespace: first threaded active reference count test
In reply to Christian BraunerTest that namespace becomes inactive after thread exits. This verifies active reference counting works with threads, not just processes.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 138 +++++++++++++++++++++ 1 file changed, 138 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +138 -0
@@ -12,9 +12,12 @@#include <sys/stat.h> #include <sys/types.h> #include <sys/wait.h> +#include <sys/syscall.h> #include <unistd.h> +#include <pthread.h> #include "../kselftest_harness.h" #include "../filesystems/utils.h" +#include "wrappers.h" #ifndef FD_NSFS_ROOT #define FD_NSFS_ROOT -10003/* Root of the nsfs filesystem */
@@ -2113,4 +2116,139 @@ TEST(ns_mixed_types_same_owner)ASSERT_LT (u_fd,0 ); } +/* Thread test helpers and structures */ +struct thread_ns_info { +__u64 ns_id; +int pipefd; +int syncfd_read; +int syncfd_write; +int exit_code; +}; + +static void *thread_create_namespace (void *arg) +{ +struct thread_ns_info *info = (struct thread_ns_info *)arg; +int ret; + +/* Create new network namespace */ + ret =unshare (CLONE_NEWNET ); +if (ret <0 ) { + info->exit_code =1 ; +return NULL ; + } + +/* Get namespace ID */ +int fd =open ("/proc/thread-self/ns/net" ,O_RDONLY ); +if (fd <0 ) { + info->exit_code =2 ; +return NULL ; + } + + ret =ioctl (fd,NS_GET_ID , &info->ns_id); +close (fd); +if (ret <0 ) { + info->exit_code =3 ; +return NULL ; + } + +/* Send namespace ID to main thread */ +if (write (info->pipefd, &info->ns_id,sizeof (info->ns_id)) !=sizeof (info->ns_id)) { + info->exit_code =4 ; +return NULL ; + } + +/* Wait for signal to exit */ +char sync_byte; +if (read (info->syncfd_read, &sync_byte,1 ) !=1 ) { + info->exit_code =5 ; +return NULL ; + } + + info->exit_code =0 ; +return NULL ; +} + +/* +* Test that namespace becomes inactive after thread exits. +* This verifies active reference counting works with threads, not just processes. +*/ +TEST (thread_ns_inactive_after_exit) +{ +pthread_t thread; +struct thread_ns_info info; +struct file_handle *handle; +int pipefd[2 ]; +int syncpipe[2 ]; +int ret; +char sync_byte; +char buf[sizeof (*handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); +ASSERT_EQ (pipe (syncpipe),0 ); + + info.pipefd = pipefd[1 ]; + info.syncfd_read = syncpipe[0 ]; + info.syncfd_write =-1 ; + info.exit_code =-1 ; + +/* Create thread that will create a namespace */ + ret =pthread_create (&thread,NULL , thread_create_namespace, &info); +ASSERT_EQ (ret,0 ); + +/* Read namespace ID from thread */ +__u64 ns_id; + ret =read (pipefd[0 ], &ns_id,sizeof (ns_id)); +if (ret !=sizeof (ns_id)) { + sync_byte ='X' ; +write (syncpipe[1 ], &sync_byte,1 ); +pthread_join (thread,NULL ); +close (pipefd[0 ]); +close (pipefd[1 ]); +close (syncpipe[0 ]); +close (syncpipe[1 ]); +SKIP (return,"Failed to read namespace ID from thread" ); + } + +TH_LOG ("Thread created namespace with ID %llu" , (unsigned long long )ns_id); + +/* Construct file handle */ + handle = (struct file_handle *)buf; + handle->handle_bytes =sizeof (struct nsfs_file_handle ); + handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *fh = (struct nsfs_file_handle *)handle->f_handle; + fh->ns_id = ns_id; + fh->ns_type =0 ; + fh->ns_inum =0 ; + +/* Namespace should be active while thread is alive */ +TH_LOG ("Attempting to open namespace while thread is alive (should succeed)" ); +int nsfd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_GE (nsfd,0 ); +close (nsfd); + +/* Signal thread to exit */ +TH_LOG ("Signaling thread to exit" ); + sync_byte ='X' ; +ASSERT_EQ (write (syncpipe[1 ], &sync_byte,1 ),1 ); +close (syncpipe[1 ]); + +/* Wait for thread to exit */ +ASSERT_EQ (pthread_join (thread,NULL ),0 ); +close (pipefd[0 ]); +close (pipefd[1 ]); +close (syncpipe[0 ]); + +if (info.exit_code !=0 ) +SKIP (return,"Thread failed to create namespace" ); + +TH_LOG ("Thread exited, namespace should be inactive" ); + +/* Namespace should now be inactive */ + nsfd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_LT (nsfd,0 ); +/* Should fail with ENOENT (inactive) or ESTALE (gone) */ +TH_LOG ("Namespace inactive as expected: %s (errno=%d)" ,strerror (errno), errno); +ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 68/72 selftests/namespace: second threaded active reference count test
In reply to Christian BraunerTest that a namespace remains active while a thread holds an fd to it. Even after the thread exits, the namespace should remain active as long as another thread holds a file descriptor to it.
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 99 ++++++++++++++++++++++ 1 file changed, 99 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +99 -0
@@ -2251,4 +2251,103 @@ TEST(thread_ns_inactive_after_exit)ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); } +/* +* Test that a namespace remains active while a thread holds an fd to it. +* Even after the thread exits, the namespace should remain active as long as +* another thread holds a file descriptor to it. +*/ +TEST (thread_ns_fd_keeps_active) +{ +pthread_t thread; +struct thread_ns_info info; +struct file_handle *handle; +int pipefd[2 ]; +int syncpipe[2 ]; +int ret; +char sync_byte; +char buf[sizeof (*handle) +MAX_HANDLE_SZ ]; + +ASSERT_EQ (pipe (pipefd),0 ); +ASSERT_EQ (pipe (syncpipe),0 ); + + info.pipefd = pipefd[1 ]; + info.syncfd_read = syncpipe[0 ]; + info.syncfd_write =-1 ; + info.exit_code =-1 ; + +/* Create thread that will create a namespace */ + ret =pthread_create (&thread,NULL , thread_create_namespace, &info); +ASSERT_EQ (ret,0 ); + +/* Read namespace ID from thread */ +__u64 ns_id; + ret =read (pipefd[0 ], &ns_id,sizeof (ns_id)); +if (ret !=sizeof (ns_id)) { + sync_byte ='X' ; +write (syncpipe[1 ], &sync_byte,1 ); +pthread_join (thread,NULL ); +close (pipefd[0 ]); +close (pipefd[1 ]); +close (syncpipe[0 ]); +close (syncpipe[1 ]); +SKIP (return,"Failed to read namespace ID from thread" ); + } + +TH_LOG ("Thread created namespace with ID %llu" , (unsigned long long )ns_id); + +/* Construct file handle */ + handle = (struct file_handle *)buf; + handle->handle_bytes =sizeof (struct nsfs_file_handle ); + handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *fh = (struct nsfs_file_handle *)handle->f_handle; + fh->ns_id = ns_id; + fh->ns_type =0 ; + fh->ns_inum =0 ; + +/* Open namespace while thread is alive */ +TH_LOG ("Opening namespace while thread is alive" ); +int nsfd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_GE (nsfd,0 ); + +/* Signal thread to exit */ +TH_LOG ("Signaling thread to exit" ); + sync_byte ='X' ; +write (syncpipe[1 ], &sync_byte,1 ); +close (syncpipe[1 ]); + +/* Wait for thread to exit */ +pthread_join (thread,NULL ); +close (pipefd[0 ]); +close (pipefd[1 ]); +close (syncpipe[0 ]); + +if (info.exit_code !=0 ) { +close (nsfd); +SKIP (return,"Thread failed to create namespace" ); + } + +TH_LOG ("Thread exited, but main thread holds fd - namespace should remain active" ); + +/* Namespace should still be active because we hold an fd */ +int nsfd2 =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_GE (nsfd2,0 ); + +/* Verify it's the same namespace */ +struct stat st1, st2; +ASSERT_EQ (fstat (nsfd, &st1),0 ); +ASSERT_EQ (fstat (nsfd2, &st2),0 ); +ASSERT_EQ (st1.st_ino, st2.st_ino); +close (nsfd2); + +TH_LOG ("Closing fd - namespace should become inactive" ); +close (nsfd); + +/* Now namespace should be inactive */ + nsfd =open_by_handle_at (FD_NSFS_ROOT , handle,O_RDONLY ); +ASSERT_LT (nsfd,0 ); +/* Should fail with ENOENT (inactive) or ESTALE (gone) */ +TH_LOG ("Namespace inactive as expected: %s (errno=%d)" ,strerror (errno), errno); +ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 69/72 selftests/namespace: third threaded active reference count test
In reply to Christian BraunerTest that namespaces become inactive after subprocess with multiple threads exits. Create a subprocess that unshares user and network namespaces, then creates two threads that share those namespaces. Verify that after all threads and subprocess exit, the namespaces are no longer listed by listns() and cannot be opened by open_by_handle_at().
Signed-off-by Christian Brauner <[email protected]>
--- .../selftests/namespaces/ns_active_ref_test.c | 319 +++++++++++++++++++++ 1 file changed, 319 insertions(+)
tools/testing/selftests/namespaces/ns_active_ref_test.c +319 -0
@@ -9,6 +9,7 @@#include <string.h> #include <linux/nsfs.h> #include <sys/mount.h> +#include <sys/socket.h> #include <sys/stat.h> #include <sys/types.h> #include <sys/wait.h>
@@ -2350,4 +2351,322 @@ TEST(thread_ns_fd_keeps_active)ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); } +/* Structure for thread data in subprocess */ +struct thread_sleep_data { +int syncfd_read; +}; + +static void *thread_sleep_and_wait (void *arg) +{ +struct thread_sleep_data *data = (struct thread_sleep_data *)arg; +char sync_byte; + +/* Wait for signal to exit - read will unblock when pipe is closed */ + (void )read (data->syncfd_read, &sync_byte,1 ); +return NULL ; +} + +/* +* Test that namespaces become inactive after subprocess with multiple threads exits. +* Create a subprocess that unshares user and network namespaces, then creates two +* threads that share those namespaces. Verify that after all threads and subprocess +* exit, the namespaces are no longer listed by listns() and cannot be opened by +* open_by_handle_at(). +*/ +TEST (thread_subprocess_ns_inactive_after_all_exit) +{ +int pipefd[2 ]; +int sv[2 ]; +pid_t pid; +int status; +__u64 user_id, net_id; +struct file_handle *user_handle, *net_handle; +char user_buf[sizeof (*user_handle) +MAX_HANDLE_SZ ]; +char net_buf[sizeof (*net_handle) +MAX_HANDLE_SZ ]; +char sync_byte; +int ret; + +ASSERT_EQ (pipe (pipefd),0 ); +ASSERT_EQ (socketpair (AF_UNIX ,SOCK_STREAM ,0 , sv),0 ); + + pid =fork (); +ASSERT_GE (pid,0 ); + +if (pid ==0 ) { +/* Child process */ +close (pipefd[0 ]); +close (sv[0 ]); + +/* Create user namespace with mappings */ +if (setup_userns () <0 ) { +fprintf (stderr,"Child: setup_userns() failed: %s\n" ,strerror (errno)); +close (pipefd[1 ]); +close (sv[1 ]); +exit (1 ); + } +fprintf (stderr,"Child: setup_userns() succeeded\n" ); + +/* Get user namespace ID */ +int user_fd =open ("/proc/self/ns/user" ,O_RDONLY ); +if (user_fd <0 ) { +fprintf (stderr,"Child: open(/proc/self/ns/user) failed: %s\n" ,strerror (errno)); +close (pipefd[1 ]); +close (sv[1 ]); +exit (1 ); + } + +if (ioctl (user_fd,NS_GET_ID , &user_id) <0 ) { +fprintf (stderr,"Child: ioctl(NS_GET_ID) for user ns failed: %s\n" ,strerror (errno)); +close (user_fd); +close (pipefd[1 ]); +close (sv[1 ]); +exit (1 ); + } +close (user_fd); +fprintf (stderr,"Child: user ns ID = %llu\n" , (unsigned long long )user_id); + +/* Unshare network namespace */ +if (unshare (CLONE_NEWNET ) <0 ) { +fprintf (stderr,"Child: unshare(CLONE_NEWNET) failed: %s\n" ,strerror (errno)); +close (pipefd[1 ]); +close (sv[1 ]); +exit (1 ); + } +fprintf (stderr,"Child: unshare(CLONE_NEWNET) succeeded\n" ); + +/* Get network namespace ID */ +int net_fd =open ("/proc/self/ns/net" ,O_RDONLY ); +if (net_fd <0 ) { +fprintf (stderr,"Child: open(/proc/self/ns/net) failed: %s\n" ,strerror (errno)); +close (pipefd[1 ]); +close (sv[1 ]); +exit (1 ); + } + +if (ioctl (net_fd,NS_GET_ID , &net_id) <0 ) { +fprintf (stderr,"Child: ioctl(NS_GET_ID) for net ns failed: %s\n" ,strerror (errno)); +close (net_fd); +close (pipefd[1 ]); +close (sv[1 ]); +exit (1 ); + } +close (net_fd); +fprintf (stderr,"Child: net ns ID = %llu\n" , (unsigned long long )net_id); + +/* Send namespace IDs to parent */ +if (write (pipefd[1 ], &user_id,sizeof (user_id)) !=sizeof (user_id)) { +fprintf (stderr,"Child: write(user_id) failed: %s\n" ,strerror (errno)); +exit (1 ); + } +if (write (pipefd[1 ], &net_id,sizeof (net_id)) !=sizeof (net_id)) { +fprintf (stderr,"Child: write(net_id) failed: %s\n" ,strerror (errno)); +exit (1 ); + } +close (pipefd[1 ]); +fprintf (stderr,"Child: sent namespace IDs to parent\n" ); + +/* Create two threads that share the namespaces */ +pthread_t thread1, thread2; +struct thread_sleep_data data; + data.syncfd_read = sv[1 ]; + +int ret_thread =pthread_create (&thread1,NULL , thread_sleep_and_wait, &data); +if (ret_thread !=0 ) { +fprintf (stderr,"Child: pthread_create(thread1) failed: %s\n" ,strerror (ret_thread)); +close (sv[1 ]); +exit (1 ); + } +fprintf (stderr,"Child: created thread1\n" ); + + ret_thread =pthread_create (&thread2,NULL , thread_sleep_and_wait, &data); +if (ret_thread !=0 ) { +fprintf (stderr,"Child: pthread_create(thread2) failed: %s\n" ,strerror (ret_thread)); +close (sv[1 ]); +pthread_cancel (thread1); +exit (1 ); + } +fprintf (stderr,"Child: created thread2\n" ); + +/* Wait for threads to complete - they will unblock when parent writes */ +fprintf (stderr,"Child: waiting for threads to exit\n" ); +pthread_join (thread1,NULL ); +fprintf (stderr,"Child: thread1 exited\n" ); +pthread_join (thread2,NULL ); +fprintf (stderr,"Child: thread2 exited\n" ); + +close (sv[1 ]); + +/* Exit - namespaces should become inactive */ +fprintf (stderr,"Child: all threads joined, exiting with success\n" ); +exit (0 ); + } + +/* Parent process */ +close (pipefd[1 ]); +close (sv[1 ]); + +TH_LOG ("Parent: waiting to read namespace IDs from child" ); + +/* Read namespace IDs from child */ + ret =read (pipefd[0 ], &user_id,sizeof (user_id)); +if (ret !=sizeof (user_id)) { +TH_LOG ("Parent: failed to read user_id, ret=%d, errno=%s" , ret,strerror (errno)); +close (pipefd[0 ]); + sync_byte ='X' ; + (void )write (sv[0 ], &sync_byte,1 ); +close (sv[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read user namespace ID from child" ); + } + + ret =read (pipefd[0 ], &net_id,sizeof (net_id)); +close (pipefd[0 ]); +if (ret !=sizeof (net_id)) { +TH_LOG ("Parent: failed to read net_id, ret=%d, errno=%s" , ret,strerror (errno)); + sync_byte ='X' ; + (void )write (sv[0 ], &sync_byte,1 ); +close (sv[0 ]); +waitpid (pid,NULL ,0 ); +SKIP (return,"Failed to read network namespace ID from child" ); + } + +TH_LOG ("Child created user ns %llu and net ns %llu with 2 threads" , + (unsigned long long )user_id, (unsigned long long )net_id); + +/* Construct file handles */ + user_handle = (struct file_handle *)user_buf; + user_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + user_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *user_fh = (struct nsfs_file_handle *)user_handle->f_handle; + user_fh->ns_id = user_id; + user_fh->ns_type =0 ; + user_fh->ns_inum =0 ; + + net_handle = (struct file_handle *)net_buf; + net_handle->handle_bytes =sizeof (struct nsfs_file_handle ); + net_handle->handle_type =FILEID_NSFS ; +struct nsfs_file_handle *net_fh = (struct nsfs_file_handle *)net_handle->f_handle; + net_fh->ns_id = net_id; + net_fh->ns_type =0 ; + net_fh->ns_inum =0 ; + +/* Verify namespaces are active while subprocess and threads are alive */ +TH_LOG ("Verifying namespaces are active while subprocess with threads is running" ); +int user_fd =open_by_handle_at (FD_NSFS_ROOT , user_handle,O_RDONLY ); +ASSERT_GE (user_fd,0 ); + +int net_fd =open_by_handle_at (FD_NSFS_ROOT , net_handle,O_RDONLY ); +ASSERT_GE (net_fd,0 ); + +close (user_fd); +close (net_fd); + +/* Also verify they appear in listns() */ +TH_LOG ("Verifying namespaces appear in listns() while active" ); +struct ns_id_req req = { + .size =sizeof (struct ns_id_req ), + .spare =0 , + .ns_id =0 , + .ns_type =CLONE_NEWUSER , + .spare2 =0 , + .user_ns_id =0 , + }; +__u64 ns_ids[256 ]; +int nr_ids =sys_listns (&req, ns_ids,256 ,0 ); +if (nr_ids <0 ) { +TH_LOG ("listns() not available, skipping listns verification" ); + }else { +/* Check if user_id is in the list */ +int found_user =0 ; +for (int i =0 ; i < nr_ids; i++) { +if (ns_ids[i] == user_id) { + found_user =1 ; +break ; + } + } +ASSERT_TRUE (found_user); +TH_LOG ("User namespace found in listns() as expected" ); + +/* Check network namespace */ + req.ns_type =CLONE_NEWNET ; + nr_ids =sys_listns (&req, ns_ids,256 ,0 ); +if (nr_ids >=0 ) { +int found_net =0 ; +for (int i =0 ; i < nr_ids; i++) { +if (ns_ids[i] == net_id) { + found_net =1 ; +break ; + } + } +ASSERT_TRUE (found_net); +TH_LOG ("Network namespace found in listns() as expected" ); + } + } + +/* Signal threads to exit */ +TH_LOG ("Signaling threads to exit" ); + sync_byte ='X' ; +/* Write two bytes - one for each thread */ +ASSERT_EQ (write (sv[0 ], &sync_byte,1 ),1 ); +ASSERT_EQ (write (sv[0 ], &sync_byte,1 ),1 ); +close (sv[0 ]); + +/* Wait for child process to exit */ +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status)); +if (WEXITSTATUS (status) !=0 ) { +TH_LOG ("Child process failed with exit code %d" ,WEXITSTATUS (status)); +SKIP (return,"Child process failed" ); + } + +TH_LOG ("Subprocess and all threads have exited successfully" ); + +/* Verify namespaces are now inactive - open_by_handle_at should fail */ +TH_LOG ("Verifying namespaces are inactive after subprocess and threads exit" ); + user_fd =open_by_handle_at (FD_NSFS_ROOT , user_handle,O_RDONLY ); +ASSERT_LT (user_fd,0 ); +TH_LOG ("User namespace inactive as expected: %s (errno=%d)" , +strerror (errno), errno); +ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); + + net_fd =open_by_handle_at (FD_NSFS_ROOT , net_handle,O_RDONLY ); +ASSERT_LT (net_fd,0 ); +TH_LOG ("Network namespace inactive as expected: %s (errno=%d)" , +strerror (errno), errno); +ASSERT_TRUE (errno ==ENOENT || errno ==ESTALE ); + +/* Verify namespaces do NOT appear in listns() */ +TH_LOG ("Verifying namespaces do NOT appear in listns() when inactive" ); +memset (&req,0 ,sizeof (req)); + req.size =sizeof (struct ns_id_req ); + req.ns_type =CLONE_NEWUSER ; + nr_ids =sys_listns (&req, ns_ids,256 ,0 ); +if (nr_ids >=0 ) { +int found_user =0 ; +for (int i =0 ; i < nr_ids; i++) { +if (ns_ids[i] == user_id) { + found_user =1 ; +break ; + } + } +ASSERT_FALSE (found_user); +TH_LOG ("User namespace correctly not listed in listns()" ); + +/* Check network namespace */ + req.ns_type =CLONE_NEWNET ; + nr_ids =sys_listns (&req, ns_ids,256 ,0 ); +if (nr_ids >=0 ) { +int found_net =0 ; +for (int i =0 ; i < nr_ids; i++) { +if (ns_ids[i] == net_id) { + found_net =1 ; +break ; + } + } +ASSERT_FALSE (found_net); +TH_LOG ("Network namespace correctly not listed in listns()" ); + } + } +} +TEST_HARNESS_MAIN
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 70/72 selftests/namespace: commit_creds() active reference tests
In reply to Christian BraunerTest credential changes and their impact on namespace active references.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/.gitignore | 1 + tools/testing/selftests/namespaces/Makefile | 4 +- .../selftests/namespaces/cred_change_test.c | 814 +++++++++++++++++++++ 3 files changed, 818 insertions(+), 1 deletion(-)
tools/testing/selftests/namespaces/.gitignore +1 -0
@@ -5,3 +5,4 @@ ns_active_ref_test listns_test listns_permissions_test siocgskns_test +cred_change_test
tools/testing/selftests/namespaces/Makefile +3 -1
@@ -8,7 +8,8 @@ TEST_GEN_PROGS := nsid_test \ ns_active_ref_test \ listns_test \ listns_permissions_test \ - siocgskns_test + siocgskns_test \ + cred_change_test include ../lib.mk
@@ -16,4 +17,5 @@ $(OUTPUT)/ns_active_ref_test: ../filesystems/utils.c $(OUTPUT)/listns_test: ../filesystems/utils.c $(OUTPUT)/listns_permissions_test: ../filesystems/utils.c $(OUTPUT)/siocgskns_test: ../filesystems/utils.c +$(OUTPUT)/cred_change_test: ../filesystems/utils.c
tools/testing/selftests/namespaces/cred_change_test.c new file +814 -0
814 lines not on this page · raw message
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 71/72 selftests/namespace: add stress test
In reply to Christian BraunerStress tests for namespace active reference counting.
These tests validate that the active reference counting system can handle high load scenarios including rapid namespace creation/destruction, large numbers of concurrent namespaces, and various edge cases under stress.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/.gitignore | 1 + tools/testing/selftests/namespaces/Makefile | 4 +- tools/testing/selftests/namespaces/stress_test.c | 626 +++++++++++++++++++++++ 3 files changed, 630 insertions(+), 1 deletion(-)
tools/testing/selftests/namespaces/.gitignore +1 -0
@@ -6,3 +6,4 @@ listns_test listns_permissions_test siocgskns_test cred_change_test +stress_test
tools/testing/selftests/namespaces/Makefile +3 -1
@@ -9,7 +9,8 @@ TEST_GEN_PROGS := nsid_test \ listns_test \ listns_permissions_test \ siocgskns_test \ - cred_change_test + cred_change_test \ + stress_test include ../lib.mk
@@ -18,4 +19,5 @@ $(OUTPUT)/listns_test: ../filesystems/utils.c $(OUTPUT)/listns_permissions_test: ../filesystems/utils.c $(OUTPUT)/siocgskns_test: ../filesystems/utils.c $(OUTPUT)/cred_change_test: ../filesystems/utils.c +$(OUTPUT)/stress_test: ../filesystems/utils.c
tools/testing/selftests/namespaces/stress_test.c new file +626 -0
626 lines not on this page · raw message
Signature · 1 line
2.47.3
Christian Brauner
maintainerPATCH v4 72/72 selftests/namespace: test listns() pagination
In reply to Christian BraunerMinimal test case to reproduce KASAN out-of-bounds in listns pagination.
Signed-off-by Christian Brauner <[email protected]>
--- tools/testing/selftests/namespaces/.gitignore | 1 + tools/testing/selftests/namespaces/Makefile | 4 +- .../selftests/namespaces/listns_pagination_bug.c | 138 +++++++++++++++++++++ 3 files changed, 142 insertions(+), 1 deletion(-)
tools/testing/selftests/namespaces/.gitignore +1 -0
@@ -7,3 +7,4 @@ listns_permissions_test siocgskns_test cred_change_test stress_test +listns_pagination_bug
tools/testing/selftests/namespaces/Makefile +3 -1
@@ -10,7 +10,8 @@ TEST_GEN_PROGS := nsid_test \ listns_permissions_test \ siocgskns_test \ cred_change_test \ - stress_test + stress_test \ + listns_pagination_bug include ../lib.mk
@@ -20,4 +21,5 @@ $(OUTPUT)/listns_permissions_test: ../filesystems/utils.c $(OUTPUT)/siocgskns_test: ../filesystems/utils.c $(OUTPUT)/cred_change_test: ../filesystems/utils.c $(OUTPUT)/stress_test: ../filesystems/utils.c +$(OUTPUT)/listns_pagination_bug: ../filesystems/utils.c
tools/testing/selftests/namespaces/listns_pagination_bug.c new file +138 -0
138 lines not on this page · raw message
Signature · 1 line
2.47.3