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

int main(void)
{
    int fd;
    void *addr;
    size_t map_len = 6000;  /* Not a multiple of page size (4096) */
    struct stat sb;

    /* Open the file for reading and writing */
    fd = open("testfile.dat", O_RDWR);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    /* Get file size for information */
    fstat(fd, &sb);
    printf("File size: %ld bytes\n", (long)sb.st_size);

    /* Map 6000 bytes from offset 0.
     * Kernel internally rounds up to 8192 bytes (2 pages).
     * File is larger (9500 bytes), so bytes 6000–8191 also map to file.
     */
    addr = mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }

    /* fd is no longer needed after mmap() succeeds */
    close(fd);

    /* Access bytes within the requested range – safe */
    printf("First byte: %d\n", ((unsigned char *)addr)[0]);
    printf("Last byte of requested range: %d\n", ((unsigned char *)addr)[5999]);

    /* NOTE: accessing addr[8192] or beyond would raise SIGSEGV
     * because that address is outside the mapped region.
     */

    /* Unmap when done */
    if (munmap(addr, map_len) == -1) {
        perror("munmap");
        exit(EXIT_FAILURE);
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>

int main(void)
{
    int fd;
    char *addr;
    long page_size;

    page_size = sysconf(_SC_PAGESIZE);  /* Typically 4096 */
    printf("System page size: %ld\n", page_size);

    /* Create a small file: only 2200 bytes */
    fd = open("small.dat", O_RDWR | O_CREAT | O_TRUNC, 0600);
    if (fd == -1) { perror("open"); exit(EXIT_FAILURE); }

    /* Write 2200 bytes of 'A' into the file */
    char buf[2200];
    memset(buf, 'A', sizeof(buf));
    if (write(fd, buf, sizeof(buf)) != sizeof(buf)) {
        perror("write"); exit(EXIT_FAILURE);
    }

    /* Map 2 full pages (8192 bytes), even though file is only 2200 bytes */
    addr = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) { perror("mmap"); exit(EXIT_FAILURE); }

    close(fd);

    /* Safe: bytes 0–2199 are mapped to the file */
    printf("addr[0]    = '%c' (file data)\n", addr[0]);
    printf("addr[2199] = '%c' (file data)\n", addr[2199]);

    /* Safe: bytes 2200–4095 exist in the first page but are zeroed (not file) */
    printf("addr[2200] = %d  (zero-padded, NOT in file)\n", (int)(unsigned char)addr[2200]);
    printf("addr[4095] = %d  (zero-padded, NOT in file)\n", (int)(unsigned char)addr[4095]);

    /* DANGER: addr[4096] is on the SECOND page which has no file backing.
     * Accessing it would raise SIGBUS.
     * Uncomment the next line to see SIGBUS in action (process will crash):
     */
    /* printf("addr[4096] = %d\n", (int)(unsigned char)addr[4096]); */

    printf("If you access addr[4096], you get SIGBUS.\n");
    printf("If you access addr[%ld], you get SIGSEGV.\n", 2 * page_size);

    munmap(addr, 2 * page_size);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>

#define MAP_SIZE   8192  /* 2 pages */
#define INIT_SIZE  2200  /* Small initial file */

int main(void)
{
    int fd;
    char *addr;

    /* Step 1: Create a small file */
    fd = open("grow.dat", O_RDWR | O_CREAT | O_TRUNC, 0600);
    if (fd == -1) { perror("open"); exit(EXIT_FAILURE); }

    /* Write INIT_SIZE bytes so the file exists */
    char buf[INIT_SIZE];
    memset(buf, 0, sizeof(buf));
    write(fd, buf, sizeof(buf));

    /* Step 2: Map MAP_SIZE (8192) bytes – more than the file */
    addr = mmap(NULL, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) { perror("mmap"); exit(EXIT_FAILURE); }

    printf("File size before ftruncate: %d bytes\n", INIT_SIZE);
    printf("addr[4096] would raise SIGBUS right now.\n");

    /* Step 3: Extend the file to MAP_SIZE using ftruncate()
     * Now the file is 8192 bytes. Pages 0 and 1 both have file backing.
     * addr[4096] is now SAFE to access.
     */
    if (ftruncate(fd, MAP_SIZE) == -1) {
        perror("ftruncate"); exit(EXIT_FAILURE);
    }
    printf("File extended to %d bytes via ftruncate()\n", MAP_SIZE);

    /* Step 4: Now addr[4096] is safe */
    addr[4096] = 'X';
    printf("addr[4096] = '%c'  (now safe after ftruncate)\n", addr[4096]);

    close(fd);
    munmap(addr, MAP_SIZE);
    return 0;
}

• The kernel rounds up the mapping length to the next page boundary.
• Bytes within the rounded-up first page but beyond EOF are accessible and zeroed (SUSv3).
• Pages completely beyond EOF in the mapping → SIGBUS on access.
• Addresses beyond the entire mapping → SIGSEGV on access.
• You can cure SIGBUS by extending the file with ftruncate() or write().
• Always check the page size at runtime using sysconf(_SC_PAGESIZE).

#include <stdio.h>
#include <unistd.h>

/* Round size up to the next multiple of page_size */
static size_t round_up_to_page(size_t size, long page_size)
{
    return (size + page_size - 1) & ~(page_size - 1);
}

int main(void)
{
    long page_size = sysconf(_SC_PAGESIZE);
    printf("Page size: %ld bytes\n", page_size);

    /* Example: file is 5000 bytes, you want to align mapping to page boundary */
    size_t file_size = 5000;
    size_t aligned   = round_up_to_page(file_size, page_size);
    printf("5000 bytes rounded up to page boundary: %zu bytes\n", aligned);
    /* Output: 8192 bytes (next 4096-byte boundary) */

    size_t file_size2 = 8192;
    size_t aligned2   = round_up_to_page(file_size2, page_size);
    printf("8192 bytes rounded up to page boundary: %zu bytes\n", aligned2);
    /* Output: 8192 bytes (already aligned) */

    return 0;
}