Why does my server show

            total      used      free   shared buffers    cached
    Mem: 12286456  11715372    571084        0   81912   6545228
-/+ buffers/cache:  5088232   7198224
   Swap: 24571408     54528  24516880

I have no idea on calculating the memory in linux. I think it says that 5088232 is used where as 7198224 is free, meaning it is actually consuming 5GB of RAM?


4 Answers 4


Meaning of the values

The first line means:

  • total: Your total (physical) RAM (excluding a small bit that the kernel permanently reserves for itself at startup); that's why it shows ca. 11.7 GiB , and not 12 GiB, which you probably have.

  • used: memory in use by the OS.

  • free: memory not in use.

  • shared / buffers / cached: This shows memory usage for specific purposes, these values are included in the value for used.

The second line gives first line values adjusted. It gives the original value for used minus the sum buffers+cached and the original value for free plus the sum buffers+cached, hence its title. These new values are often more meaningful than those of first line.

The last line (Swap:) gives information about swap space usage (i.e. memory contents that have been temporarily moved to disk).


To actually understand what the numbers mean, you need a bit of background about the virtual memory (VM) subsystem in Linux. Just a short version: Linux (like most modern OS) will always try to use free RAM for caching stuff, so Mem: free will almost always be very low. Therefore the line -/+ buffers/cache: is shown, because it shows how much memory is free when ignoring caches; caches will be freed automatically if memory gets scarce, so they do not really matter.

A Linux system is really low on memory if the free value in -/+ buffers/cache: line gets low.

For more details about the meaning of the numbers, see e.g. the questions:

Changes in procps 3.3.10

Note that the output of free was changed in procps 3.3.10 (released in 2014). The columns reported are now "total", "used", "free", "shared", "buff/cache", "available", and the meanings of some of the values changed, mainly to better account for the Linux kernel's slab cache.

See Debian Bug report #565518 for the motivation, and What do the changes in free output from 14.04 to 16.04 mean? for more details information.

  • Could you expand on what kinds of things Linux may be caching? Would it be files that have been accessed or network stuff? Aug 2, 2015 at 13:08
  • @CMCDragonkai: The answer to serverfault.com/questions/23433/… addresses in detail what constitues "cache" and "buffer".
    – sleske
    Aug 2, 2015 at 16:03
  • 8
    I do not think the statement "total = used + free" is correct, see the following output on my machine: $ free -h total used free shared buff/cache available Mem: 3.4G 585M 152M 11M 2.6G 2.5G Swap: 4.0G 84M 3.9G
    – SCBuergel
    Feb 13, 2017 at 9:35
  • @Sebastian: Ah, interesting. It seems the ouput of free was changed (in 3.3.10). I edited my answer to mention this. If you are interested in this change, consider asking a new question :-).
    – sleske
    Feb 13, 2017 at 10:17
  • 4
    total = used + free + buff/cache Oct 26, 2018 at 17:41

The currently accepted answer from 2009 is out-of-date. It is important to make sure that the information you are getting is correct and matches the version of free (distributed in the Debian package procps or equivalent in your distribution). It is also helpful to look at the output of man free, and also man 5 proc, which contains information about /proc/meminfo, the file where free gets its data from on Linux.

By default, free's output is in kibibytes (1 kibibyte = 1024 bytes), as you can see in the manual page. I prefer to use the -h argument, which shows suffixes, like this:

$ free -h
              total        used        free      shared  buff/cache   available
Mem:           15Gi       6.1Gi       1.9Gi       301Mi       7.5Gi       8.8Gi
Swap:         979Mi          0B       979Mi

The first line Mem means:

  • total (Mem): total installed memory (that is MemTotal from /proc/meminfo), this all the memory in RAM
  • used (Mem): used memory, equal to total - free - buffers - cache
  • free (Mem): unused memory (that is MemFree), this all the memory that is unused for anything (even caches) in RAM
  • shared (Mem): this is the amount of memory used mainly for tmpfs (Shmem)
  • buff/cache (Mem), sum of buffers and cache:
    • buffers: memory used by kernel buffers (Buffers), which is memory that the kernel can take advantage of
    • cache: memory used by the page cache and slabs (Cached and SReclaimable). The page cache contains the contents of files in the filesystem cached to RAM, and it is generally a good thing for this to be a high number. I presume "slabs" are a similar caching feature.
  • available (Mem): this is an estimate of how much memory is available for starting new applications, without swapping. It includes most of memory counted in the cache field (since the page cache can be dropped to start new applications), but it does not count swap (since it is generally preferable not to use slow swap space).

The second line is Swap. This is my explanation:

  • total (Swap): this is the total amount of disk space reserved for swap (SwapTotal in proc/meminfo). You can check by checking that this matches with the output of swapon -s.
  • used (Swap): the amount of swap disk space that is currently being used. Again, you can check this by comparing it with the output of swapon -s
  • free (Swap): the amount of swap disk space that is currently not being used (SwapFree in /proc/meminfo). It is equal to total (Swap) - used (Swap)
  • Thanks for that answer! One question from my side: If I would like to look if a server will run out of memor, should I then use the number of free Mem or should I also consider the number regarding buffer+cache?
    – Tobitor
    Jan 8, 2021 at 12:36
  • @Flimm At least in Ubuntu 18 and 20 total is just MemTotal (without SwapTotal). Why would total from the first line (Mem) include SwapTotal even though it's beeing explicitly listed in the line below (Swap)? Jan 23, 2021 at 20:15
  • @DonFoumare By "Ubuntu 18", do you mean Ubuntu 18.04 or Ubuntu 18.10? Likewise, by "Ubuntu 20", do you mean Ubuntu 20.04 or Ubuntu 20.10? Any way, I think you're right, after looking at map free and man 5 proc. I've edited my answer.
    – Flimm
    Jan 25, 2021 at 8:15
  • @DonFoumare This is why I love contributing to ServerFault! Any misunderstandings I have get corrected for free! :)
    – Flimm
    Jan 25, 2021 at 8:31
  • @Flimm I meant Ubuntu 18.04 and 20.04 Jan 25, 2021 at 14:32

The buffers/cache line shows you how much memory is used by programs (first of those columns), and is free for programs to use (second column). It's a fairly esoteric number, and not something you'd really look at much in practice.

  • And what does the first line (mem line) means Nov 17, 2009 at 11:14
  • 8
    That you've got 12GB of RAM installed in the system, 11.5GB of which is used and 0.5GB or so is currently unused. Approximately 82MB of the used memory is used for buffers (network connections, etc), whilst about 6.5GB is being used to store copies of data on disk, so that data won't have to be re-read if it's needed again.
    – womble
    Nov 17, 2009 at 11:33
  • 3
    @Muhammad: "82MB is free." - no, 57MiB is free (but that doesn't really matter, see my answer). "Now it all means that the system has reached its limits" - No, not at all. The system has 6.9GiB in use for caching, which it will readily give to applications, so there's lots of room. Also, swap usage is very low (ony ca. 50MiB). If memory starts getting tight, swap usage will rise. At present you're barely using half the RAM you have.
    – sleske
    Nov 17, 2009 at 11:50
  • 5
    Have you considered asking a new question at some point?
    – womble
    Nov 17, 2009 at 13:27
  • 3
    I disagree, the buffers/cache line is the actual free memory of the system and therefore most relevant if you want to know if the system has room for programs.
    – eckes
    Jul 4, 2015 at 15:27

The accepted answer and even more Flimm's are very clear but are missing one detail, presumably because most people do not use a lot of shared memory. As I do not have enough rep to comment, I am adding another answer:

Below the output of free -g on a RHEL 7 system (procps 3.3.10). One can see that buff/cache is more than just buffer and cache memory, because otherwise numbers do not add up for available: how can there be only 231Gb available memory for new processes when 388Gb are used for caching?

              total        used        free      shared  buff/cache   available
Mem:            755         349          17         172         388         231
Swap:            62           0          62

Actually buff/cache includes shared (unfortunate naming I would say). I could not find a precise definition other than a related kernel commit, however available = buff|cache + free - shared (swap is not relevant here) more or less holds in my experience. This is indirectly described in this RedHat article with:

Cached: Memory in the pagecache (Diskcache and Shared Memory)

One important corollary is that on systems using shared memory heavily, used and buff/cache are not the best figures to look at to get an idea of memory consumption, available is more reliable --and since shared memory is not reclaimable it is potentially much lower!

So to build on top of Flimm's list:

  • total: overal RAM available for memory allocation (that is MemTotal from /proc/meminfo)
  • used: used memory, equal to total - free - buff|cache
  • free: unused memory (that is MemFree), this all the memory that is unused for anything (even caches) in RAM. The kernel likes to bring this close to zero.
  • shared: amount of memory used for tmpfs, mainly shared memory (/dev/shmem)
  • buff/cache, sum of:
    • buffers: memory used by kernel buffers (usually small)
    • cache: page cache, contents of files in the filesystem cached to RAM, but also shared memory pages in use. Also includes SReclaimable (kernel cached structures, part of the "slab")
  • available: memory available for new processes, seems to be roughly equal to buff|cache + free - shared. This is the "real" free[able] memory.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .