首页 > 代码库 > 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 流程分析