首页 > 代码库 > runc create container 流程分析
runc create container 流程分析
1、// runc/create.go
Action: func(context *cli.Context) error
首先调用spec, err := setupSpec(context)加载配置文件config.json的内容。之后调用status, err := startcontainer(context, spec, true)进行容器的创建工作，其中最后一个布尔型的参数为true，表示进行容器的创建。
2、// runc/utils_linux.go
func startContainer(context *cli.Context, spec *specs.Spec, create bool) (int ,error)
首先调用container, err := createContainer(context, id, spec)创建容器, 之后填充runner结构r，如下所示：
r := &runner{
enableSubreaper: !context.Bool("no-subreaper"),
shouldDestroy: true,
container: container,
listenFDs: listenFDs, // if os.Getenv("LISTEN_FDS") != "" { listenFDs = activation.Files(false) }
console: context.String("console")
detach: detach,
pidFile: context.String("pid-file")
create: create,
}
最后调用r.run(&spec.Process)。
--------------------------------------------------------------------开始创建容器对象---------------------------------------------------------------------
3、// runc/utils_linux.go
func createContainer(context *cli.Context, id string, spec *specs.Spec) (libcontainer.Container, error)
首先调用config, err := specconv.CreateLibcontainerConfig(&specconv.CreateOpts{...})将配置转换为符合libcontainer要求的配置格式。之后调用factory, err := loadFactory(context)加载factory对象。最后，调用factory.Create(id, config)创建一个libcontainer的container对象。
4、// runc/utils_linux.go
// loadFactory returns the configured factory instance for execing containers
func loadFactory(context *cli.Context) (libcontainer.Factory, error)
首先获取root dir的绝对路径abs(默认为/run/runc，用于存储容器的状态)以及cgroupManager，最后调用libcontainer.New(abs, cgroupManager, libcontainer.CriuPath(context.GlobalString("criu")))来生产一个Factory实例。
5、// runc/libcontainer/factory_linux.go
// New returns a linux based container factory based in the root directory and configures the factory with the provided option funcs
func New(root string, options ...func(*LinuxFactory) error) (Factory, error)
首先填充一个LinuxFactory对象，如下所示：
l := &LinuxFactory{
Root: root,
InitArgs: []string{"/proc/self/exec", "init"},
Validator: validate.New(),
CriuPath: "criu",
}
接着调用Cgroupfs(l)将l的NewCgroupsManager设置为利用本地的cgroups filesystem implementation来创建和管理cgroups（相对应的，也可以利用systemd来）。再遍历options，来对l进行选择性配置。从这个函数的调用处可知，主要配置了cgroups和criupath。最后，返回l。
6、// runc/libcontainer/factory_linux.go
func (l *LinuxFactory) Create(id string, config *configs.Config) (Container)
该函数首先对id和config进行验证，接着获取uid, gid, containerRoot并且创建containerRoot(默认为/run/runc/container-id)。之后再创建一个FIFO文件，填充一个linuxContainer对象，如下所示：
c := &linuxContainer{
id: id,
root: containerRoot,
config: config,
initArgs: l.InitArgs,
criuPath: l.CriuPath,
cgroupManager: l.NewCgroupsManager(config.Cgroups, nil)
}
c.state = &stoppedState{c: c}
最后，return c
--------------------------------------------------------------------创建容器对象结束---------------------------------------------------------------------
7、// runc/utils_linux.go
func (r *runner) run(config *specs.Process) (int ,error)
(1)、调用process, err := newProcess(*config)，根据config配置一个libcontainer.Process对象。如果r.listenFDs的数目不为0的话，扩展process.Env和process.ExtraFiles，然后获取rootuid和rootgid。
(2)、接着调用tty, err := setupIO(process, rootuid, rootgid, r.console, config.Terminal, r.detach || r.create)设置和process的IO。
(3)、调用handler := newSignalHandler(tty, r.enableSubreaper)以及之后的status, err := handler.forward(process)对来自process的SIGNAL进行处理（如果没有detach并且不是create容器的话）。
(4)、调用startFn(process)，如果是create容器的话，那么startFn := r.container.Start，否则startFn := r.container.Run。因为我们是对create 容器进行分析 ，因此startFn为r.container.Start。
(5)、调用tty.ClosePostStart()关闭已经传递给容器的fds。
8、// runc/libcontainer/container_linux.go
func (c *linuxContainer) Start(process *Process)
这个函数很简单，先调用status, err := c.currentStatus()获取容器的当前状态，最后调用c.start(process, status == Stopped)，在create时，此时容器的状态确实为Stopped
9、// runc/libcontainer/container_linux.go
func (c *linuxContainer) start(process *Process, isInit bool) error
首先调用parent, err := c.newParentProcess(process, isInit)获取一个parentProcess的接口类型。然后再调用parent.start()启动进程。最后，如果isInit为true，即create容器时，c.state = &createdState{c: c}， 假如c.config.Hooks != nil的话，执行一些c.config.Hooks.Poststart。（在基本的runc spec生成的config.json中hooks为空）
10、// runc/libcontainer/container_linux.go
func (c *linuxContainer) newParentProcess(p *Process, doInit bool) (parentProcess, error)
调用parentPipe, childPipe, err := newPipe()生成一个管道，接着打开rootDir, err = os.Open(c.root)，即打开/run/runc/container-id。然后调用cmd, err := c.commandTemplate(p, childPipe, rootDir)配置启动命令。commandTemplate中最重要的内容为
(1)、添加了两个ExtraFiles：cmd.ExtraFiles = append(p.ExtraFiles, childPipe, rootDir)
(2)、cmd.Env = append(cmd.Env, fmt.Sprintf("_LIBCONTAINER_INITPIPE=%d", stdioFdCount+len(cmd.ExtraFiles)-2),
fmt.Sprintf("_LIBCONTAINER_STATEDIR=%d", stdioFdCount+len(cmd.ExtraFiles)-1))
最后，若为create container，则调用c.newInitProcess(p, cmd, parentPipe, childPipe, rootDir)，否则调用c.newSetnsProcess(p, cmd, parentPipe, childPipe, rootDir)
11、// runc/libcontainer/container_linux.go
func (c *linuxContainer) newInitProcess(p *Process, cmd *exec.Cmd, parentPipe, childPipe, rootDir *os.File) (*initProcess, error)
(1)、首先扩展cmd.Env = append(cmd.Env, "_LIBCONTAINER_INITTYPE="+string(initStandard)) (initStandard是一个值为"standard"的string)。
(2)、接着获取config.Namespace的nsMaps，类型为map[configs.NamespaceType]string。再调用_, sharePidns := nsMaps[configs.NEWPID]
(3)、调用data, err := c.bootstrapData(c.config.Namespaces.CloneFlags(), nsMaps, "")
(4)、最后返回: return &initProcess {
cmd: cmd,
childPipe: childPipe,
parentPipe: parentPipe,
manager: c.cgroupManager,
config: c.newInitConfig(p), // 根据c和p填充结构initConfig
container: c,
process: p,
bootstrapData: data,
sharePidns: sharePidns,
rootDir: rootDir,
}
12、// runc/libcontainer/container_linux.go
// bootstrapData encodes the necessary data in netlink binary format as a io.Reader
// Consumer can write the data to a bootstrap program such as one that uses nsenter package to bootsrap the container‘s init process correctly
// with correct namespaces, uid/gid, mapping etc
func (c *linuxContainer) bootstrapData(cloneFlags uintptr, nsMaps map[configs.NamespaceType]string, consolePath) (io.Reader, error)
先创建一个利用r := nl.NewlinkRequest(int(InitMsg), 0)创建一个netlink message。之后，将cloneFlags，console path, namespace path等信息写入。最后，return bytes.NewReader(r.Serialize())
13、// runc/libcontainer/process_linux.go
(1)、调用p.cmd.Start启动runc init
(2)、io.Copy(p.parentPipe, p.bootstrapData) // 将bootstrapData的数据传入runc init
(3)、p.execSetns() // 获取容器init进程的pid，process = os.FindProcess(pid.Pid), p.cmd.Process = process, p.process.ops = p
(4)、fds, err := getPipeFds(p.pid()) // save the standard descriptor names before the container can potentially move them
(5)、p.setExternalDescriptors(fds)
(6)、p.manager.Apply(p.pid()) // do this before syncing with child so that no children can escape the cgroup
(7)、p.createNetworkInterfaces() // creating network interfaces
(8)、p.sendConfig() // sending config to init process, utils.WriteJSON(p.parentPipe, p.config)
(9)、进入loop，从p.parenPipe中获取同步状态procSync
loop :
for {
dec.Decode(&procSync)
switch procSync.Type {
case procReady:
... // set oom_score_adj, set rlimits, call prestart hooks
utils.WriteJSON(p.parentPipe, syncT{procRun}) // reading syncT run type
sentRun = true
case procHooks:
...
case procError:
...
}
}
....
syscall.Shutdown(int(p.parentPipe.Fd()), syscall.SHUT_WR)
-------------------------------------------------------------------------runc init 执行流程----------------------------------------------------------
1、// main_unix.go
Action: func(context *cli.Context) error
factory, _ := libcontainer.New("")
factory.StartInitialization()
2、// runc/libcontainer/factory_linux.go
// StartInitialization loads a container by opening fd from the parent to read the configuration and state
func (l *LinuxFactory) StartInitialization() (err error)
这个函数很简单，从"_LIBCONTAINER_INITPIPE"等环境变量中获取pipefd, rootfd(/run/runc/container-id), it(初始化类型，create中为standard)，接着调用i, err = newContainerInit(it, pipe, rootfd)，最后调用i.Init()
3、// runc/libcontainer/init_linux.go
func newContainerInit(t initType, pipe *os.File, stateDirFD int) (inter, error)
该函数很简单，先调用json.NewDecoder(pipe).Decode(&config)中从管道中获取配置信息，再调用populateProcessEnvironment(config.Env)将config中的环境变量加载到当前进程中。最后，根据initType的不同，当t为initSetns时，返回&linuxSetnsInit{config: config}。在create container时，则返回&linuxStandardInit{pipe: pipe, parentPid: syscall.Getppid(), config: config, stateDirFD: stateDirFD}
4、// runc/libcontainer/standard_init_linux.go
func (l *linuxStandardInit) Init() error
(1)、该函数先处理l.config.Config.NoNewKeyring，l.config.Console, setupNetwork, setupRoute, label.Init()
(2)、if l.config.Config.Namespaces.Contains(configs.NEWNS) -> setupRootfs(l.config.Config, console, l.pipe)
(3)、设置hostname, apparmor.ApplyProfile(...), label.SetProcessLabel(...)，l.config.Config.Sysctl
(4)、调用remountReadonly(path)重新挂载ReadonlyPaths，在配置文件中为/proc/asound,/proc/bus, /proc/fs等等
(5)、调用maskPath(path)设置maskedPaths，pdeath := system.GetParentDeathSignal(), 处理l.config.NoNewPrivileges
(6)、调用syncParentReady(l.pipe) // 告诉父进程容器可以执行Execv了, 从父进程来看，create已经完成了
(7)、处理l.config.Config.Seccomp 和 l.config.NoNewPrivileges, finalizeNamespace(l.config)，pdeath.Restore(), 判断syscall.Getppid()和l.parentPid是否相等，找到name, err := exec.Lookpath(l.config.Args[0])，最后l.pipe.Close()，init完成。此时create 在子进程中也完成了。
(8)、fd, err := syscall.Openat(l.stateDirFD, execFifoFilename, os.O_WRONLY|syscall.O_CLOEXEC, 0) ---> wait for the fifo to be opened on the other side before exec‘ing the user process,其实此处就是在等待start命令。之后，再往fd中写一个字节，用于同步：syscall.Write(fd, []byte("0"))
(9)、调用syscall.Exec(name, l.config.Args[0:], os.Environ())执行容器命令
runc create container 流程分析