kernel - Implement CPU localization hinting for low level page allocations
[dragonfly.git] / sys / vm / vm_kern.c
CommitLineData
984263bc 1/*
99ad9bc4
MD
2 * (MPSAFE)
3 *
984263bc
MD
4 * Copyright (c) 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * The Mach Operating System project at Carnegie-Mellon University.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
dc71b7ab 18 * 3. Neither the name of the University nor the names of its contributors
984263bc
MD
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * from: @(#)vm_kern.c 8.3 (Berkeley) 1/12/94
35 *
36 *
37 * Copyright (c) 1987, 1990 Carnegie-Mellon University.
38 * All rights reserved.
39 *
40 * Authors: Avadis Tevanian, Jr., Michael Wayne Young
41 *
42 * Permission to use, copy, modify and distribute this software and
43 * its documentation is hereby granted, provided that both the copyright
44 * notice and this permission notice appear in all copies of the
45 * software, derivative works or modified versions, and any portions
46 * thereof, and that both notices appear in supporting documentation.
47 *
48 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
49 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
50 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
51 *
52 * Carnegie Mellon requests users of this software to return to
53 *
54 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
55 * School of Computer Science
56 * Carnegie Mellon University
57 * Pittsburgh PA 15213-3890
58 *
59 * any improvements or extensions that they make and grant Carnegie the
60 * rights to redistribute these changes.
61 *
62 * $FreeBSD: src/sys/vm/vm_kern.c,v 1.61.2.2 2002/03/12 18:25:26 tegge Exp $
63 */
64
65/*
66 * Kernel memory management.
67 */
68
69#include <sys/param.h>
70#include <sys/systm.h>
71#include <sys/proc.h>
72#include <sys/malloc.h>
c5a45196
MD
73#include <sys/kernel.h>
74#include <sys/sysctl.h>
984263bc
MD
75
76#include <vm/vm.h>
77#include <vm/vm_param.h>
78#include <sys/lock.h>
79#include <vm/pmap.h>
80#include <vm/vm_map.h>
81#include <vm/vm_object.h>
82#include <vm/vm_page.h>
83#include <vm/vm_pageout.h>
e1359933 84#include <vm/vm_kern.h>
984263bc
MD
85#include <vm/vm_extern.h>
86
e4846942 87struct vm_map kernel_map;
e4846942
MD
88struct vm_map clean_map;
89struct vm_map buffer_map;
984263bc 90
070a58b3
MD
91static __inline
92int
93KMVMCPU(int kmflags)
94{
95 if ((kmflags & KM_CPU_SPEC) == 0)
96 return 0;
97 return VM_ALLOC_CPU(KM_GETCPU(kmflags));
98}
99
8ec5b2c9
MD
100/*
101 * Allocate pageable swap-backed anonymous memory
102 */
103void *
3091de50 104kmem_alloc_swapbacked(kmem_anon_desc_t *kp, vm_size_t size, vm_subsys_t id)
8ec5b2c9
MD
105{
106 int error;
107 vm_pindex_t npages;
108
109 size = round_page(size);
110 npages = size / PAGE_SIZE;
111
112 if (kp->map == NULL)
113 kp->map = &kernel_map;
114 kp->data = vm_map_min(&kernel_map);
115 kp->size = size;
116 kp->object = vm_object_allocate(OBJT_DEFAULT, npages);
117
118 error = vm_map_find(kp->map, kp->object, NULL, 0,
119 &kp->data, size,
3091de50
MD
120 PAGE_SIZE, TRUE,
121 VM_MAPTYPE_NORMAL, id,
8ec5b2c9
MD
122 VM_PROT_ALL, VM_PROT_ALL, 0);
123 if (error) {
124 kprintf("kmem_alloc_swapbacked: %zd bytes failed %d\n",
125 size, error);
126 kp->data = (vm_offset_t)0;
127 kmem_free_swapbacked(kp);
128 return NULL;
129 }
130 return ((void *)(intptr_t)kp->data);
131}
132
133void
134kmem_free_swapbacked(kmem_anon_desc_t *kp)
135{
136 if (kp->data) {
137 /*
138 * The object will be deallocated by kmem_free().
139 */
140 kmem_free(kp->map, kp->data, kp->size);
141 kp->data = (vm_offset_t)0;
142 } else {
143 /*
144 * Failure during allocation, object must be deallocated
145 * manually.
146 */
147 vm_object_deallocate(kp->object);
148 }
149 kp->object = NULL;
150}
151
984263bc 152/*
99ad9bc4 153 * Allocate pageable memory to the kernel's address map. "map" must
8ec5b2c9
MD
154 * be kernel_map or a submap of kernel_map. Caller must adjust map or
155 * enter VM pages itself.
984263bc 156 *
99ad9bc4 157 * No requirements.
984263bc 158 */
984263bc 159vm_offset_t
3091de50 160kmem_alloc_pageable(vm_map_t map, vm_size_t size, vm_subsys_t id)
984263bc
MD
161{
162 vm_offset_t addr;
5f910b2f 163 int result;
984263bc
MD
164
165 size = round_page(size);
166 addr = vm_map_min(map);
0adbcbd6
MD
167 result = vm_map_find(map, NULL, NULL,
168 (vm_offset_t) 0, &addr, size,
3091de50
MD
169 PAGE_SIZE, TRUE,
170 VM_MAPTYPE_NORMAL, id,
0adbcbd6 171 VM_PROT_ALL, VM_PROT_ALL, 0);
2de4f77e 172 if (result != KERN_SUCCESS)
984263bc 173 return (0);
984263bc
MD
174 return (addr);
175}
176
177/*
99ad9bc4 178 * Same as kmem_alloc_pageable, except that it create a nofault entry.
984263bc 179 *
99ad9bc4 180 * No requirements.
984263bc 181 */
984263bc 182vm_offset_t
3091de50
MD
183kmem_alloc_nofault(vm_map_t map, vm_size_t size, vm_subsys_t id,
184 vm_size_t align)
984263bc
MD
185{
186 vm_offset_t addr;
5f910b2f 187 int result;
984263bc
MD
188
189 size = round_page(size);
190 addr = vm_map_min(map);
0adbcbd6
MD
191 result = vm_map_find(map, NULL, NULL,
192 (vm_offset_t) 0, &addr, size,
3091de50
MD
193 align, TRUE,
194 VM_MAPTYPE_NORMAL, id,
0adbcbd6 195 VM_PROT_ALL, VM_PROT_ALL, MAP_NOFAULT);
2de4f77e 196 if (result != KERN_SUCCESS)
984263bc 197 return (0);
984263bc
MD
198 return (addr);
199}
200
201/*
99ad9bc4
MD
202 * Allocate wired-down memory in the kernel's address map or a submap.
203 *
204 * No requirements.
984263bc
MD
205 */
206vm_offset_t
3091de50 207kmem_alloc3(vm_map_t map, vm_size_t size, vm_subsys_t id, int kmflags)
984263bc
MD
208{
209 vm_offset_t addr;
e40cfbd7 210 vm_offset_t gstart;
984263bc 211 vm_offset_t i;
a108bf71 212 int count;
e40cfbd7 213 int cow;
984263bc
MD
214
215 size = round_page(size);
216
e1359933
MD
217 if (kmflags & KM_KRESERVE)
218 count = vm_map_entry_kreserve(MAP_RESERVE_COUNT);
219 else
220 count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
a108bf71 221
e40cfbd7
MD
222 if (kmflags & KM_STACK) {
223 cow = MAP_IS_KSTACK;
224 gstart = PAGE_SIZE;
225 } else {
226 cow = 0;
227 gstart = 0;
228 }
229
984263bc
MD
230 /*
231 * Use the kernel object for wired-down kernel pages. Assume that no
232 * region of the kernel object is referenced more than once.
a108bf71 233 *
984263bc
MD
234 * Locate sufficient space in the map. This will give us the final
235 * virtual address for the new memory, and thus will tell us the
236 * offset within the kernel map.
237 */
238 vm_map_lock(map);
9388fcaa 239 if (vm_map_findspace(map, vm_map_min(map), size, PAGE_SIZE, 0, &addr)) {
984263bc 240 vm_map_unlock(map);
e1359933
MD
241 if (kmflags & KM_KRESERVE)
242 vm_map_entry_krelease(count);
243 else
244 vm_map_entry_release(count);
984263bc
MD
245 return (0);
246 }
b12defdc
MD
247 vm_object_hold(&kernel_object);
248 vm_object_reference_locked(&kernel_object);
a108bf71 249 vm_map_insert(map, &count,
0adbcbd6
MD
250 &kernel_object, NULL,
251 addr, addr, addr + size,
3091de50 252 VM_MAPTYPE_NORMAL, id,
0adbcbd6 253 VM_PROT_ALL, VM_PROT_ALL, cow);
b12defdc
MD
254 vm_object_drop(&kernel_object);
255
984263bc 256 vm_map_unlock(map);
e1359933
MD
257 if (kmflags & KM_KRESERVE)
258 vm_map_entry_krelease(count);
259 else
260 vm_map_entry_release(count);
984263bc
MD
261
262 /*
263 * Guarantee that there are pages already in this object before
cde87949 264 * calling vm_map_wire. This is to prevent the following
984263bc
MD
265 * scenario:
266 *
267 * 1) Threads have swapped out, so that there is a pager for the
268 * kernel_object. 2) The kmsg zone is empty, and so we are
cde87949 269 * kmem_allocing a new page for it. 3) vm_map_wire calls vm_fault;
984263bc
MD
270 * there is no page, but there is a pager, so we call
271 * pager_data_request. But the kmsg zone is empty, so we must
272 * kmem_alloc. 4) goto 1 5) Even if the kmsg zone is not empty: when
273 * we get the data back from the pager, it will be (very stale)
274 * non-zero data. kmem_alloc is defined to return zero-filled memory.
275 *
276 * We're intentionally not activating the pages we allocate to prevent a
cde87949 277 * race with page-out. vm_map_wire will wire the pages.
984263bc 278 */
398c240d 279 vm_object_hold(&kernel_object);
e40cfbd7 280 for (i = gstart; i < size; i += PAGE_SIZE) {
984263bc
MD
281 vm_page_t mem;
282
e4846942 283 mem = vm_page_grab(&kernel_object, OFF_TO_IDX(addr + i),
d2d8515b 284 VM_ALLOC_FORCE_ZERO | VM_ALLOC_NORMAL |
070a58b3 285 VM_ALLOC_RETRY | KMVMCPU(kmflags));
54341a3b 286 vm_page_unqueue_nowakeup(mem);
984263bc
MD
287 vm_page_wakeup(mem);
288 }
398c240d 289 vm_object_drop(&kernel_object);
984263bc
MD
290
291 /*
292 * And finally, mark the data as non-pageable.
e40cfbd7
MD
293 *
294 * NOTE: vm_map_wire() handles any kstack guard.
984263bc 295 */
ad23467e 296 vm_map_wire(map, addr, addr + size, kmflags);
984263bc
MD
297
298 return (addr);
299}
300
301/*
99ad9bc4
MD
302 * Release a region of kernel virtual memory allocated with kmem_alloc,
303 * and return the physical pages associated with that region.
984263bc 304 *
99ad9bc4
MD
305 * WARNING! If the caller entered pages into the region using pmap_kenter()
306 * it must remove the pages using pmap_kremove[_quick]() before freeing the
307 * underlying kmem, otherwise resident_count will be mistabulated.
45758e38 308 *
99ad9bc4 309 * No requirements.
984263bc
MD
310 */
311void
51f9d31c 312kmem_free(vm_map_t map, vm_offset_t addr, vm_size_t size)
984263bc 313{
418ff780 314 vm_map_remove(map, trunc_page(addr), round_page(addr + size));
984263bc
MD
315}
316
317/*
99ad9bc4
MD
318 * Used to break a system map into smaller maps, usually to reduce
319 * contention and to provide large KVA spaces for subsystems like the
320 * buffer cache.
984263bc
MD
321 *
322 * parent Map to take range from
e4846942 323 * result
984263bc
MD
324 * size Size of range to find
325 * min, max Returned endpoints of map
326 * pageable Can the region be paged
99ad9bc4
MD
327 *
328 * No requirements.
984263bc 329 */
e4846942
MD
330void
331kmem_suballoc(vm_map_t parent, vm_map_t result,
332 vm_offset_t *min, vm_offset_t *max, vm_size_t size)
984263bc 333{
5f910b2f 334 int ret;
984263bc
MD
335
336 size = round_page(size);
337
338 *min = (vm_offset_t) vm_map_min(parent);
0adbcbd6
MD
339 ret = vm_map_find(parent, NULL, NULL,
340 (vm_offset_t) 0, min, size,
3091de50
MD
341 PAGE_SIZE, TRUE,
342 VM_MAPTYPE_UNSPECIFIED, VM_SUBSYS_SYSMAP,
0adbcbd6 343 VM_PROT_ALL, VM_PROT_ALL, 0);
984263bc 344 if (ret != KERN_SUCCESS) {
086c1d7e 345 kprintf("kmem_suballoc: bad status return of %d.\n", ret);
984263bc
MD
346 panic("kmem_suballoc");
347 }
348 *max = *min + size;
349 pmap_reference(vm_map_pmap(parent));
e4846942 350 vm_map_init(result, *min, *max, vm_map_pmap(parent));
984263bc
MD
351 if ((ret = vm_map_submap(parent, *min, *max, result)) != KERN_SUCCESS)
352 panic("kmem_suballoc: unable to change range to submap");
984263bc
MD
353}
354
984263bc 355/*
99ad9bc4
MD
356 * Allocates pageable memory from a sub-map of the kernel. If the submap
357 * has no room, the caller sleeps waiting for more memory in the submap.
984263bc 358 *
99ad9bc4 359 * No requirements.
984263bc 360 */
984263bc 361vm_offset_t
3091de50 362kmem_alloc_wait(vm_map_t map, vm_size_t size, vm_subsys_t id)
984263bc
MD
363{
364 vm_offset_t addr;
a108bf71 365 int count;
984263bc
MD
366
367 size = round_page(size);
368
e1359933 369 count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
a108bf71 370
984263bc
MD
371 for (;;) {
372 /*
373 * To make this work for more than one map, use the map's lock
374 * to lock out sleepers/wakers.
375 */
376 vm_map_lock(map);
9388fcaa
MD
377 if (vm_map_findspace(map, vm_map_min(map),
378 size, PAGE_SIZE, 0, &addr) == 0) {
984263bc 379 break;
c809941b 380 }
984263bc
MD
381 /* no space now; see if we can ever get space */
382 if (vm_map_max(map) - vm_map_min(map) < size) {
e1359933 383 vm_map_entry_release(count);
984263bc
MD
384 vm_map_unlock(map);
385 return (0);
386 }
387 vm_map_unlock(map);
377d4740 388 tsleep(map, 0, "kmaw", 0);
984263bc 389 }
a108bf71 390 vm_map_insert(map, &count,
0adbcbd6
MD
391 NULL, NULL,
392 (vm_offset_t) 0, addr, addr + size,
3091de50
MD
393 VM_MAPTYPE_NORMAL, id,
394 VM_PROT_ALL, VM_PROT_ALL, 0);
984263bc 395 vm_map_unlock(map);
e1359933 396 vm_map_entry_release(count);
99ad9bc4 397
984263bc
MD
398 return (addr);
399}
400
d491f445
JH
401/*
402 * Allocates a region from the kernel address map and physical pages
403 * within the specified address range to the kernel object. Creates a
404 * wired mapping from this region to these pages, and returns the
405 * region's starting virtual address. The allocated pages are not
406 * necessarily physically contiguous. If M_ZERO is specified through the
407 * given flags, then the pages are zeroed before they are mapped.
408 */
b524ca76 409vm_offset_t
3091de50
MD
410kmem_alloc_attr(vm_map_t map, vm_size_t size, vm_subsys_t id,
411 int flags, vm_paddr_t low,
afd2da4d 412 vm_paddr_t high, vm_memattr_t memattr)
b524ca76 413{
3e60310c
FT
414 vm_offset_t addr, i, offset;
415 vm_page_t m;
416 int count;
b524ca76 417
d491f445 418 size = round_page(size);
3e60310c
FT
419 count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
420 vm_map_lock(map);
421 if (vm_map_findspace(map, vm_map_min(map), size, PAGE_SIZE,
0adbcbd6 422 flags, &addr)) {
3e60310c
FT
423 vm_map_unlock(map);
424 vm_map_entry_release(count);
425 return (0);
426 }
4b579b46 427 offset = addr - vm_map_min(&kernel_map);
3e60310c
FT
428 vm_object_hold(&kernel_object);
429 vm_object_reference_locked(&kernel_object);
0adbcbd6
MD
430 vm_map_insert(map, &count,
431 &kernel_object, NULL,
432 offset, addr, addr + size,
3091de50 433 VM_MAPTYPE_NORMAL, id,
0adbcbd6 434 VM_PROT_ALL, VM_PROT_ALL, 0);
3e60310c
FT
435 vm_map_unlock(map);
436 vm_map_entry_release(count);
437 vm_object_drop(&kernel_object);
438 for (i = 0; i < size; i += PAGE_SIZE) {
439 m = vm_page_alloc_contig(low, high, PAGE_SIZE, 0, PAGE_SIZE, memattr);
440 if (!m) {
441 return (0);
442 }
443 vm_object_hold(&kernel_object);
444 vm_page_insert(m, &kernel_object, OFF_TO_IDX(offset + i));
445 vm_object_drop(&kernel_object);
afd2da4d 446 if (flags & M_ZERO)
3e60310c
FT
447 pmap_zero_page(VM_PAGE_TO_PHYS(m));
448 m->valid = VM_PAGE_BITS_ALL;
449 }
450 vm_map_wire(map, addr, addr + size, 0);
451 return (addr);
b524ca76
MD
452}
453
454
984263bc 455/*
99ad9bc4
MD
456 * Returns memory to a submap of the kernel, and wakes up any processes
457 * waiting for memory in that map.
984263bc 458 *
99ad9bc4 459 * No requirements.
984263bc
MD
460 */
461void
57e43348 462kmem_free_wakeup(vm_map_t map, vm_offset_t addr, vm_size_t size)
984263bc 463{
a108bf71
MD
464 int count;
465
e1359933 466 count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
984263bc 467 vm_map_lock(map);
418ff780 468 vm_map_delete(map, trunc_page(addr), round_page(addr + size), &count);
984263bc
MD
469 wakeup(map);
470 vm_map_unlock(map);
e1359933 471 vm_map_entry_release(count);
984263bc
MD
472}
473
474/*
da23a592
MD
475 * Create the kernel_ma for (KvaStart,KvaEnd) and insert mappings to
476 * cover areas already allocated or reserved thus far.
984263bc 477 *
da23a592
MD
478 * The areas (virtual_start, virtual_end) and (virtual2_start, virtual2_end)
479 * are available so the cutouts are the areas around these ranges between
480 * KvaStart and KvaEnd.
791c6551 481 *
99ad9bc4
MD
482 * Depend on the zalloc bootstrap cache to get our vm_map_entry_t.
483 * Called from the low level boot code only.
984263bc 484 */
984263bc 485void
da23a592 486kmem_init(void)
984263bc 487{
791c6551 488 vm_offset_t addr;
5f910b2f 489 vm_map_t m;
a108bf71 490 int count;
984263bc 491
c8f922ba
MD
492 m = &kernel_map;
493 vm_map_init(m, KvaStart, KvaEnd, &kernel_pmap);
984263bc
MD
494 vm_map_lock(m);
495 /* N.B.: cannot use kgdb to debug, starting with this assignment ... */
e4846942 496 m->system_map = 1;
a108bf71 497 count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
791c6551
MD
498 addr = KvaStart;
499 if (virtual2_start) {
500 if (addr < virtual2_start) {
0adbcbd6
MD
501 vm_map_insert(m, &count,
502 NULL, NULL,
503 (vm_offset_t) 0, addr, virtual2_start,
3091de50 504 VM_MAPTYPE_NORMAL, VM_SUBSYS_RESERVED,
0adbcbd6 505 VM_PROT_ALL, VM_PROT_ALL, 0);
791c6551
MD
506 }
507 addr = virtual2_end;
508 }
da23a592 509 if (addr < virtual_start) {
0adbcbd6
MD
510 vm_map_insert(m, &count,
511 NULL, NULL,
512 (vm_offset_t) 0, addr, virtual_start,
3091de50 513 VM_MAPTYPE_NORMAL, VM_SUBSYS_RESERVED,
0adbcbd6 514 VM_PROT_ALL, VM_PROT_ALL, 0);
e4846942 515 }
da23a592 516 addr = virtual_end;
791c6551 517 if (addr < KvaEnd) {
0adbcbd6
MD
518 vm_map_insert(m, &count,
519 NULL, NULL,
520 (vm_offset_t) 0, addr, KvaEnd,
3091de50 521 VM_MAPTYPE_NORMAL, VM_SUBSYS_RESERVED,
0adbcbd6 522 VM_PROT_ALL, VM_PROT_ALL, 0);
e4846942 523 }
984263bc
MD
524 /* ... and ending with the completion of the above `insert' */
525 vm_map_unlock(m);
a108bf71
MD
526 vm_map_entry_release(count);
527}
c5a45196 528
99ad9bc4
MD
529/*
530 * No requirements.
531 */
c5a45196
MD
532static int
533kvm_size(SYSCTL_HANDLER_ARGS)
534{
535 unsigned long ksize = KvaSize;
536
537 return sysctl_handle_long(oidp, &ksize, 0, req);
538}
d48fd7e8
AH
539SYSCTL_PROC(_vm, OID_AUTO, kvm_size, CTLTYPE_ULONG|CTLFLAG_RD,
540 0, 0, kvm_size, "LU", "Size of KVM");
c5a45196 541
99ad9bc4
MD
542/*
543 * No requirements.
544 */
c5a45196
MD
545static int
546kvm_free(SYSCTL_HANDLER_ARGS)
547{
548 unsigned long kfree = virtual_end - kernel_vm_end;
549
550 return sysctl_handle_long(oidp, &kfree, 0, req);
551}
d48fd7e8
AH
552SYSCTL_PROC(_vm, OID_AUTO, kvm_free, CTLTYPE_ULONG|CTLFLAG_RD,
553 0, 0, kvm_free, "LU", "Amount of KVM free");
c5a45196 554