1 // Copyright 2020 The Prometheus Authors 2 // Licensed under the Apache License, Version 2.0 (the "License"); 3 // you may not use this file except in compliance with the License. 4 // You may obtain a copy of the License at 5 // 6 // http://www.apache.org/licenses/LICENSE-2.0 7 // 8 // Unless required by applicable law or agreed to in writing, software 9 // distributed under the License is distributed on an "AS IS" BASIS, 10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 // See the License for the specific language governing permissions and 12 // limitations under the License. 13 14 package procfs 15 16 import ( 17 "bufio" 18 "bytes" 19 "fmt" 20 "strconv" 21 "strings" 22 23 "github.com/prometheus/procfs/internal/util" 24 ) 25 26 // Cgroup models one line from /proc/[pid]/cgroup. Each Cgroup struct describes the placement of a PID inside a 27 // specific control hierarchy. The kernel has two cgroup APIs, v1 and v2. v1 has one hierarchy per available resource 28 // controller, while v2 has one unified hierarchy shared by all controllers. Regardless of v1 or v2, all hierarchies 29 // contain all running processes, so the question answerable with a Cgroup struct is 'where is this process in 30 // this hierarchy' (where==what path on the specific cgroupfs). By prefixing this path with the mount point of 31 // *this specific* hierarchy, you can locate the relevant pseudo-files needed to read/set the data for this PID 32 // in this hierarchy 33 // 34 // Also see http://man7.org/linux/man-pages/man7/cgroups.7.html 35 type Cgroup struct { 36 // HierarchyID that can be matched to a named hierarchy using /proc/cgroups. Cgroups V2 only has one 37 // hierarchy, so HierarchyID is always 0. For cgroups v1 this is a unique ID number 38 HierarchyID int 39 // Controllers using this hierarchy of processes. Controllers are also known as subsystems. For 40 // Cgroups V2 this may be empty, as all active controllers use the same hierarchy 41 Controllers []string 42 // Path of this control group, relative to the mount point of the cgroupfs representing this specific 43 // hierarchy 44 Path string 45 } 46 47 // parseCgroupString parses each line of the /proc/[pid]/cgroup file 48 // Line format is hierarchyID:[controller1,controller2]:path. 49 func parseCgroupString(cgroupStr string) (*Cgroup, error) { 50 var err error 51 52 fields := strings.SplitN(cgroupStr, ":", 3) 53 if len(fields) < 3 { 54 return nil, fmt.Errorf("%w: 3+ fields required, found %d fields in cgroup string: %s", ErrFileParse, len(fields), cgroupStr) 55 } 56 57 cgroup := &Cgroup{ 58 Path: fields[2], 59 Controllers: nil, 60 } 61 cgroup.HierarchyID, err = strconv.Atoi(fields[0]) 62 if err != nil { 63 return nil, fmt.Errorf("%w: hierarchy ID: %q", ErrFileParse, cgroup.HierarchyID) 64 } 65 if fields[1] != "" { 66 ssNames := strings.Split(fields[1], ",") 67 cgroup.Controllers = append(cgroup.Controllers, ssNames...) 68 } 69 return cgroup, nil 70 } 71 72 // parseCgroups reads each line of the /proc/[pid]/cgroup file. 73 func parseCgroups(data []byte) ([]Cgroup, error) { 74 var cgroups []Cgroup 75 scanner := bufio.NewScanner(bytes.NewReader(data)) 76 for scanner.Scan() { 77 mountString := scanner.Text() 78 parsedMounts, err := parseCgroupString(mountString) 79 if err != nil { 80 return nil, err 81 } 82 cgroups = append(cgroups, *parsedMounts) 83 } 84 85 err := scanner.Err() 86 return cgroups, err 87 } 88 89 // Cgroups reads from /proc/<pid>/cgroups and returns a []*Cgroup struct locating this PID in each process 90 // control hierarchy running on this system. On every system (v1 and v2), all hierarchies contain all processes, 91 // so the len of the returned struct is equal to the number of active hierarchies on this system. 92 func (p Proc) Cgroups() ([]Cgroup, error) { 93 data, err := util.ReadFileNoStat(p.path("cgroup")) 94 if err != nil { 95 return nil, err 96 } 97 return parseCgroups(data) 98 } 99