mirror of
https://github.com/genuinetools/reg.git
synced 2024-08-21 14:20:23 -04:00
133 lines
3.9 KiB
Go
133 lines
3.9 KiB
Go
package mount // import "github.com/docker/docker/pkg/mount"
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
func parseInfoFile(r io.Reader, filter FilterFunc) ([]*Info, error) {
|
|
s := bufio.NewScanner(r)
|
|
out := []*Info{}
|
|
for s.Scan() {
|
|
if err := s.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
/*
|
|
36 35 98:0 /mnt1 /mnt2 rw,noatime master:1 - ext3 /dev/root rw,errors=continue
|
|
(1)(2)(3) (4) (5) (6) (7) (8) (9) (10) (11)
|
|
|
|
(1) mount ID: unique identifier of the mount (may be reused after umount)
|
|
(2) parent ID: ID of parent (or of self for the top of the mount tree)
|
|
(3) major:minor: value of st_dev for files on filesystem
|
|
(4) root: root of the mount within the filesystem
|
|
(5) mount point: mount point relative to the process's root
|
|
(6) mount options: per mount options
|
|
(7) optional fields: zero or more fields of the form "tag[:value]"
|
|
(8) separator: marks the end of the optional fields
|
|
(9) filesystem type: name of filesystem of the form "type[.subtype]"
|
|
(10) mount source: filesystem specific information or "none"
|
|
(11) super options: per super block options
|
|
*/
|
|
|
|
text := s.Text()
|
|
fields := strings.Split(text, " ")
|
|
numFields := len(fields)
|
|
if numFields < 10 {
|
|
// should be at least 10 fields
|
|
return nil, fmt.Errorf("Parsing '%s' failed: not enough fields (%d)", text, numFields)
|
|
}
|
|
|
|
p := &Info{}
|
|
// ignore any numbers parsing errors, as there should not be any
|
|
p.ID, _ = strconv.Atoi(fields[0])
|
|
p.Parent, _ = strconv.Atoi(fields[1])
|
|
mm := strings.Split(fields[2], ":")
|
|
if len(mm) != 2 {
|
|
return nil, fmt.Errorf("Parsing '%s' failed: unexpected minor:major pair %s", text, mm)
|
|
}
|
|
p.Major, _ = strconv.Atoi(mm[0])
|
|
p.Minor, _ = strconv.Atoi(mm[1])
|
|
|
|
p.Root = fields[3]
|
|
p.Mountpoint = fields[4]
|
|
p.Opts = fields[5]
|
|
|
|
var skip, stop bool
|
|
if filter != nil {
|
|
// filter out entries we're not interested in
|
|
skip, stop = filter(p)
|
|
if skip {
|
|
continue
|
|
}
|
|
}
|
|
|
|
// one or more optional fields, when a separator (-)
|
|
i := 6
|
|
for ; i < numFields && fields[i] != "-"; i++ {
|
|
switch i {
|
|
case 6:
|
|
p.Optional = fields[6]
|
|
default:
|
|
/* NOTE there might be more optional fields before the such as
|
|
fields[7]...fields[N] (where N < sepIndex), although
|
|
as of Linux kernel 4.15 the only known ones are
|
|
mount propagation flags in fields[6]. The correct
|
|
behavior is to ignore any unknown optional fields.
|
|
*/
|
|
break
|
|
}
|
|
}
|
|
if i == numFields {
|
|
return nil, fmt.Errorf("Parsing '%s' failed: missing separator ('-')", text)
|
|
}
|
|
|
|
// There should be 3 fields after the separator...
|
|
if i+4 > numFields {
|
|
return nil, fmt.Errorf("Parsing '%s' failed: not enough fields after a separator", text)
|
|
}
|
|
// ... but in Linux <= 3.9 mounting a cifs with spaces in a share name
|
|
// (like "//serv/My Documents") _may_ end up having a space in the last field
|
|
// of mountinfo (like "unc=//serv/My Documents"). Since kernel 3.10-rc1, cifs
|
|
// option unc= is ignored, so a space should not appear. In here we ignore
|
|
// those "extra" fields caused by extra spaces.
|
|
p.Fstype = fields[i+1]
|
|
p.Source = fields[i+2]
|
|
p.VfsOpts = fields[i+3]
|
|
|
|
out = append(out, p)
|
|
if stop {
|
|
break
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// Parse /proc/self/mountinfo because comparing Dev and ino does not work from
|
|
// bind mounts
|
|
func parseMountTable(filter FilterFunc) ([]*Info, error) {
|
|
f, err := os.Open("/proc/self/mountinfo")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer f.Close()
|
|
|
|
return parseInfoFile(f, filter)
|
|
}
|
|
|
|
// PidMountInfo collects the mounts for a specific process ID. If the process
|
|
// ID is unknown, it is better to use `GetMounts` which will inspect
|
|
// "/proc/self/mountinfo" instead.
|
|
func PidMountInfo(pid int) ([]*Info, error) {
|
|
f, err := os.Open(fmt.Sprintf("/proc/%d/mountinfo", pid))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer f.Close()
|
|
|
|
return parseInfoFile(f, nil)
|
|
}
|