std: implement sendfile on linux

This changset adds a `sendfile(2)` syscall bindings to the linux bits
component. Where available, the `sendfile64(2)` syscall will be
transparently called.

A wrapping function has also been added to the std.os to transform
errno returns to Zig errors.

Author: terinjokes

lib/std/os.zig

@@ -3111,6 +3111,67 @@ pub fn send(
     return sendto(sockfd, buf, flags, null, 0);
 }
 
+pub const SendFileError = error{
+    /// There was an unspecified error while reading from infd.
+    InputOutput,
+
+    /// There was insufficient memory for reading from infd.
+    NoMem,
+
+    /// The value provided for count overflows the maximum size of either
+    /// infd or outfd.
+    Overflow,
+
+    /// Offset was provided, but infd is not seekable.
+    Unseekable,
+
+    /// The outfd is marked nonblocking and the requested operation would block, and
+    /// there is no global event loop configured.
+    WouldBlock,
+} || UnexpectedError;
+
+/// Transfer data between file descriptors.
+///
+/// The `sendfile` call copies `count` bytes from one file descriptor to another within the kernel. This can
+/// be more performant than transferring data from the kernel to user space and back, such as with
+/// `read` and `write` calls.
+///
+/// The `infd` should be a file descriptor opened for reading, and `outfd` should be a file descriptor
+/// opened for writing. Copying will begin at `offset`, if not null, which will be updated to reflect
+/// the number of bytes read. If `offset` is null, the copying will begin at the current seek position,
+/// and the file position will be updated.
+pub fn sendfile(outfd: fd_t, infd: fd_t, offset: ?*u64, count: usize) SendFileError!usize {
+    while (true) {
+        var rc: usize = undefined;
+        var err: usize = undefined;
+        if (builtin.os == .linux) {
+            rc = system.sendfile(outfd, infd, offset, count);
+            err = errno(rc);
+        } else {
+            @compileError("sendfile unimplemented for this target");
+        }
+
+        switch (err) {
+            0 => return @intCast(usize, rc),
+            else => return unexpectedErrno(err),
+
+            EBADF => unreachable,
+            EINVAL => unreachable,
+            EFAULT => unreachable,
+            EAGAIN => if (std.event.Loop.instance) |loop| {
+                loop.waitUntilFdWritable(outfd);
+                continue;
+            } else {
+                return error.WouldBlock;
+            },
+            EIO => return error.InputOutput,
+            ENOMEM => return error.NoMem,
+            EOVERFLOW => return error.Overflow,
+            ESPIPE => return error.Unseekable,
+        }
+    }
+}
+
 pub const PollError = error{
     /// The kernel had no space to allocate file descriptor tables.
     SystemResources,

lib/std/os/linux.zig

@@ -846,6 +846,14 @@ pub fn sendto(fd: i32, buf: [*]const u8, len: usize, flags: u32, addr: ?*const s
     return syscall6(SYS_sendto, @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @intCast(usize, alen));
 }
 
+pub fn sendfile(outfd: i32, infd: i32, offset: ?*u64, count: usize) usize {
+    if (@hasDecl(@This(), "SYS_sendfile64")) {
+        return syscall4(SYS_sendfile64, @bitCast(usize, @as(isize, outfd)), @bitCast(usize, @as(isize, infd)), @ptrToInt(offset), count);
+    } else {
+        return syscall4(SYS_sendfile, @bitCast(usize, @as(isize, outfd)), @bitCast(usize, @as(isize, infd)), @ptrToInt(offset), count);
+    }
+}
+
 pub fn socketpair(domain: i32, socket_type: i32, protocol: i32, fd: [2]i32) usize {
     if (builtin.arch == .i386) {
         return socketcall(SC_socketpair, &[4]usize{ @intCast(usize, domain), @intCast(usize, socket_type), @intCast(usize, protocol), @ptrToInt(&fd[0]) });