Each line in the file represents one memory segment. There are exactly six columns on every line.

When a process attaches two System V shared memory segments and uses standard libraries, the maps file looks like this. Each group of lines is explained below.

/* /proc/12345/maps — annotated */

08048000-0804c000  r-xp  00000000  08:01  456789  /home/user/shm_attach  /* q: text segment */
0804c000-0804d000  rw-p  00003000  08:01  456789  /home/user/shm_attach  /* q: data segment */
0804d000-0804e000  r--p  00004000  08:01  456789  /home/user/shm_attach  /* q: string constants (read-only) */

b7e00000-b7e10000  rw-s  00000000  00:06  3       SYSV00000000 (deleted) /* w: shm segment 1 */
b7e10000-b7e20000  rw-s  00000000  00:06  4       SYSV00000000 (deleted) /* w: shm segment 2 */

b7e20000-b7f60000  r-xp  00000000  08:01  1234    /lib/libc-2.17.so      /* e: C library text */
b7f60000-b7f62000  rw-p  00140000  08:01  1234    /lib/libc-2.17.so      /* e: C library data */

b7f70000-b7f90000  r-xp  00000000  08:01  5678    /lib/ld-2.17.so        /* r: dynamic linker */
b7f90000-b7f91000  rw-p  0001f000  08:01  5678    /lib/ld-2.17.so

bffdf000-c0000000  rw-p  00000000  00:00  0       [stack]                /* t: process stack */
ffffe000-fffff000  r-xp  00000000  00:00  0       [vdso]                 /* y: virtual DSO */
    

The permission field is always 4 characters, e.g. rw-s or r-xp.

The tag for a System V shared memory segment has two parts:

/* How the kernel implements System V shm internally (simplified concept) */

/* Step 1: create a file in a hidden tmpfs (RAM filesystem) */
int fd = open("/dev/shm/.internal_shm_XXXX", O_RDWR | O_CREAT, 0600);

/* Step 2: immediately unlink — removes the name, data stays in RAM */
unlink("/dev/shm/.internal_shm_XXXX");

/* Step 3: shmat() mmap()-maps this anonymous fd into the process VA space */
void *addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

/* Result in /proc/PID/maps:
   b7e40000-b7e41000  rw-s  00000000  00:06  3  SYSV00000000 (deleted)
   The "(deleted)" is because the tmpfs name was unlinked in step 2.       */
    

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/shm.h>

#define SHM_SIZE 4096

int main(void)
{
    int   shmid;
    char *addr;
    FILE *fp;
    char  line[512];

    /* Create a shared memory segment using IPC_PRIVATE */
    shmid = shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0660);
    if (shmid == -1) { perror("shmget"); exit(EXIT_FAILURE); }

    /* Attach — kernel chooses the virtual address */
    addr = shmat(shmid, NULL, 0);
    if (addr == (void *)-1) { perror("shmat"); exit(EXIT_FAILURE); }

    printf("Shared memory attached at: %p  (shmid=%d)\n\n", addr, shmid);

    /* Open /proc/self/maps — this is our own process's map */
    fp = fopen("/proc/self/maps", "r");
    if (!fp) { perror("fopen"); exit(EXIT_FAILURE); }

    printf("=== Lines containing 'SYSV' in /proc/self/maps ===\n");
    while (fgets(line, sizeof(line), fp) != NULL) {
        if (strstr(line, "SYSV"))
            printf("  %s", line);
    }
    fclose(fp);

    shmctl(shmid, IPC_RMID, NULL);
    shmdt(addr);
    return 0;
}
/*
 * Compile: gcc -o maps_demo maps_demo.c
 * Run:     ./maps_demo
 *
 * Sample output:
 * Shared memory attached at: 0xb7e40000  (shmid=3)
 *
 * === Lines containing 'SYSV' in /proc/self/maps ===
 *   b7e40000-b7e41000 rw-s 00000000 00:06 3  SYSV00000000 (deleted)
 */
    

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/shm.h>

int main(void)
{
    int   id1, id2;
    char *a1, *a2;
    FILE *fp;
    char  line[512];

    id1 = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0660);
    id2 = shmget(IPC_PRIVATE, 8192, IPC_CREAT | 0660);
    a1  = shmat(id1, NULL, 0);
    a2  = shmat(id2, NULL, 0);

    printf("Segment 1: shmid=%-4d  addr=%p  size=4096\n", id1, a1);
    printf("Segment 2: shmid=%-4d  addr=%p  size=8192\n\n", id2, a2);

    fp = fopen("/proc/self/maps", "r");
    printf("%-40s %-6s  Type\n", "Address Range", "Perms");
    printf("%-40s %-6s  ----\n", "-------------", "-----");

    while (fgets(line, sizeof(line), fp) != NULL) {
        char range[40], perms[8], off[12], dev[8], ino[16], name[256];
        name[0] = '\0';
        sscanf(line, "%39s %7s %11s %7s %15s %255[^\n]",
               range, perms, off, dev, ino, name);

        const char *type =
            strstr(name, "SYSV")    ? "*** SHM SEGMENT ***" :
            strstr(name, ".so")     ? "shared library"      :
            strstr(name, "[stack]") ? "stack"               :
            strstr(name, "[vdso]")  ? "vdso"                :
            strlen(name) > 0        ? "file mapping"        :
                                      "anonymous";

        printf("%-40s %-6s  %s\n", range, perms, type);
    }
    fclose(fp);

    shmctl(id1, IPC_RMID, NULL);
    shmctl(id2, IPC_RMID, NULL);
    shmdt(a1);
    shmdt(a2);
    return 0;
}
    

[vdso] stands for Virtual Dynamic Shared Object. The kernel maps a tiny shared library into every process automatically. Its purpose is to make certain very-frequent system calls faster by running them partly in user space, avoiding the full user-to-kernel context switch overhead.