tee(2)

💖 tee(2) 💖

okay bestie, so this is the system call manual page for tee — that's <hotpink>tee(2)</hotpink> from the System Calls Manual section 💅 (yes, there's also a tee(1) command and no, they are not the same thing, don't @ me). this whole page lives in the Linux man-pages, and we're gonna get through it together, no cap ✨

---

🌸 NAME 🌸

tee — duplicating pipe content 🫶

📚 LIBRARY 📚

Standard C library (libc, -lc) — so pretty standard, iconic behavior, lowkey nothing fancy 🎀

✨ SYNOPSIS ✨

#define _GNU_SOURCE         /* See feature_test_macros(7) */
#include <fcntl.h>

ssize_t tee(int fd_in, int fd_out, size_t size, unsigned int flags);

not me needing that #define _GNU_SOURCE first or the compiler just ghosting me 😭 it's the See feature_test_macros(7) thing, keep it bestie.

🦋 DESCRIPTION 🦋

tee() duplicates up to size bytes of data from the pipe referred to by the file descriptor fd_in to the pipe referred to by the file descriptor fd_out. 🪄

and here's the gag, the main character twist: it does not consume the data that is duplicated from fd_in. so that data stays put and can be copied by a subsequent splice(2). it's giving "borrow your notes but you still have your notes" energy 📝💖

flags is a bit mask that is composed by ORing together zero or more of the following values:

• SPLICE_F_MOVE — currently has no effect for tee(); see splice(2). it's just there, vibing 🙈
• SPLICE_F_NONBLOCK — do not block on I/O; see splice(2) for further details. the ✨impatient✨ option, we love her
• SPLICE_F_MORE — currently has no effect for tee(), but may be implemented in the future; see splice(2). she's a maybe, a future era 💭
• SPLICE_F_GIFT — unused for tee(); see vmsplice(2). literally unused, she came to the party with nothing 🎁💀

🎀 RETURN VALUE 🎀

upon successful completion, tee() returns the number of bytes that were duplicated between the input and output. 📏

a return value of 0 means that there was no data to transfer, and it would not make sense to block, because there are no writers connected to the write end of the pipe referred to by fd_in. so 0 = nobody's writing, nothing to do, go home girl 🌙

on error, tee() returns -1 and errno is set to indicate the error. classic 😔

💀 ERRORS 💀

• EAGAIN — SPLICE_F_NONBLOCK was specified in flags or one of the file descriptors had been marked as nonblocking (O_NONBLOCK), and the operation would block. she said "i would block but i'm literally not allowed to" 🙅♀️
• EINVAL — fd_in or fd_out does not refer to a pipe; or fd_in and fd_out refer to the same pipe. bestie these are PIPES only, and they gotta be different pipes, iykyk 🚫
• ENOMEM — out of memory. the laptop said no 🌪️

🌈 STANDARDS 🌈

Linux. that's it, that's the standard 👑

⭐ HISTORY ⭐

Linux 2.6.17, glibc 2.5. a lil retro moment, we respect the elders 🕰️

💜 NOTES 💜

conceptually, tee() copies the data between the two pipes. but in reality, no real data copying takes place though — under the covers, tee() assigns data to the output by merely grabbing a reference to the input. 🫢

the way that it's fake-copying but actually just holding a reference?? efficiency icon fr fr, not a single byte was moved and yet ✨everything✨ happened. no cap.

🧚 EXAMPLES 🧚

the example below implements a basic tee(1) program using the tee() system call. here is an example of its use:

$ date | ./a.out out.log | cat;
Tue Oct 28 10:06:00 CET 2014
$ cat out.log;
Tue Oct 28 10:06:00 CET 2014

see how date's output went into the file and to cat? that's the whole point bestie, oh she ATE 👑

🍓 Program source 🍓

#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int
main(int argc, char *argv[])
{
    int      fd;
    ssize_t  size, ssize;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <file>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    fd = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    for (;;) {
        /*
         * tee stdin to stdout.
         */
        size = tee(STDIN_FILENO, STDOUT_FILENO,
                  INT_MAX, SPLICE_F_NONBLOCK);
        if (size < 0) {
            if (errno == EAGAIN)
                continue;
            perror("tee");
            exit(EXIT_FAILURE);
        }
        if (size == 0)
            break;

        /*
         * Consume stdin by splicing it to a file.
         */
        while (size > 0) {
            ssize = splice(STDIN_FILENO, NULL, fd, NULL,
                          size, SPLICE_F_MOVE);
            if (ssize < 0) {
                perror("splice");
                exit(EXIT_FAILURE);
            }
            size -= ssize;
        }
    }

    close(fd);
    exit(EXIT_SUCCESS);
}

copy it exactly, bestie, every include, every SSIZE_MAX-adjacent vibe, don't be "fixing" the indentation 💅

🔥 SEE ALSO 🔥

splice(2), vmsplice(2), pipe(7) — the whole friend group, go read them too 🫶

---

and that's the page!! 🌟 this was Linux man-pages 6.20, dated 2026-02-08 — shoutout to the man-pages girlies for keeping the tee(2) lore alive, ilysm, drink water, and remember: tee() never consumes, she only shares 💖✨🎀🦋🌸