将子命名空间的挂载传播到父命名空间?

时间:2018-01-08 19:10:45

标签: c linux filesystems linux-containers linux-namespaces

如何将在子命名空间中创建的装载传播到父级?

详细

我正在尝试创建一个利用overlayfs的工具来允许在只读目录上进行写入。棘手的是,我希望任何用户都能够在没有root权限的情况下使用它。因此我希望这可以通过mount命名空间来实现,前提是管理员已经挂载了一个共享目录,然后任何用户都应该能够在该父树命名空间可见的树下创建一个覆盖(因此任何用户都可以登录) shell可以看到覆盖挂载)。

这是我尝试的,但不起作用:

# admin creates a shared tree for users to mount under
sudo mkdir /overlays
# bind mount over itself with MS_REC | MS_SHARED
sudo mount --bind --rshared /overlays /overlays

假设用户想要在/some/readonly/dir上创建叠加层,则应创建/overlays/user/{upper,work,mnt}。我希望他们能够在使用以下代码传播的/overlays目录下安装叠加层。

// user_overlay.c
#define _GNU_SOURCE                                                                                                                                                                                          
#include <sched.h>                                                                                                                                                                                           

#include <stdio.h>                                                                                                                                                                                           
#include <stdlib.h>                                                                                                                                                                                          
#include <signal.h>                                                                                                                                                                                          
#include <linux/capability.h>                                                                                                                                                                                
#include <sys/mount.h>                                                                                                                                                                                       
#include <sys/types.h>                                                                                                                                                                                       
#include <sys/wait.h>                                                                                                                                                                                        
#include <unistd.h>                                                                                                                                                                                          

int child(void *args)                                                                                                                                                                                        
{                                                                                                                                                                                                            
    pid_t p;                                                                                                                               
    p = mount("overlay", "/overlays/user/mnt", "overlay", 0, "lowerdir=/some/readonly/dir,upperdir=/overlays/user/upper,workdir=/overlays/user/work");                                                                           
    if (p == -1){                                                                                                                                                                                            
        perror("Failed to mount overlay");                                                                                                                                                                                     
        exit(1);                                                                                                                                                                                             
    }                                                                                                                                                                                                        

    // Expose the mount to the parent namespace                                                                                                                                                              
    p = mount("none", "/overlays/user/mnt", NULL, MS_SHARED, NULL);                                                                                                                                                 
    if (p == -1){                                                                                                                                                                                            
        perror("Failed to mark mount as shared");                                                                                                                                                                                     
        exit(1);                                                                                                                                                                                             
    }                                                                                                                                                                                                        

    // Exec bash so I can ensure that the mnt was created
    // though in practice I would just daemonize this proc
    // such that the mount is visible in the parent 
    // until this proc is killed
    char *newargv[] = { "/bin/bash", NULL };                                                                                                                                                                 

    execv("/bin/bash", newargv);                                                                                                                                                                             
    perror("exec");                                                                                                                                                                                          
    exit(EXIT_FAILURE);                                                                                                                                                                                      

    return 0;                                                                                                                                                                                                
}                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
int main()                                                                                                                                                                                                   
{                                                                                                                                                                                                            
    pid_t p = clone(child, malloc(4096) + 4096, CLONE_NEWNS | CLONE_NEWUSER | SIGCHLD, NULL);                                                                                                                
    if (p == -1) {                                                                                                                                                                                           
        perror("clone");                                                                                                                                                                                     
        exit(1);                                                                                                                                                                                             
    }                                                                                                                                                                                                        

    // Wait until the bash proc in the child finishes
    waitpid(p, NULL, 0);                                                                                                                                                                                     
    return 0;                          
}

执行gcc user_overlay.c -o user_overlay && ./user_overlay确实会在该子进程中挂载叠加层,但/overlays/user/mnt不会传播到父进程。但是,父母和孩子都可以看到对/overlays/user/upper的修改。

1 个答案:

答案 0 :(得分:4)

您尝试实现的目标似乎是不可能的,至少不使用上述方法。您希望通过var set2 = new List<ReferenceClassObjectTest>() { new ReferenceClassObjectTest { Id = 1, TestObject = new TestObject { Id = 2 } }, new ReferenceClassObjectTest { Id = 2, TestObject = new TestObject { Id = 3 } }, }; var set3 = new List<ReferenceClassObjectTest>() { new ReferenceClassObjectTest { Id = 1, TestObject = new TestObject { Id = 2 } }, new ReferenceClassObjectTest { Id = 2, TestObject = new TestObject { Id = 3 } }, }; Assert.IsTrue(set2.ContainsExactly(set3)); 创建新的用户命名空间,为非特权用户授予安装权限。但是,引用mount_namespaces(7)(强调我的):

  

安装命名空间的限制
  请注意有关安装命名空间的以下几点:
  * mount命名空间具有所有者用户命名空间。 其所有者用户命名空间与其父安装命名空间的所有者用户命名空间不同的安装命名空间被视为权限较低的安装命名空间。

     

* 创建权限较低的安装命名空间时,共享安装将减少为从属安装。(共享和从安装将在下面讨论。)这可确保在权限较低的安装命名空间中执行的映射不会传播更多特权的mount命名空间。

这意味着您创建的坐标实际上具有CLONE_NEWUSER传播类型,而不是您期望的slave。这会导致挂载事件不会传播到父挂载命名空间。