Cfrtjryk

My /proc/meminfo shows about 500 MB is allocated as Shmem. I want to get more specific figures. I found an explanation here:

https://lists.kernelnewbies.org/pipermail/kernelnewbies/2013-July/008628.html

It includes tmpfs memory, SysV shared memory (from ipc/shm.c),
POSIX shared memory (under /dev/shm [which is a tmpfs]), and shared anonymous mappings
(from mmap of /dev/zero with MAP_SHARED: see call to shmem_zero_setup()
from drivers/char/mem.c): whatever allocates pages through mm/shmem.c.

2-> as per the developer comments NR_SHMEM included tmpfs and GEM
pages whct is Gem pages

Ah yes, and the Graphics Execution Manager uses shmem for objects shared
with the GPU: see use of shmem_read_mapping_page*() in drivers/gpu/drm/.

I have about

• 50MB in user-visible tmpfs, found with df -h -t tmpfs.


• 40MB (10,000 pages of 4096 bytes) in sysvipc shared memory, found with ipcs -mu.

I would like to get some more positive accounting, for what uses the 500MB! Is there a way to show total GEM allocations? (Or any other likely contributor).

I expect I have some GEM allocations, since I am running a graphical desktop on intel graphics hardware. My kernel version is 4.18.16-200.fc28.x86_64 (Fedora Workstation 28).

These appear in process maps as “drm mm object” or “i915”. You can see this in /proc/<pid>/maps; given the PID of a process using GEM/DRM:

awk '/(drm mm object)|i915/ { hypidx = index($1, "-"); from = substr($1, 1, hypidx - 1); to = substr($1, hypidx + 1); sum += strtonum("0x" to) - strtonum("0x" from) } END { print sum }' /proc/${PID}/maps

will show the total size of the allocated GEM buffers. Calculating the total can be done by feeding in all maps which contain at least one occurrence of “drm mm object” or “i915”; as root:

find /proc -maxdepth 2 -name maps |

xargs grep -E -l "(drm mm object)|i915" |

xargs awk '/(drm mm object)|i915/ { hypidx = index($1, "-"); sum += strtonum("0x" substr($1, hypidx + 1)) - strtonum("0x" substr($1, 1, hypidx - 1)) } END { print sum }'

(-maxdepth 2 is necessary to avoid looking at thread maps). Some additional inode-based de-duplication might be necessary.

You can find some of the shmem files by looking through all open files, in /proc/*/fd/ and /proc/*/map_files/ (or /proc/*/maps).

With the right hacks, it appears possible to reliably identify which files belong to the hidden shmem filesystem(s).

Each shared memory object is a file with a name. And the names can be used to identify which kernel subsystem created the file.

• SYSV00000000


• i915 (i.e. intel gpu)


• memfd:gdk-wayland


• dev/zero (for any "anonymous" shared mapping)


• ...

However this does not show all DRM / GEM allocations. DRM buffers can exist without being mapped, simply as a numeric handle. These are tied to the open DRM file they were created on. When the program crashes or is killed, the DRM file will be closed, and all its DRM handles will be cleaned up automatically. (Unless some other software keeps a copy of the file descriptor open, like this old bug.)

https://www.systutorials.com/docs/linux/man/7-drm-gem/

You can find open DRM files in /proc/*/fd/, but they show as a zero-size file with zero blocks allocated.

For example right now, I am still unable to account for over 50% / 300MB of my Shmem.

$ grep Shmem: /proc/meminfo

Shmem:            612732 kB



$ df -h -t tmpfs

Filesystem      Size  Used Avail Use% Mounted on

tmpfs           3.9G   59M  3.8G   2% /dev/shm

tmpfs           3.9G  2.5M  3.9G   1% /run

tmpfs           3.9G     0  3.9G   0% /sys/fs/cgroup

tmpfs           3.9G  9.0M  3.9G   1% /tmp

tmpfs           786M   20K  786M   1% /run/user/42

tmpfs           786M  8.0M  778M   2% /run/user/1000

tmpfs           786M  5.7M  781M   1% /run/user/1001



$ sudo ipcs -mu



------ Shared Memory Status --------

segments allocated 20

pages allocated 4226

pages resident  3990

pages swapped   0

Swap performance: 0 attempts     0 successes  

All open files on hidden shmem filesystem(s):

$ sudo python3 ~/shm -s

15960   /SYSV*

79140   /i915

7912    /memfd:gdk-wayland

1164    /memfd:pulseaudio

104176

Here is a "before and after", logging out one of my two logged-in GNOME users. It might be explained if gnome-shell had over 100MB of unmapped DRM buffers.

$ grep Shmem: /proc/meminfo

Shmem:            478780 kB

$ df -t tmpfs -h

Filesystem      Size  Used Avail Use% Mounted on

tmpfs           3.9G  4.0K  3.9G   1% /dev/shm

tmpfs           3.9G  2.5M  3.9G   1% /run

tmpfs           3.9G     0  3.9G   0% /sys/fs/cgroup

tmpfs           3.9G  276K  3.9G   1% /tmp

tmpfs           786M   20K  786M   1% /run/user/42

tmpfs           786M  8.0M  778M   2% /run/user/1000

tmpfs           786M  5.7M  781M   1% /run/user/1001

$ sudo ./shm -s

80  /SYSV*

114716  /i915

1692    /memfd:gdk-wayland

1156    /memfd:pulseaudio

117644



$ grep Shmem: /proc/meminfo

Shmem:            313008 kB

$ df -t tmpfs -h

Filesystem      Size  Used Avail Use% Mounted on

tmpfs           3.9G  4.0K  3.9G   1% /dev/shm

tmpfs           3.9G  2.1M  3.9G   1% /run

tmpfs           3.9G     0  3.9G   0% /sys/fs/cgroup

tmpfs           3.9G  204K  3.9G   1% /tmp

tmpfs           786M   20K  786M   1% /run/user/42

tmpfs           786M  6.8M  780M   1% /run/user/1000

$ sudo ./shm -s

40  /SYSV*

88496   /i915

1692    /memfd:gdk-wayland

624 /memfd:pulseaudio

90852

Python script to generate the above output:

#!/bin/python3

# Reads Linux /proc.  No str, all bytes.



import sys

import os

import stat

import glob

import collections

import math



# File.

# 'name' is first name encountered, we don't track hardlinks.

Inode = collections.namedtuple('Inode', ['name', 'bytes', 'pids'])



# inode number -> Inode object

inodes = dict()

# pid -> program name

pids = dict()

# filename -> list() of Inodes

filenames = dict()



def add_file(pid, proclink):

    try:

        vfs = os.statvfs(proclink)



        # The tmpfs which reports 0 blocks is an internal shm mount

        # python doesn't admit f_fsid ...

        if vfs.f_blocks != 0:

            return

        filename = os.readlink(proclink)

        # ... but all the shm files are deleted (hack :)

        if not filename.endswith(b' (deleted)'):

            return

        filename = filename[:-10]

        # I tried a consistency check that all our st_dev are the same

        # but actually there can be more than one internal shm mount!

        # i915 added a dedicated "gemfs" so they could control mount options.



        st = os.stat(proclink)



        # hack the second: ignore deleted character devices from devpts

        if stat.S_ISCHR(st.st_mode):

            return



        # Read process name succesfully,

        # before we record file owned by process.

        if pid not in pids:

            pids[pid] = open(b'/proc/' + pid + b'/comm', 'rb').read()[:-1]



        if st.st_ino not in inodes:

            inode_pids = set()

            inode_pids.add(pid)



            inode = Inode(name=filename,

                          bytes=st.st_blocks * 512,

                          pids=inode_pids)

            inodes[st.st_ino] = inode

        else:

            inode = inodes[st.st_ino]

            inode.pids.add(pid)



        # Group SYSV shared memory objects.

        # There could be many, and the rest of the name is just a numeric ID

        if filename.startswith(b'/SYSV'):

            filename = b'/SYSV*'



        filename_inodes = filenames.setdefault(filename, set())

        filename_inodes.add(st.st_ino)



    except FileNotFoundError:

        # File disappeared (race condition).

        # Don't bother to distinguish "file closed" from "process exited".

        pass



summary = False

if sys.argv[1:]:

    if sys.argv[1:] == ['-s']:

        summary = True

    else:

        print("Usage: {0} [-s]".format(sys.argv[0]))

        sys.exit(2)



os.chdir(b'/proc')

for pid in glob.iglob(b'[0-9]*'):

    for f in glob.iglob(pid + b'/fd/*'):

        add_file(pid, f)

    for f in glob.iglob(pid + b'/map_files/*'):

        add_file(pid, f)



def pid_name(pid):

    return pid + b'/' + pids[pid]



def kB(b):

    return str(math.ceil(b / 1024)).encode('US-ASCII')



out = sys.stdout.buffer



total = 0

for (filename, filename_inodes) in sorted(filenames.items(), key=lambda p: p[0]):

    filename_bytes = 0

    for ino in filename_inodes:

        inode = inodes[ino]

        filename_bytes += inode.bytes

        if not summary:

            out.write(kB(inode.bytes))

            out.write(b't')

            #out.write(str(ino).encode('US-ASCII'))

            #out.write(b't')            

            out.write(inode.name)

            out.write(b't')

            out.write(b' '.join(map(pid_name, inode.pids)))

            out.write(b'n')

    total += filename_bytes

    out.write(kB(filename_bytes))

    out.write(b't')

    out.write(filename)

    out.write(b'n')

out.write(kB(total))

out.write(b'n')