cubefs

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
// NetProtocolStats stores the contents from /proc/net/protocols.
27
type NetProtocolStats map[string]NetProtocolStatLine
28

29
// NetProtocolStatLine contains a single line parsed from /proc/net/protocols. We
30
// only care about the first six columns as the rest are not likely to change
31
// and only serve to provide a set of capabilities for each protocol.
32
type NetProtocolStatLine struct {
33
	Name         string // 0 The name of the protocol
34
	Size         uint64 // 1 The size, in bytes, of a given protocol structure. e.g. sizeof(struct tcp_sock) or sizeof(struct unix_sock)
35
	Sockets      int64  // 2 Number of sockets in use by this protocol
36
	Memory       int64  // 3 Number of 4KB pages allocated by all sockets of this protocol
37
	Pressure     int    // 4 This is either yes, no, or NI (not implemented). For the sake of simplicity we treat NI as not experiencing memory pressure.
38
	MaxHeader    uint64 // 5 Protocol specific max header size
39
	Slab         bool   // 6 Indicates whether or not memory is allocated from the SLAB
40
	ModuleName   string // 7 The name of the module that implemented this protocol or "kernel" if not from a module
41
	Capabilities NetProtocolCapabilities
42
}
43

44
// NetProtocolCapabilities contains a list of capabilities for each protocol.
45
type NetProtocolCapabilities struct {
46
	Close               bool // 8
47
	Connect             bool // 9
48
	Disconnect          bool // 10
49
	Accept              bool // 11
50
	IoCtl               bool // 12
51
	Init                bool // 13
52
	Destroy             bool // 14
53
	Shutdown            bool // 15
54
	SetSockOpt          bool // 16
55
	GetSockOpt          bool // 17
56
	SendMsg             bool // 18
57
	RecvMsg             bool // 19
58
	SendPage            bool // 20
59
	Bind                bool // 21
60
	BacklogRcv          bool // 22
61
	Hash                bool // 23
62
	UnHash              bool // 24
63
	GetPort             bool // 25
64
	EnterMemoryPressure bool // 26
65
}
66

67
// NetProtocols reads stats from /proc/net/protocols and returns a map of
68
// PortocolStatLine entries. As of this writing no official Linux Documentation
69
// exists, however the source is fairly self-explanatory and the format seems
70
// stable since its introduction in 2.6.12-rc2
71
// Linux 2.6.12-rc2 - https://elixir.bootlin.com/linux/v2.6.12-rc2/source/net/core/sock.c#L1452
72
// Linux 5.10 - https://elixir.bootlin.com/linux/v5.10.4/source/net/core/sock.c#L3586
73
func (fs FS) NetProtocols() (NetProtocolStats, error) {
74
	data, err := util.ReadFileNoStat(fs.proc.Path("net/protocols"))
75
	if err != nil {
76
		return NetProtocolStats{}, err
77
	}
78
	return parseNetProtocols(bufio.NewScanner(bytes.NewReader(data)))
79
}
80

81
func parseNetProtocols(s *bufio.Scanner) (NetProtocolStats, error) {
82
	nps := NetProtocolStats{}
83

84
	// Skip the header line
85
	s.Scan()
86

87
	for s.Scan() {
88
		line, err := nps.parseLine(s.Text())
89
		if err != nil {
90
			return NetProtocolStats{}, err
91
		}
92

93
		nps[line.Name] = *line
94
	}
95
	return nps, nil
96
}
97

98
func (ps NetProtocolStats) parseLine(rawLine string) (*NetProtocolStatLine, error) {
99
	line := &NetProtocolStatLine{Capabilities: NetProtocolCapabilities{}}
100
	var err error
101
	const enabled = "yes"
102
	const disabled = "no"
103

104
	fields := strings.Fields(rawLine)
105
	line.Name = fields[0]
106
	line.Size, err = strconv.ParseUint(fields[1], 10, 64)
107
	if err != nil {
108
		return nil, err
109
	}
110
	line.Sockets, err = strconv.ParseInt(fields[2], 10, 64)
111
	if err != nil {
112
		return nil, err
113
	}
114
	line.Memory, err = strconv.ParseInt(fields[3], 10, 64)
115
	if err != nil {
116
		return nil, err
117
	}
118
	if fields[4] == enabled {
119
		line.Pressure = 1
120
	} else if fields[4] == disabled {
121
		line.Pressure = 0
122
	} else {
123
		line.Pressure = -1
124
	}
125
	line.MaxHeader, err = strconv.ParseUint(fields[5], 10, 64)
126
	if err != nil {
127
		return nil, err
128
	}
129
	if fields[6] == enabled {
130
		line.Slab = true
131
	} else if fields[6] == disabled {
132
		line.Slab = false
133
	} else {
134
		return nil, fmt.Errorf("unable to parse capability for protocol: %s", line.Name)
135
	}
136
	line.ModuleName = fields[7]
137

138
	err = line.Capabilities.parseCapabilities(fields[8:])
139
	if err != nil {
140
		return nil, err
141
	}
142

143
	return line, nil
144
}
145

146
func (pc *NetProtocolCapabilities) parseCapabilities(capabilities []string) error {
147
	// The capabilities are all bools so we can loop over to map them
148
	capabilityFields := [...]*bool{
149
		&pc.Close,
150
		&pc.Connect,
151
		&pc.Disconnect,
152
		&pc.Accept,
153
		&pc.IoCtl,
154
		&pc.Init,
155
		&pc.Destroy,
156
		&pc.Shutdown,
157
		&pc.SetSockOpt,
158
		&pc.GetSockOpt,
159
		&pc.SendMsg,
160
		&pc.RecvMsg,
161
		&pc.SendPage,
162
		&pc.Bind,
163
		&pc.BacklogRcv,
164
		&pc.Hash,
165
		&pc.UnHash,
166
		&pc.GetPort,
167
		&pc.EnterMemoryPressure,
168
	}
169

170
	for i := 0; i < len(capabilities); i++ {
171
		if capabilities[i] == "y" {
172
			*capabilityFields[i] = true
173
		} else if capabilities[i] == "n" {
174
			*capabilityFields[i] = false
175
		} else {
176
			return fmt.Errorf("unable to parse capability block for protocol: position %d", i)
177
		}
178
	}
179
	return nil
180
}
181