{"id":21649,"date":"2026-09-22T12:58:28","date_gmt":"2026-09-22T10:58:28","guid":{"rendered":"https:\/\/webhosting.de\/?p=21649"},"modified":"2026-09-22T12:58:31","modified_gmt":"2026-09-22T10:58:31","slug":"linux-procfs-for-administrators","status":"publish","type":"post","link":"https:\/\/webhosting.de\/en\/linux-procfs-fuer-administratoren\/","title":{"rendered":"Linux procfs for Administrators: An Overview of Important Files"},"content":{"rendered":"<div class=\"wh-article\"><p class=\"wh-lead\">The <strong>Linux procfs<\/strong> Displays the current state of the kernel via virtual files under \/proc. For system administration, load, memory, processes, file descriptors, and block devices are particularly relevant. It\u2019s crucial to understand the context: Some values are snapshots, while others are counters since boot or moving averages. Therefore, never interpret a single value in isolation; instead, cross-reference it with relevant signals and the context of the host, VM, or container.  <\/p><nav class=\"wh-toc\" aria-label=\"Contents of this article\"><p class=\"wh-toc-title\">Go directly to the section<\/p><div class=\"wh-toc-grid\"><a class=\"wh-toc-link\" href=\"#proc-basics\">Understanding procfs: A Virtual Kernel View Instead of Data Storage<\/a><a class=\"wh-toc-link\" href=\"#proc-time-context\">Putting Metrics, Snapshots, and Visibility into Perspective<\/a><br><a class=\"wh-toc-link\" href=\"#proc-sysctl-boundary\">Reading, Configuring, and Securing \/proc\/sys<\/a><br><a class=\"wh-toc-link\" href=\"#proc-overview-table\">The Most Important procfs Files by Administrative Task<\/a><br><a class=\"wh-toc-link\" href=\"#proc-load-memory\">Load, CPU, and Memory<\/a><br><a class=\"wh-toc-link\" href=\"#proc-process-io\">Examine Processes and Disk I\/O<\/a><br><a class=\"wh-toc-link\" href=\"#proc-monitoring\">procfs in Operation: Queries, Monitoring, and Data Protection<\/a><br><a class=\"wh-toc-link\" href=\"#proc-troubleshooting\">Troubleshooting Paths for Slow Services and Resource Bottlenecks<\/a><br><a class=\"wh-toc-link\" href=\"#proc-decisions\">Correct Common Misconceptions and Choose the Right Tools<\/a><\/div><\/nav><h2 id=\"proc-basics\">Understanding procfs: A Virtual Kernel View Instead of Data Storage<\/h2><p>The <strong>procfs<\/strong> is a virtual file system: The entries under \/proc represent data structures and states of the running Linux kernel. They are not permanently stored on a storage device. When read, the kernel generates the corresponding view based on its current state; after a reboot, for example, many counters reset. Therefore, \/proc is an interface for monitoring and, to some extent, control\u2014not a location for your own files or persistent configurations.  <\/p><p>For administrative purposes, three categories must be distinguished. Global status files such as \/proc\/meminfo, \/proc\/stat, or \/proc\/loadavg provide kernel-wide metrics. Directories with numeric names, such as \/proc\/1234, provide details about a single process. In contrast, \/proc\/sys contains kernel parameters that may be either readable or writable, depending on permissions and the parameter in question. The similarity in file names should not obscure the fact that status queries and configuration changes have fundamentally different consequences.  <\/p><p>The available paths and fields are not identical on every Linux system. The kernel version and configuration, architecture, detected hardware, and loaded modules all influence the visible entries. Namespaces also alter individual views. In particular, a procfs associated with a PID namespace restricts the process and PID views; however, this does not mean that global files automatically display container- or cgroup-specific values. Scripts should check files and fields before evaluating their contents, rather than assuming a complete procfs structure that is identical everywhere.  <\/p><p>This should be distinguished from sysfs under \/sys: It primarily represents devices, drivers, and hardware objects. cgroup2 is also relevant for resource allocation and group limits. However, procfs remains the primary source for many kernel and process states required for initial diagnosis.  <\/p><h2 id=\"proc-time-context\">Putting Metrics, Snapshots, and Visibility into Perspective<\/h2><p>With procfs, the value alone rarely explains a problem. First, its time reference must be clarified: Some entries are <strong>Cumulative counters<\/strong> since system startup; others describe a current state; still others represent moving time windows. A high counter reading initially indicates only that an event has been accumulating since boot. A rate is derived only from two measurement points: the difference between the values divided by the time interval between them. This applies, for example, to many CPU, interrupt, and disk counters.  <\/p><p>The \/proc\/uptime file provides the elapsed runtime and the aggregated idle time. It helps to place counters in a temporal context since system startup, but it does not replace a time series. A single query is a snapshot; to draw reliable conclusions about trends, peaks, or recurring loads, repeated queries with timestamps are required. Values may change even while being read because the kernel continues to run.  <\/p><p>Even the visible data has its limitations. \/proc\/self always refers to the process that is currently resolving the path. This makes it useful for scripts and interactive checks without requiring a PID. However, access to other processes\u2019 directories can be restricted by file permissions, Linux capabilities, and the procfs mount option <code data-no-translation=\"\">hidepid<\/code> be limited. In this case, the lack of visibility is not due to a faulty procfs, but rather a safeguard against the disclosure of sensitive process information.  <\/p><p>Special caution is required in containers. A procfs bound to a PID namespace displays only the processes within that namespace view for process-related paths. Global kernel files such as \/proc\/meminfo, \/proc\/stat, or \/proc\/diskstats, on the other hand, may still reflect host values and are not automatically limited to the container\u2019s limits. Before any diagnosis, it is therefore necessary to clarify whether the issue concerns processes, global kernel values, or the resources actually allocated; a container\u2019s limits and usage should also be included in the cgroup2 analysis.  <\/p><h2 id=\"proc-sysctl-boundary\">Reading, Configuring, and Securing \/proc\/sys<\/h2><p>The Division <strong>\/proc\/sys<\/strong> is the file system view of the sysctl interface. Reading a value is used for diagnostic purposes. Writing to a setting, on the other hand, immediately changes the behavior of the running kernel and can affect services, resource consumption, or security features. The fact that a change takes effect without a reboot does not mean it is risk-free or automatically permanent: persistence depends on the chosen system configuration.  <\/p><p>The directory structure makes it easier to get started. The \/proc\/sys\/fs directory contains, among other things, global filesystem and file handle parameters. \/proc\/sys\/vm groups together memory management settings, while \/proc\/sys\/net contains network-related parameters. Which subdirectories and keys are available depends, in turn, on the kernel configuration and the system\u2019s capabilities. An existing parameter is therefore not a universal tuning solution; its documentation and the specific workload are the determining factors.    <\/p><p>A counterexample to apparent optimization is <code data-no-translation=\"\">drop_caches<\/code> under \/proc\/sys\/vm. The kernel documentation classifies this function as intended for debugging and testing and advises against using it for any other purpose, because flushing reusable caches can reduce performance. Low free memory alone is not a reason to discard caches: The kernel deliberately uses RAM for the file cache as well.  <\/p><p>There should be a clear rationale for every change. First, record the initial value; document the purpose and expected side effects; make the change in a controlled manner; and then monitor the relevant metrics and service behavior. Plan the rollback in advance, and only incorporate a value into a permanent configuration after it has been technically verified. Further fundamentals regarding parameters and their controlled management are covered in the article <a href=\"https:\/\/webhosting.de\/en\/kernel-tuning-linux-sysctl-parameter-serverboost-opti\/\">Kernel tuning in Linux hosting: Sysctl parameters at a glance<\/a>.<\/p><h2 id=\"proc-overview-table\">The Most Important procfs Files by Administrative Task<\/h2><p>The choice of a procfs file should be based on administrative considerations, not on the goal of obtaining the most complete directory listing possible. Global files often provide kernel-wide values, process paths describe a single visible process, and entries under \/proc\/sys\/fs provide configuration information and system-wide limits. Some values represent current states, while others are counters accumulated since boot or moving averages. This distinction determines whether a single read is sufficient or whether two measurement points are necessary. <\/p><div class=\"wh-table-scroll\" tabindex=\"0\" role=\"region\" aria-label=\"Important procfs files for common administrative tasks\"><table><caption>Important procfs files for common administrative tasks<\/caption><thead><tr><th scope=\"col\">Path<\/th><th scope=\"col\">Purpose<\/th><th scope=\"col\">Typical question<\/th><th scope=\"col\">Data Characteristics<\/th><th scope=\"col\">Important Limitation<\/th><th scope=\"col\">Secure Read Query<\/th><\/tr><\/thead><tbody><tr><td>\/proc\/loadavg<\/td><td>system load<\/td><td>Are there any pending tasks?<\/td><td>1-, 5-, and 15-minute averages<\/td><td>Not just CPU utilization<\/td><td>cat \/proc\/loadavg<\/td><\/tr><tr><td>\/proc\/stat<\/td><td>CPU and Kernel Counters<\/td><td>How is CPU time distributed?<\/td><td>Cumulative since boot<\/td><td>Do not evaluate iowait in isolation<\/td><td>grep -E \u201a^(cpu|intr|ctxt|processes)\u2018 \/proc\/stat<\/td><\/tr><tr><td>\/proc\/meminfo<\/td><td>Storage Overview<\/td><td>Is there storage available?<\/td><td>Current stored values<\/td><td>MemFree alone is not enough; it is not necessarily cgroup-specific within the container<\/td><td>cat \/proc\/meminfo<\/td><\/tr><tr><td>\/proc\/pressure\/cpu<\/td><td>CPU stalls<\/td><td>Are tasks waiting for the CPU?<\/td><td>Time Windows and Counters<\/td><td>\"full\" at the system level cannot be interpreted and is output as null<\/td><td>cat \/proc\/pressure\/cpu<\/td><\/tr><tr><td>\/proc\/pressure\/memory<\/td><td>storage pressure<\/td><td>Does memory shortage block tasks?<\/td><td>Time Windows and Counters<\/td><td>PSI must be available<\/td><td>cat \/proc\/pressure\/memory<\/td><\/tr><tr><td>\/proc\/pressure\/io<\/td><td>I\/O Stalls<\/td><td>Are tasks waiting for I\/O?<\/td><td>Time Windows and Counters<\/td><td>No substitute for equipment analysis<\/td><td>cat \/proc\/pressure\/io<\/td><\/tr><tr><td>\/proc\/\/status<\/td><td>Process Status<\/td><td>How large and active is a process?<\/td><td>Current Process Data<\/td><td>Permissions and the PID namespace can restrict access<\/td><td>cat \/proc\/$$\/status<\/td><\/tr><tr><td>\/proc\/\/fd<\/td><td>Open descriptors<\/td><td>What objects does a process hold?<\/td><td>Current symbolic links<\/td><td>Many FDs do not automatically indicate a leak<\/td><td>ls -l \/proc\/$$\/fd<\/td><\/tr><tr><td>\/proc\/\/maps<\/td><td>Virtual Mappings<\/td><td>What areas does a process involve?<\/td><td>Current Mapping List<\/td><td>Often too extensive for an initial analysis<\/td><td>cat \/proc\/$$\/maps<\/td><\/tr><tr><td>\/proc\/diskstats<\/td><td>Block Device I\/O<\/td><td>Which devices work?<\/td><td>Cumulative since boot<\/td><td>Estimates require two samples; values may be host-wide<\/td><td>cat \/proc\/diskstats<\/td><\/tr><tr><td>\/proc\/sys\/fs\/file-nr<\/td><td>File Handle Usage<\/td><td>How many handles does the system use?<\/td><td>Current Counter and Threshold<\/td><td>The middle field is zero on modern Linux systems<\/td><td>cat \/proc\/sys\/fs\/file-nr<\/td><\/tr><tr><td>\/proc\/sys\/fs\/file-max<\/td><td>File handle limit<\/td><td>What is the global cap?<\/td><td>Active Parameter<\/td><td>Do not confuse this with a process limit<\/td><td>cat \/proc\/sys\/fs\/file-max<\/td><\/tr><\/tbody><\/table><\/div><p>The table is a starting point, not a diagnostic workflow. An unusual value always requires independent verification: load with CPU and I\/O data, memory values with pressure stall information, and process metrics with the behavior of the service. In particular, \/proc\/diskstats and \/proc\/stat are <strong>Cumulative counters<\/strong>; their difference over a known interval is more meaningful for rates than the absolute value. In containers, it is also necessary to check whether a file provides global kernel values or a view specific to each cgroup. The following sections therefore organize the signals by load, memory, processes, and I\/O.<\/p><h2 id=\"proc-load-memory\">Load, CPU, and Memory: Evaluating Signals in Combination<\/h2><p>If a program is running slowly, `\/proc\/loadavg` is a good place to start, but it does not provide a definitive assessment of CPU usage. The three values represent the average load over the last 1, 5, and 15 minutes. The load includes not only runnable units in state R, but also tasks in the uninterruptible waiting state D, such as those waiting for I\/O. The fourth field shows the number of currently executable scheduling units compared to all existing ones. High <strong>Load Average<\/strong> may therefore indicate CPU contention, blocked I\/O operations, or both. <\/p><figure class=\"wp-block-image size-large wh-figure\"><img loading=\"lazy\" width=\"800\" height=\"534\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-last-speicher-signale-4bfe68af-detail1-fe433c8680-1024x683.webp\" class=\"wp-image-21653\" alt=\"Conceptual integration of load, memory, CPU, and I\/O signals.\" decoding=\"async\" srcset=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-last-speicher-signale-4bfe68af-detail1-fe433c8680-1024x683.webp 1024w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-last-speicher-signale-4bfe68af-detail1-fe433c8680-300x200.webp 300w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-last-speicher-signale-4bfe68af-detail1-fe433c8680-768x512.webp 768w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-last-speicher-signale-4bfe68af-detail1-fe433c8680-18x12.webp 18w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-last-speicher-signale-4bfe68af-detail1-fe433c8680.webp 1536w\" sizes=\"auto, (max-width: 800px) 100vw, 800px\"><figcaption>Conceptual illustration: Only when several core indicators are considered together is it possible to reliably classify load.<\/figcaption><\/figure><div class=\"wh-code-window\" data-wh-code=\"\"><div class=\"wh-code-toolbar\"><span>Terminal<\/span><button type=\"button\" class=\"wh-code-copy\" data-wh-copy=\"\" hidden=\"\">Copy code<\/button><span class=\"wh-copy-status\" aria-live=\"polite\"><\/span><span data-wh-copy-success=\"\" hidden=\"\">Copied<\/span><span data-wh-copy-fallback=\"\" hidden=\"\">Code highlighted\u2014please copy<\/span><\/div><pre class=\"wh-code\" data-no-translation=\"\" translate=\"no\"><code class=\"language-sh\">cat \/proc\/loadavg\ngrep -E '^(cpu|intr|ctxt|processes)' \/proc\/stat\ncat \/proc\/meminfo\ncat \/proc\/pressure\/memory<\/code><\/pre><\/div><p>The CPU lines in \/proc\/stat contain time shares since system startup in USER_HZ. To determine utilization shares from this data, two queries must be compared; a single reading shows only accumulated time. The iowait value is not a direct measure of storage latency: its calculation has documented limitations and may even decrease under certain circumstances. Therefore, device metrics and I\/O-PSI are also useful for identifying I\/O-related causes. <\/p><p>Even a low MemFree value does not necessarily indicate a RAM shortage. Linux specifically uses unused memory for caching. MemAvailable estimates how much memory new applications are likely to receive without swapping, and is usually more helpful for an initial assessment. Only when MemAvailable becomes scarce and memory stalls occur at the same time does the evidence point to <strong>storage pressure<\/strong>. In a container, however, these global memory values may originate from the host; for guaranteed or limited resources, the cgroup2 view is also relevant. <\/p><p>The files under \/proc\/pressure supplement this view. For \"memory\" and \"io,\" \"some\" means that at least some tasks were blocked during a portion of the time window; \"full\" indicates a state in which all non-idle tasks were blocked simultaneously. The values `avg10`, `avg60`, and `avg300` refer to 10, 60, and 300 seconds, respectively; `total` is a cumulative stall counter. For CPU, \u201cfull\u201d is not semantically defined at the system-wide level and has been output as \u201cnull\u201d since Linux 5.13 for compatibility reasons; therefore, it should not be interpreted as a diagnostic value at the system level. CPU, memory, and io PSI answer different questions and should not be used interchangeably. <\/p><p>If a service is responding slowly when MemFree is low, first check MemAvailable and \/proc\/pressure\/memory. If both appear normal, this rules out acute system-wide memory pressure. Next, \/proc\/\/status can show whether the affected process has, for example, a high VmRSS approximation, many threads, or an unusual state. This combination helps distinguish between cache-heavy but normal memory usage and a problem that requires further process analysis. <\/p><h2 id=\"proc-process-io\">Examining Processes, File Descriptors, and Disk I\/O<\/h2><p>To ensure a safe exercise with a guaranteed process, $$ represents the PID of the current shell. The status file is more human-readable than the field-oriented stat file. Name identifies the process, State its status, PPid the parent process, and Threads the number of threads. VmRSS is a quick approximation of resident memory; its RSS accounting is scalable and asynchronous and may therefore be inaccurate; VmSize, on the other hand, describes the virtual address space. FDSize describes the size of the descriptor table, not necessarily the number of currently open entries. Voluntary and involuntary context switches can help in classifying scheduling behavior, but they do not, on their own, prove the presence of an error.  <\/p><div class=\"wh-code-window\" data-wh-code=\"\"><div class=\"wh-code-toolbar\"><span>Terminal<\/span><button type=\"button\" class=\"wh-code-copy\" data-wh-copy=\"\" hidden=\"\">Copy code<\/button><span class=\"wh-copy-status\" aria-live=\"polite\"><\/span><span data-wh-copy-success=\"\" hidden=\"\">Copied<\/span><span data-wh-copy-fallback=\"\" hidden=\"\">Code highlighted\u2014please copy<\/span><\/div><pre class=\"wh-code\" data-no-translation=\"\" translate=\"no\"><code class=\"language-sh\">cat \/proc\/$$\/status\nls -l \/proc\/$$\/fd<\/code><\/pre><\/div><figure class=\"wp-block-image size-large wh-figure\"><img loading=\"lazy\" width=\"800\" height=\"534\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-prozess-fd-io-4bfe68af-detail2-5a910998ae-1024x683.webp\" class=\"wp-image-21654\" alt=\"Separate representation of process resources and system-wide device I\/O with an abstracted mediation layer.\" decoding=\"async\" srcset=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-prozess-fd-io-4bfe68af-detail2-5a910998ae-1024x683.webp 1024w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-prozess-fd-io-4bfe68af-detail2-5a910998ae-300x200.webp 300w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-prozess-fd-io-4bfe68af-detail2-5a910998ae-768x512.webp 768w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-prozess-fd-io-4bfe68af-detail2-5a910998ae-18x12.webp 18w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/09\/procfs-prozess-fd-io-4bfe68af-detail2-5a910998ae.webp 1536w\" sizes=\"auto, (max-width: 800px) 100vw, 800px\"><figcaption>Conceptual illustration: Process data and block device I\/O are separate levels of analysis that cannot be directly mapped on a one-to-one basis.<\/figcaption><\/figure><p>The fd directory contains symbolic links to open files, pipes, devices, or sockets. It can be used, for example, to find a process that continues to keep a deleted log file open. However, a large number of open file descriptors is to be expected with proxies, databases, or event-driven servers. For filtered views and cross-process mapping, <a href=\"https:\/\/webhosting.de\/en\/lsof-linux-open-files-analysis-and-diagnosis\/\">Use lsof to analyze open files<\/a> A suitable addition. Command lines from `cmdline` can reveal confidential arguments; `environ` is even more sensitive due to potential credentials or tokens and should not be queried routinely. <\/p><p>maps lists virtual memory regions along with their permissions, offset, device, inode, and, if applicable, path. smaps supplements this with detailed memory values for each mapping and provides a more accurate\u2014though more resource-intensive\u2014snapshot than RSS information. Both files are intended for in-depth memory analysis: their output can be extensive, and interpreting individual mappings requires context. For a quick overview, `status` and the system-wide memory and PSI files are usually more efficient. <\/p><p>When the system is under heavy load and CPU utilization is low, \/proc\/diskstats expands the diagnostics to the device level. The file maintains cumulative I\/O statistics for each block device. To evaluate activity as a rate, two points in time must be compared. Physical drives, partitions, and virtual or Device Mapper devices must be clearly distinguished; counters from different levels must not be added together indiscriminately. An open file descriptor of a process cannot be directly mapped to a diskstats device counter: the file system, cache, and mapping layers lie in between. However, in conjunction with \/proc\/pressure\/io, it is still possible to verify whether observable I\/O stalls and device activity coincide in time. <\/p><h2 id=\"proc-monitoring\">procfs in Operation: Queries, Monitoring, and Data Protection<\/h2><p>For reproducible system diagnostics, treat procfs queries as measurement points: Record the timestamp, system context, and the specific query. Many values are cumulative counters since startup; only the difference between two values divided by the time interval yields a rate. This applies, for example, to counters from <code data-no-translation=\"\">\/proc\/diskstats<\/code>. A single query can therefore indicate activity, but it cannot reliably quantify either throughput or a sustained decline in performance.  <\/p><p>A monitoring system should, among other things, retrieve storage values at fixed intervals from <code data-no-translation=\"\">\/proc\/meminfo<\/code>, device values from <code data-no-translation=\"\">\/proc\/diskstats<\/code>, monitor process and system states, as well as print signals if kernel support is available. It must convert raw values to the appropriate units, calculate differences for counters, and store historical data. In containers, it must not equate global procfs values with the workload\u2019s resource limits: process paths may be limited to the PID namespace, while memory or device values may partially reflect the host. Supplementary cgroup2 metrics are required for a group\u2019s limits and utilization. Only time-series data allows for reliable thresholds: A high value may be normal if it fits within the expected load window; a sudden increase relative to its own baseline is often more relevant. The available procfs entries depend on the running kernel and its configuration.  <\/p><p>Direct files and tools complement each other. <code data-no-translation=\"\">ps<\/code>, <code data-no-translation=\"\">top<\/code> or <code data-no-translation=\"\">htop<\/code> are suitable for an interactive view of the process; <code data-no-translation=\"\">free<\/code>, <code data-no-translation=\"\">vmstat<\/code>, <code data-no-translation=\"\">iostat<\/code>, <code data-no-translation=\"\">pidstat<\/code>, <code data-no-translation=\"\">ss<\/code> and <code data-no-translation=\"\">sar<\/code> Depending on the installation, they process data for specific queries. procfs remains useful if you want to examine the kernel source directly or build a small, easy-to-understand script. For alerts and capacity planning, time-series data is usually the more appropriate level.<\/p><aside class=\"wh-callout wh-callout-warning\"><p class=\"wh-callout-title\">Do Not Disclose Process Data Carelessly<\/p><p>Command lines may contain paths, client IDs, or accidentally provided credentials. A process's environment variables are often even more sensitive. Collect, store, and share this data only if it is necessary for diagnostics; restrict access to authorized individuals.<\/p><\/aside><p>Visibility restrictions also apply to read-only queries. Access rights, mount options, and PID namespaces can hide process data or limit it to a container view. Conversely, having a separate \/proc mount does not mean that every global kernel file contains only data from the container. A missing process entry or an unexpectedly high global value is therefore initially an indication that the execution environment, mount options, and cgroup context need to be clarified.  <\/p><h2 id=\"proc-troubleshooting\">Troubleshooting Paths for Slow Services and Resource Bottlenecks<\/h2><p>Troubleshooting starts with a symptom, not with a single value that is supposedly to blame. Next, check at least one independent signal and note whether the observation applies to the host, a virtual machine, or a container. This way, for example, you can avoid hastily attributing a high load to a CPU problem or a large number of open descriptors to a leak. The following steps are preliminary diagnostic checks and are not a substitute for application-specific logs.<\/p><div class=\"wh-table-scroll\" tabindex=\"0\" role=\"region\" aria-label=\"Compact Diagnostic Paths with procfs\"><table><caption>Compact Diagnostic Paths with procfs<\/caption><thead><tr><th scope=\"col\">Symptom<\/th><th scope=\"col\">Read this first<\/th><th scope=\"col\">Adjust accordingly<\/th><th scope=\"col\">Avoiding Misinterpretation<\/th><\/tr><\/thead><tbody><tr><td>High Load<\/td><td>\/proc\/loadavg<\/td><td>\/proc\/stat, \/proc\/pressure\/io, \/proc\/diskstats<\/td><td>Load includes tasks that are ready to run and those that are waiting indefinitely, not just CPU work.<\/td><\/tr><tr><td>Estimated storage pressure<\/td><td>\/proc\/meminfo<\/td><td>\/proc\/pressure\/memory, \/proc\/\/status<\/td><td>A low MemFree value alone does not indicate a lack of RAM; MemAvailable and stalls also count.<\/td><\/tr><tr><td>Notable I\/O Wait Time<\/td><td>\/proc\/stat<\/td><td>\/proc\/pressure\/io, \/proc\/diskstats at two measurement points<\/td><td>iowait is not a direct measure of latency and has documented limitations.<\/td><\/tr><tr><td>Many open files<\/td><td>\/proc\/sys\/fs\/file-nr and \/proc\/sys\/fs\/file-max<\/td><td>\/proc\/\/fd, service behavior<\/td><td>Many metrics may be normal for a server; limits and growth are more important.<\/td><\/tr><tr><td>Service won't start<\/td><td>\/proc\/\/status, if a process is created<\/td><td>\/proc\/\/fd, service log, used resources<\/td><td>A hidden process may have terminated or may be running outside the visible PID namespace.<\/td><\/tr><\/tbody><\/table><\/div><p>If the load average is high, first check whether running or queued tasks are driving the number up. The load metrics represent averages over one, five, and 15 minutes and take into account both R and D states. Therefore, compare CPU time metrics with I\/O pressure and device activity only with caution. In particular, <strong>iowait<\/strong> should not be interpreted in isolation as memory latency.   <\/p><p>If the application is running slowly and MemFree is low, <strong>MemAvailable<\/strong> the better initial context value. Include memory PSI and the status of the affected process, such as its VmRSS, number of threads, and state. PSI distinguishes between memory and I\/O by <code data-no-translation=\"\">some<\/code> for partially blocked tasks and <code data-no-translation=\"\">full<\/code> for completely blocking non-idler tasks. If PSI files are missing, this may be due to the kernel configuration or the environment; it does not rule out a bottleneck.   <\/p><p>For file and process diagnostics, permissions and <strong>PID Namespaces<\/strong> limit its usefulness. In containers, \/proc often describes only the assigned process space. If access is denied or directories are incomplete, you should therefore check user permissions, procfs mount options, and the namespace context before drawing any technical conclusions based on the absence of data.  <\/p><h2 id=\"proc-decisions\">Correct Common Misconceptions and Choose the Right Tools<\/h2><p>Four common oversights in Linux administration often lead to incorrect actions. Few <code data-no-translation=\"\">MemFree<\/code> does not automatically indicate a RAM shortage, because the kernel uses memory as a cache, among other things; for new applications, `MemAvailable` is a more meaningful estimate. A high load does not prove CPU saturation, since tasks that are waiting indefinitely are also factored in. A high iowait percentage does not measure the immediate latency of a storage device. And procfs is not identical everywhere: kernel version, configuration, hardware, modules, and namespaces all influence the files and fields.   <\/p><p>Choose the method based on the question. For a specific root cause analysis, use <strong>procfs<\/strong> Raw data directly from the running kernel. Specialized command-line tools are usually more efficient for getting a quick, human-readable overview. When trends, alerts, or capacity decisions matter, you need a monitoring solution that timeseries-processes measurement points, calculates counter differences, and maintains historical comparison values. For resource limits of individual services or containers, an analysis at the cgroup level complements the global host view; PSI can also be available on a per-cgroup basis with the appropriate configuration.  <\/p><p>Particular caution is warranted when it comes to <code data-no-translation=\"\">\/proc\/sys<\/code>. Reading a parameter is for diagnostic purposes; writing to it changes active kernel behavior. Change a value only if the cause is understood, the initial value has been documented, the effects can be observed, and a way to revert the change is established. The directories <code data-no-translation=\"\">fs<\/code>, <code data-no-translation=\"\">vm<\/code> and <code data-no-translation=\"\">net<\/code> They organize parameters by topic, but do not provide universal tuning guidelines.  <\/p><p>The example <code data-no-translation=\"\">drop_caches<\/code> illustrates the difference between intervention and optimization: The kernel documentation describes the interface as non-destructive, but warns of performance issues and does not recommend it as a routine operational measure outside of testing or debugging scenarios. A conservative rule of thumb is therefore: Measure first, then make a well-founded, limited change, observe the effects and side effects, and document the decision.  <\/p><section class=\"wh-sources\"><h2>Sources and Current State of Knowledge<\/h2><p>Status of the research: <time datetime=\"2026-09-22\">2026-09-22<\/time><\/p><p>Research status: September 22, 2026. The visible procfs paths and fields may vary depending on the kernel version, configuration, hardware, namespaces, and permissions. The kernel documentation referenced for `drop_caches` and network parameters is version-specific; if your kernel version differs, consult the documentation for the kernel you are using.<\/p><div class=\"wh-source-urls\"><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/docs.kernel.org\/filesystems\/proc.html<\/span><\/p><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/docs.kernel.org\/admin-guide\/sysctl\/<\/span><\/p><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/docs.kernel.org\/admin-guide\/sysctl\/fs.html<\/span><\/p><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/docs.kernel.org\/5.17\/admin-guide\/sysctl\/vm.html<\/span><\/p><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/docs.kernel.org\/7.1\/admin-guide\/sysctl\/net.html<\/span><\/p><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/man7.org\/linux\/man-pages\/man5\/proc_loadavg.5.html<\/span><\/p><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/www.man7.org\/linux\/man-pages\/man5\/proc_stat.5.html<\/span><\/p><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/www.man7.org\/linux\/man-pages\/man5\/proc_meminfo.5.html<\/span><\/p><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/docs.kernel.org\/accounting\/psi.html<\/span><\/p><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/man7.org\/linux\/man-pages\/man5\/proc_pid_status.5.html<\/span><\/p><p><span class=\"wh-source-url\" data-no-translation=\"\" dir=\"ltr\">https:\/\/man7.org\/linux\/man-pages\/man5\/proc_diskstats.5.html<\/span><\/p><\/div><\/section><\/div>","protected":false},"excerpt":{"rendered":"<p>procfs provides direct insight into the running Linux kernel. This guide explains important files under \/proc, categorizes counters and snapshots, and outlines safe diagnostic paths for load, memory, processes, I\/O, and sysctl parameters.<\/p>","protected":false},"author":1,"featured_media":21652,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[780],"tags":[],"class_list":["post-21649","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-administration-anleitungen"],"acf":[],"_wp_attached_file":null,"_wp_attachment_metadata":null,"surfer_file_name":null,"surfer_file_original_url":null,"_wp_attachment_image_alt":null,"litespeed-optimize-set":null,"litespeed-optimize-size":null,"_oembed_b5e1eb923ad3b086e579b1befcd4075c":null,"_elementor_source_image_hash":null,"stockpack_author_name":null,"stockpack_author_url":null,"stockpack_provider":null,"stockpack_image_url":null,"stockpack_license":null,"stockpack_license_url":null,"stockpack_modification":null,"color":null,"original_id":null,"original_url":null,"original_link":null,"unsplash_location":null,"unsplash_sponsor":null,"unsplash_exif":null,"unsplash_attachment_metadata":null,"_elementor_is_screenshot":null,"_source_url":null,"_elementor_migrations_state_8b2d":null,"envato_tk_source_kit":null,"envato_tk_source_index":null,"envato_tk_manifest":null,"envato_tk_folder_name":null,"envato_tk_builder":null,"envato_elements_download_event":null,"_menu_item_type":null,"_menu_item_menu_item_parent":null,"_menu_item_object_id":null,"_menu_item_object":null,"_menu_item_target":null,"_menu_item_classes":null,"_menu_item_xfn":null,"_menu_item_url":null,"_trp_menu_languages":null,"rank_math_primary_category":"780","_wh_make_key":"wh_4bfe68af3a01e55dbd77837eb0b68ff1","rank_math_internal_links_processed":"1","_wh_make_topic":"Linux procfs f\u00fcr Administratoren \u2013 wichtige Dateien im \u00dcberblick","_wh_make_input_keywords":["procfs linux","\/proc filesystem","linux administration"],"_wh_make_config":{"research_model":"gpt-5.6-terra","writer_model":"gpt-5.6-terra","review_model":"gpt-5.6-sol","image_model":"gpt-image-2.5-flare","image_quality":"medium","image_format":"webp","final_status":"draft","charts_enabled":true},"_wh_make_links":{"I1":{"id":"I1","post_id":20324,"url":"https:\/\/webhosting.de\/kernel-livepatch-oracle-linux-oracle-ksplice-ueberblick-sicherheit\/","title":"Kernel Livepatch on Oracle Linux: An Overview of oracle ksplice","excerpt":"Using Oracle Ksplice, I apply kernel and user-space security updates on Oracle Linux without shutting down the system\u2014and without interrupting running workloads. This post explains the practical use of kernel livepatching, highlights the Ksplice clients, and shows how I roll out updates in a secure, reproducible, and auditable manner. Key points: Reboot-free: Kernel updates run without downtime. User space: glibc\/OpenSSL can be patched live. Hypervisor: KVM and Xen updates during operation. Rollback: Undo patches without a reboot. Automated: Control via client and API. Kernel Livepatch: Short and Clear With Kernel Livepatch, I apply security fixes directly to the active kernel\u2014without rebooting. Patches modify functions in memory, allowing services to continue running and eliminating the need for maintenance windows. This reduces downtime, lowers risk, and keeps systems continuously available. I close vulnerabilities faster because I don\u2019t have to plan for reboots. For production servers operating 24\/7, this is a clear advantage, especially for databases and virtualization. Oracle Ksplice at a Glance Oracle Ksplice delivers live patches for the kernel, hypervisor, and critical user-space libraries. I apply updates in a controlled manner, monitor the status, and roll back changes immediately if necessary. This allows me to maintain a high level of security without halting workloads. The Enhanced Client extends the scope beyond the kernel to address glibc, OpenSSL, and KVM\/Xen. This results in a consistent patching approach for hosts and guests, both on-premises and in the cloud. Process in the Kernel: Step by Step Ksplice calculates the diff between the original and target kernels and uses it to build a patch module. I load this module into the running system, where it replaces or supplements the affected functions. Before applying the patch, Ksplice checks the consistency of the active kernel to ensure that no discrepancies lead to risky states. Services remain available during the update; the process remains lightweight. If multiple fixes are pending, I automate the process\u2014for example, with `ksplice upgrade -y`\u2014and document the result immediately after the rollout. User Space, KV"},"I2":{"id":"I2","post_id":18128,"url":"https:\/\/webhosting.de\/kernel-tuning-linux-sysctl-parameter-serverboost-opti\/","title":"Kernel tuning in Linux hosting: Sysctl parameters at a glance","excerpt":"Kernel tuning in Linux hosting delivers measurable performance gains because I fine-tune sysctl parameters for networking, memory, CPU, and security. I load profiles without rebooting and fine-tune values based on workloads, concurrency, and I\/O behavior so that the server responds quickly and operates reliably under load. Key Areas: sysctl controls kernel behavior at runtime. Optimizing the network: backlogs, sockets, TCP. Optimizing memory: Swapping, dirty pages Fine-tuning the CPU: scheduler, PIDs Hardening security without overhead What is sysctl in Linux hosting? With sysctl, I read and modify kernel parameters at runtime without compiling the kernel. The values are stored as files in the \/proc\/sys directory\u2014such as net\/ipv4\/tcp_max_syn_backlog\u2014and control networking, memory, and security. For hosting workloads with many connections, direct tuning reduces latency spikes and timeouts. I make temporary changes using `sysctl -w` and save permanent profiles in `\/etc\/sysctl.d\/*.conf`. Then I reload everything with `sysctl --system` and check `dmesg` and journal logs so I can quickly identify misconfigurations. How I Use sysctl Safely Before making changes, I back up profiles and document current values using `sysctl -a` so I can roll back at any time. I first test new values on staging VMs with comparable load. Afterward, I increase parameters incrementally, monitor metrics, and make further adjustments. This is how I prevent OOM kills, socket drops, and sporadic retransmissions. For reproducible setups, I create a separate file such as \/etc\/sysctl.d\/99-hosting.conf and load it in a controlled manner. Test # temporarily: sudo sysctl -w net.core.somaxconn=65535 sudo sysctl -w net.ipv4.tcp_max_syn_backlog=4096 Set # permanently: sudo tee \/etc\/sysctl.d\/99-hosting.conf &gt;\/dev\/null &lt;&lt;&#039;EOF&#039; net.core.somaxconn = 65535 net.ipv4.tcp_max_syn_backlog = 4096 vm.swappiness = 10 vm.dirty_ratio = 20 EOF sudo sysctl --system Network parameters for web servers For a large number of concurrent connections, I increase somaxconn to prevent the listen backlog of Nginx or Apache from overflowing. With `net.ipv4.tcp_max_syn_backlog`, I increase the queue of half-open connections, which under high traffic..."},"I3":{"id":"I3","post_id":20594,"url":"https:\/\/webhosting.de\/lsof-linux-offene-dateien-analyse-diagnose\/","title":"Using lsof Effectively: Analyzing Open Files and Processes","excerpt":"Ich setze lsof linux ein, um in Sekunden zu sehen, welcher Prozess welche Datei, Socket oder welchen Port offen h\u00e4lt. So erkenne ich blockierte Logs, belegte Ports und gesperrte Dateien ohne Umwege und l\u00f6se St\u00f6rungen zielgerichtet. Zentrale Punkte Damit der Einstieg gelingt, fasse ich die wichtigsten Aspekte kurz zusammen. Ressourcen sichtbar machen: Prozesse, Dateien, Verzeichnisse, Ger\u00e4te, Pipes, Sockets. Filter nutzen: nach Prozessname (-c), PID (-p), Benutzer (-u), Datei, Verzeichnis (+d\/+D), Port (-i). Fehler eingrenzen: gesperrte Dateien finden, Portkonflikte aufl\u00f6sen, h\u00e4ngende Dienste zuordnen. Netzwerk pr\u00fcfen: aktive Verbindungen und belegte Ports schnell identifizieren. Workflow straffen: erst eingrenzen, dann gezielt pr\u00fcfen, anschlie\u00dfend handeln. Warum lsof im Alltag z\u00e4hlt Ich nutze lsof, wenn ein Dienst nicht startet, eine Datei \u201ebusy\u201c meldet oder ein Port bereits belegt ist. Das Tool verbindet Datei, Prozess, Benutzer und Netzwerk in einer klaren Sicht. Ich erkenne sofort, welcher PID den Zugriff h\u00e4lt und seit wann. So handle ich statt zu raten und beende den richtigen Prozess, statt versehentlich den falschen Dienst zu stoppen. Gerade auf produktiven Servern gewinne ich damit Minuten bis Stunden, weil ich die Ursache direkt am Prozess festmache. Dieser Ansatz spart Tickets, reduziert Ausf\u00e4lle und schafft belastbare Erkenntnisse. Grundsyntax und Ausgabe verstehen Die Grundform lautet lsof [Optionen] &lt;Ziel&gt; und liefert ohne Parameter alle aktuell offenen Objekte. Auf stark ausgelasteten Systemen filtere ich die Ausgabe, statt mich durch tausende Zeilen zu arbeiten. Wichtig ist, dass Linux \u201eDatei\u201c weit fasst: dazu z\u00e4hlen Verzeichnisse, Ger\u00e4te, Bibliotheken und Netzwerk-Sockets. In der Ausgabe helfen Spalten wie COMMAND, PID, USER, FD, TYPE, NAME. Ich richte meinen Blick zuerst auf FD (Dateideskriptor), TYPE (REG, DIR, IPv4\/6) und NAME mit Pfad oder Portangabe. Wer diese Spalten liest, versteht in kurzer Zeit den aktuellen Systemzustand und ordnet Ressourcen sauber zu Prozessen. Installation und Berechtigungen in der Praxis Auf vielen Distributionen ist lsof nicht vorinstalliert. Ich installiere es daher fr\u00fchzeitig \u00fcber den Paketmanager (apt insta"}},"_wh_make_stage":"entwurf","_wh_make_research_date":"2026-09-22","_wh_make_sitemap_info":{"index":"https:\/\/webhosting.de\/sitemap_index.xml","sitemaps":["https:\/\/webhosting.de\/post-sitemap1.xml","https:\/\/webhosting.de\/post-sitemap2.xml","https:\/\/webhosting.de\/post-sitemap3.xml","https:\/\/webhosting.de\/post-sitemap4.xml"],"url_count":3092,"fetched_at":"2026-09-22T03:42:35+00:00","selected_ids":[20324,18128,20594]},"_wh_make_draft_hash":"bfdaf9e7d44d670e5d156feda1b7015d25a643f1321ba185b7f8fd15d38a8ca1","_wh_make_work":{"version":"2.1","identity":{"sheet_ref":"1VMjxV8Q73i0Q1HO6s-u4jNHVRF0snliGCeg97intLPs","sheet_name":"Tabellenblatt1","external_id":"1386","topic":"Linux procfs f\u00fcr Administratoren \u2013 wichtige Dateien im \u00dcberblick","keywords":["procfs linux","\/proc filesystem","linux administration"],"category_input":"780"},"config":{"research_model":"gpt-5.6-terra","writer_model":"gpt-5.6-terra","review_model":"gpt-5.6-sol","image_model":"gpt-image-2.5-flare","image_quality":"medium","image_format":"webp","final_status":"draft","charts_enabled":true},"phase":"done","pending":null,"receipts":{"71a606c73073acb4042020c3952de4d4":"b009a40f880ed74f6b5c58a57387d8a137ddcd313831b4b7e65b3b6087a873e3","bf5ef0afe81bff06d64e1f2192080095":"bd6119be8c56af22935021629da9b86028c2ef7388132396679f3db5839ddede","23d7b85a19c3a588cf1ae808e44a02d5":"64ecae8725e3c95dffe3e421b8a0de19a8d1c0e5576f82dd46c2b974dd1a1dce","265b0195f2bbd3fe54c408a58c583078":"aab6a20756ff5321fc40862a310de7f77aefe7b7f8a61282bb207c4b29812784","10dd185c9e68e880cbfa341be1017e42":"94f28451bd20d4ad72c4e2180c32bb8b7640443dc3237764503598ba56c4b72f","2b344208a5cdfa03fb14b181daaacab7":"91449995ef6b1bfdf300839ec11234d6ad68916af1c9fdc7dfb150b84e6fe6e0","47b9972c3a85c20d135bb6f77968c58a":"39d8b4bef966e2703db549b06bc5b3cacd5a2f43bee688201a3ded4b6fe1e816","1e91e3d00fd20b26c9ae106396ec02bf":"b9b19889bff8bc7c45288c5cea913db3b6b3c36daf687f7b1be215760e6b63c7","1a13bbea094331829e89c25e79bcbca3":"5b15a2466f705fdb76c37f948bac4ae5c7ab5bfbb512add5307bb8aba06f1eb9","34526c07aeb09223cbe08bd32e68d423":"dc36dbb668a58a0903f4fb7f87cfe4ebf7b573044f95d01457af5c2c8a11ed15","b1c43b362eaa9c6b4a47c5ca0d44df0c":"246dc1a7993f7605763d10eecbb6009de0932af5b0d25a34f7310ed61f1d804e","245b49e67839ba6a8c9166f5f2077523":"a6585bdbd0935af0fe730a94d5f759320610ac3b1aa3e7042997e00919daeb25","e3ab60134a30110be714c49548588248":"be05c9f92fd706c6639d1294e032c30a9630b42042fa49f53ed7d1d70f29ac8d"},"parts":{"1":[{"id":"proc-basics","heading":"procfs verstehen: virtuelle Kernelansicht statt Datenspeicher","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Das ","ref":""},{"kind":"strong","text":"procfs","ref":""},{"kind":"text","text":" ist ein virtuelles Dateisystem: Die Eintr\u00e4ge unter \/proc bilden Datenstrukturen und Zust\u00e4nde des laufenden Linux-Kernels ab. Sie liegen nicht als dauerhaft gespeicherte Inhalte auf einem Datentr\u00e4ger. Beim Lesen erzeugt der Kernel die jeweilige Ansicht aus seinem aktuellen Zustand; nach einem Neustart beginnen etwa viele Z\u00e4hler erneut. Deshalb ist \/proc eine Schnittstelle f\u00fcr Beobachtung und teilweise Steuerung, kein Ort f\u00fcr eigene Dateien oder persistente Konfigurationen. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr die Administration sind drei Bereiche zu unterscheiden. Globale Statusdateien wie \/proc\/meminfo, \/proc\/stat oder \/proc\/loadavg beschreiben den Host beziehungsweise die sichtbare Systeminstanz. Verzeichnisse mit numerischen Namen, etwa \/proc\/1234, liefern Details zu einem einzelnen Prozess. Unter \/proc\/sys liegen dagegen Kernelparameter, die abh\u00e4ngig von Berechtigung und Parameter sowohl lesbar als auch schreibbar sein k\u00f6nnen. Die \u00e4hnliche Dateiform darf nicht dar\u00fcber hinwegt\u00e4uschen, dass Statusabfrage und Konfigurations\u00e4nderung grundverschiedene Folgen haben. ","ref":""},{"kind":"citation","text":"","ref":"S8"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Welche Pfade und Felder vorhanden sind, ist nicht auf jedem Linux-System identisch. Kernelversion und -konfiguration, Architektur, erkannte Hardware sowie geladene Module beeinflussen die sichtbaren Eintr\u00e4ge. Auch ein Prozess- oder anderer Namespace kann die Ansicht begrenzen. Skripte sollten daher Dateien und Felder pr\u00fcfen, bevor sie deren Inhalt auswerten, statt eine vollst\u00e4ndige, \u00fcberall gleiche procfs-Struktur vorauszusetzen. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Davon abzugrenzen ist sysfs unter \/sys: Es stellt vor allem Ger\u00e4te, Treiber und Hardwareobjekte dar. F\u00fcr Ressourcenverteilung und Grenzen von Gruppen ist au\u00dferdem cgroup2 relevant. procfs bleibt jedoch die unmittelbare Quelle f\u00fcr viele Kernel- und Prozesszust\u00e4nde, die bei einer ersten Diagnose ben\u00f6tigt werden. ","ref":""},{"kind":"citation","text":"","ref":"S8"}]}]},{"id":"proc-time-context","heading":"Z\u00e4hler, Momentaufnahmen und Sichtbarkeit richtig einordnen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Der Wert allein erkl\u00e4rt bei procfs selten ein Problem. Zuerst ist sein Zeitbezug zu kl\u00e4ren: Einige Angaben sind ","ref":""},{"kind":"strong","text":"kumulative Z\u00e4hler","ref":""},{"kind":"text","text":" seit Systemstart, andere beschreiben einen aktuellen Zustand, wieder andere bilden gleitende Zeitfenster ab. Ein hoher Z\u00e4hlerstand zeigt zun\u00e4chst nur, dass sich ein Ereignis seit dem Boot summiert hat. Eine Rate entsteht erst aus zwei Messpunkten: Differenz der Werte geteilt durch das dazwischenliegende Zeitintervall. Das gilt beispielsweise f\u00fcr viele CPU-, Interrupt- und Datentr\u00e4gerz\u00e4hler. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Datei \/proc\/uptime liefert die vergangene Betriebsdauer und die aggregierte Idle-Zeit. Sie hilft, Z\u00e4hler seit dem Start zeitlich einzuordnen, ersetzt aber keine Messreihe. Eine einmalige Abfrage ist eine Momentaufnahme; f\u00fcr belastbare Aussagen \u00fcber Trends, Spitzen oder wiederkehrende Last braucht es wiederholte Abfragen mit Zeitstempel. Dabei k\u00f6nnen sich Werte bereits w\u00e4hrend des Lesens ver\u00e4ndern, weil der Kernel weiterarbeitet. ","ref":""},{"kind":"citation","text":"","ref":"S8"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Auch die sichtbaren Daten haben Grenzen. \/proc\/self verweist stets auf den Prozess, der den Pfad gerade aufl\u00f6st. Damit ist er f\u00fcr Skripte und interaktive Pr\u00fcfungen praktisch, ohne eine PID anzunehmen. Der Zugriff auf fremde Prozessverzeichnisse kann jedoch durch Dateirechte, Linux-Capabilities und die procfs-Mount-Option ","ref":""},{"kind":"code","text":"hidepid","ref":""},{"kind":"text","text":" eingeschr\u00e4nkt sein. Fehlende Einblicke sind in diesem Fall kein defektes procfs, sondern ein Schutz gegen das Auslesen sensibler Prozessinformationen. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Besondere Vorsicht gilt in Containern. Eine procfs-Instanz kann an einen PID-Namespace gebunden sein; dann zeigt \/proc nur die Prozesse, die in dieser Namespace-Sicht existieren. Werte und PIDs aus einem Container beschreiben folglich nicht automatisch den gesamten Host. Vor jeder Diagnose ist daher zu kl\u00e4ren, ob die Shell auf dem Host, in einer VM oder in einem Container l\u00e4uft. ","ref":""},{"kind":"citation","text":"","ref":"S8"}]}]},{"id":"proc-sysctl-boundary","heading":"Lesen, konfigurieren und absichern unter \/proc\/sys","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Der Bereich ","ref":""},{"kind":"strong","text":"\/proc\/sys","ref":""},{"kind":"text","text":" ist die Dateisystemansicht der sysctl-Schnittstelle. Das Lesen eines Werts dient der Diagnostik. Ein Schreibzugriff ver\u00e4ndert dagegen unmittelbar das Verhalten des laufenden Kernels und kann Dienste, Ressourcenverbrauch oder Sicherheitsmerkmale beeinflussen. Dass eine \u00c4nderung ohne Neustart wirkt, macht sie nicht risikolos und auch nicht automatisch dauerhaft: Persistenz h\u00e4ngt von der gew\u00e4hlten Systemkonfiguration ab. ","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Verzeichnisstruktur erleichtert die erste Einordnung. Unter \/proc\/sys\/fs stehen unter anderem globale Dateisystem- und File-Handle-Parameter. \/proc\/sys\/vm b\u00fcndelt Einstellungen der Speicherverwaltung, w\u00e4hrend \/proc\/sys\/net netzwerkbezogene Parameter enth\u00e4lt. Welche Unterverzeichnisse und Schl\u00fcssel verf\u00fcgbar sind, h\u00e4ngt wiederum von Kernelkonfiguration und Funktionen des Systems ab. Ein vorhandener Parameter ist daher kein allgemeines Tuning-Rezept; seine Dokumentation und der konkrete Workload sind ma\u00dfgeblich. ","ref":""},{"kind":"citation","text":"","ref":"S10"},{"kind":"citation","text":"","ref":"S11"},{"kind":"citation","text":"","ref":"S12"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Ein Gegenbeispiel f\u00fcr scheinbare Optimierung ist ","ref":""},{"kind":"code","text":"drop_caches","ref":""},{"kind":"text","text":" unter \/proc\/sys\/vm. Die Kernel-Dokumentation ordnet die Funktion Debugging und Tests zu und r\u00e4t von einem Einsatz au\u00dferhalb solcher Zwecke ab, weil das Leeren wiederverwendbarer Caches Leistung kosten kann. Wenig freier Speicher ist f\u00fcr sich genommen kein Grund, Caches zu verwerfen: Der Kernel nutzt RAM bewusst auch f\u00fcr Dateicache. ","ref":""},{"kind":"citation","text":"","ref":"S11"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Vor jeder \u00c4nderung sollte eine nachvollziehbare Ursache vorliegen. Sichere zuerst den Ausgangswert, dokumentiere Zweck und erwartete Nebenwirkungen, \u00e4ndere kontrolliert und beobachte anschlie\u00dfend passende Messwerte sowie Dienstverhalten. Plane den R\u00fcckweg vorab und \u00fcbernimm einen Wert erst nach fachlicher Pr\u00fcfung in eine dauerhafte Konfiguration. Weiterf\u00fchrende Grundlagen zu Parametern und ihrer kontrollierten Verwaltung behandelt der Beitrag ","ref":""},{"kind":"internal_link","text":"Kernel-Tuning im Linux-Hosting: Sysctl-Parameter im \u00dcberblick","ref":"I2"},{"kind":"text","text":".","ref":""}]}]}],"2":[{"id":"proc-overview-table","heading":"Die wichtigsten procfs-Dateien nach Administrationsaufgabe","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Die Auswahl einer procfs-Datei sollte von der Administrationsfrage ausgehen, nicht von einer m\u00f6glichst vollst\u00e4ndigen Verzeichnisliste. Globale Dateien beschreiben den Host oder den sichtbaren Namespace, Prozesspfade einen einzelnen Prozess, und Eintr\u00e4ge unter \/proc\/sys\/fs liefern Konfiguration und systemweite Grenzen. Einige Werte sind aktuelle Zust\u00e4nde, andere seit dem Boot kumulierte Z\u00e4hler oder gleitende Durchschnitte. Diese Unterscheidung entscheidet dar\u00fcber, ob ein einzelnes Auslesen gen\u00fcgt oder zwei Messpunkte n\u00f6tig sind.","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"table","caption":"Wichtige procfs-Dateien f\u00fcr typische Verwaltungsfragen","headers":["Pfad","Zweck","Typische Frage","Datencharakter","Wichtige Einschr\u00e4nkung","Sichere Leseabfrage"],"rows":[["\/proc\/loadavg","Systemlast","Sind Aufgaben wartend?","1-, 5-, 15-Minuten-Mittel","Keine reine CPU-Auslastung","cat \/proc\/loadavg"],["\/proc\/stat","CPU- und Kernelz\u00e4hler","Wie verteilen sich CPU-Zeiten?","Seit Boot kumuliert","iowait nicht isoliert bewerten","grep -E '^(cpu|intr|ctxt|processes)' \/proc\/stat"],["\/proc\/meminfo","Speicher\u00fcbersicht","Ist Speicher verf\u00fcgbar?","Aktuelle Speicherwerte","MemFree allein gen\u00fcgt nicht","cat \/proc\/meminfo"],["\/proc\/pressure\/cpu","CPU-Stalls","Warten Tasks auf CPU?","Zeitfenster und Z\u00e4hler","full kann systemweit null sein","cat \/proc\/pressure\/cpu"],["\/proc\/pressure\/memory","Speicherdruck","Blockiert Speicherknappheit Tasks?","Zeitfenster und Z\u00e4hler","PSI muss verf\u00fcgbar sein","cat \/proc\/pressure\/memory"],["\/proc\/pressure\/io","I\/O-Stalls","Warten Tasks auf I\/O?","Zeitfenster und Z\u00e4hler","Kein Ersatz f\u00fcr Ger\u00e4teanalyse","cat \/proc\/pressure\/io"],["\/proc\/<PID>\/status","Prozessstatus","Wie gro\u00df und aktiv ist ein Prozess?","Aktuelle Prozessdaten","Rechte k\u00f6nnen Zugriff begrenzen","cat \/proc\/$$\/status"],["\/proc\/<PID>\/fd","Offene Deskriptoren","Welche Objekte h\u00e4lt ein Prozess?","Aktuelle symbolische Links","Viele FDs sind nicht automatisch ein Leck","ls -l \/proc\/$$\/fd"],["\/proc\/<PID>\/maps","Virtuelle Mappings","Welche Bereiche hat ein Prozess eingebunden?","Aktuelle Mappingliste","F\u00fcr die Erstanalyse oft zu umfangreich","cat \/proc\/$$\/maps"],["\/proc\/diskstats","Blockger\u00e4te-I\/O","Welche Ger\u00e4te arbeiten?","Seit Boot kumuliert","Raten erfordern zwei Stichproben","cat \/proc\/diskstats"],["\/proc\/sys\/fs\/file-nr","File-Handle-Nutzung","Wie viele Handles nutzt das System?","Aktueller Z\u00e4hler und Grenze","Mittleres Feld ist auf modernen Linux-Systemen null","cat \/proc\/sys\/fs\/file-nr"],["\/proc\/sys\/fs\/file-max","File-Handle-Grenze","Welche globale Obergrenze gilt?","Aktiver Parameter","Nicht mit Prozesslimit verwechseln","cat \/proc\/sys\/fs\/file-max"]],"source_ids":["S1","S3","S4","S5","S6","S7","S9","S10"]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Tabelle ist eine Einstiegshilfe, keine Diagnosekette. Ein auff\u00e4lliger Wert verlangt stets ein unabh\u00e4ngiges Gegenzeichen: Load mit CPU- und I\/O-Daten, Speicherwerte mit Pressure Stall Information und Prozessgr\u00f6\u00dfen mit dem Verhalten des Dienstes. Besonders \/proc\/diskstats und \/proc\/stat sind ","ref":""},{"kind":"strong","text":"kumulative Z\u00e4hler","ref":""},{"kind":"text","text":"; ihre Differenz \u00fcber ein bekanntes Intervall ist f\u00fcr Raten aussagekr\u00e4ftiger als der absolute Stand. Die folgenden Abschnitte ordnen die Signale deshalb nach Last, Speicher, Prozessen und I\/O ein.","ref":""}]}]},{"id":"proc-load-memory","heading":"Last, CPU und Speicher: Signale kombiniert bewerten","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Bei einer langsamen Anwendung ist \/proc\/loadavg ein sinnvoller Start, aber kein Urteil \u00fcber die CPU. Die drei Werte bilden die durchschnittliche Last der letzten 1, 5 und 15 Minuten ab. In die Last gehen nicht nur laufbereite Einheiten im Zustand R ein, sondern auch Tasks im ununterbrechbaren Wartezustand D, etwa bei I\/O. Das vierte Feld zeigt die aktuell ausf\u00fchrbaren gegen\u00fcber allen existierenden Scheduling-Einheiten. Hoher ","ref":""},{"kind":"strong","text":"Load Average","ref":""},{"kind":"text","text":" kann daher auf CPU-Konkurrenz, blockierte I\/O-Zugriffe oder beides hinweisen.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"code","language":"sh","code":"cat \/proc\/loadavg\ngrep -E '^(cpu|intr|ctxt|processes)' \/proc\/stat\ncat \/proc\/meminfo\ncat \/proc\/pressure\/memory","source_ids":["S3","S4","S5","S6"]},{"type":"paragraph","runs":[{"kind":"text","text":"Die CPU-Zeilen aus \/proc\/stat enthalten Zeitanteile seit dem Systemstart in USER_HZ. Um daraus Auslastungsanteile zu ermitteln, m\u00fcssen zwei Abfragen verglichen werden; ein einzelner Stand zeigt nur angesammelte Zeit. Der Wert iowait ist dabei kein unmittelbares Latenzma\u00df f\u00fcr Storage: Seine Berechnung hat dokumentierte Grenzen und kann unter bestimmten Umst\u00e4nden sogar sinken. F\u00fcr eine I\/O-Ursache sind daher zus\u00e4tzlich Ger\u00e4tewerte und I\/O-PSI sinnvoll.","ref":""},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Auch ein niedriger Wert bei MemFree beweist noch keine RAM-Not. Linux nutzt unbenutzten Arbeitsspeicher gezielt f\u00fcr Cache. MemAvailable sch\u00e4tzt, wie viel Speicher neue Anwendungen voraussichtlich ohne Swapping erhalten k\u00f6nnen, und ist f\u00fcr die erste Einordnung meist hilfreicher. Erst wenn MemAvailable knapp wird und gleichzeitig Speicher-Stalls auftreten, verdichtet sich der Hinweis auf ","ref":""},{"kind":"strong","text":"Speicherdruck","ref":""},{"kind":"text","text":".","ref":""},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Dateien unter \/proc\/pressure erg\u00e4nzen diese Sicht: some bedeutet, dass wenigstens einige Tasks w\u00e4hrend eines Anteils des Zeitfensters nicht weiterkamen; full steht f\u00fcr einen Zustand, in dem alle nicht-idlen Tasks gleichzeitig blockiert waren. Die Angaben avg10, avg60 und avg300 beziehen sich auf 10, 60 und 300 Sekunden, total ist ein kumulierter Stall-Z\u00e4hler. CPU-, memory- und io-PSI beantworten unterschiedliche Fragen und sollten nicht gegeneinander ausgetauscht werden.","ref":""},{"kind":"citation","text":"","ref":"S6"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Reagiert ein Dienst bei geringem MemFree langsam, pr\u00fcfst du zun\u00e4chst MemAvailable und \/proc\/pressure\/memory. Sind beide unauff\u00e4llig, spricht das gegen akuten systemweiten Speicherdruck. Anschlie\u00dfend kann \/proc\/<PID>\/status zeigen, ob der betroffene Prozess etwa ungew\u00f6hnlich viel VmRSS belegt, viele Threads hat oder in einem auff\u00e4lligen State steht. Diese Kombination trennt eine Cache-lastige, aber normale Speichernutzung von einem Problem, das weitere Prozessanalyse verlangt.","ref":""},{"kind":"citation","text":"","ref":"S7"}]}]},{"id":"proc-process-io","heading":"Prozesse, Dateideskriptoren und Datentr\u00e4ger-I\/O untersuchen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr eine sichere \u00dcbung mit einem garantiert vorhandenen Prozess steht $$ f\u00fcr die PID der aktuellen Shell. Die status-Datei ist menschenlesbarer als die feldorientierte stat-Datei. Name identifiziert den Prozess, State seinen Zustand, PPid den Elternprozess und Threads die Thread-Anzahl. VmRSS beschreibt den aktuell im RAM residenten Anteil; VmSize ist dagegen virtueller Adressraum. FDSize beschreibt die Gr\u00f6\u00dfe der Deskriptortabelle, nicht zwingend die Zahl aktuell offener Eintr\u00e4ge. Freiwillige und unfreiwillige Kontextwechsel k\u00f6nnen bei der Einordnung von Scheduling-Verhalten helfen, sind allein aber kein Fehlerbeweis.","ref":""},{"kind":"citation","text":"","ref":"S7"}]},{"type":"code","language":"sh","code":"cat \/proc\/$$\/status\nls -l \/proc\/$$\/fd","source_ids":["S7","S1"]},{"type":"paragraph","runs":[{"kind":"text","text":"Das fd-Verzeichnis enth\u00e4lt symbolische Links auf offene Dateien, Pipes, Ger\u00e4te oder Sockets. Es hilft etwa, einen Prozess zu finden, der eine gel\u00f6schte Logdatei weiterhin ge\u00f6ffnet h\u00e4lt. Eine gro\u00dfe Zahl offener Dateideskriptoren ist jedoch bei Proxys, Datenbanken oder ereignisorientierten Servern durchaus erwartbar. F\u00fcr gefilterte Ansichten und die Zuordnung \u00fcber Prozesse hinweg ist ","ref":""},{"kind":"internal_link","text":"lsof zur Analyse offener Dateien einsetzen","ref":"I3"},{"kind":"text","text":" eine passende Erg\u00e4nzung. Kommandozeilen aus cmdline k\u00f6nnen vertrauliche Argumente preisgeben; environ ist wegen m\u00f6glicher Zugangsdaten oder Tokens noch sensibler und keine Routineabfrage.","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"maps listet virtuelle Speicherbereiche mit Berechtigungen, Offset, Ger\u00e4t, Inode und gegebenenfalls Pfad. smaps erg\u00e4nzt je Mapping detaillierte Speicherwerte. Beide Dateien sind f\u00fcr vertiefte Speicheranalysen gedacht: Ihre Ausgabe kann gro\u00df sein, und die Interpretation einzelner Mappings erfordert Kontext. F\u00fcr den ersten Blick sind status und die systemweiten Speicher- und PSI-Dateien meist effizienter.","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei hohem Load und geringer CPU-Auslastung erweitert \/proc\/diskstats die Diagnose um die Ger\u00e4teebene. Die Datei f\u00fchrt pro Blockger\u00e4t kumulative I\/O-Statistiken. Um Aktivit\u00e4t als Rate zu bewerten, m\u00fcssen zwei Zeitpunkte verglichen werden. Dabei sind physische Laufwerke, Partitionen und virtuelle oder Device-Mapper-Ger\u00e4te sauber zu unterscheiden; Z\u00e4hler verschiedener Ebenen d\u00fcrfen nicht blind addiert werden. Zusammen mit \/proc\/pressure\/io l\u00e4sst sich so pr\u00fcfen, ob beobachtbare I\/O-Stalls und Ger\u00e4teaktivit\u00e4t zeitlich zusammenfallen.","ref":""},{"kind":"citation","text":"","ref":"S9"}]}]}],"3":[{"id":"proc-monitoring","heading":"procfs im Betrieb: Abfragen, Monitoring und Datenschutz","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr wiederholbare Betriebsdiagnosen behandelst du procfs-Abfragen als Messpunkte: Du notierst Zeitstempel, Systemkontext und die konkrete Abfrage. Viele Werte sind seit dem Start kumulierte Z\u00e4hler; erst die Differenz zweier Werte geteilt durch das Zeitintervall ergibt eine Rate. Das gilt etwa f\u00fcr Z\u00e4hler aus ","ref":""},{"kind":"code","text":"\/proc\/diskstats","ref":""},{"kind":"text","text":". Eine Einzelabfrage kann daher Aktivit\u00e4t belegen, aber weder Durchsatz noch eine dauerhafte Verschlechterung zuverl\u00e4ssig quantifizieren. ","ref":""},{"kind":"citation","text":"","ref":"S9"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Ein Monitoring-System sollte in festen Intervallen unter anderem Speicherwerte aus ","ref":""},{"kind":"code","text":"\/proc\/meminfo","ref":""},{"kind":"text","text":", Ger\u00e4tewerte aus ","ref":""},{"kind":"code","text":"\/proc\/diskstats","ref":""},{"kind":"text","text":", Prozess- und Systemzust\u00e4nde sowie bei verf\u00fcgbarer Kernelunterst\u00fctzung Drucksignale erfassen. Es muss Rohwerte in passende Einheiten umrechnen, bei Z\u00e4hlern Differenzen bilden und Historien speichern. Erst zeitliche Verl\u00e4ufe erlauben belastbare Schwellenwerte: Ein hoher Wert kann normal sein, wenn er zum erwarteten Lastfenster passt; ein pl\u00f6tzlicher Anstieg gegen\u00fcber der eigenen Baseline ist oft relevanter. Die verf\u00fcgbaren procfs-Eintr\u00e4ge h\u00e4ngen vom laufenden Kernel und seiner Konfiguration ab. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Direkte Dateien und Werkzeuge erg\u00e4nzen sich. ","ref":""},{"kind":"code","text":"ps","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"top","ref":""},{"kind":"text","text":" oder ","ref":""},{"kind":"code","text":"htop","ref":""},{"kind":"text","text":" eignen sich f\u00fcr die interaktive Prozesssicht; ","ref":""},{"kind":"code","text":"free","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"vmstat","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"iostat","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"pidstat","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"ss","ref":""},{"kind":"text","text":" und ","ref":""},{"kind":"code","text":"sar","ref":""},{"kind":"text","text":" bereiten je nach Installation Daten f\u00fcr bestimmte Fragen auf. procfs bleibt sinnvoll, wenn du die Kernelquelle direkt pr\u00fcfen oder ein kleines, nachvollziehbares Skript bauen m\u00f6chtest. F\u00fcr Alarmierung und Kapazit\u00e4tsplanung sind Zeitreihendaten meist die passendere Ebene.","ref":""}]},{"type":"callout","variant":"warning","title":"Prozessdaten nicht unbedacht weitergeben","runs":[{"kind":"text","text":"Kommandozeilen k\u00f6nnen Pfade, Mandantenkennungen oder versehentlich \u00fcbergebene Zugangsdaten enthalten. Umgebungsvariablen eines Prozesses sind h\u00e4ufig noch sensibler. Erfasse, speichere und teile diese Daten nur, wenn sie f\u00fcr die Diagnose erforderlich sind; beschr\u00e4nke Zugriffe auf berechtigte Personen.","ref":""}]},{"type":"paragraph","runs":[{"kind":"text","text":"Auch bei rein lesenden Abfragen gelten Sichtbarkeitsgrenzen. Zugriffsrechte, Mount-Optionen und PID-Namespaces k\u00f6nnen Prozessdaten ausblenden oder auf eine Containeransicht begrenzen. Ein fehlender Eintrag ist deshalb nicht automatisch ein fehlendes Problem auf dem Host, sondern zun\u00e4chst ein Hinweis darauf, die Ausf\u00fchrungsumgebung zu kl\u00e4ren. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]}]},{"id":"proc-troubleshooting","heading":"Diagnosepfade f\u00fcr langsame Dienste und Ressourcenengp\u00e4sse","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Troubleshooting beginnt mit einem Symptom, nicht mit einem vermeintlich schuldigen Einzelwert. Pr\u00fcfe danach mindestens ein unabh\u00e4ngiges Signal und halte fest, ob die Beobachtung den Host, eine virtuelle Maschine oder einen Container betrifft. So vermeidest du beispielsweise, einen hohen Load vorschnell als CPU-Problem oder eine gro\u00dfe Zahl offener Deskriptoren vorschnell als Leck zu bewerten. Die folgenden Pfade sind lesende Erstdiagnosen und ersetzen keine anwendungsbezogenen Logs.","ref":""}]},{"type":"table","caption":"Kompakte Diagnosepfade mit procfs","headers":["Symptom","Zuerst lesen","Danach abgleichen","Fehlinterpretation vermeiden"],"rows":[["Hoher Load","\/proc\/loadavg","\/proc\/stat, \/proc\/pressure\/io, \/proc\/diskstats","Load umfasst laufbereite und ununterbrechbar wartende Tasks, nicht nur CPU-Arbeit."],["Vermuteter Speicherdruck","\/proc\/meminfo","\/proc\/pressure\/memory, \/proc\/<PID>\/status","Niedriges MemFree allein beweist keinen RAM-Mangel; MemAvailable und Stalls z\u00e4hlen mit."],["Auff\u00e4llige I\/O-Wartezeit","\/proc\/stat","\/proc\/pressure\/io, \/proc\/diskstats in zwei Messpunkten","iowait ist keine direkte Latenzmessung und hat dokumentierte Einschr\u00e4nkungen."],["Viele offene Dateien","\/proc\/sys\/fs\/file-nr und \/proc\/sys\/fs\/file-max","\/proc\/<PID>\/fd, Dienstverhalten","Viele Deskriptoren k\u00f6nnen f\u00fcr einen Server normal sein; Grenzen und Wachstum sind wichtiger."],["Dienst startet nicht","\/proc\/<PID>\/status, sofern ein Prozess entsteht","\/proc\/<PID>\/fd, Dienstjournal, belegte Ressourcen","Ein nicht sichtbarer Prozess kann beendet sein oder au\u00dferhalb des sichtbaren PID-Namespace laufen."]],"source_ids":["S1","S3","S4","S5","S6","S9","S10"]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei hoher Load Average pr\u00fcfst du zun\u00e4chst, ob ausf\u00fchrbare oder wartende Aufgaben die Zahl treiben. Die Load-Angaben bilden Durchschnittswerte \u00fcber ein, f\u00fcnf und 15 Minuten ab und ber\u00fccksichtigen sowohl R- als auch D-Zust\u00e4nde. Vergleiche deshalb CPU-Zeitfelder nur mit Vorsicht mit I\/O-Druck und Ger\u00e4teaktivit\u00e4t. Insbesondere ","ref":""},{"kind":"strong","text":"iowait","ref":""},{"kind":"text","text":" darf nicht isoliert als Speicherlatenz gelesen werden. ","ref":""},{"kind":"citation","text":"","ref":"S3"},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei einer langsamen Anwendung und kleinem MemFree ist ","ref":""},{"kind":"strong","text":"MemAvailable","ref":""},{"kind":"text","text":" der bessere erste Kontextwert. Erg\u00e4nze Speicher-PSI und den Status des betroffenen Prozesses, etwa dessen VmRSS, Threadzahl und Zustand. PSI unterscheidet bei Speicher und I\/O zwischen ","ref":""},{"kind":"code","text":"some","ref":""},{"kind":"text","text":" f\u00fcr teilweise blockierte Tasks und ","ref":""},{"kind":"code","text":"full","ref":""},{"kind":"text","text":" f\u00fcr vollst\u00e4ndige Blockierung nicht-idler Tasks. Fehlen PSI-Dateien, kann dies an Kernelkonfiguration oder Umgebung liegen; es widerlegt keinen Engpass. ","ref":""},{"kind":"citation","text":"","ref":"S5"},{"kind":"citation","text":"","ref":"S6"}]},{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr Datei- und Prozessdiagnosen k\u00f6nnen Rechte und ","ref":""},{"kind":"strong","text":"PID-Namespaces","ref":""},{"kind":"text","text":" die Aussagekraft einschr\u00e4nken. In Containern beschreibt \/proc h\u00e4ufig nur die zugeordnete Prozesswelt. Bei verweigertem Zugriff oder unvollst\u00e4ndigen Verzeichnissen pr\u00fcfst du daher Nutzerrechte, procfs-Mount-Optionen und den Namespace-Kontext, bevor du aus der Abwesenheit von Daten eine technische Schlussfolgerung ziehst. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]}]},{"id":"proc-decisions","heading":"Typische Fehlannahmen korrigieren und passende Werkzeuge w\u00e4hlen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Vier Kurzschl\u00fcsse f\u00fchren in der Linux-Administration h\u00e4ufig zu falschen Ma\u00dfnahmen. Wenig ","ref":""},{"kind":"code","text":"MemFree","ref":""},{"kind":"text","text":" bedeutet nicht automatisch RAM-Not, weil der Kernel Speicher unter anderem als Cache nutzt; f\u00fcr neue Anwendungen ist MemAvailable die aussagekr\u00e4ftigere Sch\u00e4tzung. Hoher Load beweist keine CPU-S\u00e4ttigung, da auch ununterbrechbar wartende Aufgaben einflie\u00dfen. Ein hoher iowait-Anteil misst keine unmittelbare Latenz eines Datentr\u00e4gers. Und procfs ist nicht \u00fcberall identisch: Kernelversion, Konfiguration, Hardware, Module und Namespaces beeinflussen Dateien und Felder. ","ref":""},{"kind":"citation","text":"","ref":"S1"},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"W\u00e4hle die Methode nach der Frage. F\u00fcr eine punktuelle Ursachenanalyse liefert ","ref":""},{"kind":"strong","text":"procfs","ref":""},{"kind":"text","text":" unmittelbare Rohdaten des laufenden Kernels. F\u00fcr eine schnelle, menschenlesbare \u00dcbersicht sind spezialisierte Kommandozeilenwerkzeuge meist effizienter. Wenn Trends, Alarmierung oder Kapazit\u00e4tsentscheidungen z\u00e4hlen, ben\u00f6tigst du ein Monitoring, das Messpunkte zeitlich einordnet, Z\u00e4hlerdifferenzen berechnet und historische Vergleichswerte vorh\u00e4lt. Bei Ressourcenlimits einzelner Dienste oder Container erg\u00e4nzt eine Analyse auf cgroup-Ebene die globale Hostansicht; PSI kann bei passender Konfiguration auch pro cgroup verf\u00fcgbar sein. ","ref":""},{"kind":"citation","text":"","ref":"S6"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Besondere Zur\u00fcckhaltung gilt f\u00fcr ","ref":""},{"kind":"code","text":"\/proc\/sys","ref":""},{"kind":"text","text":". Das Lesen eines Parameters ist Diagnostik, das Schreiben ver\u00e4ndert aktives Kernelverhalten. \u00c4ndere einen Wert nur, wenn die Ursache verstanden ist, der Ausgangswert dokumentiert wurde, Auswirkungen beobachtbar sind und ein R\u00fcckweg feststeht. Die Verzeichnisse ","ref":""},{"kind":"code","text":"fs","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"vm","ref":""},{"kind":"text","text":" und ","ref":""},{"kind":"code","text":"net","ref":""},{"kind":"text","text":" ordnen Parameter thematisch, liefern aber keine universellen Tuningvorgaben. ","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Das Beispiel ","ref":""},{"kind":"code","text":"drop_caches","ref":""},{"kind":"text","text":" zeigt den Unterschied zwischen Eingriff und Optimierung: Die Kernel-Dokumentation beschreibt die Schnittstelle als nicht destruktiv, warnt jedoch vor Leistungsproblemen und empfiehlt sie nicht als regul\u00e4re Betriebsma\u00dfnahme au\u00dferhalb von Test- oder Debug-Szenarien. Eine konservative Regel lautet daher: Erst messen, dann eine begr\u00fcndete \u00c4nderung begrenzt vornehmen, Wirkung und Nebenwirkungen beobachten und die Entscheidung dokumentieren. ","ref":""},{"kind":"citation","text":"","ref":"S11"}]}]}]},"plan":{"reader_question":"Welche Informationen liefert das \/proc filesystem bei der Linux-Administration, wie lassen sich die wichtigsten Dateien sicher lesen und wie sind ihre Werte einzuordnen?","sections":[{"id":"proc-basics","heading":"procfs verstehen: virtuelle Kernelansicht statt Datenspeicher","part":1,"target_words":270,"purpose":"Erkl\u00e4rt \/proc als virtuelles Dateisystem des laufenden Kernels und grenzt es von persistenten Dateien ab. Ordnet globale Statusdateien, Prozessverzeichnisse und \/proc\/sys als unterschiedliche Schnittstellen ein. Beschreibt, warum Eintr\u00e4ge je nach Kernelversion, Konfiguration, Hardware, Modulen und Namespace variieren k\u00f6nnen, und grenzt procfs knapp von sysfs sowie cgroup2 ab.","source_ids":["S1","S8"],"internal_link_ids":[]},{"id":"proc-time-context","heading":"Z\u00e4hler, Momentaufnahmen und Sichtbarkeit richtig einordnen","part":1,"target_words":270,"purpose":"Vermittelt die n\u00f6tige Leselogik vor einzelnen Dateien: Werte k\u00f6nnen seit Systemstart kumulieren, einen aktuellen Zustand zeigen oder gleitende Zeitfenster abbilden. Erkl\u00e4rt mit \/proc\/uptime, weshalb zwei Abfragen f\u00fcr Raten n\u00f6tig sind. Behandelt Rechte, hidepid, Linux-Capabilities, \/proc\/self und PID-Namespaces als Grenzen der sichtbaren Prozesswelt.","source_ids":["S1","S8"],"internal_link_ids":[]},{"id":"proc-sysctl-boundary","heading":"Lesen, konfigurieren und absichern unter \/proc\/sys","part":1,"target_words":270,"purpose":"Trennt reine Diagnostik klar vom Schreiben nach \/proc\/sys, das aktives Kernelverhalten ver\u00e4ndert. Erkl\u00e4rt die thematischen Bereiche fs, vm und net, ohne pauschale Tuningwerte zu empfehlen. Nutzt drop_caches als Gegenbeispiel f\u00fcr vermeintliche Optimierungen und formuliert Voraussetzungen f\u00fcr \u00c4nderungen: Ursache verstehen, Ausgangswert sichern, Auswirkungen pr\u00fcfen und R\u00fcckweg planen.","source_ids":["S2","S10","S11","S12"],"internal_link_ids":["I2"]},{"id":"proc-overview-table","heading":"Die wichtigsten procfs-Dateien nach Administrationsaufgabe","part":2,"target_words":280,"purpose":"Enth\u00e4lt die zentrale informative Tabelle mit den Spalten Pfad, Zweck, typische Frage, Datencharakter, wichtige Einschr\u00e4nkung und sichere Leseabfrage. Sie umfasst mindestens \/proc\/loadavg, \/proc\/stat, \/proc\/meminfo, die drei PSI-Dateien, \/proc\/<PID>\/status, \/proc\/<PID>\/fd, \/proc\/<PID>\/maps, \/proc\/diskstats sowie \/proc\/sys\/fs\/file-nr und file-max. Leitet anschlie\u00dfend zur aufgabengeleiteten Detailanalyse \u00fcber.","source_ids":["S1","S3","S4","S5","S6","S7","S9","S10"],"internal_link_ids":[]},{"id":"proc-load-memory","heading":"Last, CPU und Speicher: Signale kombiniert bewerten","part":2,"target_words":280,"purpose":"Zeigt sichere Lesebeispiele f\u00fcr \/proc\/loadavg, ausgew\u00e4hlte Zeilen aus \/proc\/stat und \/proc\/meminfo. Erkl\u00e4rt die Load Average mit R- und D-Tasks, USER_HZ bei CPU-Zeiten, die Einschr\u00e4nkungen von iowait sowie MemAvailable als Sch\u00e4tzung. Erg\u00e4nzt PSI f\u00fcr CPU-, Speicher- und I\/O-Stalls mit some und full. Praxisfall: Eine langsame Anwendung bei niedrigem MemFree wird \u00fcber MemAvailable, memory PSI und Prozessstatus eingeordnet.","source_ids":["S3","S4","S5","S6","S7"],"internal_link_ids":[]},{"id":"proc-process-io","heading":"Prozesse, Dateideskriptoren und Datentr\u00e4ger-I\/O untersuchen","part":2,"target_words":280,"purpose":"Erkl\u00e4rt die Abfrage des aktuellen Shell-Prozesses \u00fcber \/proc\/$$\/status und \/proc\/$$\/fd. Ordnet Name, State, PPid, Threads, VmRSS, FDSize und Kontextwechsel in status ein; behandelt cmdline und besonders environ als potenziell vertrauliche Daten. Stuft maps und smaps als vertiefende, umfangreiche Speicheranalyse ein. Erkl\u00e4rt diskstats als kumulative Ger\u00e4tewerte und unterscheidet physische Ger\u00e4te, Partitionen und virtuelle Ger\u00e4te. Verkn\u00fcpft dies mit dem Fall hoher Load bei geringer CPU-Auslastung.","source_ids":["S1","S7","S9"],"internal_link_ids":["I3"]},{"id":"proc-monitoring","heading":"procfs im Betrieb: Abfragen, Monitoring und Datenschutz","part":3,"target_words":260,"purpose":"\u00dcbertr\u00e4gt procfs in wiederholbare Betriebsabl\u00e4ufe: Nur-Lese-Abfragen, Zeitstempel und zwei Messpunkte f\u00fcr Raten. Erkl\u00e4rt, welche Daten ein Monitoring-System in Intervallen erfassen und wie es Differenzen, Einheiten, Historien und Schwellenwerte aufbereiten muss. Ordnet procfs gegen\u00fcber ps, top beziehungsweise htop, free, vmstat, iostat, pidstat, ss und sar ein. Betont den sorgf\u00e4ltigen Umgang mit Kommandozeilen, Umgebungen und Prozessdaten.","source_ids":["S1","S5","S9"],"internal_link_ids":[]},{"id":"proc-troubleshooting","heading":"Diagnosepfade f\u00fcr langsame Dienste und Ressourcenengp\u00e4sse","part":3,"target_words":260,"purpose":"Enth\u00e4lt eine zweite, kompakte Tabelle mit Symptom, zuerst lesen, danach abgleichen und zu vermeidender Fehlinterpretation. Behandelt mindestens hohen Load, vermuteten Speicherdruck, auff\u00e4llige I\/O-Wartezeiten, viele offene Dateien und einen nicht startenden Dienst. Die Abl\u00e4ufe f\u00fchren von einem Symptom zu mehreren unabh\u00e4ngigen Signalen und benennen ausdr\u00fccklich, wann Rechte, Containergrenzen oder fehlende Kerneloptionen die Diagnoseansicht begrenzen.","source_ids":["S1","S3","S4","S5","S6","S9","S10"],"internal_link_ids":[]},{"id":"proc-decisions","heading":"Typische Fehlannahmen korrigieren und passende Werkzeuge w\u00e4hlen","part":3,"target_words":260,"purpose":"Fasst die entscheidenden Grenzen zusammen: wenig MemFree ist nicht automatisch RAM-Not, hoher Load beweist keine CPU-S\u00e4ttigung, iowait ist keine direkte Latenzmessung und procfs ist nicht auf jedem System identisch. Formuliert Entscheidungskriterien f\u00fcr direkte procfs-Analyse, Spezialwerkzeuge, Zeitreihenmonitoring und vertiefte cgroup-Analyse. Schlie\u00dft mit einer konservativen Regel f\u00fcr \/proc\/sys: nur begr\u00fcndet \u00e4ndern, Wirkung beobachten und \u00c4nderungen dokumentieren.","source_ids":["S1","S2","S4","S6","S11"],"internal_link_ids":[]}]},"repairs":1,"reviews":2,"issues":[],"guard":{"content_md5":"fe641734889fa48edfed948b0aab44cc","title":"Linux procfs for Administrators: An Overview of Important Files","slug":"linux-procfs-for-administrators","excerpt":"procfs provides direct insight into the running Linux kernel. This guide explains important files under \/proc, categorizes counters and snapshots, and outlines safe diagnostic paths for load, memory, processes, I\/O, and sysctl parameters.","status":"draft","featured_media":21652},"verify":{"content_md5":"fe641734889fa48edfed948b0aab44cc","title":"Linux procfs for Administrators: An Overview of Important Files","slug":"linux-procfs-for-administrators","excerpt":"procfs provides direct insight into the running Linux kernel. This guide explains important files under \/proc, categorizes counters and snapshots, and outlines safe diagnostic paths for load, memory, processes, I\/O, and sysctl parameters.","status":"draft","featured_media":21652},"row_number":1880,"created_at":"2026-09-22T06:47:00+00:00","updated_at":"2026-09-22T06:54:07+00:00","verified_at":"2026-09-22T06:54:03+00:00"},"_wh_make_research":"Recherche-Briefing: Linux procfs f\u00fcr Administratoren \u2013 wichtige Dateien im \u00dcberblick\n\nStand der Recherche: 22. September 2026. Zielumfang des sp\u00e4teren Fachartikels: 2.400 bis 2.700 W\u00f6rter.\n\nLeserfrage und Artikelziel\n\nDer Artikel beantwortet die praktische Frage: Welche Informationen liefert das \/proc filesystem bei der Linux-Administration, wie lassen sich die wichtigsten Dateien sicher lesen und wie sind ihre Werte einzuordnen?\n\nDer Schwerpunkt sollte nicht auf einer vollst\u00e4ndigen Liste aller Eintr\u00e4ge liegen. Sinnvoller ist eine Orientierung nach Administrationsaufgaben: Systemlast, CPU, Arbeitsspeicher, Prozesse, offene Dateien, Datentr\u00e4ger-I\/O, Netzwerk sowie Laufzeitparameter unter \/proc\/sys. Leser sollen nach dem Artikel wissen, welche Dateien bei einem konkreten Symptom als Erstes relevant sind, welche Werte nur Momentaufnahmen darstellen und wann spezialisierte Werkzeuge die bessere Wahl sind.\n\nGesicherte Funktionsweise\n\nprocfs ist ein virtuelles Dateisystem. Die Eintr\u00e4ge unter \/proc repr\u00e4sentieren Datenstrukturen und Zust\u00e4nde des laufenden Linux-Kernels; sie sind keine gew\u00f6hnlichen Dateien auf einem persistenten Datentr\u00e4ger. \/proc dient einerseits zum Auslesen von System- und Prozessinformationen, andererseits k\u00f6nnen bestimmte Kernelparameter \u00fcber \/proc\/sys zur Laufzeit konfiguriert werden. Welche Eintr\u00e4ge vorhanden sind, h\u00e4ngt unter anderem von Kernelversion, Kernelkonfiguration, Hardware, geladenen Modulen und Namespaces ab. ([docs.kernel.org](https:\/\/docs.kernel.org\/filesystems\/proc.html?utm_source=openai))\n\nDer Artikel sollte ausdr\u00fccklich zwischen drei Bereichen unterscheiden:\n\nErstens: globale, \u00fcberwiegend lesbare Statusdateien wie \/proc\/meminfo, \/proc\/stat, \/proc\/loadavg und \/proc\/diskstats.\n\nZweitens: prozessbezogene Verzeichnisse unter \/proc\/<PID>. Sie enthalten beispielsweise Statusdaten, Kommandozeile, offene Dateideskriptoren und Speicherabbildungen eines konkreten Prozesses. Der Link \/proc\/self verweist jeweils auf den Prozess, der ihn gerade liest. F\u00fcr fremde Prozesse gelten Zugriffspr\u00fcfungen; sensible Daten k\u00f6nnen au\u00dferdem durch die Mount-Option hidepid eingeschr\u00e4nkt oder verborgen sein. ([docs.kernel.org](https:\/\/docs.kernel.org\/filesystems\/proc.html?utm_source=openai))\n\nDrittens: \/proc\/sys als sysctl-Schnittstelle. Dort sind manche Werte lesbar und schreibbar. Der sp\u00e4tere Artikel sollte Lesezugriffe und \u00c4nderungen klar trennen: Das blo\u00dfe Anzeigen eines Werts ist Diagnostik, das Schreiben ver\u00e4ndert Kernelverhalten zur Laufzeit und verlangt eine fachliche Begr\u00fcndung, dokumentierte Auswirkungen sowie einen R\u00fcckweg. ([docs.kernel.org](https:\/\/docs.kernel.org\/admin-guide\/sysctl\/?utm_source=openai))\n\nVoraussetzungen und sichere Einordnung\n\nAdressiert werden Linux-Administratoren mit Shell-Grundkenntnissen. F\u00fcr viele Lesebeispiele gen\u00fcgt ein unprivilegierter Account; bei fremden Prozessen oder gesch\u00fctzten Daten k\u00f6nnen Rechte, Linux-Capabilities und die procfs-Mount-Optionen den Zugriff verhindern. Das ist kein Fehlerfall, sondern ein Sicherheitsmerkmal. ([docs.kernel.org](https:\/\/docs.kernel.org\/filesystems\/proc.html?utm_source=openai))\n\nDer Artikel sollte vorab vermitteln, dass procfs Werte in verschiedenen Einheiten und Zeitbez\u00fcgen ausgibt. Manche Z\u00e4hler gelten seit Systemstart, andere spiegeln einen aktuellen Zustand, wieder andere sind gleitende Durchschnitte. Erst zwei zeitlich getrennte Abfragen machen aus einem monotonen Z\u00e4hler eine Rate. Ein einzelner hoher Z\u00e4hler ist daher meist kein Leistungsnachweis.\n\nSichere Terminalbeispiele k\u00f6nnen konsequent nur lesend sein:\n\nTerminalbefehl:\ncat \/proc\/meminfo\n\nTerminalbefehl:\ncat \/proc\/loadavg\n\nTerminalbefehl:\ngrep -E '^(cpu|intr|ctxt|processes)' \/proc\/stat\n\nTerminalbefehl:\ncat \/proc\/$$\/status\n\nTerminalbefehl:\nls -l \/proc\/$$\/fd\n\nTerminalbefehl:\nfindmnt -T \/proc\n\nDie Beispiele verwenden $$ bewusst f\u00fcr die aktuelle Shell statt einer angenommenen PID. Sie \u00e4ndern weder Systemparameter noch Prozessdaten.\n\nKernstruktur f\u00fcr den sp\u00e4teren Artikel\n\n1. Systemzustand und Auslastung\n\n\/proc\/loadavg zeigt die Auslastungsdurchschnitte f\u00fcr 1, 5 und 15 Minuten. Anders als eine vereinfachende Erkl\u00e4rung \u201eCPU-Auslastung\u201c nahelegt, umfasst die Load Average laufbereite Scheduling-Einheiten im Zustand R und Einheiten im ununterbrechbaren Wartezustand D, h\u00e4ufig bei I\/O-Wartevorg\u00e4ngen. Der Artikel sollte daraus ableiten: Ein hoher Load-Wert beweist keine CPU-\u00dcberlastung; er ist ein Anlass, CPU-, Speicher- und I\/O-Signale zusammen zu pr\u00fcfen. Das vierte Feld zeigt aktuell ausf\u00fchrbare gegen\u00fcber insgesamt existierenden Kernel-Scheduling-Einheiten. ([man7.org](https:\/\/man7.org\/linux\/man-pages\/man5\/proc_loadavg.5.html?utm_source=openai))\n\n\/proc\/stat liefert globale Kernelstatistiken, insbesondere CPU-Zeitanteile seit dem Boot. CPU-Zeiten werden in USER_HZ gef\u00fchrt, wobei die Architektur beachtet werden muss. Der iowait-Wert verdient einen deutlichen Warnhinweis: Laut Manpage ist er aus mehreren Gr\u00fcnden nicht zuverl\u00e4ssig und kann unter bestimmten Bedingungen sogar sinken. Deshalb sollte der Artikel iowait nicht als isolierte I\/O-Latenzmessung darstellen. ([man7.org](https:\/\/www.man7.org\/linux\/man-pages\/man5\/proc_stat.5.html))\n\nErg\u00e4nzend passt \/proc\/uptime: Betriebsdauer und aggregierte Idle-Zeit liefern Kontext f\u00fcr Z\u00e4hler seit dem Boot, sind aber kein Ersatz f\u00fcr eine Zeitreihe.\n\n2. Arbeitsspeicher, Swap und Speicherdruck\n\n\/proc\/meminfo ist die zentrale Rohdatenquelle f\u00fcr die Speicher\u00fcbersicht. Die Datei liefert unter anderem MemTotal, MemFree, MemAvailable, Cached, Buffers und Swap-Werte. Besonders wichtig ist die Erkl\u00e4rung, dass MemAvailable eine Sch\u00e4tzung des Speichers ist, der f\u00fcr neue Anwendungen ohne Swapping verf\u00fcgbar sein soll. Der Artikel sollte nicht suggerieren, dass ein geringer MemFree-Wert allein Speichermangel bedeutet: Dateicache ist ein erwarteter Bestandteil der Speichernutzung. ([man7.org](https:\/\/www.man7.org\/linux\/man-pages\/man5\/proc_meminfo.5.html))\n\nF\u00fcr neuere oder entsprechend konfigurierte Systeme ist \/proc\/pressure besonders wertvoll. Die Dateien cpu, memory und io enthalten Stall-Anteile f\u00fcr 10, 60 und 300 Sekunden sowie einen kumulierten Stall-Z\u00e4hler. \u201esome\u201c bedeutet, dass mindestens einige Tasks blockiert waren; \u201efull\u201c beschreibt den Zustand, dass alle nicht-idlen Tasks gleichzeitig blockiert waren. Bei CPU-Druck ist systemweites full historisch beziehungsweise semantisch besonders einzuordnen und kann als null erscheinen. ([docs.kernel.org](https:\/\/docs.kernel.org\/accounting\/psi.html))\n\nPraxisfall: Eine Anwendung reagiert langsam, obwohl MemFree klein ist. Ablauf: MemAvailable pr\u00fcfen, anschlie\u00dfend \/proc\/pressure\/memory lesen und bei Bedarf prozessbezogen \/proc\/<PID>\/status betrachten. Erst die Kombination kann darauf hindeuten, ob echter Speicherdruck vorliegt.\n\n3. Prozesse gezielt untersuchen\n\n\/proc\/<PID>\/status ist f\u00fcr Menschen besser lesbar als die feldbasierte Datei \/proc\/<PID>\/stat. Sinnvolle Felder f\u00fcr den Artikel: Name, State, Pid, PPid, Threads, VmSize, VmRSS, FDSize, Kontextwechsel sowie gegebenenfalls Capabilities und Seccomp. Die Datei b\u00fcndelt Informationen aus stat und statm in menschenlesbarer Form. ([man7.org](https:\/\/man7.org\/linux\/man-pages\/man5\/proc_pid_status.5.html?utm_source=openai))\n\n\/proc\/<PID>\/cmdline hilft bei der Zuordnung eines Prozesses, kann aber Argumente enthalten, die vertraulich sein sollen. \/proc\/<PID>\/environ ist noch sensibler und sollte im Artikel nicht als Routinewerkzeug empfohlen werden. Der Hinweis ist wichtig, weil Kommandozeilen oder Umgebungsvariablen fehlerhaft konfigurierte Zugangsdaten enthalten k\u00f6nnen.\n\n\/proc\/<PID>\/fd zeigt die offenen Dateideskriptoren als symbolische Links. Praxisfall: Ein Dienst erreicht sein Dateideskriptor-Limit oder h\u00e4lt gel\u00f6schte Logdateien ge\u00f6ffnet. Der Artikel sollte erkl\u00e4ren, dass diese Ansicht eine Diagnosehilfe ist, aber keine pauschale Aussage \u00fcber ein Leck erlaubt: viele offene Deskriptoren k\u00f6nnen f\u00fcr Proxy-, Datenbank- oder Event-Server erwartbar sein.\n\n\/proc\/<PID>\/maps und \/proc\/<PID>\/smaps sind Spezialwerkzeuge f\u00fcr Speicheranalysen. maps listet virtuelle Speicherbereiche samt Berechtigungen, Offset, Ger\u00e4t, Inode und Pfad; smaps erg\u00e4nzt Speichernutzungswerte je Mapping. Wegen Umfang und Kosten sollte der Artikel diese Dateien als vertiefende Analyse einordnen, nicht als erste Standardabfrage. ([docs.kernel.org](https:\/\/docs.kernel.org\/filesystems\/proc.html))\n\n4. Datentr\u00e4ger und I\/O\n\n\/proc\/diskstats enth\u00e4lt I\/O-Statistiken je Blockger\u00e4t. Entscheidend ist die Einschr\u00e4nkung: Es handelt sich um kumulative Z\u00e4hler. F\u00fcr Raten, etwa gelesene Sektoren pro Sekunde, muss ein Tool zwei Stichproben vergleichen und die Differenz durch das Zeitintervall teilen. Au\u00dferdem m\u00fcssen Partitionen, virtuelle Ger\u00e4te, Device Mapper und physische Laufwerke sauber unterschieden werden. ([man7.org](https:\/\/man7.org\/linux\/man-pages\/man5\/proc_diskstats.5.html))\n\nPraxisfall: Hohe Load Average bei geringer CPU-Auslastung. Die sinnvolle Pr\u00fcfsequenz ist: \/proc\/loadavg als Symptom, \/proc\/stat mit Vorsicht beim iowait, \/proc\/diskstats als Ger\u00e4teperspektive und \/proc\/pressure\/io f\u00fcr beobachtbaren I\/O-Stall. Diese Kombination ist aussagekr\u00e4ftiger als ein einzelner Wert. ([man7.org](https:\/\/man7.org\/linux\/man-pages\/man5\/proc_loadavg.5.html?utm_source=openai))\n\n5. Laufzeitparameter unter \/proc\/sys\n\nDer Artikel sollte \/proc\/sys nicht als Tuning-Katalog behandeln. Sinnvoll sind exemplarische Lesef\u00e4lle:\n\n\/proc\/sys\/fs\/file-nr und file-max zur Einordnung systemweiter File-Handle-Nutzung und -Grenze. Bei file-nr ist das mittlere Feld auf Linux 2.6 und sp\u00e4ter stets null; dies ist laut Kernel-Dokumentation kein Fehler. ([docs.kernel.org](https:\/\/docs.kernel.org\/admin-guide\/sysctl\/fs.html?utm_source=openai))\n\n\/proc\/sys\/vm als Bereich f\u00fcr Speicherverwaltung. Warnbeispiel: drop_caches darf nicht als permanente Speicheroptimierung erscheinen. Die Kernel-Dokumentation beschreibt den Eingriff als nicht destruktiv, warnt aber vor Leistungsproblemen und empfiehlt seine Nutzung au\u00dferhalb von Test- oder Debug-Umgebungen nicht. ([docs.kernel.org](https:\/\/docs.kernel.org\/5.17\/admin-guide\/sysctl\/vm.html?utm_source=openai))\n\n\/proc\/sys\/net enth\u00e4lt netzwerkbezogene Einstellungen, wobei die vorhandenen Unterverzeichnisse von der Kernelkonfiguration abh\u00e4ngen. Statt konkrete Tuningwerte ohne Workload-Kontext zu nennen, sollte der Artikel auf die thematische Struktur und die Pflicht zur jeweiligen Kernel-Dokumentation verweisen. ([docs.kernel.org](https:\/\/docs.kernel.org\/7.1\/admin-guide\/sysctl\/net.html?utm_source=openai))\n\nEntscheidungsalternativen\n\nprocfs eignet sich f\u00fcr direkte Kernelansichten, Troubleshooting und einfache Skripte. F\u00fcr regelm\u00e4\u00dfiges Monitoring sind jedoch spezialisierte Werkzeuge und Zeitreihensysteme h\u00e4ufig geeigneter, weil sie Differenzen berechnen, Einheiten aufbereiten, Historien speichern und Schwellenwerte auswerten k\u00f6nnen. Der Artikel kann ps, top beziehungsweise htop, free, vmstat, iostat, pidstat, ss und sar als Einordnungsalternativen nennen, ohne zu behaupten, dass sie \u00fcberall identisch implementiert sind.\n\nsysfs unter \/sys ist abzugrenzen: Dort stehen prim\u00e4r Ger\u00e4te-, Treiber- und Hardwareobjekte im Vordergrund, w\u00e4hrend procfs den Prozess- und Kernelzustand sowie sysctl-Parameter sichtbar macht. F\u00fcr cgroup-bezogene Ressourcenanalysen ist die cgroup2-Schnittstelle relevant; PSI-Daten existieren bei passender Konfiguration auch pro cgroup. ([docs.kernel.org](https:\/\/docs.kernel.org\/accounting\/psi.html))\n\nGrenzen und typische Fehler\n\nWichtig ist der Hinweis auf Container und PID-Namespaces: Die sichtbare Prozesswelt kann von der Hostansicht abweichen. procfs-Instanzen k\u00f6nnen mit einem PID-Namespace verbunden sein; daraus folgt, dass \/proc in einem Container nicht automatisch den Gesamtzustand des Hosts zeigt. ([docs.kernel.org](https:\/\/docs.kernel.org\/filesystems\/proc.html?utm_source=openai))\n\nTypische Fehler, die der Artikel klar korrigieren sollte:\n\n\u201eWenig freier Speicher bedeutet RAM-Not.\u201c Korrekt ist: Cache und MemAvailable einbeziehen.\n\n\u201eHoher Load bedeutet CPU ist voll.\u201c Korrekt ist: auch blockierte D-Tasks und I\/O-Symptome pr\u00fcfen.\n\n\u201eiowait misst unmittelbar die Speicherlatenz.\u201c Korrekt ist: Der Wert hat dokumentierte Einschr\u00e4nkungen.\n\n\u201e\/proc-Dateien sind \u00fcberall gleich.\u201c Korrekt ist: Verf\u00fcgbarkeit und Felder k\u00f6nnen von Architektur, Kernelkonfiguration und Version abh\u00e4ngen.\n\n\u201eSchreiben nach \/proc\/sys ist nur tempor\u00e4res Feintuning.\u201c Korrekt ist: Es ver\u00e4ndert aktives Kernelverhalten und kann Seiteneffekte erzeugen.\n\nGeeignete Tabelleninformationen\n\nEine zentrale \u00dcbersichtstabelle sollte diese Spalten enthalten: Pfad, Zweck, typische Frage, Datencharakter, wichtige Einschr\u00e4nkung, sichere Leseabfrage.\n\nAufzunehmen sind mindestens \/proc\/loadavg, \/proc\/stat, \/proc\/meminfo, \/proc\/pressure\/cpu, \/proc\/pressure\/memory, \/proc\/pressure\/io, \/proc\/<PID>\/status, \/proc\/<PID>\/fd, \/proc\/<PID>\/maps, \/proc\/diskstats, \/proc\/sys\/fs\/file-nr und \/proc\/sys\/fs\/file-max.\n\nEine zweite, kleinere Tabelle kann die Diagnosepfade b\u00fcndeln: Symptom, zuerst lesen, danach abgleichen, Fehlinterpretation vermeiden. Ein Chart ist ohne eigene Zeitreihendaten nicht sinnvoll; stattdessen sollte der Artikel erkl\u00e4ren, welche procfs-Werte ein Monitoring-System in Intervallen erfassen m\u00fcsste.","_wh_make_sources":{"S1":{"id":"S1","url":"https:\/\/docs.kernel.org\/filesystems\/proc.html?utm_source=openai","title":"The \/proc Filesystem \u2014 The Linux Kernel Documentation"},"S2":{"id":"S2","url":"https:\/\/docs.kernel.org\/admin-guide\/sysctl\/?utm_source=openai","title":"Documentation for \/proc\/sys \u2014 The Linux Kernel Documentation"},"S3":{"id":"S3","url":"https:\/\/man7.org\/linux\/man-pages\/man5\/proc_loadavg.5.html?utm_source=openai","title":"proc_loadavg(5) - Linux manual page"},"S4":{"id":"S4","url":"https:\/\/www.man7.org\/linux\/man-pages\/man5\/proc_stat.5.html","title":"proc_stat(5) - Linux manual page"},"S5":{"id":"S5","url":"https:\/\/www.man7.org\/linux\/man-pages\/man5\/proc_meminfo.5.html","title":"proc_meminfo(5) - Linux manual page"},"S6":{"id":"S6","url":"https:\/\/docs.kernel.org\/accounting\/psi.html","title":"PSI - Pressure Stall Information \u2014 The Linux Kernel documentation"},"S7":{"id":"S7","url":"https:\/\/man7.org\/linux\/man-pages\/man5\/proc_pid_status.5.html?utm_source=openai","title":"proc_pid_status(5) - Linux manual page"},"S8":{"id":"S8","url":"https:\/\/docs.kernel.org\/filesystems\/proc.html","title":"The \/proc Filesystem \u2014 The Linux Kernel Documentation"},"S9":{"id":"S9","url":"https:\/\/man7.org\/linux\/man-pages\/man5\/proc_diskstats.5.html","title":"proc_diskstats(5) - Linux manual page"},"S10":{"id":"S10","url":"https:\/\/docs.kernel.org\/admin-guide\/sysctl\/fs.html?utm_source=openai","title":"Documentation for \/proc\/sys\/fs\/ \u2014 The Linux Kernel Documentation"},"S11":{"id":"S11","url":"https:\/\/docs.kernel.org\/5.17\/admin-guide\/sysctl\/vm.html?utm_source=openai","title":"Documentation for \/proc\/sys\/vm\/ \u2014 The Linux Kernel documentation"},"S12":{"id":"S12","url":"https:\/\/docs.kernel.org\/7.1\/admin-guide\/sysctl\/net.html?utm_source=openai","title":"Documentation for \/proc\/sys\/net\/ \u2014 The Linux Kernel Documentation"}},"_wh_make_usage":{"research":{"input_tokens":30521,"output_tokens":3813,"response_id":"resp_073ed8ff6b382178016ab2246876cc87d2b8503366ac1664e4","model":"gpt-5.6-terra","search_calls":3},"plan_bf5ef0afe81bff06d64e1f2192080095":{"input_tokens":6058,"output_tokens":1559,"response_id":"resp_0de368bfe35cea85016ab224a353d087d28d1dd339864c9ac0","model":"gpt-5.6-terra","search_calls":0},"part1_23d7b85a19c3a588cf1ae808e44a02d5":{"input_tokens":8462,"output_tokens":1774,"response_id":"resp_08c3c732be80a763016ab224b8d5a487d28a666b4d2d7de86d","model":"gpt-5.6-terra","search_calls":0},"part2_265b0195f2bbd3fe54c408a58c583078":{"input_tokens":8587,"output_tokens":2518,"response_id":"resp_0d6f6e442e8828d9016ab224d32bc087d294d2ec6d0f53ae99","model":"gpt-5.6-terra","search_calls":0},"part3_10dd185c9e68e880cbfa341be1017e42":{"input_tokens":8569,"output_tokens":2695,"response_id":"resp_0e13b6bb3db886f2016ab224f7f0f887d29c8e52b06d1ccc26","model":"gpt-5.6-terra","search_calls":0},"package_2b344208a5cdfa03fb14b181daaacab7":{"input_tokens":13729,"output_tokens":1220,"response_id":"resp_0eab4b76e280b0c9016ab2252000ec87d29b728d74143c9b58","model":"gpt-5.6-terra","search_calls":0},"review_47b9972c3a85c20d135bb6f77968c58a":{"input_tokens":42548,"output_tokens":1816,"response_id":"resp_06b1fa8a0870acc2016ab2253577d487d2826514bcbe3f7af1","model":"gpt-5.6-sol","search_calls":3},"repair_1e91e3d00fd20b26c9ae106396ec02bf":{"input_tokens":15734,"output_tokens":5609,"response_id":"resp_05eb95a26f473ddc016ab22566298087d2aabd6ac45b7b59bb","model":"gpt-5.6-terra","search_calls":0},"review_1a13bbea094331829e89c25e79bcbca3":{"input_tokens":36697,"output_tokens":1127,"response_id":"resp_0253a1b193c86284016ab225a478bc87d290374c823bac6e4d","model":"gpt-5.6-sol","search_calls":2},"image_hero":{"input_tokens":111,"output_tokens":343,"response_id":"","model":"gpt-image-2.5-flare","search_calls":0},"image_detail1":{"input_tokens":100,"output_tokens":343,"response_id":"","model":"gpt-image-2.5-flare","search_calls":0},"image_detail2":{"input_tokens":117,"output_tokens":343,"response_id":"","model":"gpt-image-2.5-flare","search_calls":0}},"_wh_make_last_error":"","_wh_make_write_intent":{"before":{"content_md5":"b70de2ef86b367d71a1ba876dbc337ce","title":"Linux procfs for Administrators: An Overview of Important Files","slug":"linux-procfs-for-administrators","excerpt":"procfs provides direct insight into the running Linux kernel. This guide explains important files under \/proc, categorizes counters and snapshots, and outlines safe diagnostic paths for load, memory, processes, I\/O, and sysctl parameters.","status":"draft","featured_media":0},"expected":{"content_md5":"fe641734889fa48edfed948b0aab44cc","title":"Linux procfs for Administrators: An Overview of Important Files","slug":"linux-procfs-for-administrators","excerpt":"procfs provides direct insight into the running Linux kernel. This guide explains important files under \/proc, categorizes counters and snapshots, and outlines safe diagnostic paths for load, memory, processes, I\/O, and sysctl parameters.","status":"draft","featured_media":21652},"at":"2026-09-22T06:53:51+00:00"},"_wh_make_design_version":"2.1.1","rank_math_title":"Linux procfs: wichtige \/proc-Dateien erkl\u00e4rt","_wh_make_doc":{"title":"Linux procfs for Administrators: An Overview of Important Files","slug":"linux-procfs-for-administrators","excerpt":"procfs provides direct insight into the running Linux kernel. This guide explains important files under \/proc, categorizes counters and snapshots, and outlines safe diagnostic paths for load, memory, processes, I\/O, and sysctl parameters.","seo":{"title":"Linux procfs: An Explanation of Important \/proc Files","description":"Important procfs files for Linux administrators: How to correctly read and interpret system load, memory, processes, I\/O, and \/proc\/sys.","focus_keyword":"Linux procfs"},"lead":[{"kind":"text","text":"Das ","ref":""},{"kind":"strong","text":"Linux procfs","ref":""},{"kind":"text","text":" zeigt den aktuellen Zustand des Kernels \u00fcber virtuelle Dateien unter \/proc. F\u00fcr die Administration sind vor allem Last, Speicher, Prozesse, Dateideskriptoren und Blockger\u00e4te relevant. Entscheidend ist die Einordnung: Manche Werte sind Momentaufnahmen, andere Z\u00e4hler seit dem Boot oder gleitende Mittelwerte. Lies deshalb nie nur einen Einzelwert, sondern gleiche ihn mit passenden Signalen und dem Kontext von Host, VM oder Container ab. ","ref":""},{"kind":"citation","text":"","ref":"S1"}],"images":{"hero":{"prompt":"Konzeptionelle technische Illustration eines Linux-Servers als transparenter Kern mit mehreren klar getrennten Datenstr\u00f6men zu virtuellen Dateiansichten: CPU-Auslastung, Arbeitsspeicher, Prozesse, Datentr\u00e4ger-I\/O und Netzwerk. Abstrakte Terminal- und Dateisystemelemente, dunkler neutraler Hintergrund, pr\u00e4ziser Editorial-Stil, keine Schrift, keine Zahlen, keine Logos.","alt":"Konzeptionelle Darstellung von Kernelzust\u00e4nden, die \u00fcber procfs sichtbar werden.","caption":"Konzeptionelle Illustration: procfs macht ausgew\u00e4hlte Zust\u00e4nde des laufenden Kernels als Dateiansichten zug\u00e4nglich.","filename_base":"linux-procfs-kernelansicht","section_id":"","after_block":0},"detail1":{"prompt":"Konzeptionelle Infografik zu kombinierter Linux-Diagnose: ein zentraler Lastindikator verzweigt zu CPU-Zeit, verf\u00fcgbarem Speicher, Speicher-Stalls und I\/O-Stalls. Zeige Zusammenh\u00e4nge durch farblich zur\u00fcckhaltende Linien und abstrahierte Systemmodule, ohne Text, Zahlen, Legenden oder Logos.","alt":"Konzeptionelle Verkn\u00fcpfung von Last-, Speicher-, CPU- und I\/O-Signalen.","caption":"Konzeptionelle Illustration: Erst mehrere Kernelindikatoren zusammen erm\u00f6glichen eine belastbare Einordnung von Last.","filename_base":"procfs-last-speicher-signale","section_id":"proc-load-memory","after_block":1},"detail2":{"prompt":"Konzeptionelle technische Darstellung mit zwei getrennten Analyseebenen: links ein einzelner Linux-Prozess mit offenen Dateideskriptoren und virtuellen Speicherbereichen, rechts systemweite Blockger\u00e4te-I\/O. Dazwischen eine abstrahierte Dateisystem-, Cache- und Device-Mapper-Schicht, die keine direkte 1:1-Verbindung suggeriert. Sachlicher dunkler Stil, keine Schrift, Zahlen oder Logos.","alt":"Getrennte Darstellung von Prozessressourcen und systemweiter Ger\u00e4te-I\/O mit abstrahierter Vermittlungsschicht.","caption":"Konzeptionelle Illustration: Prozessdaten und Blockger\u00e4te-I\/O sind getrennte Analyseebenen, die nicht direkt eins zu eins zugeordnet werden k\u00f6nnen.","filename_base":"procfs-prozess-fd-io","section_id":"proc-process-io","after_block":2}},"chart":null,"social":{"facebook":"Linux procfs richtig nutzen: Welche \/proc-Dateien bei Last, Speicherproblemen, Prozessen und I\/O wirklich weiterhelfen \u2013 und warum Einzelwerte oft t\u00e4uschen.","instagram":"procfs ist keine gew\u00f6hnliche Dateiablage: So ordnest du \/proc-Werte f\u00fcr Last, Speicher, Prozesse und I\/O korrekt ein.","tiktok":"Hoher Load ist nicht automatisch CPU-Last. Diese procfs-Dateien helfen bei der Linux-Diagnose.","youtube":"Linux procfs erkl\u00e4rt: Wichtige \/proc-Dateien f\u00fcr Last, RAM, Prozesse und I\/O richtig lesen","threads":"procfs liefert Kernel-Rohdaten, aber selten sofort eine Diagnose. Entscheidend sind Zeitbezug, Namespace und der Abgleich mehrerer Signale.","x":"Linux procfs f\u00fcr Admins: \/proc\/loadavg, meminfo, stat, pressure, Prozesspfade und diskstats richtig einordnen. Warum hohe Load, wenig MemFree oder iowait allein keine Diagnose sind."},"avatar_script":"procfs ist die direkte Dateiansicht auf viele Zust\u00e4nde des laufenden Linux-Kernels. F\u00fcr die t\u00e4gliche Diagnose ist nicht entscheidend, m\u00f6glichst viele Dateien zu kennen, sondern passende Signale zusammenzuf\u00fchren. Ein hoher Load Average kann CPU-Konkurrenz bedeuten, aber ebenso auf wartende I\/O-Tasks hinweisen. Wenig MemFree ist normal, wenn der Kernel RAM als Cache verwendet; MemAvailable und Speicher-PSI liefern den wichtigeren Kontext. Prozessverzeichnisse helfen bei einzelnen Diensten, k\u00f6nnen aber durch Rechte, hidepid oder PID-Namespaces eingeschr\u00e4nkt sein. Unter \/proc\/sys beginnt dagegen Konfiguration: Lesen ist Diagnostik, Schreiben ver\u00e4ndert aktives Kernelverhalten. F\u00fcr Trends und Alarmierung erg\u00e4nzen Monitoring-Werkzeuge die punktuelle procfs-Abfrage.","version_note":"Recherchestand: 22. September 2026. Die sichtbaren procfs-Pfade und Felder k\u00f6nnen je nach Kernelversion, Konfiguration, Hardware, Namespaces und Berechtigungen abweichen. Die f\u00fcr drop_caches und Netzwerkparameter herangezogenen Kernel-Dokumentationen sind versionsgebunden; pr\u00fcfe bei abweichender Kernelversion die Dokumentation des eingesetzten Kernels.","sections":[{"id":"proc-basics","heading":"procfs verstehen: virtuelle Kernelansicht statt Datenspeicher","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Das ","ref":""},{"kind":"strong","text":"procfs","ref":""},{"kind":"text","text":" ist ein virtuelles Dateisystem: Die Eintr\u00e4ge unter \/proc bilden Datenstrukturen und Zust\u00e4nde des laufenden Linux-Kernels ab. Sie liegen nicht als dauerhaft gespeicherte Inhalte auf einem Datentr\u00e4ger. Beim Lesen erzeugt der Kernel die jeweilige Ansicht aus seinem aktuellen Zustand; nach einem Neustart beginnen etwa viele Z\u00e4hler erneut. Deshalb ist \/proc eine Schnittstelle f\u00fcr Beobachtung und teilweise Steuerung, kein Ort f\u00fcr eigene Dateien oder persistente Konfigurationen. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr die Administration sind drei Bereiche zu unterscheiden. Globale Statusdateien wie \/proc\/meminfo, \/proc\/stat oder \/proc\/loadavg liefern kernelweite Kennzahlen. Verzeichnisse mit numerischen Namen, etwa \/proc\/1234, liefern Details zu einem einzelnen Prozess. Unter \/proc\/sys liegen dagegen Kernelparameter, die abh\u00e4ngig von Berechtigung und Parameter sowohl lesbar als auch schreibbar sein k\u00f6nnen. Die \u00e4hnliche Dateiform darf nicht dar\u00fcber hinwegt\u00e4uschen, dass Statusabfrage und Konfigurations\u00e4nderung grundverschiedene Folgen haben. ","ref":""},{"kind":"citation","text":"","ref":"S8"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Welche Pfade und Felder vorhanden sind, ist nicht auf jedem Linux-System identisch. Kernelversion und -konfiguration, Architektur, erkannte Hardware sowie geladene Module beeinflussen die sichtbaren Eintr\u00e4ge. Auch Namespaces ver\u00e4ndern einzelne Ansichten. Ein procfs, das mit einem PID-Namespace verbunden ist, begrenzt insbesondere die Prozess- und PID-Sicht; daraus folgt jedoch nicht, dass globale Dateien automatisch container- oder cgroup-spezifische Werte zeigen. Skripte sollten Dateien und Felder pr\u00fcfen, bevor sie deren Inhalt auswerten, statt eine vollst\u00e4ndige, \u00fcberall gleiche procfs-Struktur vorauszusetzen. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Davon abzugrenzen ist sysfs unter \/sys: Es stellt vor allem Ger\u00e4te, Treiber und Hardwareobjekte dar. F\u00fcr Ressourcenverteilung und Grenzen von Gruppen ist au\u00dferdem cgroup2 relevant. procfs bleibt jedoch die unmittelbare Quelle f\u00fcr viele Kernel- und Prozesszust\u00e4nde, die bei einer ersten Diagnose ben\u00f6tigt werden. ","ref":""},{"kind":"citation","text":"","ref":"S8"}]}]},{"id":"proc-time-context","heading":"Z\u00e4hler, Momentaufnahmen und Sichtbarkeit richtig einordnen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Der Wert allein erkl\u00e4rt bei procfs selten ein Problem. Zuerst ist sein Zeitbezug zu kl\u00e4ren: Einige Angaben sind ","ref":""},{"kind":"strong","text":"kumulative Z\u00e4hler","ref":""},{"kind":"text","text":" seit Systemstart, andere beschreiben einen aktuellen Zustand, wieder andere bilden gleitende Zeitfenster ab. Ein hoher Z\u00e4hlerstand zeigt zun\u00e4chst nur, dass sich ein Ereignis seit dem Boot summiert hat. Eine Rate entsteht erst aus zwei Messpunkten: Differenz der Werte geteilt durch das dazwischenliegende Zeitintervall. Das gilt beispielsweise f\u00fcr viele CPU-, Interrupt- und Datentr\u00e4gerz\u00e4hler. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Datei \/proc\/uptime liefert die vergangene Betriebsdauer und die aggregierte Idle-Zeit. Sie hilft, Z\u00e4hler seit dem Start zeitlich einzuordnen, ersetzt aber keine Messreihe. Eine einmalige Abfrage ist eine Momentaufnahme; f\u00fcr belastbare Aussagen \u00fcber Trends, Spitzen oder wiederkehrende Last braucht es wiederholte Abfragen mit Zeitstempel. Dabei k\u00f6nnen sich Werte bereits w\u00e4hrend des Lesens ver\u00e4ndern, weil der Kernel weiterarbeitet. ","ref":""},{"kind":"citation","text":"","ref":"S8"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Auch die sichtbaren Daten haben Grenzen. \/proc\/self verweist stets auf den Prozess, der den Pfad gerade aufl\u00f6st. Damit ist er f\u00fcr Skripte und interaktive Pr\u00fcfungen praktisch, ohne eine PID anzunehmen. Der Zugriff auf fremde Prozessverzeichnisse kann jedoch durch Dateirechte, Linux-Capabilities und die procfs-Mount-Option ","ref":""},{"kind":"code","text":"hidepid","ref":""},{"kind":"text","text":" eingeschr\u00e4nkt sein. Fehlende Einblicke sind in diesem Fall kein defektes procfs, sondern ein Schutz gegen das Auslesen sensibler Prozessinformationen. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Besondere Vorsicht gilt in Containern. Ein an einen PID-Namespace gebundenes procfs zeigt bei prozessbezogenen Pfaden nur die Prozesse dieser Namespace-Sicht. Globale Kerneldateien wie \/proc\/meminfo, \/proc\/stat oder \/proc\/diskstats k\u00f6nnen dagegen weiterhin Werte des Hosts widerspiegeln und sind nicht automatisch auf das Containerlimit begrenzt. Vor jeder Diagnose ist daher zu kl\u00e4ren, ob die Frage Prozesse, globale Kernelwerte oder die tats\u00e4chlich zugewiesenen Ressourcen betrifft; Limits und Nutzung eines Containers geh\u00f6ren zus\u00e4tzlich in die cgroup2-Analyse. ","ref":""},{"kind":"citation","text":"","ref":"S8"}]}]},{"id":"proc-sysctl-boundary","heading":"Lesen, konfigurieren und absichern unter \/proc\/sys","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Der Bereich ","ref":""},{"kind":"strong","text":"\/proc\/sys","ref":""},{"kind":"text","text":" ist die Dateisystemansicht der sysctl-Schnittstelle. Das Lesen eines Werts dient der Diagnostik. Ein Schreibzugriff ver\u00e4ndert dagegen unmittelbar das Verhalten des laufenden Kernels und kann Dienste, Ressourcenverbrauch oder Sicherheitsmerkmale beeinflussen. Dass eine \u00c4nderung ohne Neustart wirkt, macht sie nicht risikolos und auch nicht automatisch dauerhaft: Persistenz h\u00e4ngt von der gew\u00e4hlten Systemkonfiguration ab. ","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Verzeichnisstruktur erleichtert die erste Einordnung. Unter \/proc\/sys\/fs stehen unter anderem globale Dateisystem- und File-Handle-Parameter. \/proc\/sys\/vm b\u00fcndelt Einstellungen der Speicherverwaltung, w\u00e4hrend \/proc\/sys\/net netzwerkbezogene Parameter enth\u00e4lt. Welche Unterverzeichnisse und Schl\u00fcssel verf\u00fcgbar sind, h\u00e4ngt wiederum von Kernelkonfiguration und Funktionen des Systems ab. Ein vorhandener Parameter ist daher kein allgemeines Tuning-Rezept; seine Dokumentation und der konkrete Workload sind ma\u00dfgeblich. ","ref":""},{"kind":"citation","text":"","ref":"S10"},{"kind":"citation","text":"","ref":"S11"},{"kind":"citation","text":"","ref":"S12"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Ein Gegenbeispiel f\u00fcr scheinbare Optimierung ist ","ref":""},{"kind":"code","text":"drop_caches","ref":""},{"kind":"text","text":" unter \/proc\/sys\/vm. Die Kernel-Dokumentation ordnet die Funktion Debugging und Tests zu und r\u00e4t von einem Einsatz au\u00dferhalb solcher Zwecke ab, weil das Leeren wiederverwendbarer Caches Leistung kosten kann. Wenig freier Speicher ist f\u00fcr sich genommen kein Grund, Caches zu verwerfen: Der Kernel nutzt RAM bewusst auch f\u00fcr Dateicache. ","ref":""},{"kind":"citation","text":"","ref":"S11"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Vor jeder \u00c4nderung sollte eine nachvollziehbare Ursache vorliegen. Sichere zuerst den Ausgangswert, dokumentiere Zweck und erwartete Nebenwirkungen, \u00e4ndere kontrolliert und beobachte anschlie\u00dfend passende Messwerte sowie Dienstverhalten. Plane den R\u00fcckweg vorab und \u00fcbernimm einen Wert erst nach fachlicher Pr\u00fcfung in eine dauerhafte Konfiguration. Weiterf\u00fchrende Grundlagen zu Parametern und ihrer kontrollierten Verwaltung behandelt der Beitrag ","ref":""},{"kind":"internal_link","text":"Kernel-Tuning im Linux-Hosting: Sysctl-Parameter im \u00dcberblick","ref":"I2"},{"kind":"text","text":".","ref":""}]}]},{"id":"proc-overview-table","heading":"Die wichtigsten procfs-Dateien nach Administrationsaufgabe","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Die Auswahl einer procfs-Datei sollte von der Administrationsfrage ausgehen, nicht von einer m\u00f6glichst vollst\u00e4ndigen Verzeichnisliste. Globale Dateien liefern oft kernelweite Werte, Prozesspfade beschreiben einen einzelnen sichtbaren Prozess, und Eintr\u00e4ge unter \/proc\/sys\/fs liefern Konfiguration und systemweite Grenzen. Einige Werte sind aktuelle Zust\u00e4nde, andere seit dem Boot kumulierte Z\u00e4hler oder gleitende Durchschnitte. Diese Unterscheidung entscheidet dar\u00fcber, ob ein einzelnes Auslesen gen\u00fcgt oder zwei Messpunkte n\u00f6tig sind.","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"table","caption":"Wichtige procfs-Dateien f\u00fcr typische Verwaltungsfragen","headers":["Pfad","Zweck","Typische Frage","Datencharakter","Wichtige Einschr\u00e4nkung","Sichere Leseabfrage"],"rows":[["\/proc\/loadavg","Systemlast","Sind Aufgaben wartend?","1-, 5-, 15-Minuten-Mittel","Keine reine CPU-Auslastung","cat \/proc\/loadavg"],["\/proc\/stat","CPU- und Kernelz\u00e4hler","Wie verteilen sich CPU-Zeiten?","Seit Boot kumuliert","iowait nicht isoliert bewerten","grep -E '^(cpu|intr|ctxt|processes)' \/proc\/stat"],["\/proc\/meminfo","Speicher\u00fcbersicht","Ist Speicher verf\u00fcgbar?","Aktuelle Speicherwerte","MemFree allein gen\u00fcgt nicht; im Container nicht zwingend cgroup-spezifisch","cat \/proc\/meminfo"],["\/proc\/pressure\/cpu","CPU-Stalls","Warten Tasks auf CPU?","Zeitfenster und Z\u00e4hler","Systemweites full ist nicht interpretierbar und wird als null ausgegeben","cat \/proc\/pressure\/cpu"],["\/proc\/pressure\/memory","Speicherdruck","Blockiert Speicherknappheit Tasks?","Zeitfenster und Z\u00e4hler","PSI muss verf\u00fcgbar sein","cat \/proc\/pressure\/memory"],["\/proc\/pressure\/io","I\/O-Stalls","Warten Tasks auf I\/O?","Zeitfenster und Z\u00e4hler","Kein Ersatz f\u00fcr Ger\u00e4teanalyse","cat \/proc\/pressure\/io"],["\/proc\/<PID>\/status","Prozessstatus","Wie gro\u00df und aktiv ist ein Prozess?","Aktuelle Prozessdaten","Rechte und PID-Namespace k\u00f6nnen Zugriff begrenzen","cat \/proc\/$$\/status"],["\/proc\/<PID>\/fd","Offene Deskriptoren","Welche Objekte h\u00e4lt ein Prozess?","Aktuelle symbolische Links","Viele FDs sind nicht automatisch ein Leck","ls -l \/proc\/$$\/fd"],["\/proc\/<PID>\/maps","Virtuelle Mappings","Welche Bereiche hat ein Prozess eingebunden?","Aktuelle Mappingliste","F\u00fcr die Erstanalyse oft zu umfangreich","cat \/proc\/$$\/maps"],["\/proc\/diskstats","Blockger\u00e4te-I\/O","Welche Ger\u00e4te arbeiten?","Seit Boot kumuliert","Raten erfordern zwei Stichproben; Werte k\u00f6nnen hostweit sein","cat \/proc\/diskstats"],["\/proc\/sys\/fs\/file-nr","File-Handle-Nutzung","Wie viele Handles nutzt das System?","Aktueller Z\u00e4hler und Grenze","Mittleres Feld ist auf modernen Linux-Systemen null","cat \/proc\/sys\/fs\/file-nr"],["\/proc\/sys\/fs\/file-max","File-Handle-Grenze","Welche globale Obergrenze gilt?","Aktiver Parameter","Nicht mit Prozesslimit verwechseln","cat \/proc\/sys\/fs\/file-max"]],"source_ids":["S1","S3","S4","S5","S6","S7","S9","S10"]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Tabelle ist eine Einstiegshilfe, keine Diagnosekette. Ein auff\u00e4lliger Wert verlangt stets ein unabh\u00e4ngiges Gegenzeichen: Load mit CPU- und I\/O-Daten, Speicherwerte mit Pressure Stall Information und Prozessgr\u00f6\u00dfen mit dem Verhalten des Dienstes. Besonders \/proc\/diskstats und \/proc\/stat sind ","ref":""},{"kind":"strong","text":"kumulative Z\u00e4hler","ref":""},{"kind":"text","text":"; ihre Differenz \u00fcber ein bekanntes Intervall ist f\u00fcr Raten aussagekr\u00e4ftiger als der absolute Stand. In Containern ist zus\u00e4tzlich zu pr\u00fcfen, ob eine Datei globale Kernelwerte oder eine pro cgroup verf\u00fcgbare Sicht liefert. Die folgenden Abschnitte ordnen die Signale deshalb nach Last, Speicher, Prozessen und I\/O ein.","ref":""}]}]},{"id":"proc-load-memory","heading":"Last, CPU und Speicher: Signale kombiniert bewerten","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Bei einer langsamen Anwendung ist \/proc\/loadavg ein sinnvoller Start, aber kein Urteil \u00fcber die CPU. Die drei Werte bilden die durchschnittliche Last der letzten 1, 5 und 15 Minuten ab. In die Last gehen nicht nur laufbereite Einheiten im Zustand R ein, sondern auch Tasks im ununterbrechbaren Wartezustand D, etwa bei I\/O. Das vierte Feld zeigt die aktuell ausf\u00fchrbaren gegen\u00fcber allen existierenden Scheduling-Einheiten. Hoher ","ref":""},{"kind":"strong","text":"Load Average","ref":""},{"kind":"text","text":" kann daher auf CPU-Konkurrenz, blockierte I\/O-Zugriffe oder beides hinweisen.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"code","language":"sh","code":"cat \/proc\/loadavg\ngrep -E '^(cpu|intr|ctxt|processes)' \/proc\/stat\ncat \/proc\/meminfo\ncat \/proc\/pressure\/memory","source_ids":["S3","S4","S5","S6"]},{"type":"paragraph","runs":[{"kind":"text","text":"Die CPU-Zeilen aus \/proc\/stat enthalten Zeitanteile seit dem Systemstart in USER_HZ. Um daraus Auslastungsanteile zu ermitteln, m\u00fcssen zwei Abfragen verglichen werden; ein einzelner Stand zeigt nur angesammelte Zeit. Der Wert iowait ist dabei kein unmittelbares Latenzma\u00df f\u00fcr Storage: Seine Berechnung hat dokumentierte Grenzen und kann unter bestimmten Umst\u00e4nden sogar sinken. F\u00fcr eine I\/O-Ursache sind daher zus\u00e4tzlich Ger\u00e4tewerte und I\/O-PSI sinnvoll.","ref":""},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Auch ein niedriger Wert bei MemFree beweist noch keine RAM-Not. Linux nutzt unbenutzten Arbeitsspeicher gezielt f\u00fcr Cache. MemAvailable sch\u00e4tzt, wie viel Speicher neue Anwendungen voraussichtlich ohne Swapping erhalten k\u00f6nnen, und ist f\u00fcr die erste Einordnung meist hilfreicher. Erst wenn MemAvailable knapp wird und gleichzeitig Speicher-Stalls auftreten, verdichtet sich der Hinweis auf ","ref":""},{"kind":"strong","text":"Speicherdruck","ref":""},{"kind":"text","text":". In einem Container k\u00f6nnen diese globalen Speicherwerte allerdings vom Host stammen; f\u00fcr zugesicherte oder begrenzte Ressourcen ist die cgroup2-Sicht zus\u00e4tzlich ma\u00dfgeblich.","ref":""},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Dateien unter \/proc\/pressure erg\u00e4nzen diese Sicht. Bei memory und io bedeutet some, dass wenigstens einige Tasks w\u00e4hrend eines Anteils des Zeitfensters nicht weiterkamen; full steht dort f\u00fcr einen Zustand, in dem alle nicht-idlen Tasks gleichzeitig blockiert waren. Die Angaben avg10, avg60 und avg300 beziehen sich auf 10, 60 und 300 Sekunden, total ist ein kumulierter Stall-Z\u00e4hler. F\u00fcr CPU ist systemweites full semantisch nicht definiert und wird seit Linux 5.13 aus Kompatibilit\u00e4tsgr\u00fcnden als null ausgegeben; als Diagnosewert ist es auf Systemebene daher nicht zu interpretieren. CPU-, memory- und io-PSI beantworten unterschiedliche Fragen und sollten nicht gegeneinander ausgetauscht werden.","ref":""},{"kind":"citation","text":"","ref":"S6"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Reagiert ein Dienst bei geringem MemFree langsam, pr\u00fcfst du zun\u00e4chst MemAvailable und \/proc\/pressure\/memory. Sind beide unauff\u00e4llig, spricht das gegen akuten systemweiten Speicherdruck. Anschlie\u00dfend kann \/proc\/<PID>\/status zeigen, ob der betroffene Prozess etwa eine hohe VmRSS-N\u00e4herung, viele Threads oder einen auff\u00e4lligen State aufweist. Diese Kombination trennt eine Cache-lastige, aber normale Speichernutzung von einem Problem, das weitere Prozessanalyse verlangt.","ref":""},{"kind":"citation","text":"","ref":"S7"}]}]},{"id":"proc-process-io","heading":"Prozesse, Dateideskriptoren und Datentr\u00e4ger-I\/O untersuchen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr eine sichere \u00dcbung mit einem garantiert vorhandenen Prozess steht $$ f\u00fcr die PID der aktuellen Shell. Die status-Datei ist menschenlesbarer als die feldorientierte stat-Datei. Name identifiziert den Prozess, State seinen Zustand, PPid den Elternprozess und Threads die Thread-Anzahl. VmRSS ist eine schnelle N\u00e4herung f\u00fcr residenten Speicher, deren RSS-Buchf\u00fchrung skalierbar und asynchron erfolgt und deshalb ungenau sein kann; VmSize beschreibt dagegen virtuellen Adressraum. FDSize beschreibt die Gr\u00f6\u00dfe der Deskriptortabelle, nicht zwingend die Zahl aktuell offener Eintr\u00e4ge. Freiwillige und unfreiwillige Kontextwechsel k\u00f6nnen bei der Einordnung von Scheduling-Verhalten helfen, sind allein aber kein Fehlerbeweis.","ref":""},{"kind":"citation","text":"","ref":"S7"},{"kind":"citation","text":"","ref":"S1"}]},{"type":"code","language":"sh","code":"cat \/proc\/$$\/status\nls -l \/proc\/$$\/fd","source_ids":["S7","S1"]},{"type":"paragraph","runs":[{"kind":"text","text":"Das fd-Verzeichnis enth\u00e4lt symbolische Links auf offene Dateien, Pipes, Ger\u00e4te oder Sockets. Es hilft etwa, einen Prozess zu finden, der eine gel\u00f6schte Logdatei weiterhin ge\u00f6ffnet h\u00e4lt. Eine gro\u00dfe Zahl offener Dateideskriptoren ist jedoch bei Proxys, Datenbanken oder ereignisorientierten Servern durchaus erwartbar. F\u00fcr gefilterte Ansichten und die Zuordnung \u00fcber Prozesse hinweg ist ","ref":""},{"kind":"internal_link","text":"lsof zur Analyse offener Dateien einsetzen","ref":"I3"},{"kind":"text","text":" eine passende Erg\u00e4nzung. Kommandozeilen aus cmdline k\u00f6nnen vertrauliche Argumente preisgeben; environ ist wegen m\u00f6glicher Zugangsdaten oder Tokens noch sensibler und keine Routineabfrage.","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"maps listet virtuelle Speicherbereiche mit Berechtigungen, Offset, Ger\u00e4t, Inode und gegebenenfalls Pfad. smaps erg\u00e4nzt je Mapping detaillierte Speicherwerte und liefert gegen\u00fcber RSS-Angaben eine genauere, aber aufwendigere Momentaufnahme. Beide Dateien sind f\u00fcr vertiefte Speicheranalysen gedacht: Ihre Ausgabe kann gro\u00df sein, und die Interpretation einzelner Mappings erfordert Kontext. F\u00fcr den ersten Blick sind status und die systemweiten Speicher- und PSI-Dateien meist effizienter.","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei hohem Load und geringer CPU-Auslastung erweitert \/proc\/diskstats die Diagnose um die Ger\u00e4teebene. Die Datei f\u00fchrt pro Blockger\u00e4t kumulative I\/O-Statistiken. Um Aktivit\u00e4t als Rate zu bewerten, m\u00fcssen zwei Zeitpunkte verglichen werden. Dabei sind physische Laufwerke, Partitionen und virtuelle oder Device-Mapper-Ger\u00e4te sauber zu unterscheiden; Z\u00e4hler verschiedener Ebenen d\u00fcrfen nicht blind addiert werden. Ein offener Dateideskriptor eines Prozesses l\u00e4sst sich dabei nicht unmittelbar einem diskstats-Ger\u00e4tez\u00e4hler zuordnen: Dateisystem, Cache und Mapping-Schichten liegen dazwischen. Zusammen mit \/proc\/pressure\/io l\u00e4sst sich dennoch pr\u00fcfen, ob beobachtbare I\/O-Stalls und Ger\u00e4teaktivit\u00e4t zeitlich zusammenfallen.","ref":""},{"kind":"citation","text":"","ref":"S9"}]}]},{"id":"proc-monitoring","heading":"procfs im Betrieb: Abfragen, Monitoring und Datenschutz","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr wiederholbare Betriebsdiagnosen behandelst du procfs-Abfragen als Messpunkte: Du notierst Zeitstempel, Systemkontext und die konkrete Abfrage. Viele Werte sind seit dem Start kumulierte Z\u00e4hler; erst die Differenz zweier Werte geteilt durch das Zeitintervall ergibt eine Rate. Das gilt etwa f\u00fcr Z\u00e4hler aus ","ref":""},{"kind":"code","text":"\/proc\/diskstats","ref":""},{"kind":"text","text":". Eine Einzelabfrage kann daher Aktivit\u00e4t belegen, aber weder Durchsatz noch eine dauerhafte Verschlechterung zuverl\u00e4ssig quantifizieren. ","ref":""},{"kind":"citation","text":"","ref":"S9"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Ein Monitoring-System sollte in festen Intervallen unter anderem Speicherwerte aus ","ref":""},{"kind":"code","text":"\/proc\/meminfo","ref":""},{"kind":"text","text":", Ger\u00e4tewerte aus ","ref":""},{"kind":"code","text":"\/proc\/diskstats","ref":""},{"kind":"text","text":", Prozess- und Systemzust\u00e4nde sowie bei verf\u00fcgbarer Kernelunterst\u00fctzung Drucksignale erfassen. Es muss Rohwerte in passende Einheiten umrechnen, bei Z\u00e4hlern Differenzen bilden und Historien speichern. In Containern darf es globale procfs-Werte nicht mit den Ressourcenlimits der Workload gleichsetzen: Prozesspfade k\u00f6nnen auf den PID-Namespace begrenzt sein, w\u00e4hrend Speicher- oder Ger\u00e4tewerte teilweise den Host abbilden. F\u00fcr Limits und Auslastung einer Gruppe sind erg\u00e4nzende cgroup2-Metriken n\u00f6tig. Erst zeitliche Verl\u00e4ufe erlauben belastbare Schwellenwerte: Ein hoher Wert kann normal sein, wenn er zum erwarteten Lastfenster passt; ein pl\u00f6tzlicher Anstieg gegen\u00fcber der eigenen Baseline ist oft relevanter. Die verf\u00fcgbaren procfs-Eintr\u00e4ge h\u00e4ngen vom laufenden Kernel und seiner Konfiguration ab. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Direkte Dateien und Werkzeuge erg\u00e4nzen sich. ","ref":""},{"kind":"code","text":"ps","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"top","ref":""},{"kind":"text","text":" oder ","ref":""},{"kind":"code","text":"htop","ref":""},{"kind":"text","text":" eignen sich f\u00fcr die interaktive Prozesssicht; ","ref":""},{"kind":"code","text":"free","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"vmstat","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"iostat","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"pidstat","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"ss","ref":""},{"kind":"text","text":" und ","ref":""},{"kind":"code","text":"sar","ref":""},{"kind":"text","text":" bereiten je nach Installation Daten f\u00fcr bestimmte Fragen auf. procfs bleibt sinnvoll, wenn du die Kernelquelle direkt pr\u00fcfen oder ein kleines, nachvollziehbares Skript bauen m\u00f6chtest. F\u00fcr Alarmierung und Kapazit\u00e4tsplanung sind Zeitreihendaten meist die passendere Ebene.","ref":""}]},{"type":"callout","variant":"warning","title":"Prozessdaten nicht unbedacht weitergeben","runs":[{"kind":"text","text":"Kommandozeilen k\u00f6nnen Pfade, Mandantenkennungen oder versehentlich \u00fcbergebene Zugangsdaten enthalten. Umgebungsvariablen eines Prozesses sind h\u00e4ufig noch sensibler. Erfasse, speichere und teile diese Daten nur, wenn sie f\u00fcr die Diagnose erforderlich sind; beschr\u00e4nke Zugriffe auf berechtigte Personen.","ref":""}]},{"type":"paragraph","runs":[{"kind":"text","text":"Auch bei rein lesenden Abfragen gelten Sichtbarkeitsgrenzen. Zugriffsrechte, Mount-Optionen und PID-Namespaces k\u00f6nnen Prozessdaten ausblenden oder auf eine Containeransicht begrenzen. Umgekehrt bedeutet eine eigene \/proc-Einh\u00e4ngung nicht, dass jede globale Kerneldatei nur Daten des Containers enth\u00e4lt. Ein fehlender Prozesseintrag oder ein unerwartet hoher globaler Wert ist deshalb zun\u00e4chst ein Hinweis darauf, Ausf\u00fchrungsumgebung, Mount-Optionen und cgroup-Kontext zu kl\u00e4ren. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]}]},{"id":"proc-troubleshooting","heading":"Diagnosepfade f\u00fcr langsame Dienste und Ressourcenengp\u00e4sse","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Troubleshooting beginnt mit einem Symptom, nicht mit einem vermeintlich schuldigen Einzelwert. Pr\u00fcfe danach mindestens ein unabh\u00e4ngiges Signal und halte fest, ob die Beobachtung den Host, eine virtuelle Maschine oder einen Container betrifft. So vermeidest du beispielsweise, einen hohen Load vorschnell als CPU-Problem oder eine gro\u00dfe Zahl offener Deskriptoren vorschnell als Leck zu bewerten. Die folgenden Pfade sind lesende Erstdiagnosen und ersetzen keine anwendungsbezogenen Logs.","ref":""}]},{"type":"table","caption":"Kompakte Diagnosepfade mit procfs","headers":["Symptom","Zuerst lesen","Danach abgleichen","Fehlinterpretation vermeiden"],"rows":[["Hoher Load","\/proc\/loadavg","\/proc\/stat, \/proc\/pressure\/io, \/proc\/diskstats","Load umfasst laufbereite und ununterbrechbar wartende Tasks, nicht nur CPU-Arbeit."],["Vermuteter Speicherdruck","\/proc\/meminfo","\/proc\/pressure\/memory, \/proc\/<PID>\/status","Niedriges MemFree allein beweist keinen RAM-Mangel; MemAvailable und Stalls z\u00e4hlen mit."],["Auff\u00e4llige I\/O-Wartezeit","\/proc\/stat","\/proc\/pressure\/io, \/proc\/diskstats in zwei Messpunkten","iowait ist keine direkte Latenzmessung und hat dokumentierte Einschr\u00e4nkungen."],["Viele offene Dateien","\/proc\/sys\/fs\/file-nr und \/proc\/sys\/fs\/file-max","\/proc\/<PID>\/fd, Dienstverhalten","Viele Deskriptoren k\u00f6nnen f\u00fcr einen Server normal sein; Grenzen und Wachstum sind wichtiger."],["Dienst startet nicht","\/proc\/<PID>\/status, sofern ein Prozess entsteht","\/proc\/<PID>\/fd, Dienstjournal, belegte Ressourcen","Ein nicht sichtbarer Prozess kann beendet sein oder au\u00dferhalb des sichtbaren PID-Namespace laufen."]],"source_ids":["S1","S3","S4","S5","S6","S9","S10"]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei hoher Load Average pr\u00fcfst du zun\u00e4chst, ob ausf\u00fchrbare oder wartende Aufgaben die Zahl treiben. Die Load-Angaben bilden Durchschnittswerte \u00fcber ein, f\u00fcnf und 15 Minuten ab und ber\u00fccksichtigen sowohl R- als auch D-Zust\u00e4nde. Vergleiche deshalb CPU-Zeitfelder nur mit Vorsicht mit I\/O-Druck und Ger\u00e4teaktivit\u00e4t. Insbesondere ","ref":""},{"kind":"strong","text":"iowait","ref":""},{"kind":"text","text":" darf nicht isoliert als Speicherlatenz gelesen werden. ","ref":""},{"kind":"citation","text":"","ref":"S3"},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei einer langsamen Anwendung und kleinem MemFree ist ","ref":""},{"kind":"strong","text":"MemAvailable","ref":""},{"kind":"text","text":" der bessere erste Kontextwert. Erg\u00e4nze Speicher-PSI und den Status des betroffenen Prozesses, etwa dessen VmRSS, Threadzahl und Zustand. PSI unterscheidet bei Speicher und I\/O zwischen ","ref":""},{"kind":"code","text":"some","ref":""},{"kind":"text","text":" f\u00fcr teilweise blockierte Tasks und ","ref":""},{"kind":"code","text":"full","ref":""},{"kind":"text","text":" f\u00fcr vollst\u00e4ndige Blockierung nicht-idler Tasks. Fehlen PSI-Dateien, kann dies an Kernelkonfiguration oder Umgebung liegen; es widerlegt keinen Engpass. ","ref":""},{"kind":"citation","text":"","ref":"S5"},{"kind":"citation","text":"","ref":"S6"}]},{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr Datei- und Prozessdiagnosen k\u00f6nnen Rechte und ","ref":""},{"kind":"strong","text":"PID-Namespaces","ref":""},{"kind":"text","text":" die Aussagekraft einschr\u00e4nken. In Containern beschreibt \/proc h\u00e4ufig nur die zugeordnete Prozesswelt. Bei verweigertem Zugriff oder unvollst\u00e4ndigen Verzeichnissen pr\u00fcfst du daher Nutzerrechte, procfs-Mount-Optionen und den Namespace-Kontext, bevor du aus der Abwesenheit von Daten eine technische Schlussfolgerung ziehst. ","ref":""},{"kind":"citation","text":"","ref":"S1"}]}]},{"id":"proc-decisions","heading":"Typische Fehlannahmen korrigieren und passende Werkzeuge w\u00e4hlen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Vier Kurzschl\u00fcsse f\u00fchren in der Linux-Administration h\u00e4ufig zu falschen Ma\u00dfnahmen. Wenig ","ref":""},{"kind":"code","text":"MemFree","ref":""},{"kind":"text","text":" bedeutet nicht automatisch RAM-Not, weil der Kernel Speicher unter anderem als Cache nutzt; f\u00fcr neue Anwendungen ist MemAvailable die aussagekr\u00e4ftigere Sch\u00e4tzung. Hoher Load beweist keine CPU-S\u00e4ttigung, da auch ununterbrechbar wartende Aufgaben einflie\u00dfen. Ein hoher iowait-Anteil misst keine unmittelbare Latenz eines Datentr\u00e4gers. Und procfs ist nicht \u00fcberall identisch: Kernelversion, Konfiguration, Hardware, Module und Namespaces beeinflussen Dateien und Felder. ","ref":""},{"kind":"citation","text":"","ref":"S1"},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"W\u00e4hle die Methode nach der Frage. F\u00fcr eine punktuelle Ursachenanalyse liefert ","ref":""},{"kind":"strong","text":"procfs","ref":""},{"kind":"text","text":" unmittelbare Rohdaten des laufenden Kernels. F\u00fcr eine schnelle, menschenlesbare \u00dcbersicht sind spezialisierte Kommandozeilenwerkzeuge meist effizienter. Wenn Trends, Alarmierung oder Kapazit\u00e4tsentscheidungen z\u00e4hlen, ben\u00f6tigst du ein Monitoring, das Messpunkte zeitlich einordnet, Z\u00e4hlerdifferenzen berechnet und historische Vergleichswerte vorh\u00e4lt. Bei Ressourcenlimits einzelner Dienste oder Container erg\u00e4nzt eine Analyse auf cgroup-Ebene die globale Hostansicht; PSI kann bei passender Konfiguration auch pro cgroup verf\u00fcgbar sein. ","ref":""},{"kind":"citation","text":"","ref":"S6"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Besondere Zur\u00fcckhaltung gilt f\u00fcr ","ref":""},{"kind":"code","text":"\/proc\/sys","ref":""},{"kind":"text","text":". Das Lesen eines Parameters ist Diagnostik, das Schreiben ver\u00e4ndert aktives Kernelverhalten. \u00c4ndere einen Wert nur, wenn die Ursache verstanden ist, der Ausgangswert dokumentiert wurde, Auswirkungen beobachtbar sind und ein R\u00fcckweg feststeht. Die Verzeichnisse ","ref":""},{"kind":"code","text":"fs","ref":""},{"kind":"text","text":", ","ref":""},{"kind":"code","text":"vm","ref":""},{"kind":"text","text":" und ","ref":""},{"kind":"code","text":"net","ref":""},{"kind":"text","text":" ordnen Parameter thematisch, liefern aber keine universellen Tuningvorgaben. ","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Das Beispiel ","ref":""},{"kind":"code","text":"drop_caches","ref":""},{"kind":"text","text":" zeigt den Unterschied zwischen Eingriff und Optimierung: Die Kernel-Dokumentation beschreibt die Schnittstelle als nicht destruktiv, warnt jedoch vor Leistungsproblemen und empfiehlt sie nicht als regul\u00e4re Betriebsma\u00dfnahme au\u00dferhalb von Test- oder Debug-Szenarien. Eine konservative Regel lautet daher: Erst messen, dann eine begr\u00fcndete \u00c4nderung begrenzt vornehmen, Wirkung und Nebenwirkungen beobachten und die Entscheidung dokumentieren. ","ref":""},{"kind":"citation","text":"","ref":"S11"}]}]}]},"_wh_make_word_report":{"words":2798,"min":2000,"max":3000,"target":2500,"ok":true,"missing":0,"excess":0,"lead_words":64,"section_words":{"proc-basics":252,"proc-time-context":269,"proc-sysctl-boundary":230,"proc-overview-table":380,"proc-load-memory":369,"proc-process-io":319,"proc-monitoring":331,"proc-troubleshooting":332,"proc-decisions":252}},"_wh_make_review":{"verdict":"pass","issues":[],"checked_source_ids":["S1","S3","S4","S5","S6","S7","S9","S10","S11","S12"],"summary":"Der Artikel ist fachlich plausibel und durch die gepr\u00fcften Kernel-Dokumentationen sowie Linux-Manpages gest\u00fctzt. Die Abgrenzung von Momentaufnahmen, gleitenden Mittelwerten und kumulativen Z\u00e4hlern ist korrekt. Load Average, iowait, MemAvailable, PSI, Prozessstatus, Dateideskriptoren, diskstats und file-nr werden mit den n\u00f6tigen Einschr\u00e4nkungen erkl\u00e4rt. Schreibzugriffe unter \/proc\/sys sind klar von lesender Diagnostik getrennt; drop_caches wird nicht als regul\u00e4re Optimierung empfohlen. Container-, Namespace- und cgroup-Grenzen sind angemessen formuliert. Die Terminalbeispiele sind lesend, die Bildkonzepte suggerieren keine falsche direkte Zuordnung zwischen Prozessdateien und Blockger\u00e4te-I\/O, und es werden keine eigenen Messungen oder Tests behauptet. Versionsgebundene Quellen werden im Versionshinweis transparent kenntlich gemacht."},"_wh_make_review_doc_hash":"170001268aa02e1f1b3ca6d6477a053be0a1d7b6c241271836a300e46634ed3c","_yoast_wpseo_primary_category":null,"rank_math_schema_blogposting":null,"rank_math_schema_videoobject":null,"_oembed_049c719bc4a9f89deaead66a7da9fddc":null,"_oembed_time_049c719bc4a9f89deaead66a7da9fddc":null,"_yoast_wpseo_focuskw":null,"inline_featured_image":null,"_yoast_wpseo_linkdex":null,"_eael_widget_elements":null,"_oembed_c3b0f6959478faf92a1f343d8f96b19e":null,"_oembed_27e3473bf8bec795fbeb3a9d38489348":null,"_trp_translated_slug_en_us":null,"_yoast_wpseo_title":null,"tldname":null,"tldpreis":null,"tldrubrik":null,"tldpolicylink":null,"tldsize":null,"tldregistrierungsdauer":null,"tldtransfer":null,"tldwhoisprivacy":null,"tldregistrarchange":null,"tldregistrantchange":null,"tldwhoisupdate":null,"tldnameserverupdate":null,"tlddeletesofort":null,"tlddeleteexpire":null,"tldumlaute":null,"tldrestore":null,"tldsubcategory":null,"tldbildname":null,"tldbildurl":null,"tldclean":null,"tldcategory":null,"tldpolicy":null,"tldbesonderheiten":null,"tld_bedeutung":null,"_oembed_d167040d816d8f94c072940c8009f5f8":null,"_oembed_b0a0fa59ef14f8870da2c63f2027d064":null,"_oembed_4792fa4dfb2a8f09ab950a73b7f313ba":null,"_oembed_33ceb1fe54a8ab775d9410abf699878d":null,"_oembed_fd7014d14d919b45ec004937c0db9335":null,"_oembed_21a029d076783ec3e8042698c351bd7e":null,"_oembed_be5ea8a0c7b18e658f08cc571a909452":null,"_oembed_a9ca7a298b19f9b48ec5914e010294d2":null,"_oembed_f8db6b27d08a2bb1f920e7647808899a":null,"_oembed_168ebde5096e77d8a89326519af9e022":null,"_oembed_cdb76f1b345b42743edfe25481b6f98f":null,"_oembed_87b0613611ae54e86e8864265404b0a1":null,"_oembed_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_oembed_time_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_tldname":null,"_tldclean":null,"_tldpreis":null,"_tldcategory":null,"_tldsubcategory":null,"_tldpolicy":null,"_tldpolicylink":null,"_tldsize":null,"_tldregistrierungsdauer":null,"_tldtransfer":null,"_tldwhoisprivacy":null,"_tldregistrarchange":null,"_tldregistrantchange":null,"_tldwhoisupdate":null,"_tldnameserverupdate":null,"_tlddeletesofort":null,"_tlddeleteexpire":null,"_tldumlaute":null,"_tldrestore":null,"_tldbildname":null,"_tldbildurl":null,"_tld_bedeutung":null,"_tldbesonderheiten":null,"_oembed_8357e2b8a2575c74ed5978f262a10126":null,"_oembed_ad96e4112edb9f8ffa35731d4098bc6b":null,"_oembed_3d5fea5103dd0d22ec5d6a33eff7f863":null,"_oembed_819a879e7da16dd629cfd15a97334c8a":null,"_oembed_time_819a879e7da16dd629cfd15a97334c8a":null,"_wh_make_writer_raw":null,"_wh_make_design_backup_204":null,"_wp_desired_post_slug":null,"_oembed_0d8a206f09633e3d62b95a15a4dd0487":null,"_oembed_time_0d8a206f09633e3d62b95a15a4dd0487":null,"_aioseo_description":null,"_eb_attr":null,"_eb_data_table":null,"_acf_changed":null,"_wpcode_auto_insert":null,"_edit_last":"1","_edit_lock":"1790075357:1","_oembed_e7b913c6c84084ed9702cb4feb012ddd":null,"_oembed_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_time_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_03514b67990db061d7c4672de26dc514":null,"_oembed_time_03514b67990db061d7c4672de26dc514":null,"rank_math_news_sitemap_robots":null,"rank_math_robots":null,"_eael_post_view_count":"98","_trp_automatically_translated_slug_ru_ru":null,"_trp_automatically_translated_slug_et":null,"_trp_automatically_translated_slug_lv":null,"_trp_automatically_translated_slug_fr_fr":null,"_trp_automatically_translated_slug_en_us":null,"_wp_old_slug":null,"_trp_automatically_translated_slug_da_dk":null,"_trp_automatically_translated_slug_pl_pl":null,"_trp_automatically_translated_slug_es_es":null,"_trp_automatically_translated_slug_hu_hu":null,"_trp_automatically_translated_slug_fi":null,"_trp_automatically_translated_slug_ja":null,"_trp_automatically_translated_slug_lt_lt":null,"_elementor_edit_mode":null,"_elementor_template_type":null,"_elementor_version":null,"_elementor_pro_version":null,"_wp_page_template":null,"_elementor_page_settings":null,"_elementor_data":null,"_elementor_css":null,"_elementor_conditions":null,"_happyaddons_elements_cache":null,"_oembed_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_time_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_time_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_59808117857ddf57e478a31d79f76e4d":null,"_oembed_time_59808117857ddf57e478a31d79f76e4d":null,"_oembed_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_time_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_81002f7ee3604f645db4ebcfd1912acf":null,"_oembed_time_81002f7ee3604f645db4ebcfd1912acf":null,"_elementor_screenshot":null,"_oembed_7ea3429961cf98fa85da9747683af827":null,"_oembed_time_7ea3429961cf98fa85da9747683af827":null,"_elementor_controls_usage":null,"_elementor_page_assets":[],"_elementor_screenshot_failed":null,"theplus_transient_widgets":null,"_eael_custom_js":null,"_wp_old_date":null,"_trp_automatically_translated_slug_it_it":null,"_trp_automatically_translated_slug_pt_pt":null,"_trp_automatically_translated_slug_zh_cn":null,"_trp_automatically_translated_slug_nl_nl":null,"_trp_automatically_translated_slug_pt_br":null,"_trp_automatically_translated_slug_sv_se":null,"rank_math_analytic_object_id":null,"_trp_automatically_translated_slug_ro_ro":null,"_trp_automatically_translated_slug_sk_sk":null,"_trp_automatically_translated_slug_bg_bg":null,"_trp_automatically_translated_slug_sl_si":null,"litespeed_vpi_list":null,"litespeed_vpi_list_mobile":null,"rank_math_seo_score":"75","rank_math_contentai_score":null,"ilj_limitincominglinks":"","ilj_maxincominglinks":"1","ilj_limitoutgoinglinks":"","ilj_maxoutgoinglinks":"1","ilj_limitlinksperparagraph":"","ilj_linksperparagraph":"1","ilj_blacklistdefinition":[],"ilj_linkdefinition":[],"_eb_reusable_block_ids":null,"rank_math_focus_keyword":"Linux procfs","rank_math_og_content_image":null,"surfer_last_post_update":null,"surfer_last_post_update_direction":null,"surfer_keywords":null,"surfer_location":null,"surfer_draft_id":null,"surfer_permalink_hash":null,"surfer_scrape_ready":null,"_thumbnail_id":"21652","_yoast_wpseo_metadesc":null,"_yoast_wpseo_content_score":null,"_yoast_wpseo_focuskeywords":null,"_yoast_wpseo_keywordsynonyms":null,"_yoast_wpseo_estimated-reading-time-minutes":null,"rank_math_description":"Wichtige procfs-Dateien f\u00fcr Linux-Administratoren: Systemlast, Speicher, Prozesse, I\/O und \/proc\/sys korrekt lesen und einordnen.","footnotes":null,"_links":{"self":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/21649","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/comments?post=21649"}],"version-history":[{"count":4,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/21649\/revisions"}],"predecessor-version":[{"id":21657,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/21649\/revisions\/21657"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/media\/21652"}],"wp:attachment":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/media?parent=21649"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/categories?post=21649"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/tags?post=21649"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}