1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
/*
* HardInfo - Displays System Information
* Copyright (C) 2003-2007 L. A. F. Pereira <l@tia.mat.br>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 2 or later.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <string.h>
#include "devices.h"
GHashTable *memlabels = NULL;
gint comparMem (gpointer a, gpointer b) {return strcmp( (char*)a, (char*)b );}
void scan_memory_do(void)
{
gchar **keys, *tmp, *memstr, *lgstr, *tmp_label, *trans_val;
static gint offset = -1;
gint i;
GList *list=NULL, *a;
if (offset == -1) {
/* gah. linux 2.4 adds three lines of data we don't need in
* /proc/meminfo.
* The lines look something like this:
* total: used: free: shared: buffers: cached:
* Mem: 3301101568 1523159040 1777942528 0 3514368 1450356736
* Swap: 0 0 0
*/
gchar *os_kernel = module_call_method("computer::getOSKernel");
if (os_kernel) {
offset = strstr(os_kernel, "Linux 2.4") ? 3 : 0;
g_free(os_kernel);
} else {
offset = 0;
}
}
g_file_get_contents("/proc/meminfo", &tmp, NULL, NULL);
keys = g_strsplit(tmp, "\n", 0);
g_free(tmp);
for (i = offset; keys[i]; i++) {
gchar **newkeys = g_strsplit(keys[i], ":", 0);
if (!newkeys[0]) {
g_strfreev(newkeys);
break;
}
g_strstrip(newkeys[0]);
g_strstrip(newkeys[1]);
/* try to find a localizable label */
tmp = g_hash_table_lookup(memlabels, newkeys[0]);
if (tmp)
tmp_label = _(tmp);
else
tmp_label = newkeys[0];
if (strstr(newkeys[1], "kB")) {
trans_val = g_strdup_printf("%d %s", atoi(newkeys[1]), _("KiB") );
} else {
trans_val = strdup(newkeys[1]);
}
/*add MemTotal for internal usage*/
if(strcmp(newkeys[0],"MemTotal")==0) moreinfo_add_with_prefix("DEV", newkeys[0], g_strdup(newkeys[1]));
list = g_list_prepend(list, g_strdup_printf("%s=%s", tmp_label, trans_val));
g_free(trans_val);
g_strfreev(newkeys);
}
g_strfreev(keys);
//Sort memory information
list=g_list_sort(list,(GCompareFunc)comparMem);
//add memory information
memstr=strdup("");lgstr=strdup("");
while(list){
char **datas = g_strsplit(list->data,"=",2);
if (!datas[0]) {
g_strfreev(datas);
break;
}
moreinfo_add_with_prefix("DEV", datas[0], g_strdup(datas[1]));
tmp = g_strconcat(memstr, list->data, "\n", NULL);
g_free(memstr);
memstr=tmp;
tmp = g_strconcat(lgstr,"UpdateInterval$", datas[0], "=1000\n", NULL);
g_free(lgstr);
lgstr = tmp;
g_strfreev(datas);
//next and free
a=list;
list=list->next;
free(a->data);
g_list_free_1(a);
}
tmp=meminfo; meminfo = memstr; g_free(tmp);
tmp=lginterval; lginterval = lgstr; g_free(tmp);
}
void init_memory_labels(void)
{
static const struct {
char *proc_label;
char *real_label;
} proc2real[] = {
/* https://docs.kernel.org/filesystems/proc.html */
{ "MemTotal", N_("Total physical memory usable by the system") },
{ "MemFree", N_("Free memory which is not used for anything") },
{ "SwapTotal", N_("Virtual memory, total swap space available") },
{ "SwapFree", N_("Virtual memory, remaining swap space available") },
{ "SwapCached", N_("Memory present within main memory and in the swapfile") },
{ "HighTotal", N_("HighTotal value can vary based on the type of kernel used") },
{ "HighFree", N_("Amount of memory that is not directly mapped into kernel space") },
{ "LowTotal", N_("LowTotal value can vary based on the type of kernel used") },
{ "LowFree", N_("Total and free memory directly mapped into kernel space") },
{ "MemAvailable", N_("Available memory for allocation to any process, without swapping") },
{ "Buffers", N_("Memory in buffer cache, temporary storage for raw disk blocks") },
{ "Cached", N_("Memory in the page cache (diskcache, shared memory, tmpfs and shmem)") },
{ "Active", N_("Memory used more recently and not swapped out or reclaimed") },
{ "Inactive", N_("Memory not been used recently and can be swapped out or reclaimed") },
{ "Active(anon)", N_("Anonymous memory used more recently and not swapped out") },
{ "Inactive(anon)", N_("Anonymous memory not been used and can be swapped out") },
{ "Active(file)", N_("Pagecache memory been used more recently and not reclaimed") },
{ "Inactive(file)", N_("Pagecache memory reclaimable without huge performance impact") },
{ "Unevictable", N_("Unevictable pages can't be swapped out for a variety of reasons") },
{ "Mlocked", N_("Pages locked to memory using the mlock() system call") },
{ "Zswap", N_("Memory consumed by the zswap backend (compressed size)") },
{ "Zswapped", N_("Amount of anonymous memory stored in zswap (original size)") },
{ "Dirty", N_("Memory waiting to be written back to disk") },
{ "Writeback", N_(" Memory which is actively being written back to disk") },
{ "AnonPages", N_("Non-file backed pages mapped into userspace page tables") },
{ "Mapped", N_("Files which have been mmapped, such as libraries") },
{ "Shmem", N_("Total memory used by shared memory (shmem) and tmpfs") },
{ "KReclaimable", N_("Kernel allocations reclaimable under memory pressure") },
{ "Slab", N_("In-kernel data structures cache") },
{ "SReclaimable", N_("Part of Slab, that might be reclaimed, such as caches") },
{ "SUnreclaim", N_("Part of Slab, that cannot be reclaimed on memory pressure") },
{ "KernelStack", N_("Memory consumed by the kernel stacks of all tasks") },
{ "PageTables", N_("Memory consumed by userspace page tables") },
{ "SecPageTables", N_("Memory consumed by secondary page tables") },
{ "NFS_Unstable", N_("Previous counted pages which had been written to the server") },
{ "Bounce", N_("Memory used for block device bounce buffers") },
{ "WritebackTmp", N_("Memory used by FUSE for temporary writeback buffers") },
{ "CommitLimit", N_("Total memory currently available to be allocated on the system") },
{ "Committed_AS", N_("The amount of memory presently allocated on the system") },
{ "VmallocTotal", N_("Total size of vmalloc virtual address space") },
{ "VmallocUsed", N_("Amount of vmalloc area which is used") },
{ "VmallocChunk", N_("Largest contiguous block of vmalloc area which is free") },
{ "Percpu", N_("Memory allocated to the percpu allocator") },
{ "HardwareCorrupted", N_("Amount of memory the kernel identifies as corrupted") },
{ "AnonHugePages", N_("Non-file backed huge pages mapped into userspace page tables") },
{ "ShmemHugePages", N_("Memory used by shmem and tmpfs allocated with huge pages") },
{ "ShmemPmdMapped", N_("Shared memory mapped into userspace with huge pages") },
{ "FileHugePages", N_("Memory used for fs data (page cache) allocated with huge pages") },
{ "FilePmdMapped", N_("Page cache mapped into userspace with huge pages") },
{ "CmaTotal", N_("Memory reserved for the Contiguous Memory Allocator (CMA)") },
{ "CmaFree", N_("Free remaining memory in the CMA reserves") },
{ "Unaccepted", N_("Amount of unaccepted memory usable by the kernel") },
{ "HugePages_Total", N_("Size of the pool of huge pages") },
{ "HugePages_Free", N_("Number of huge pages available") },
{ "HugePages_Rsvd", N_("Number of huge pages reserved") },
{ "HugePages_Surp", N_("Number of huge pages surplus") },
{ "Hugepagesize", N_("Huge page size, used in conjunction with hugepages parameter") },
{ "Hugetlb", N_("Total amount of memory consumed by huge pages of all sizes") },
{ "DirectMap4k", N_("Breakdown of page table sizes of 4k size") },
{ "DirectMap2M", N_("Breakdown of page table sizes of 2M size") },
{ "DirectMap1G", N_("Breakdown of page table sizes of 1G size") },
{ NULL },
};
gint i;
memlabels = g_hash_table_new(g_str_hash, g_str_equal);
for (i = 0; proc2real[i].proc_label; i++) {
g_hash_table_insert(memlabels, proc2real[i].proc_label,
_(proc2real[i].real_label));
}
}
|
