srctree

for (consolidated.items) |cmd| {

switch (cmd) {

.write_data => |data| {

try out_file.pwritevAll(&iovec, data.out_offset);

},

.copy_range => |range| {

 

{

var iovecs = [_]std.posix.iovec_const{

.{

},

.{

},

};

try stream.writevAll(&iovecs);

 

const both_msgs = client_change_cipher_spec_msg ++ finished_msg;

var both_msgs_vec = [_]std.posix.iovec_const{.{

}};

try stream.writevAll(&both_msgs_vec);

 

var total_amt: usize = 0;

while (true) {

var amt = try stream.writev(iovecs_buf[i..iovec_end]);

total_amt += encrypted_amt - overhead_len;

amt -= encrypted_amt;

i += 1;

// not sent; otherwise the caller would not know to retry the call.

if (amt == 0 and (!end or i < iovec_end - 1)) return total_amt;

}

}

}

 

 

const record = ciphertext_buf[record_start..ciphertext_end];

iovecs[iovec_end] = .{

};

iovec_end += 1;

}

/// If the number read is less than `len` it means the stream reached the end.

/// Reaching the end of the stream is not an error condition.

pub fn readAtLeast(c: *Client, stream: anytype, buffer: []u8, len: usize) !usize {

return readvAtLeast(c, stream, &iovecs, len);

}

 

var amt = try c.readvAdvanced(stream, iovecs[vec_i..]);

off_i += amt;

if (c.eof() or off_i >= len) return off_i;

vec_i += 1;

}

}

}

 

 

var ask_iovecs_buf: [2]std.posix.iovec = .{

.{

},

.{

},

};

 

var bytes_i: usize = 0;

while (true) {

const v = vp.iovecs[vp.idx];

const src = bytes[bytes_i..][0..@min(dest.len, bytes.len - bytes_i)];

@memcpy(dest[0..src.len], src);

bytes_i += src.len;

vp.off += src.len;

vp.off = 0;

vp.idx += 1;

if (vp.idx >= vp.iovecs.len) {

fn peek(vp: VecPut) []u8 {

if (vp.idx >= vp.iovecs.len) return &.{};

const v = vp.iovecs[vp.idx];

}

 

// After writing to the result of peek(), one can call next() to

fn next(vp: *VecPut, len: usize) void {

vp.total += len;

vp.off += len;

vp.off = 0;

vp.idx += 1;

}

fn freeSize(vp: VecPut) usize {

if (vp.idx >= vp.iovecs.len) return 0;

var total: usize = 0;

if (vp.idx + 1 >= vp.iovecs.len) return total;

return total;

}

};

fn limitVecs(iovecs: []std.posix.iovec, len: usize) []std.posix.iovec {

var bytes_left: usize = len;

for (iovecs, 0..) |*iovec, vec_i| {

return iovecs[0 .. vec_i + 1];

}

}

return iovecs;

}

 

// TODO improve this to use ReadFileScatter

if (iovecs.len == 0) return @as(usize, 0);

const first = iovecs[0];

}

 

return posix.readv(self.handle, iovecs);

/// reads from the underlying OS layer.

/// * The OS layer expects pointer addresses to be inside the application's address space

/// even if the length is zero. Meanwhile, in Zig, slices may have undefined pointer

/// when the length is zero.

///

/// Related open issue: https://github.com/ziglang/zig/issues/7699

// addresses outside the application's address space.

var garbage: [1]u8 = undefined;

for (iovecs) |*v| {

}

 

var i: usize = 0;

var amt = try self.readv(iovecs[i..]);

var eof = amt == 0;

off += amt;

i += 1;

if (i >= iovecs.len) return off;

eof = false;

}

if (eof) return off;

}

}

 

// TODO improve this to use ReadFileScatter

if (iovecs.len == 0) return @as(usize, 0);

const first = iovecs[0];

}

 

return posix.preadv(self.handle, iovecs, offset);

var amt = try self.preadv(iovecs[i..], offset + off);

var eof = amt == 0;

off += amt;

i += 1;

if (i >= iovecs.len) return off;

eof = false;

}

if (eof) return off;

}

}

 

// TODO improve this to use WriteFileScatter

if (iovecs.len == 0) return @as(usize, 0);

const first = iovecs[0];

}

 

return posix.writev(self.handle, iovecs);

/// writes from the underlying OS layer.

/// * The OS layer expects pointer addresses to be inside the application's address space

/// even if the length is zero. Meanwhile, in Zig, slices may have undefined pointer

/// when the length is zero.

/// See https://github.com/ziglang/zig/issues/7699

/// See equivalent function: `std.net.Stream.writevAll`.

// addresses outside the application's address space.

var garbage: [1]u8 = undefined;

for (iovecs) |*v| {

}

 

var i: usize = 0;

while (true) {

var amt = try self.writev(iovecs[i..]);

i += 1;

if (i >= iovecs.len) return;

}

}

}

 

// TODO improve this to use WriteFileScatter

if (iovecs.len == 0) return @as(usize, 0);

const first = iovecs[0];

}

 

return posix.pwritev(self.handle, iovecs, offset);

while (true) {

var amt = try self.pwritev(iovecs[i..], offset + off);

off += amt;

i += 1;

if (i >= iovecs.len) return;

}

}

}

 

var i: usize = 0;

while (i < headers.len) {

amt = try posix.sendfile(out_fd, in_fd, offset, count, headers[i..], trls, flags);

i += 1;

if (i >= headers.len) break :hdrs;

}

}

}

if (count == 0) {

}

var i: usize = 0;

while (i < trailers.len) {

i += 1;

if (i >= trailers.len) return;

}

amt = try posix.writev(self.handle, trailers[i..]);

}

}

 

var buf2: [line2.len]u8 = undefined;

var write_vecs = [_]posix.iovec_const{

.{

},

.{

},

};

var read_vecs = [_]posix.iovec{

.{

},

.{

},

};

 

var buf2: [line2.len]u8 = undefined;

var write_vecs = [_]posix.iovec_const{

.{

},

.{

},

};

var read_vecs = [_]posix.iovec{

.{

},

.{

},

};

 

const line2 = "second line\n";

var vecs = [_]posix.iovec_const{

.{

},

.{

},

};

 

const trailer2 = "second trailer\n";

var hdtr = [_]posix.iovec_const{

.{

},

.{

},

.{

},

.{

},

};

 

 

if (conn.read_end != conn.read_start) return;

 

var iovecs = [1]std.posix.iovec{

};

const nread = try conn.readvDirect(&iovecs);

if (nread == 0) return error.EndOfStream;

}

 

var iovecs = [2]std.posix.iovec{

};

const nread = try conn.readvDirect(&iovecs);

 

 

var iovecs_len: usize = 0;

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

for (options.extra_headers) |header| {

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

if (header.value.len != 0) {

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

}

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

}

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

) catch unreachable;

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

}

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

} else if (content.len > 0) {

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

}

const send_buffer_len = r.send_buffer_end - r.send_buffer_start;

var iovecs: [2]std.posix.iovec_const = .{

.{

},

.{

},

};

const n = try r.stream.writev(&iovecs);

 

var iovecs: [5]std.posix.iovec_const = .{

.{

},

.{

},

.{

},

.{

},

.{

},

};

// TODO make this writev instead of writevAll, which involves

var iovecs_len: usize = 0;

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

if (r.chunk_len > 0) {

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

}

 

if (end_trailers) |trailers| {

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

for (trailers) |trailer| {

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

 

if (trailer.value.len != 0) {

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

}

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

}

 

iovecs[iovecs_len] = .{

};

iovecs_len += 1;

}

 

// TODO improve this to use ReadFileScatter

if (iovecs.len == 0) return @as(usize, 0);

const first = iovecs[0];

}

 

return posix.readv(s.handle, iovecs);

var i: usize = 0;

while (true) {

var amt = try self.writev(iovecs[i..]);

i += 1;

if (i >= iovecs.len) return;

}

}

}

};

 

var size: i32 = 0;

const msg_iovlen = @as(usize, @intCast(msg.msg_hdr.msg_iovlen)); // kernel side this is treated as unsigned

for (msg.msg_hdr.msg_iov[0..msg_iovlen]) |iov| {

// batch-send all messages up to the current message

if (next_unsent < i) {

const batch_size = i - next_unsent;

next_unsent = i + 1;

break;

}

}

}

if (next_unsent < kvlen or next_unsent == 0) { // want to make sure at least one syscall occurs (e.g. to trigger MSG.EOR)

 

try ring.register_files(registered_fds[0..]);

 

var buffer = [_]u8{42} ** 128;

const sqe = try ring.read(0xcccccccc, fd_index, .{ .iovecs = iovecs[0..] }, 0);

try testing.expectEqual(linux.IORING_OP.READV, sqe.opcode);

sqe.flags |= linux.IOSQE_FIXED_FILE;

 

const buffer_write = [_]u8{42} ** 128;

const iovecs_write = [_]posix.iovec_const{

};

var buffer_read = [_]u8{0} ** 128;

var iovecs_read = [_]posix.iovec{

};

 

const sqe_writev = try ring.writev(0xdddddddd, fd, iovecs_write[0..], 17);

raw_buffers[0][0.."foobar".len].* = "foobar".*;

 

var buffers = [2]posix.iovec{

};

ring.register_buffers(&buffers) catch |err| switch (err) {

error.SystemResources => {

 

try testing.expectEqual(linux.io_uring_cqe{

.user_data = 0x45454545,

.flags = 0,

}, cqe_write);

try testing.expectEqual(linux.io_uring_cqe{

.user_data = 0x12121212,

.flags = 0,

}, cqe_read);

 

}

 

test "openat" {

 

const buffer_send = [_]u8{42} ** 128;

const iovecs_send = [_]posix.iovec_const{

};

const msg_send: posix.msghdr_const = .{

.name = &address_server.any,

 

var buffer_recv = [_]u8{0} ** 128;

var iovecs_recv = [_]posix.iovec{

};

const addr = [_]u8{0} ** 4;

var address_recv = net.Address.initIp4(addr, 0);

 

}

 

pub fn prep_read_fixed(sqe: *linux.io_uring_sqe, fd: linux.fd_t, buffer: *std.posix.iovec, offset: u64, buffer_index: u16) void {

sqe.buf_index = buffer_index;

}

 

pub fn prep_write_fixed(sqe: *linux.io_uring_sqe, fd: linux.fd_t, buffer: *std.posix.iovec, offset: u64, buffer_index: u16) void {

sqe.buf_index = buffer_index;

}

 

 

pub const X_OK = system.X_OK;

 

pub const iovec = extern struct {

};

 

pub const iovec_const = extern struct {

};

 

pub const ACCMODE = enum(u2) {

}

if (native_os == .wasi and !builtin.link_libc) {

const iovs = [1]iovec{iovec{

}};

 

var nread: usize = undefined;

// TODO improve this to use ReadFileScatter

if (iov.len == 0) return 0;

const first = iov[0];

}

if (native_os == .wasi and !builtin.link_libc) {

var nread: usize = undefined;

}

if (native_os == .wasi and !builtin.link_libc) {

const iovs = [1]iovec{iovec{

}};

 

var nread: usize = undefined;

// So we simply read into the first vector only.

if (iov.len == 0) return 0;

const first = iov[0];

}

if (native_os == .wasi and !builtin.link_libc) {

var nread: usize = undefined;

 

if (native_os == .wasi and !builtin.link_libc) {

const ciovs = [_]iovec_const{iovec_const{

}};

var nwritten: usize = undefined;

switch (wasi.fd_write(fd, &ciovs, ciovs.len, &nwritten)) {

// TODO improve this to use WriteFileScatter

if (iov.len == 0) return 0;

const first = iov[0];

}

if (native_os == .wasi and !builtin.link_libc) {

var nwritten: usize = undefined;

}

if (native_os == .wasi and !builtin.link_libc) {

const ciovs = [1]iovec_const{iovec_const{

}};

 

var nwritten: usize = undefined;

// So we simply write the first vector only.

if (iov.len == 0) return 0;

const first = iov[0];

}

if (native_os == .wasi and !builtin.link_libc) {

var nwritten: usize = undefined;

fn count_iovec_bytes(iovs: []const iovec_const) usize {

var count: usize = 0;

for (iovs) |iov| {

}

return count;

}

 

var file = try tmp.dir.createFile("pwritev", .{});

defer file.close();

 

const amt = try file.writev(&iovecs);

try testing.expectEqual(@as(usize, posix.IOV_MAX), amt);

}

 

var iovecs: [10]std.posix.iovec_const = undefined;

const header_le = bswap(header);

iovecs[0] = .{

};

for (bufs, iovecs[1 .. bufs.len + 1]) |buf, *iovec| {

iovec.* = .{

};

}

try s.out.writevAll(iovecs[0 .. bufs.len + 1]);

 

const i = bufs_len.*;

bufs_len.* = i + 1;

bufs_list[i] = .{

};

}

 

};

 

var header_and_trailer: [2]std.posix.iovec_const = .{

};

 

try tar_file.writeFileAll(file, .{

 

};

var iovecs = [_]std.posix.iovec_const{

.{

},

.{

},

.{

},

.{

},

.{

},

};

cache_file.writevAll(&iovecs) catch |err| {

 

var iovecs = [_]std.posix.iovec{

.{

},

.{

},

.{

},

.{

},

};

const amt_read = try cache_file.readvAll(&iovecs);

 

}

 

f.all_buffers.items[ctypes_index] = .{

};

f.file_size += f.ctypes_buf.items.len;

 

const lazy_fwd_decl_len = self.lazy_fwd_decl_buf.items.len;

f.all_buffers.items[lazy_index] = .{

};

f.file_size += lazy_fwd_decl_len;

 

 

fn appendBufAssumeCapacity(f: *Flush, buf: []const u8) void {

if (buf.len == 0) return;

f.file_size += buf.len;

}

 

var file_size: u64 = zig_h.len;

if (zig_h.len != 0) {

all_buffers.appendAssumeCapacity(.{

});

}

 

const buf = decl_emit_h.fwd_decl.items;

if (buf.len != 0) {

all_buffers.appendAssumeCapacity(.{

});

file_size += buf.len;

}

 

var padding_left = prev_padding_size;

if (padding_left % 2 != 0) {

vecs[vec_index] = .{

};

vec_index += 1;

padding_left -= three_byte_nop.len;

}

while (padding_left > page_of_nops.len) {

vecs[vec_index] = .{

};

vec_index += 1;

padding_left -= page_of_nops.len;

}

if (padding_left > 0) {

vecs[vec_index] = .{

};

vec_index += 1;

}

}

 

vecs[vec_index] = .{

};

if (buf.len > 0) vec_index += 1;

 

var padding_left = next_padding_size;

if (padding_left % 2 != 0) {

vecs[vec_index] = .{

};

vec_index += 1;

padding_left -= three_byte_nop.len;

}

while (padding_left > page_of_nops.len) {

vecs[vec_index] = .{

};

vec_index += 1;

padding_left -= page_of_nops.len;

}

if (padding_left > 0) {

vecs[vec_index] = .{

};

vec_index += 1;

}

var padding_left = prev_padding_size;

while (padding_left > page_of_nops.len) {

vecs[vec_index] = .{

};

vec_index += 1;

padding_left -= page_of_nops.len;

}

if (padding_left > 0) {

vecs[vec_index] = .{

};

vec_index += 1;

}

}

 

vecs[vec_index] = .{

};

if (buf.len > 0) vec_index += 1;

 

var padding_left = next_padding_size;

while (padding_left > page_of_nops.len) {

vecs[vec_index] = .{

};

vec_index += 1;

padding_left -= page_of_nops.len;

}

if (padding_left > 0) {

vecs[vec_index] = .{

};

vec_index += 1;

}

if (trailing_zero) {

var zbuf = [1]u8{0};

vecs[vec_index] = .{

};

vec_index += 1;

}

 

switch (builtin.os.tag) {

.linux => {

var code_vec: [1]std.posix.iovec_const = .{.{

}};

var remote_vec: [1]std.posix.iovec_const = .{.{

}};

const rc = std.os.linux.process_vm_writev(pid, &code_vec, &remote_vec, 0);

switch (std.os.linux.E.init(rc)) {

 

switch (builtin.os.tag) {

.linux => {

var local_vec: [1]std.posix.iovec_const = .{.{

}};

var remote_vec: [1]std.posix.iovec_const = .{.{

}};

const rc = std.os.linux.process_vm_writev(pid, &local_vec, &remote_vec, 0);

switch (std.os.linux.E.init(rc)) {

 

const hdr_size = if (self.sixtyfour_bit) @as(usize, 40) else 32;

const hdr_slice: []u8 = hdr_buf[0..hdr_size];

var foff = hdr_size;

var iovecs_i: usize = 1;

var text_i: u64 = 0;

 

linecount = out.end_line;

}

foff += out.code.len;

iovecs_i += 1;

const off = self.getAddr(text_i, .t);

text_i += out.code.len;

const text_atom = if (meta.text_state != .unused) self.getAtomPtr(meta.text_atom) else continue;

const code = text_atom.code.getOwnedCode().?;

foff += code.len;

iovecs_i += 1;

const off = self.getAddr(text_i, .t);

text_i += code.len;

}

}

// global offset table is in data

iovecs_i += 1;

// data

var data_i: u64 = got_size;

const code = entry.value_ptr.*;

 

foff += code.len;

iovecs_i += 1;

const off = self.getAddr(data_i, .d);

data_i += code.len;

const code = atom.code.getOwnedCode().?; // unnamed consts must own their code

log.debug("write unnamed const: ({s})", .{self.syms.items[atom.sym_index.?].name});

foff += code.len;

iovecs_i += 1;

const off = self.getAddr(data_i, .d);

data_i += code.len;

const code = atom.code.getOwnedCode().?;

log.debug("write anon decl: {s}", .{self.syms.items[atom.sym_index.?].name});

foff += code.len;

iovecs_i += 1;

const off = self.getAddr(data_i, .d);

data_i += code.len;

const data_atom = if (meta.rodata_state != .unused) self.getAtomPtr(meta.rodata_atom) else continue;

const code = data_atom.code.getOwnedCode().?; // lazy symbols must own their code

foff += code.len;

iovecs_i += 1;

const off = self.getAddr(data_i, .d);

data_i += code.len;

const syms = try sym_buf.toOwnedSlice();

defer gpa.free(syms);

assert(2 + self.atomCount() - self.externCount() == iovecs_i); // we didn't write all the decls

iovecs_i += 1;

iovecs_i += 1;

// generate the header

self.hdr = .{

 

 

// finally, write the entire binary into the file.

var iovec = [_]std.posix.iovec_const{.{

}};

try wasm.base.file.?.writevAll(&iovec);

}