Screenplay: Sysprog: POSIX IPC¶

Virtual Memory, `mmap()`¶

First, read /etc/passwd using regular file IO
Discuss copy from/to kernel space
Basic mmap() demo: read /etc/passwd by creating a mapping and only using memory access.

code/shm/010-mmap.cc¶

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <assert.h>


int main()
{
    int fd = open("/etc/passwd", O_RDONLY);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    struct stat stat;
    int error = fstat(fd, &stat);
    if (error) {
        perror("fstat");
        return 1;
    }

    void* addr = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        return 1;
    }

    close(fd);

    ssize_t nwritten = write(STDOUT_FILENO, addr, stat.st_size);
    if (nwritten == -1) {
        perror("write");
        return 1;
    }
    assert(nwritten != 0);

    return 0;
}

Give explanation of mappings
Discuss copy -> whiteboard sketch
Show /proc/<pid>/maps
strace to see how address space is prepared
File mappings vs. anonymous

POSIX Shared Memory ¶

Show how POSIX Shared Memory is nothing but mmap() with predefined filenames. Here we show three programs,

One creates a shared memory segment
One writes into that memory; produces
One reads from it; consumes

Note

Producer and consumer do not use any locking. If multiple producers are run, then this will lead to lost increments. (This is what semaphores are there for.)

Create Shared Memory Segment ¶

Using shm_open() with O_CREAT
Ends up as a file in /dev/shm/ (a tmpfs instance)
Zero size after create.
Use ftruncate() to resize as appropriate

code/shm/020-shm-create.cc¶

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>


int main()
{
    int fd = shm_open("mein-shared-dings", O_CREAT|O_RDWR, 0666);
    if (fd == -1) {
        perror("shm_open");
        return 1;
    }

    int error = ftruncate(fd, 4096);
    if (error) {
        perror("ftruncate");
        return 1;
    }

    // alternatively, instead of using ftruncate(), we could drop one
    // byte at position 4095, creating a 4K weighing one byte, and
    // having a "hole" of 4095 bytes. but no.

    // off_t off = lseek(fd, 4095, SEEK_SET);
    // if (off == -1) {
    //     perror("lseek");
    //     return 1;
    // }
    // char c = 0;
    // ssize_t nwritten = write(fd, &c, 1);
    // if (nwritten == -1) {
    //     perror("write");
    //     return 1;
    // }

    return 0;
}

Produce into Shared Memory ¶

Using MAP_SHARED (as opposed to MAP_PRIVATE which makes write operations copy-on-write)
Opens O_RDWR: incrementing a counter requires reading it first.

code/shm/030-shm-produce.cc¶

#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <iostream>

using std::cout;
using std::endl;


int main()
{
    int fd = shm_open("mein-shared-dings", O_RDWR, /*mode unused without O_CREAT*/0);
    if (fd == -1) {
        perror("shm_open");
        return 1;
    }

    void* addr = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        return 1;
    }

    uint64_t* counter_location = (uint64_t*)addr;

    uint64_t counter = 0;
    while (true) {
        cout << counter << endl;
        *counter_location = counter++;
        sleep(1);
    }

    return 0;
}

Consume from Shared Memory ¶

code/shm/040-shm-consume.cc¶

#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <iostream>

using std::cout;
using std::endl;


int main()
{
    int fd = shm_open("mein-shared-dings", O_RDONLY, /*mode unused without O_CREAT*/0);
    if (fd == -1) {
        perror("shm_open");
        return 1;
    }

    void* addr = mmap(NULL, 4096, PROT_READ, MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        return 1;
    }

    uint64_t* counter_location = (uint64_t*)addr;

    while (true) {
        cout << *counter_location << endl;
        sleep(1);
    }

    return 0;
}

POSIX Semaphores ¶

Analogous to the shared memory demo above, this is a scenario where two parties use post and wait() on a semaphore.

Create Semaphore ¶

We create a semaphore with initial value 7 (7 wait operations without blocking).

code/shm/100-sem-create.cc¶

#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <stdio.h>


int main()
{
    sem_t* sem = sem_open("meine-semaphore", O_CREAT|O_RDWR|O_EXCL, 0666, 7);
    if (sem == SEM_FAILED) {
        perror("sem_open");
        return 1;
    }

    return 0;
}

Wait ¶

code/shm/110-sem-wait.cc¶

#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <stdio.h>


int main()
{
    sem_t* sem = sem_open("meine-semaphore", O_RDWR);
    if (sem == SEM_FAILED) {
        perror("sem_open");
        return 1;
    }

    int error = sem_wait(sem);
    if (error) {
        perror("sem_wait");
        return 1;
    }

    return 0;
}

Post ¶

code/shm/120-sem-post.cc¶

#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <stdio.h>


int main()
{
    sem_t* sem = sem_open("meine-semaphore", O_RDWR);
    if (sem == SEM_FAILED) {
        perror("sem_open");
        return 1;
    }

    int error = sem_post(sem);
    if (error) {
        perror("sem_post");
        return 1;
    }

    return 0;
}