posix_openpt() finds the next unused PTY master device, opens it, and returns a file descriptor. This is always your first step when creating a PTY pair.

Function Signature

#define _XOPEN_SOURCE 600
#include <stdlib.h>
#include <fcntl.h>

int posix_openpt(int flags);
/* Returns file descriptor on success, or -1 on error */

The flags Argument

You pass one or more of these flags ORed together:

What happens when posix_openpt() is called?

Two things happen automatically:

posix_openpt() is a POSIX-standard wrapper. On Linux it is implemented very simply — it just opens the special clone device /dev/ptmx:

/* This is how posix_openpt() is implemented on Linux */
int
posix_openpt(int flags)
{
    return open("/dev/ptmx", flags);
}

/dev/ptmx is the PTY master multiplexer. Every time you open it, the kernel automatically:

Before POSIX standardized posix_openpt(), developers had to manually open /dev/ptmx themselves. Using posix_openpt() is the portable way to do this in modern code.

This example shows all four steps together. We open the master, prepare the slave, and then print the slave’s device path. This is the correct standard sequence every PTY-using program must follow.

#define _XOPEN_SOURCE 600
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

int main(void)
{
    int mfd;        /* master file descriptor */
    char *slaveName;

    /* Step 1: Open an unused PTY master device */
    mfd = posix_openpt(O_RDWR | O_NOCTTY);
    if (mfd == -1) {
        perror("posix_openpt");
        exit(EXIT_FAILURE);
    }
    printf("PTY master fd = %d\n", mfd);

    /* Step 2: Change slave ownership and permissions */
    if (grantpt(mfd) == -1) {
        perror("grantpt");
        close(mfd);
        exit(EXIT_FAILURE);
    }

    /* Step 3: Unlock the slave so it can be opened */
    if (unlockpt(mfd) == -1) {
        perror("unlockpt");
        close(mfd);
        exit(EXIT_FAILURE);
    }

    /* Step 4: Get the slave device name */
    slaveName = ptsname(mfd);
    if (slaveName == NULL) {
        perror("ptsname");
        close(mfd);
        exit(EXIT_FAILURE);
    }

    printf("PTY slave device: %s\n", slaveName);

    /* Now you can open the slave */
    int sfd = open(slaveName, O_RDWR | O_NOCTTY);
    if (sfd == -1) {
        perror("open slave");
        close(mfd);
        exit(EXIT_FAILURE);
    }
    printf("PTY slave fd = %d\n", sfd);

    /* At this point:
       - Write to mfd  -> readable from sfd (master writes, slave reads)
       - Write to sfd  -> readable from mfd (slave writes, master reads)
    */

    close(sfd);
    close(mfd);
    return 0;
}

gcc -o pty_open pty_open.c
./pty_open
# Output example:
# PTY master fd = 3
# PTY slave device: /dev/pts/7
# PTY slave fd = 4

Every PTY pair in use consumes a small amount of non-swappable kernel memory. Because of this, the kernel enforces a limit on how many PTY pairs can exist at once.

Checking and Changing PTY Limits at Runtime

# View the current PTY limit
cat /proc/sys/kernel/pty/max

# View how many PTYs are currently in use
cat /proc/sys/kernel/pty/nr

# Increase the limit to 8192 (until next reboot)
echo 8192 | sudo tee /proc/sys/kernel/pty/max

# Make the change permanent (survives reboots)
echo "kernel.pty.max = 8192" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

When posix_openpt() is called, the kernel automatically creates a device node in /dev/pts/. This directory is a special devpts filesystem — it is not a regular directory on disk. The files in it are dynamically created and destroyed as PTY pairs are opened and closed.

# List current PTY slave device files
ls -l /dev/pts/

# Typical output:
# crw--w---- 1 ravi tty 136, 0 Jun 18 10:00 0
# crw--w---- 1 ravi tty 136, 1 Jun 18 10:05 1
# crw-rw-rw- 1 root tty   5, 2 Jun 18 09:58 ptmx

# /dev/pts/ptmx is the same as /dev/ptmx — clone device inside devpts

The number in each filename (0, 1, 2, …) is the PTY number. ptsname(mfd) returns the full path such as /dev/pts/0 for this slave.