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.

Change-Id: I86769fc4382c0771e3656e7b21137bafd99a4411

Author: terinjokes

lib/std/os.zig

@@ -3111,6 +3111,84 @@ 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 resources for processing.
+    SystemResources,
+
+    /// 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,
+} || WriteError || UnexpectedError;
+
+pub const sf_hdtr = struct {
+    headers: []iovec_const,
+    trailers: []iovec_const,
+};
+
+/// 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(infd: fd_t, outfd: fd_t, offset: u64, count: usize, optional_hdtr: ?*const sf_hdtr, flags: u32) SendFileError!usize {
+    // XXX: check if offset is > length of file, return 0 bytes written
+    // XXX: document systems where headers are sent atomically.
+    var rc: usize = undefined;
+    var err: usize = undefined;
+    if (builtin.os == .linux) {
+        while (true) {
+            try lseek_SET(infd, offset);
+
+            if (optional_hdtr) |hdtr| {
+                try writev(outfd, hdtr.headers);
+            }
+
+            rc = system.sendfile(outfd, infd, null, count);
+            err = errno(rc);
+
+            if (optional_hdtr) |hdtr| {
+                try writev(outfd, hdtr.trailers);
+            }
+
+            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.SystemResources,
+                EOVERFLOW => return error.Overflow,
+                ESPIPE => return error.Unseekable,
+            }
+        }
+    } else {
+        @compileError("sendfile unimplemented for this target");
+    }
+}
+
 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]) });