4785f1a7 |
// +build linux freebsd |
6bb0d181 |
package container
import (
"io/ioutil"
"os"
|
cfc404a3 |
"github.com/docker/docker/api/types" |
91e197d6 |
containertypes "github.com/docker/docker/api/types/container" |
18768fdc |
mounttypes "github.com/docker/docker/api/types/mount" |
6bb0d181 |
"github.com/docker/docker/pkg/chrootarchive" |
cfa2591d |
"github.com/docker/docker/pkg/mount" |
2b6bc294 |
"github.com/docker/docker/pkg/stringid" |
6bb0d181 |
"github.com/docker/docker/pkg/system"
"github.com/docker/docker/volume" |
abbbf914 |
"github.com/opencontainers/selinux/go-selinux/label" |
7120976d |
"github.com/pkg/errors" |
1009e6a4 |
"github.com/sirupsen/logrus" |
934328d8 |
"golang.org/x/sys/unix" |
6bb0d181 |
)
|
3716ec25 |
const ( |
ed74ee12 |
// DefaultStopTimeout is the timeout (in seconds) for the syscall signal used to stop a container.
DefaultStopTimeout = 10
|
db575ef6 |
containerSecretMountPath = "/run/secrets" |
3716ec25 |
) |
6bb0d181 |
// TrySetNetworkMount attempts to set the network mounts given a provided destination and
// the path to use for it; return true if the given destination was a network mount file
func (container *Container) TrySetNetworkMount(destination string, path string) bool {
if destination == "/etc/resolv.conf" {
container.ResolvConfPath = path
return true
}
if destination == "/etc/hostname" {
container.HostnamePath = path
return true
}
if destination == "/etc/hosts" {
container.HostsPath = path
return true
}
return false
}
// BuildHostnameFile writes the container's hostname file.
func (container *Container) BuildHostnameFile() error {
hostnamePath, err := container.GetRootResourcePath("hostname")
if err != nil {
return err
}
container.HostnamePath = hostnamePath
return ioutil.WriteFile(container.HostnamePath, []byte(container.Config.Hostname+"\n"), 0644)
}
// NetworkMounts returns the list of network mounts. |
9c4570a9 |
func (container *Container) NetworkMounts() []Mount {
var mounts []Mount |
6bb0d181 |
shared := container.HostConfig.NetworkMode.IsContainer() |
d98ecf2d |
parser := volume.NewParser(container.OS) |
6bb0d181 |
if container.ResolvConfPath != "" {
if _, err := os.Stat(container.ResolvConfPath); err != nil {
logrus.Warnf("ResolvConfPath set to %q, but can't stat this filename (err = %v); skipping", container.ResolvConfPath, err)
} else {
writable := !container.HostConfig.ReadonlyRootfs
if m, exists := container.MountPoints["/etc/resolv.conf"]; exists {
writable = m.RW |
eab3ac3e |
} else {
label.Relabel(container.ResolvConfPath, container.MountLabel, shared) |
6bb0d181 |
} |
9c4570a9 |
mounts = append(mounts, Mount{ |
6bb0d181 |
Source: container.ResolvConfPath,
Destination: "/etc/resolv.conf",
Writable: writable, |
e89b6e8c |
Propagation: string(parser.DefaultPropagationMode()), |
6bb0d181 |
})
}
}
if container.HostnamePath != "" {
if _, err := os.Stat(container.HostnamePath); err != nil {
logrus.Warnf("HostnamePath set to %q, but can't stat this filename (err = %v); skipping", container.HostnamePath, err)
} else {
writable := !container.HostConfig.ReadonlyRootfs
if m, exists := container.MountPoints["/etc/hostname"]; exists {
writable = m.RW |
eab3ac3e |
} else {
label.Relabel(container.HostnamePath, container.MountLabel, shared) |
6bb0d181 |
} |
9c4570a9 |
mounts = append(mounts, Mount{ |
6bb0d181 |
Source: container.HostnamePath,
Destination: "/etc/hostname",
Writable: writable, |
e89b6e8c |
Propagation: string(parser.DefaultPropagationMode()), |
6bb0d181 |
})
}
}
if container.HostsPath != "" {
if _, err := os.Stat(container.HostsPath); err != nil {
logrus.Warnf("HostsPath set to %q, but can't stat this filename (err = %v); skipping", container.HostsPath, err)
} else {
writable := !container.HostConfig.ReadonlyRootfs
if m, exists := container.MountPoints["/etc/hosts"]; exists {
writable = m.RW |
eab3ac3e |
} else {
label.Relabel(container.HostsPath, container.MountLabel, shared) |
6bb0d181 |
} |
9c4570a9 |
mounts = append(mounts, Mount{ |
6bb0d181 |
Source: container.HostsPath,
Destination: "/etc/hosts",
Writable: writable, |
e89b6e8c |
Propagation: string(parser.DefaultPropagationMode()), |
6bb0d181 |
})
}
}
return mounts
}
// CopyImagePathContent copies files in destination to the volume.
func (container *Container) CopyImagePathContent(v volume.Volume, destination string) error { |
7a7357da |
rootfs, err := container.GetResourcePath(destination) |
6bb0d181 |
if err != nil {
return err
}
if _, err = ioutil.ReadDir(rootfs); err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
|
2b6bc294 |
id := stringid.GenerateNonCryptoID()
path, err := v.Mount(id) |
6bb0d181 |
if err != nil {
return err
} |
2b6bc294 |
defer func() {
if err := v.Unmount(id); err != nil {
logrus.Warnf("error while unmounting volume %s: %v", v.Name(), err)
}
}() |
934328d8 |
if err := label.Relabel(path, container.MountLabel, true); err != nil && err != unix.ENOTSUP { |
5a277c8a |
return err
} |
b0ac69b6 |
return copyExistingContents(rootfs, path) |
6bb0d181 |
}
// ShmResourcePath returns path to shm
func (container *Container) ShmResourcePath() (string, error) { |
eaa51928 |
return container.MountsResourcePath("shm") |
6bb0d181 |
}
// HasMountFor checks if path is a mountpoint
func (container *Container) HasMountFor(path string) bool {
_, exists := container.MountPoints[path] |
1861abdc |
if exists {
return true
}
// Also search among the tmpfs mounts
for dest := range container.HostConfig.Tmpfs {
if dest == path {
return true
}
}
return false |
6bb0d181 |
}
|
7120976d |
// UnmountIpcMount uses the provided unmount function to unmount shm if it was mounted
func (container *Container) UnmountIpcMount(unmount func(pth string) error) error {
if container.HasMountFor("/dev/shm") {
return nil |
6bb0d181 |
}
|
7120976d |
// container.ShmPath should not be used here as it may point
// to the host's or other container's /dev/shm
shmPath, err := container.ShmResourcePath()
if err != nil {
return err |
6bb0d181 |
} |
7120976d |
if shmPath == "" {
return nil
}
if err = unmount(shmPath); err != nil && !os.IsNotExist(err) {
if mounted, mErr := mount.Mounted(shmPath); mounted || mErr != nil {
return errors.Wrapf(err, "umount %s", shmPath)
} |
6bb0d181 |
} |
7120976d |
return nil |
6bb0d181 |
}
// IpcMounts returns the list of IPC mounts |
9c4570a9 |
func (container *Container) IpcMounts() []Mount {
var mounts []Mount |
d98ecf2d |
parser := volume.NewParser(container.OS) |
6bb0d181 |
|
7120976d |
if container.HasMountFor("/dev/shm") {
return mounts |
6bb0d181 |
} |
7120976d |
if container.ShmPath == "" {
return mounts
}
label.SetFileLabel(container.ShmPath, container.MountLabel)
mounts = append(mounts, Mount{
Source: container.ShmPath,
Destination: "/dev/shm",
Writable: true, |
e89b6e8c |
Propagation: string(parser.DefaultPropagationMode()), |
7120976d |
}) |
6bb0d181 |
|
9c4570a9 |
return mounts |
8799c4fc |
}
|
37ce91dd |
// SecretMounts returns the mounts for the secret path. |
eaa51928 |
func (container *Container) SecretMounts() ([]Mount, error) { |
67d282a5 |
var mounts []Mount
for _, r := range container.SecretReferences { |
37ce91dd |
if r.File == nil {
continue
} |
eaa51928 |
src, err := container.SecretFilePath(*r)
if err != nil {
return nil, err
} |
67d282a5 |
mounts = append(mounts, Mount{ |
eaa51928 |
Source: src, |
67d282a5 |
Destination: getSecretTargetPath(r), |
3716ec25 |
Writable: false, |
67d282a5 |
}) |
3716ec25 |
}
|
eaa51928 |
return mounts, nil |
3716ec25 |
}
// UnmountSecrets unmounts the local tmpfs for secrets
func (container *Container) UnmountSecrets() error { |
eaa51928 |
p, err := container.SecretMountPath()
if err != nil {
return err
}
if _, err := os.Stat(p); err != nil { |
643ae8b4 |
if os.IsNotExist(err) {
return nil
} |
baffa793 |
return err |
643ae8b4 |
}
|
eaa51928 |
return mount.RecursiveUnmount(p) |
3716ec25 |
}
|
9e9fc7b5 |
// ConfigMounts returns the mounts for configs. |
eaa51928 |
func (container *Container) ConfigMounts() ([]Mount, error) { |
9e9fc7b5 |
var mounts []Mount
for _, configRef := range container.ConfigReferences {
if configRef.File == nil {
continue
} |
eaa51928 |
src, err := container.ConfigFilePath(*configRef)
if err != nil {
return nil, err
} |
9e9fc7b5 |
mounts = append(mounts, Mount{ |
eaa51928 |
Source: src, |
9e9fc7b5 |
Destination: configRef.File.Name,
Writable: false,
})
}
|
eaa51928 |
return mounts, nil |
9e9fc7b5 |
}
|
ebcb7d6b |
type conflictingUpdateOptions string
func (e conflictingUpdateOptions) Error() string {
return string(e)
}
func (e conflictingUpdateOptions) Conflict() {}
|
eed4c7b7 |
// UpdateContainer updates configuration of a container. Callers must hold a Lock on the Container. |
da9eadb0 |
func (container *Container) UpdateContainer(hostConfig *containertypes.HostConfig) error { |
ff3ea4c9 |
// update resources of container |
8799c4fc |
resources := hostConfig.Resources
cResources := &container.HostConfig.Resources |
61022436 |
// validate NanoCPUs, CPUPeriod, and CPUQuota |
39bcaee4 |
// Because NanoCPU effectively updates CPUPeriod/CPUQuota, |
61022436 |
// once NanoCPU is already set, updating CPUPeriod/CPUQuota will be blocked, and vice versa.
// In the following we make sure the intended update (resources) does not conflict with the existing (cResource).
if resources.NanoCPUs > 0 && cResources.CPUPeriod > 0 { |
ebcb7d6b |
return conflictingUpdateOptions("Conflicting options: Nano CPUs cannot be updated as CPU Period has already been set") |
61022436 |
}
if resources.NanoCPUs > 0 && cResources.CPUQuota > 0 { |
ebcb7d6b |
return conflictingUpdateOptions("Conflicting options: Nano CPUs cannot be updated as CPU Quota has already been set") |
61022436 |
}
if resources.CPUPeriod > 0 && cResources.NanoCPUs > 0 { |
ebcb7d6b |
return conflictingUpdateOptions("Conflicting options: CPU Period cannot be updated as NanoCPUs has already been set") |
61022436 |
}
if resources.CPUQuota > 0 && cResources.NanoCPUs > 0 { |
ebcb7d6b |
return conflictingUpdateOptions("Conflicting options: CPU Quota cannot be updated as NanoCPUs has already been set") |
61022436 |
}
|
8799c4fc |
if resources.BlkioWeight != 0 {
cResources.BlkioWeight = resources.BlkioWeight
}
if resources.CPUShares != 0 {
cResources.CPUShares = resources.CPUShares
} |
61022436 |
if resources.NanoCPUs != 0 {
cResources.NanoCPUs = resources.NanoCPUs
} |
8799c4fc |
if resources.CPUPeriod != 0 {
cResources.CPUPeriod = resources.CPUPeriod
}
if resources.CPUQuota != 0 {
cResources.CPUQuota = resources.CPUQuota
}
if resources.CpusetCpus != "" {
cResources.CpusetCpus = resources.CpusetCpus
}
if resources.CpusetMems != "" {
cResources.CpusetMems = resources.CpusetMems
}
if resources.Memory != 0 { |
92394785 |
// if memory limit smaller than already set memoryswap limit and doesn't
// update the memoryswap limit, then error out.
if resources.Memory > cResources.MemorySwap && resources.MemorySwap == 0 { |
ebcb7d6b |
return conflictingUpdateOptions("Memory limit should be smaller than already set memoryswap limit, update the memoryswap at the same time") |
92394785 |
} |
8799c4fc |
cResources.Memory = resources.Memory
}
if resources.MemorySwap != 0 {
cResources.MemorySwap = resources.MemorySwap
}
if resources.MemoryReservation != 0 {
cResources.MemoryReservation = resources.MemoryReservation
}
if resources.KernelMemory != 0 {
cResources.KernelMemory = resources.KernelMemory
} |
dca82b9e |
if resources.CPURealtimePeriod != 0 {
cResources.CPURealtimePeriod = resources.CPURealtimePeriod
}
if resources.CPURealtimeRuntime != 0 {
cResources.CPURealtimeRuntime = resources.CPURealtimeRuntime
} |
ff3ea4c9 |
// update HostConfig of container
if hostConfig.RestartPolicy.Name != "" { |
4754c64a |
if container.HostConfig.AutoRemove && !hostConfig.RestartPolicy.IsNone() { |
ebcb7d6b |
return conflictingUpdateOptions("Restart policy cannot be updated because AutoRemove is enabled for the container") |
4754c64a |
} |
ff3ea4c9 |
container.HostConfig.RestartPolicy = hostConfig.RestartPolicy
} |
8799c4fc |
return nil
}
|
9a2d0bc3 |
// DetachAndUnmount uses a detached mount on all mount destinations, then
// unmounts each volume normally.
// This is used from daemon/archive for `docker cp`
func (container *Container) DetachAndUnmount(volumeEventLog func(name, action string, attributes map[string]string)) error {
networkMounts := container.NetworkMounts()
mountPaths := make([]string, 0, len(container.MountPoints)+len(networkMounts)) |
6bb0d181 |
for _, mntPoint := range container.MountPoints {
dest, err := container.GetResourcePath(mntPoint.Destination)
if err != nil { |
9a2d0bc3 |
logrus.Warnf("Failed to get volume destination path for container '%s' at '%s' while lazily unmounting: %v", container.ID, mntPoint.Destination, err)
continue |
6bb0d181 |
} |
9a2d0bc3 |
mountPaths = append(mountPaths, dest) |
6bb0d181 |
}
|
9a2d0bc3 |
for _, m := range networkMounts {
dest, err := container.GetResourcePath(m.Destination)
if err != nil {
logrus.Warnf("Failed to get volume destination path for container '%s' at '%s' while lazily unmounting: %v", container.ID, m.Destination, err)
continue |
6bb0d181 |
} |
9a2d0bc3 |
mountPaths = append(mountPaths, dest)
} |
6bb0d181 |
|
9a2d0bc3 |
for _, mountPath := range mountPaths {
if err := detachMounted(mountPath); err != nil {
logrus.Warnf("%s unmountVolumes: Failed to do lazy umount fo volume '%s': %v", container.ID, mountPath, err) |
6bb0d181 |
}
} |
9a2d0bc3 |
return container.UnmountVolumes(volumeEventLog) |
6bb0d181 |
}
// copyExistingContents copies from the source to the destination and
// ensures the ownership is appropriately set.
func copyExistingContents(source, destination string) error {
volList, err := ioutil.ReadDir(source)
if err != nil {
return err
}
if len(volList) > 0 {
srcList, err := ioutil.ReadDir(destination)
if err != nil {
return err
}
if len(srcList) == 0 { |
9f676ade |
// If the source volume is empty, copies files from the root into the volume |
967ef7e6 |
if err := chrootarchive.NewArchiver(nil).CopyWithTar(source, destination); err != nil { |
6bb0d181 |
return err
}
}
}
return copyOwnership(source, destination)
}
// copyOwnership copies the permissions and uid:gid of the source file
// to the destination file
func copyOwnership(source, destination string) error {
stat, err := system.Stat(source)
if err != nil {
return err
}
|
f05a0237 |
destStat, err := system.Stat(destination)
if err != nil { |
6bb0d181 |
return err
}
|
f05a0237 |
// In some cases, even though UID/GID match and it would effectively be a no-op,
// this can return a permission denied error... for example if this is an NFS
// mount.
// Since it's not really an error that we can't chown to the same UID/GID, don't
// even bother trying in such cases.
if stat.UID() != destStat.UID() || stat.GID() != destStat.GID() {
if err := os.Chown(destination, int(stat.UID()), int(stat.GID())); err != nil {
return err
}
}
if stat.Mode() != destStat.Mode() {
return os.Chmod(destination, os.FileMode(stat.Mode()))
}
return nil |
6bb0d181 |
}
// TmpfsMounts returns the list of tmpfs mounts |
18768fdc |
func (container *Container) TmpfsMounts() ([]Mount, error) { |
d98ecf2d |
parser := volume.NewParser(container.OS) |
9c4570a9 |
var mounts []Mount |
6bb0d181 |
for dest, data := range container.HostConfig.Tmpfs { |
9c4570a9 |
mounts = append(mounts, Mount{ |
6bb0d181 |
Source: "tmpfs",
Destination: dest,
Data: data,
})
} |
18768fdc |
for dest, mnt := range container.MountPoints {
if mnt.Type == mounttypes.TypeTmpfs { |
e89b6e8c |
data, err := parser.ConvertTmpfsOptions(mnt.Spec.TmpfsOptions, mnt.Spec.ReadOnly) |
18768fdc |
if err != nil {
return nil, err
}
mounts = append(mounts, Mount{
Source: "tmpfs",
Destination: dest,
Data: data,
})
}
}
return mounts, nil |
6bb0d181 |
} |
67912303 |
|
d1e0a786 |
// EnableServiceDiscoveryOnDefaultNetwork Enable service discovery on default network
func (container *Container) EnableServiceDiscoveryOnDefaultNetwork() bool {
return false
} |
cfc404a3 |
// GetMountPoints gives a platform specific transformation to types.MountPoint. Callers must hold a Container lock.
func (container *Container) GetMountPoints() []types.MountPoint {
mountPoints := make([]types.MountPoint, 0, len(container.MountPoints))
for _, m := range container.MountPoints {
mountPoints = append(mountPoints, types.MountPoint{
Type: m.Type,
Name: m.Name,
Source: m.Path(),
Destination: m.Destination,
Driver: m.Driver,
Mode: m.Mode,
RW: m.RW,
Propagation: m.Propagation,
})
}
return mountPoints
} |