Copyright 2018 The Prometheus Authors Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

package procfs

import (
	
	
	
	
	
)
ProcLimits represents the soft limits for each of the process's resource limits. For more information see getrlimit(2): http://man7.org/linux/man-pages/man2/getrlimit.2.html.
CPU time limit in seconds.
Maximum size of files that the process may create.
Maximum size of the process's data segment (initialized data, uninitialized data, and heap).
Maximum size of the process stack in bytes.
Maximum size of a core file.
Limit of the process's resident set in pages.
Maximum number of processes that can be created for the real user ID of the calling process.
Value one greater than the maximum file descriptor number that can be opened by this process.
Maximum number of bytes of memory that may be locked into RAM.
Maximum size of the process's virtual memory address space in bytes.
Limit on the combined number of flock(2) locks and fcntl(2) leases that this process may establish.
Limit of signals that may be queued for the real user ID of the calling process.
Limit on the number of bytes that can be allocated for POSIX message queues for the real user ID of the calling process.
Limit of the nice priority set using setpriority(2) or nice(2).
Limit of the real-time priority set using sched_setscheduler(2) or sched_setparam(2).
Limit (in microseconds) on the amount of CPU time that a process scheduled under a real-time scheduling policy may consume without making a blocking system call.
	RealtimeTimeout int64
}

const (
	limitsFields    = 3
	limitsUnlimited = "unlimited"
)

var (
	limitsDelimiter = regexp.MustCompile("  +")
)
NewLimits returns the current soft limits of the process. Deprecated: use p.Limits() instead
func ( Proc) () (ProcLimits, error) {
	return .Limits()
}
Limits returns the current soft limits of the process.
func ( Proc) () (ProcLimits, error) {
	,  := os.Open(.path("limits"))
	if  != nil {
		return ProcLimits{}, 
	}
	defer .Close()

	var (
		 = ProcLimits{}
		 = bufio.NewScanner()
	)
	for .Scan() {
		 := limitsDelimiter.Split(.Text(), limitsFields)
		if len() != limitsFields {
			return ProcLimits{}, fmt.Errorf(
				"couldn't parse %s line %s", .Name(), .Text())
		}

		switch [0] {
		case "Max cpu time":
			.CPUTime,  = parseInt([1])
		case "Max file size":
			.FileSize,  = parseInt([1])
		case "Max data size":
			.DataSize,  = parseInt([1])
		case "Max stack size":
			.StackSize,  = parseInt([1])
		case "Max core file size":
			.CoreFileSize,  = parseInt([1])
		case "Max resident set":
			.ResidentSet,  = parseInt([1])
		case "Max processes":
			.Processes,  = parseInt([1])
		case "Max open files":
			.OpenFiles,  = parseInt([1])
		case "Max locked memory":
			.LockedMemory,  = parseInt([1])
		case "Max address space":
			.AddressSpace,  = parseInt([1])
		case "Max file locks":
			.FileLocks,  = parseInt([1])
		case "Max pending signals":
			.PendingSignals,  = parseInt([1])
		case "Max msgqueue size":
			.MsqqueueSize,  = parseInt([1])
		case "Max nice priority":
			.NicePriority,  = parseInt([1])
		case "Max realtime priority":
			.RealtimePriority,  = parseInt([1])
		case "Max realtime timeout":
			.RealtimeTimeout,  = parseInt([1])
		}
		if  != nil {
			return ProcLimits{}, 
		}
	}

	return , .Err()
}

func ( string) (int64, error) {
	if  == limitsUnlimited {
		return -1, nil
	}
	,  := strconv.ParseInt(, 10, 64)
	if  != nil {
		return 0, fmt.Errorf("couldn't parse value %s: %s", , )
	}
	return , nil