func init() {
reexec.Register("chrootwrite", func() {
var rootfs, path string
var uid, gid int
flag.StringVar(&rootfs, "rootfs", "", "rootfs")
flag.StringVar(&path, "path", "", "path")
flag.IntVar(&uid, "uid", 0, "uid")
flag.IntVar(&gid, "gid", 0, "gid")
flag.Parse()
if err := syscall.Chroot(rootfs); err != nil {
panic(err)
}
if err := os.Chdir("/"); err != nil {
panic(err)
}
var contents bytes.Buffer
if _, err := io.Copy(&contents, os.Stdin); err != nil {
panic(err)
}
w := RootfsWriter{}
if err := w.writeFile(lager.NewLogger("chroot-write"), path, contents.Bytes(), rootfs, uid, gid); err != nil {
panic(err)
}
})
}
func init() {
reexec.Register("namespaced", namespaced)
if reexec.Init() {
os.Exit(0)
}
}
func TestMain(m *testing.M) {
reexec.Register("enqueue", reexecEnqueue)
if reexec.Init() {
return
}
os.Exit(m.Run())
}
func TestMain(m *testing.M) {
reexec.Register("allocate", allocate)
if reexec.Init() {
return
}
os.Exit(m.Run())
}
func registerCmd(cmd string, mainFunc func()) {
log.Debugf("Registering main %s", cmd)
reexec.Register(cmd, mainFunc)
parts := strings.Split(cmd, "/")
if len(parts) == 0 {
return
}
last := parts[len(parts)-1]
log.Debugf("Registering main %s", last)
reexec.Register(last, mainFunc)
log.Debugf("Registering main %s", "./"+last)
reexec.Register("./"+last, mainFunc)
}
func main() {
for name, f := range entrypoints {
reexec.Register(name, f)
}
if !reexec.Init() {
control.Main()
}
}
// init registers the windows graph drivers to the register.
func init() {
graphdriver.Register("windowsfilter", InitFilter)
// DOCKER_WINDOWSFILTER_NOREEXEC allows for inline processing which makes
// debugging issues in the re-exec codepath significantly easier.
if os.Getenv("DOCKER_WINDOWSFILTER_NOREEXEC") != "" {
logrus.Warnf("WindowsGraphDriver is set to not re-exec. This is intended for debugging purposes only.")
noreexec = true
} else {
reexec.Register("docker-windows-write-layer", writeLayerReexec)
}
}
func main() {
registerCmd("/init", osInit.MainInit)
registerCmd(config.SYSINIT_BIN, sysinit.Main)
registerCmd("/usr/bin/dockerlaunch", dockerlaunch.Main)
registerCmd("/usr/bin/user-docker", userdocker.Main)
registerCmd("/usr/bin/system-docker", systemdocker.Main)
registerCmd("/sbin/poweroff", power.PowerOff)
registerCmd("/sbin/reboot", power.Reboot)
registerCmd("/sbin/halt", power.Halt)
registerCmd("/sbin/shutdown", power.Main)
registerCmd("/usr/bin/respawn", respawn.Main)
registerCmd("/usr/bin/ros", control.Main)
registerCmd("/usr/bin/cloud-init", cloudinit.Main)
registerCmd("/usr/sbin/netconf", network.Main)
registerCmd("/usr/sbin/wait-for-network", waitfornetwork.Main)
registerCmd("/usr/sbin/wait-for-docker", wait.Main)
if !reexec.Init() {
reexec.Register(os.Args[0], control.Main)
if !reexec.Init() {
log.Fatalf("Failed to find an entry point for %s", os.Args[0])
}
}
}
func init() {
reexec.Register("configure-container-netns", func() {
var netNsPath, containerIntf, containerIPStr, bridgeIPStr, subnetStr string
var mtu int
flag.StringVar(&netNsPath, "netNsPath", "", "netNsPath")
flag.StringVar(&containerIntf, "containerIntf", "", "containerIntf")
flag.StringVar(&containerIPStr, "containerIP", "", "containerIP")
flag.StringVar(&bridgeIPStr, "bridgeIP", "", "bridgeIP")
flag.StringVar(&subnetStr, "subnet", "", "subnet")
flag.IntVar(&mtu, "mtu", 0, "mtu")
flag.Parse()
fd, err := os.Open(netNsPath)
if err != nil {
fmt.Fprintf(os.Stderr, "opening netns `%s`: %s", netNsPath, err)
os.Exit(1)
}
defer fd.Close()
netNsExecer := &netns.Execer{}
if err = netNsExecer.Exec(fd, func() error {
containerIP := net.ParseIP(containerIPStr)
bridgeIP := net.ParseIP(bridgeIPStr)
_, subnetIPNet, err := net.ParseCIDR(subnetStr)
if err != nil {
panic(err)
}
link := devices.Link{}
intf, found, err := link.InterfaceByName(containerIntf)
if err != nil {
panic(err)
}
if !found {
return fmt.Errorf("interface `%s` was not found", containerIntf)
}
if err := link.AddIP(intf, containerIP, subnetIPNet); err != nil {
panic(err)
}
if err := link.SetUp(intf); err != nil {
panic(err)
}
if err := link.AddDefaultGW(intf, bridgeIP); err != nil {
panic(err)
}
if err := link.SetMTU(intf, mtu); err != nil {
panic(err)
}
return nil
}); err != nil {
fmt.Fprintf(os.Stderr, err.Error())
os.Exit(1)
}
})
}
func init() {
reexec.Register("fwmarker", fwMarker)
reexec.Register("redirecter", redirecter)
}
func init() {
reexec.Register("set-ipv6", reexecSetIPv6)
}
func init() {
reexec.Register(name, prepare)
}
func init() {
reexec.Register(dockerMonitor, execMonitor)
}
func init() {
reexec.Register("initd", start)
}
func init() {
reexec.Register("containerd-nslistener", setupNsListener)
}
// init registers the windows graph drivers to the register.
func init() {
graphdriver.Register("windowsfilter", InitFilter)
reexec.Register("docker-windows-write-layer", writeLayer)
}
func init() {
// like always lxc requires a hack to get this to work
reexec.Register("/.dockerinit", dockerInititalizer)
}
func init() {
reexec.Register(userlandProxyCommandName, execProxy)
}
func init() {
reexec.Register("setup-resolver", reexecSetupResolver)
}
func init() {
runtime.LockOSThread()
reexec.Register("proc_starter", start)
}
func init() {
reexec.Register("fwmarker", fwMarker)
}
func init() {
reexec.Register("docker-mountfrom", mountFromMain)
}
func init() {
reexec.Register(DriverName, initializer)
}
func init() {
reexec.Register("libnetwork-setkey", processSetKeyReexec)
}
func init() {
reexec.Register("netns-create", reexecCreateNamespace)
}
func init() {
reexec.Register("docker-untar", untar)
reexec.Register("docker-applyLayer", applyLayer)
}
