| // +build !windows |
| |
| package main |
| |
| import ( |
| "fmt" |
| "net" |
| "os" |
| "os/signal" |
| "path/filepath" |
| "strconv" |
| |
| "github.com/containerd/containerd/runtime/v1/linux" |
| "github.com/docker/docker/cmd/dockerd/hack" |
| "github.com/docker/docker/daemon" |
| "github.com/docker/docker/daemon/config" |
| "github.com/docker/docker/libcontainerd/supervisor" |
| "github.com/docker/libnetwork/portallocator" |
| "golang.org/x/sys/unix" |
| ) |
| |
| const defaultDaemonConfigFile = "/etc/docker/daemon.json" |
| |
| // setDefaultUmask sets the umask to 0022 to avoid problems |
| // caused by custom umask |
| func setDefaultUmask() error { |
| desiredUmask := 0022 |
| unix.Umask(desiredUmask) |
| if umask := unix.Umask(desiredUmask); umask != desiredUmask { |
| return fmt.Errorf("failed to set umask: expected %#o, got %#o", desiredUmask, umask) |
| } |
| |
| return nil |
| } |
| |
| func getDaemonConfDir(_ string) string { |
| return "/etc/docker" |
| } |
| |
| func (cli *DaemonCli) getPlatformContainerdDaemonOpts() ([]supervisor.DaemonOpt, error) { |
| opts := []supervisor.DaemonOpt{ |
| supervisor.WithOOMScore(cli.Config.OOMScoreAdjust), |
| supervisor.WithPlugin("linux", &linux.Config{ |
| Shim: daemon.DefaultShimBinary, |
| Runtime: daemon.DefaultRuntimeBinary, |
| RuntimeRoot: filepath.Join(cli.Config.Root, "runc"), |
| ShimDebug: cli.Config.Debug, |
| }), |
| } |
| |
| return opts, nil |
| } |
| |
| // setupConfigReloadTrap configures the USR2 signal to reload the configuration. |
| func (cli *DaemonCli) setupConfigReloadTrap() { |
| c := make(chan os.Signal, 1) |
| signal.Notify(c, unix.SIGHUP) |
| go func() { |
| for range c { |
| cli.reloadConfig() |
| } |
| }() |
| } |
| |
| // getSwarmRunRoot gets the root directory for swarm to store runtime state |
| // For example, the control socket |
| func (cli *DaemonCli) getSwarmRunRoot() string { |
| return filepath.Join(cli.Config.ExecRoot, "swarm") |
| } |
| |
| // allocateDaemonPort ensures that there are no containers |
| // that try to use any port allocated for the docker server. |
| func allocateDaemonPort(addr string) error { |
| host, port, err := net.SplitHostPort(addr) |
| if err != nil { |
| return err |
| } |
| |
| intPort, err := strconv.Atoi(port) |
| if err != nil { |
| return err |
| } |
| |
| var hostIPs []net.IP |
| if parsedIP := net.ParseIP(host); parsedIP != nil { |
| hostIPs = append(hostIPs, parsedIP) |
| } else if hostIPs, err = net.LookupIP(host); err != nil { |
| return fmt.Errorf("failed to lookup %s address in host specification", host) |
| } |
| |
| pa := portallocator.Get() |
| for _, hostIP := range hostIPs { |
| if _, err := pa.RequestPort(hostIP, "tcp", intPort); err != nil { |
| return fmt.Errorf("failed to allocate daemon listening port %d (err: %v)", intPort, err) |
| } |
| } |
| return nil |
| } |
| |
| func wrapListeners(proto string, ls []net.Listener) []net.Listener { |
| switch proto { |
| case "unix": |
| ls[0] = &hack.MalformedHostHeaderOverride{Listener: ls[0]} |
| case "fd": |
| for i := range ls { |
| ls[i] = &hack.MalformedHostHeaderOverride{Listener: ls[i]} |
| } |
| } |
| return ls |
| } |
| |
| func newCgroupParent(config *config.Config) string { |
| cgroupParent := "docker" |
| useSystemd := daemon.UsingSystemd(config) |
| if useSystemd { |
| cgroupParent = "system.slice" |
| } |
| if config.CgroupParent != "" { |
| cgroupParent = config.CgroupParent |
| } |
| if useSystemd { |
| cgroupParent = cgroupParent + ":" + "docker" + ":" |
| } |
| return cgroupParent |
| } |