메모리 매핑 Linux 3+ 커널

한번 살펴보고 커널의 가상 메모리 시스템이 초기화되기 전에 원래의 부팅 메모리 할당자를 사용하여 가상 메모리를 관리하는 데 필요한 구조 같은 것들을 할당하고 부팅 할당자가 소비하는 페이지는 그렇지 않다고 결론을 내린 것 같습니다. 바르게.

커널은 시작 시 메모리 테이블(가상 주소를 물리적 주소로 변환하는 데 사용됨)을 위해 특정 양의 메모리(전체 크기에 비례)를 예약합니다. 메모리 테이블에 할당된 메모리는 다른 어떤 것도 사용할 수 없으며 보고된 총 메모리 크기에서 뺍니다.

The bigger physical RAM size is, the smaller is the ratio of the memory which cannot be used to the total physical RAM size:
    On 12Gb desktop this ratio is around 4.5%
    On 32Gb server this ratio is around 2%
    On 512Gb server this ratio is around 1.56%

You can read about this in more details in the Where Did My Memory Go article on http://linux-mm.org/ site.

/proc/meminfofree그것이 어떻게 작동하는지 알려줄 것이지만 /proc/kcore커널이 무엇을 사용하는지 알려줄 수도 있습니다. 같은 페이지에서:

/proc/kcore

          This file represents the physical memory of the system and is
          stored in the ELF core file format.  With this pseudo-file,
          and an unstripped kernel (/usr/src/linux/vmlinux) binary, GDB
          can be used to examine the current state of any kernel data
          structures.

          The total length of the file is the size of physical memory
          (RAM) plus 4KB.

/proc/메모리 정보

          This file reports statistics about memory usage on the system.
          It is used by free(1) to report the amount of free and used
          memory (both physical and swap) on the system as well as the
          shared memory and buffers used by the kernel.  Each line of
          the file consists of a parameter name, followed by a colon,
          the value of the parameter, and an option unit of measurement
          (e.g., "kB").  The list below describes the parameter names
          and the format specifier required to read the field value.
          Except as noted below, all of the fields have been present
          since at least Linux 2.6.0.  Some fileds are displayed only if
          the kernel was configured with various options; those
          dependencies are noted in the list.

          MemTotal %lu
                 Total usable RAM (i.e., physical RAM minus a few
                 reserved bits and the kernel binary code).

          MemFree %lu
                 The sum of LowFree+HighFree.

          Buffers %lu
                 Relatively temporary storage for raw disk blocks that
                 shouldn't get tremendously large (20MB or so).

          Cached %lu
                 In-memory cache for files read from the disk (the page
                 cache).  Doesn't include SwapCached.

          SwapCached %lu
                 Memory that once was swapped out, is swapped back in
                 but still also is in the swap file.  (If memory
                 pressure is high, these pages don't need to be swapped
                 out again because they are already in the swap file.
                 This saves I/O.)

          Active %lu
                 Memory that has been used more recently and usually not
                 reclaimed unless absolutely necessary.

          Inactive %lu
                 Memory which has been less recently used.  It is more
                 eligible to be reclaimed for other purposes.

          Active(anon) %lu (since Linux 2.6.28)
                 [To be documented.]

          Inactive(anon) %lu (since Linux 2.6.28)
                 [To be documented.]

          Active(file) %lu (since Linux 2.6.28)
                 [To be documented.]

          Inactive(file) %lu (since Linux 2.6.28)
                 [To be documented.]

          Unevictable %lu (since Linux 2.6.28)
                 (From Linux 2.6.28 to 2.6.30, CONFIG_UNEVICTABLE_LRU
                 was required.)  [To be documented.]

          Mlocked %lu (since Linux 2.6.28)
                 (From Linux 2.6.28 to 2.6.30, CONFIG_UNEVICTABLE_LRU
                 was required.)  [To be documented.]

          HighTotal %lu
                 (Starting with Linux 2.6.19, CONFIG_HIGHMEM is
                 required.)  Total amount of highmem.  Highmem is all
                 memory above ~860MB of physical memory.  Highmem areas
                 are for use by user-space programs, or for the page
                 cache.  The kernel must use tricks to access this
                 memory, making it slower to access than lowmem.

          HighFree %lu
                 (Starting with Linux 2.6.19, CONFIG_HIGHMEM is
                 required.)  Amount of free highmem.

          LowTotal %lu
                 (Starting with Linux 2.6.19, CONFIG_HIGHMEM is
                 required.)  Total amount of lowmem.  Lowmem is memory
                 which can be used for everything that highmem can be
                 used for, but it is also available for the kernel's use
                 for its own data structures.  Among many other things,
                 it is where everything from Slab is allocated.  Bad
                 things happen when you're out of lowmem.

          LowFree %lu
                 (Starting with Linux 2.6.19, CONFIG_HIGHMEM is
                 required.)  Amount of free lowmem.

          MmapCopy %lu (since Linux 2.6.29)
                 (CONFIG_MMU is required.)  [To be documented.]

          SwapTotal %lu
                 Total amount of swap space available.

          SwapFree %lu
                 Amount of swap space that is currently unused.

          Dirty %lu
                 Memory which is waiting to get written back to the
                 disk.

          Writeback %lu
                 Memory which is actively being written back to the
                 disk.

          AnonPages %lu (since Linux 2.6.18)
                 Non-file backed pages mapped into user-space page
                 tables.

          Mapped %lu
                 Files which have been mmaped, such as libraries.

          Shmem %lu (since Linux 2.6.32)
                 [To be documented.]

          Slab %lu
                 In-kernel data structures cache.

          SReclaimable %lu (since Linux 2.6.19)
                 Part of Slab, that might be reclaimed, such as caches.

          SUnreclaim %lu (since Linux 2.6.19)
                 Part of Slab, that cannot be reclaimed on memory
                 pressure.

          KernelStack %lu (since Linux 2.6.32)
                 Amount of memory allocated to kernel stacks.

          PageTables %lu (since Linux 2.6.18)
                 Amount of memory dedicated to the lowest level of page
                 tables.

          Quicklists %lu (since Linux 2.6.27)
                 (CONFIG_QUICKLIST is required.)  [To be documented.]

          NFS_Unstable %lu (since Linux 2.6.18)
                 NFS pages sent to the server, but not yet committed to
                 stable storage.

          Bounce %lu (since Linux 2.6.18)
                 Memory used for block device "bounce buffers".

          WritebackTmp %lu (since Linux 2.6.26)
                 Memory used by FUSE for temporary writeback buffers.

          CommitLimit %lu (since Linux 2.6.10)
                 Based on the overcommit ratio ('vm.overcommit_ratio'),
                 this is the total amount of  memory currently available
                 to be allocated on the system.  This limit is adhered
                 to only if strict overcommit accounting is enabled
                 (mode 2 in /proc/sys/vm/overcommit_ratio).  The
                 CommitLimit is calculated using the following formula:

                     CommitLimit =
                         ([total RAM pages] - [total huge TLB pages]) *
                         overcommit_ratio / 100 + [total swap pages]

                 For example, on a system with 1GB of physical RAM and
                 7GB of swap with a overcommit_ratio of 30, this formula
                 yields a CommitLimit of 7.3GB.  For more details, see
                 the memory overcommit documentation in the kernel
                 source file Documentation/vm/overcommit-accounting.

          Committed_AS %lu
                 The amount of memory presently allocated on the system.
                 The committed memory is a sum of all of the memory
                 which has been allocated by processes, even if it has
                 not been "used" by them as of yet.  A process which
                 allocates 1GB of memory (using malloc(3) or similar),
                 but touches only 300MB of that memory will show up as
                 using only 300MB of memory even if it has the address
                 space allocated for the entire 1GB.  This 1GB is memory
                 which has been "committed" to by the VM and can be used
                 at any time by the allocating application.  With strict
                 overcommit enabled on the system (mode 2
                 /proc/sys/vm/overcommit_memory), allocations which
                 would exceed the CommitLimit (detailed above) will not
                 be permitted.  This is useful if one needs to guarantee
                 that processes will not fail due to lack of memory once
                 that memory has been successfully allocated.

          VmallocTotal %lu
                 Total size of vmalloc memory area.

          VmallocUsed %lu
                 Amount of vmalloc area which is used.

          VmallocChunk %lu
                 Largest contiguous block of vmalloc area which is free.

          HardwareCorrupted %lu (since Linux 2.6.32)
                 (CONFIG_MEMORY_FAILURE is required.)  [To be
                 documented.]

          AnonHugePages %lu (since Linux 2.6.38)
                 (CONFIG_TRANSPARENT_HUGEPAGE is required.)  Non-file
                 backed huge pages mapped into user-space page tables.

          HugePages_Total %lu
                 (CONFIG_HUGETLB_PAGE is required.)  The size of the
                 pool of huge pages.

          HugePages_Free %lu
                 (CONFIG_HUGETLB_PAGE is required.)  The number of huge
                 pages in the pool that are not yet allocated.

          HugePages_Rsvd %lu (since Linux 2.6.17)
                 (CONFIG_HUGETLB_PAGE is required.)  This is the number
                 of huge pages for which a commitment to allocate from
                 the pool has been made, but no allocation has yet been
                 made.  These reserved huge pages guarantee that an
                 application will be able to allocate a huge page from
                 the pool of huge pages at fault time.

          HugePages_Surp %lu (since Linux 2.6.24)
                 (CONFIG_HUGETLB_PAGE is required.)  This is the number
                 of huge pages in the pool above the value in
                 /proc/sys/vm/nr_hugepages.  The maximum number of
                 surplus huge pages is controlled by
                 /proc/sys/vm/nr_overcommit_hugepages.

          Hugepagesize %lu
                 (CONFIG_HUGETLB_PAGE is required.)  The size of huge
                 pages.

사용 free -b.

$ free -b
             total       used       free     shared    buffers     cached
Mem:    2147483648  237707264 1909776384          0          0          0
-/+ buffers/cache:  237707264 1909776384
Swap:            0          0          0
$ echo $(( 237707264 + 1909776384 ))
2147483648