slab.go

Documentation: github.com/prometheus/procfs

     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  	"regexp"
    21  	"strconv"
    22  	"strings"
    23  
    24  	"github.com/prometheus/procfs/internal/util"
    25  )
    26  
    27  var (
    28  	slabSpace  = regexp.MustCompile(`\s+`)
    29  	slabVer    = regexp.MustCompile(`slabinfo -`)
    30  	slabHeader = regexp.MustCompile(`# name`)
    31  )
    32  
    33  // Slab represents a slab pool in the kernel.
    34  type Slab struct {
    35  	Name         string
    36  	ObjActive    int64
    37  	ObjNum       int64
    38  	ObjSize      int64
    39  	ObjPerSlab   int64
    40  	PagesPerSlab int64
    41  	// tunables
    42  	Limit        int64
    43  	Batch        int64
    44  	SharedFactor int64
    45  	SlabActive   int64
    46  	SlabNum      int64
    47  	SharedAvail  int64
    48  }
    49  
    50  // SlabInfo represents info for all slabs.
    51  type SlabInfo struct {
    52  	Slabs []*Slab
    53  }
    54  
    55  func shouldParseSlab(line string) bool {
    56  	if slabVer.MatchString(line) {
    57  		return false
    58  	}
    59  	if slabHeader.MatchString(line) {
    60  		return false
    61  	}
    62  	return true
    63  }
    64  
    65  // parseV21SlabEntry is used to parse a line from /proc/slabinfo version 2.1.
    66  func parseV21SlabEntry(line string) (*Slab, error) {
    67  	// First cleanup whitespace.
    68  	l := slabSpace.ReplaceAllString(line, " ")
    69  	s := strings.Split(l, " ")
    70  	if len(s) != 16 {
    71  		return nil, fmt.Errorf("%w: unable to parse: %q", ErrFileParse, line)
    72  	}
    73  	var err error
    74  	i := &Slab{Name: s[0]}
    75  	i.ObjActive, err = strconv.ParseInt(s[1], 10, 64)
    76  	if err != nil {
    77  		return nil, err
    78  	}
    79  	i.ObjNum, err = strconv.ParseInt(s[2], 10, 64)
    80  	if err != nil {
    81  		return nil, err
    82  	}
    83  	i.ObjSize, err = strconv.ParseInt(s[3], 10, 64)
    84  	if err != nil {
    85  		return nil, err
    86  	}
    87  	i.ObjPerSlab, err = strconv.ParseInt(s[4], 10, 64)
    88  	if err != nil {
    89  		return nil, err
    90  	}
    91  	i.PagesPerSlab, err = strconv.ParseInt(s[5], 10, 64)
    92  	if err != nil {
    93  		return nil, err
    94  	}
    95  	i.Limit, err = strconv.ParseInt(s[8], 10, 64)
    96  	if err != nil {
    97  		return nil, err
    98  	}
    99  	i.Batch, err = strconv.ParseInt(s[9], 10, 64)
   100  	if err != nil {
   101  		return nil, err
   102  	}
   103  	i.SharedFactor, err = strconv.ParseInt(s[10], 10, 64)
   104  	if err != nil {
   105  		return nil, err
   106  	}
   107  	i.SlabActive, err = strconv.ParseInt(s[13], 10, 64)
   108  	if err != nil {
   109  		return nil, err
   110  	}
   111  	i.SlabNum, err = strconv.ParseInt(s[14], 10, 64)
   112  	if err != nil {
   113  		return nil, err
   114  	}
   115  	i.SharedAvail, err = strconv.ParseInt(s[15], 10, 64)
   116  	if err != nil {
   117  		return nil, err
   118  	}
   119  	return i, nil
   120  }
   121  
   122  // parseSlabInfo21 is used to parse a slabinfo 2.1 file.
   123  func parseSlabInfo21(r *bytes.Reader) (SlabInfo, error) {
   124  	scanner := bufio.NewScanner(r)
   125  	s := SlabInfo{Slabs: []*Slab{}}
   126  	for scanner.Scan() {
   127  		line := scanner.Text()
   128  		if !shouldParseSlab(line) {
   129  			continue
   130  		}
   131  		slab, err := parseV21SlabEntry(line)
   132  		if err != nil {
   133  			return s, err
   134  		}
   135  		s.Slabs = append(s.Slabs, slab)
   136  	}
   137  	return s, nil
   138  }
   139  
   140  // SlabInfo reads data from `/proc/slabinfo`.
   141  func (fs FS) SlabInfo() (SlabInfo, error) {
   142  	// TODO: Consider passing options to allow for parsing different
   143  	// slabinfo versions. However, slabinfo 2.1 has been stable since
   144  	// kernel 2.6.10 and later.
   145  	data, err := util.ReadFileNoStat(fs.proc.Path("slabinfo"))
   146  	if err != nil {
   147  		return SlabInfo{}, err
   148  	}
   149  
   150  	return parseSlabInfo21(bytes.NewReader(data))
   151  }
   152
View as plain text