Skip to content

Commit 2cff319

Browse files
andrewrkandrewrk
committedMar 24, 2018
std.os.linux exposes syscall functions and syscall numbers
·
0.14.00.3.0
1 parent 7350181 commit 2cff319

File tree

1 file changed

+67
-91
lines changed

1 file changed

+67
-91
lines changed
 

‎std/os/linux/index.zig

+67-91
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
const std = @import("../../index.zig");
22
const assert = std.debug.assert;
33
const builtin = @import("builtin");
4-
const arch = switch (builtin.arch) {
4+
pub use switch (builtin.arch) {
55
builtin.Arch.x86_64 => @import("x86_64.zig"),
66
builtin.Arch.i386 => @import("i386.zig"),
77
else => @compileError("unsupported arch"),
@@ -93,27 +93,6 @@ pub const O_RDONLY = 0o0;
9393
pub const O_WRONLY = 0o1;
9494
pub const O_RDWR = 0o2;
9595

96-
pub const O_CREAT = arch.O_CREAT;
97-
pub const O_EXCL = arch.O_EXCL;
98-
pub const O_NOCTTY = arch.O_NOCTTY;
99-
pub const O_TRUNC = arch.O_TRUNC;
100-
pub const O_APPEND = arch.O_APPEND;
101-
pub const O_NONBLOCK = arch.O_NONBLOCK;
102-
pub const O_DSYNC = arch.O_DSYNC;
103-
pub const O_SYNC = arch.O_SYNC;
104-
pub const O_RSYNC = arch.O_RSYNC;
105-
pub const O_DIRECTORY = arch.O_DIRECTORY;
106-
pub const O_NOFOLLOW = arch.O_NOFOLLOW;
107-
pub const O_CLOEXEC = arch.O_CLOEXEC;
108-
109-
pub const O_ASYNC = arch.O_ASYNC;
110-
pub const O_DIRECT = arch.O_DIRECT;
111-
pub const O_LARGEFILE = arch.O_LARGEFILE;
112-
pub const O_NOATIME = arch.O_NOATIME;
113-
pub const O_PATH = arch.O_PATH;
114-
pub const O_TMPFILE = arch.O_TMPFILE;
115-
pub const O_NDELAY = arch.O_NDELAY;
116-
11796
pub const SEEK_SET = 0;
11897
pub const SEEK_CUR = 1;
11998
pub const SEEK_END = 2;
@@ -394,150 +373,150 @@ pub fn getErrno(r: usize) usize {
394373
}
395374

396375
pub fn dup2(old: i32, new: i32) usize {
397-
return arch.syscall2(arch.SYS_dup2, usize(old), usize(new));
376+
return syscall2(SYS_dup2, usize(old), usize(new));
398377
}
399378

400379
pub fn chdir(path: &const u8) usize {
401-
return arch.syscall1(arch.SYS_chdir, @ptrToInt(path));
380+
return syscall1(SYS_chdir, @ptrToInt(path));
402381
}
403382

404383
pub fn execve(path: &const u8, argv: &const ?&const u8, envp: &const ?&const u8) usize {
405-
return arch.syscall3(arch.SYS_execve, @ptrToInt(path), @ptrToInt(argv), @ptrToInt(envp));
384+
return syscall3(SYS_execve, @ptrToInt(path), @ptrToInt(argv), @ptrToInt(envp));
406385
}
407386

408387
pub fn fork() usize {
409-
return arch.syscall0(arch.SYS_fork);
388+
return syscall0(SYS_fork);
410389
}
411390

412391
pub fn getcwd(buf: &u8, size: usize) usize {
413-
return arch.syscall2(arch.SYS_getcwd, @ptrToInt(buf), size);
392+
return syscall2(SYS_getcwd, @ptrToInt(buf), size);
414393
}
415394

416395
pub fn getdents(fd: i32, dirp: &u8, count: usize) usize {
417-
return arch.syscall3(arch.SYS_getdents, usize(fd), @ptrToInt(dirp), count);
396+
return syscall3(SYS_getdents, usize(fd), @ptrToInt(dirp), count);
418397
}
419398

420399
pub fn isatty(fd: i32) bool {
421400
var wsz: winsize = undefined;
422-
return arch.syscall3(arch.SYS_ioctl, usize(fd), TIOCGWINSZ, @ptrToInt(&wsz)) == 0;
401+
return syscall3(SYS_ioctl, usize(fd), TIOCGWINSZ, @ptrToInt(&wsz)) == 0;
423402
}
424403

425404
pub fn readlink(noalias path: &const u8, noalias buf_ptr: &u8, buf_len: usize) usize {
426-
return arch.syscall3(arch.SYS_readlink, @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
405+
return syscall3(SYS_readlink, @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
427406
}
428407

429408
pub fn mkdir(path: &const u8, mode: u32) usize {
430-
return arch.syscall2(arch.SYS_mkdir, @ptrToInt(path), mode);
409+
return syscall2(SYS_mkdir, @ptrToInt(path), mode);
431410
}
432411

433412
pub fn mmap(address: ?&u8, length: usize, prot: usize, flags: usize, fd: i32, offset: isize) usize {
434-
return arch.syscall6(arch.SYS_mmap, @ptrToInt(address), length, prot, flags, usize(fd),
413+
return syscall6(SYS_mmap, @ptrToInt(address), length, prot, flags, usize(fd),
435414
@bitCast(usize, offset));
436415
}
437416

438417
pub fn munmap(address: &u8, length: usize) usize {
439-
return arch.syscall2(arch.SYS_munmap, @ptrToInt(address), length);
418+
return syscall2(SYS_munmap, @ptrToInt(address), length);
440419
}
441420

442421
pub fn read(fd: i32, buf: &u8, count: usize) usize {
443-
return arch.syscall3(arch.SYS_read, usize(fd), @ptrToInt(buf), count);
422+
return syscall3(SYS_read, usize(fd), @ptrToInt(buf), count);
444423
}
445424

446425
pub fn rmdir(path: &const u8) usize {
447-
return arch.syscall1(arch.SYS_rmdir, @ptrToInt(path));
426+
return syscall1(SYS_rmdir, @ptrToInt(path));
448427
}
449428

450429
pub fn symlink(existing: &const u8, new: &const u8) usize {
451-
return arch.syscall2(arch.SYS_symlink, @ptrToInt(existing), @ptrToInt(new));
430+
return syscall2(SYS_symlink, @ptrToInt(existing), @ptrToInt(new));
452431
}
453432

454433
pub fn pread(fd: i32, buf: &u8, count: usize, offset: usize) usize {
455-
return arch.syscall4(arch.SYS_pread, usize(fd), @ptrToInt(buf), count, offset);
434+
return syscall4(SYS_pread, usize(fd), @ptrToInt(buf), count, offset);
456435
}
457436

458437
pub fn pipe(fd: &[2]i32) usize {
459438
return pipe2(fd, 0);
460439
}
461440

462441
pub fn pipe2(fd: &[2]i32, flags: usize) usize {
463-
return arch.syscall2(arch.SYS_pipe2, @ptrToInt(fd), flags);
442+
return syscall2(SYS_pipe2, @ptrToInt(fd), flags);
464443
}
465444

466445
pub fn write(fd: i32, buf: &const u8, count: usize) usize {
467-
return arch.syscall3(arch.SYS_write, usize(fd), @ptrToInt(buf), count);
446+
return syscall3(SYS_write, usize(fd), @ptrToInt(buf), count);
468447
}
469448

470449
pub fn pwrite(fd: i32, buf: &const u8, count: usize, offset: usize) usize {
471-
return arch.syscall4(arch.SYS_pwrite, usize(fd), @ptrToInt(buf), count, offset);
450+
return syscall4(SYS_pwrite, usize(fd), @ptrToInt(buf), count, offset);
472451
}
473452

474453
pub fn rename(old: &const u8, new: &const u8) usize {
475-
return arch.syscall2(arch.SYS_rename, @ptrToInt(old), @ptrToInt(new));
454+
return syscall2(SYS_rename, @ptrToInt(old), @ptrToInt(new));
476455
}
477456

478457
pub fn open(path: &const u8, flags: u32, perm: usize) usize {
479-
return arch.syscall3(arch.SYS_open, @ptrToInt(path), flags, perm);
458+
return syscall3(SYS_open, @ptrToInt(path), flags, perm);
480459
}
481460

482461
pub fn create(path: &const u8, perm: usize) usize {
483-
return arch.syscall2(arch.SYS_creat, @ptrToInt(path), perm);
462+
return syscall2(SYS_creat, @ptrToInt(path), perm);
484463
}
485464

486465
pub fn openat(dirfd: i32, path: &const u8, flags: usize, mode: usize) usize {
487-
return arch.syscall4(arch.SYS_openat, usize(dirfd), @ptrToInt(path), flags, mode);
466+
return syscall4(SYS_openat, usize(dirfd), @ptrToInt(path), flags, mode);
488467
}
489468

490469
pub fn close(fd: i32) usize {
491-
return arch.syscall1(arch.SYS_close, usize(fd));
470+
return syscall1(SYS_close, usize(fd));
492471
}
493472

494473
pub fn lseek(fd: i32, offset: isize, ref_pos: usize) usize {
495-
return arch.syscall3(arch.SYS_lseek, usize(fd), @bitCast(usize, offset), ref_pos);
474+
return syscall3(SYS_lseek, usize(fd), @bitCast(usize, offset), ref_pos);
496475
}
497476

498477
pub fn exit(status: i32) noreturn {
499-
_ = arch.syscall1(arch.SYS_exit, @bitCast(usize, isize(status)));
478+
_ = syscall1(SYS_exit, @bitCast(usize, isize(status)));
500479
unreachable;
501480
}
502481

503482
pub fn getrandom(buf: &u8, count: usize, flags: u32) usize {
504-
return arch.syscall3(arch.SYS_getrandom, @ptrToInt(buf), count, usize(flags));
483+
return syscall3(SYS_getrandom, @ptrToInt(buf), count, usize(flags));
505484
}
506485

507486
pub fn kill(pid: i32, sig: i32) usize {
508-
return arch.syscall2(arch.SYS_kill, @bitCast(usize, isize(pid)), usize(sig));
487+
return syscall2(SYS_kill, @bitCast(usize, isize(pid)), usize(sig));
509488
}
510489

511490
pub fn unlink(path: &const u8) usize {
512-
return arch.syscall1(arch.SYS_unlink, @ptrToInt(path));
491+
return syscall1(SYS_unlink, @ptrToInt(path));
513492
}
514493

515494
pub fn waitpid(pid: i32, status: &i32, options: i32) usize {
516-
return arch.syscall4(arch.SYS_wait4, @bitCast(usize, isize(pid)), @ptrToInt(status), @bitCast(usize, isize(options)), 0);
495+
return syscall4(SYS_wait4, @bitCast(usize, isize(pid)), @ptrToInt(status), @bitCast(usize, isize(options)), 0);
517496
}
518497

519498
pub fn nanosleep(req: &const timespec, rem: ?&timespec) usize {
520-
return arch.syscall2(arch.SYS_nanosleep, @ptrToInt(req), @ptrToInt(rem));
499+
return syscall2(SYS_nanosleep, @ptrToInt(req), @ptrToInt(rem));
521500
}
522501

523502
pub fn setuid(uid: u32) usize {
524-
return arch.syscall1(arch.SYS_setuid, uid);
503+
return syscall1(SYS_setuid, uid);
525504
}
526505

527506
pub fn setgid(gid: u32) usize {
528-
return arch.syscall1(arch.SYS_setgid, gid);
507+
return syscall1(SYS_setgid, gid);
529508
}
530509

531510
pub fn setreuid(ruid: u32, euid: u32) usize {
532-
return arch.syscall2(arch.SYS_setreuid, ruid, euid);
511+
return syscall2(SYS_setreuid, ruid, euid);
533512
}
534513

535514
pub fn setregid(rgid: u32, egid: u32) usize {
536-
return arch.syscall2(arch.SYS_setregid, rgid, egid);
515+
return syscall2(SYS_setregid, rgid, egid);
537516
}
538517

539518
pub fn sigprocmask(flags: u32, noalias set: &const sigset_t, noalias oldset: ?&sigset_t) usize {
540-
return arch.syscall4(arch.SYS_rt_sigprocmask, flags, @ptrToInt(set), @ptrToInt(oldset), NSIG/8);
519+
return syscall4(SYS_rt_sigprocmask, flags, @ptrToInt(set), @ptrToInt(oldset), NSIG/8);
541520
}
542521

543522
pub fn sigaction(sig: u6, noalias act: &const Sigaction, noalias oact: ?&Sigaction) usize {
@@ -548,11 +527,11 @@ pub fn sigaction(sig: u6, noalias act: &const Sigaction, noalias oact: ?&Sigacti
548527
.handler = act.handler,
549528
.flags = act.flags | SA_RESTORER,
550529
.mask = undefined,
551-
.restorer = @ptrCast(extern fn()void, arch.restore_rt),
530+
.restorer = @ptrCast(extern fn()void, restore_rt),
552531
};
553532
var ksa_old: k_sigaction = undefined;
554533
@memcpy(@ptrCast(&u8, &ksa.mask), @ptrCast(&const u8, &act.mask), 8);
555-
const result = arch.syscall4(arch.SYS_rt_sigaction, sig, @ptrToInt(&ksa), @ptrToInt(&ksa_old), @sizeOf(@typeOf(ksa.mask)));
534+
const result = syscall4(SYS_rt_sigaction, sig, @ptrToInt(&ksa), @ptrToInt(&ksa_old), @sizeOf(@typeOf(ksa.mask)));
556535
const err = getErrno(result);
557536
if (err != 0) {
558537
return result;
@@ -592,22 +571,22 @@ pub const empty_sigset = []usize{0} ** sigset_t.len;
592571
pub fn raise(sig: i32) usize {
593572
var set: sigset_t = undefined;
594573
blockAppSignals(&set);
595-
const tid = i32(arch.syscall0(arch.SYS_gettid));
596-
const ret = arch.syscall2(arch.SYS_tkill, usize(tid), usize(sig));
574+
const tid = i32(syscall0(SYS_gettid));
575+
const ret = syscall2(SYS_tkill, usize(tid), usize(sig));
597576
restoreSignals(&set);
598577
return ret;
599578
}
600579

601580
fn blockAllSignals(set: &sigset_t) void {
602-
_ = arch.syscall4(arch.SYS_rt_sigprocmask, SIG_BLOCK, @ptrToInt(&all_mask), @ptrToInt(set), NSIG/8);
581+
_ = syscall4(SYS_rt_sigprocmask, SIG_BLOCK, @ptrToInt(&all_mask), @ptrToInt(set), NSIG/8);
603582
}
604583

605584
fn blockAppSignals(set: &sigset_t) void {
606-
_ = arch.syscall4(arch.SYS_rt_sigprocmask, SIG_BLOCK, @ptrToInt(&app_mask), @ptrToInt(set), NSIG/8);
585+
_ = syscall4(SYS_rt_sigprocmask, SIG_BLOCK, @ptrToInt(&app_mask), @ptrToInt(set), NSIG/8);
607586
}
608587

609588
fn restoreSignals(set: &sigset_t) void {
610-
_ = arch.syscall4(arch.SYS_rt_sigprocmask, SIG_SETMASK, @ptrToInt(set), 0, NSIG/8);
589+
_ = syscall4(SYS_rt_sigprocmask, SIG_SETMASK, @ptrToInt(set), 0, NSIG/8);
611590
}
612591

613592
pub fn sigaddset(set: &sigset_t, sig: u6) void {
@@ -653,69 +632,69 @@ pub const iovec = extern struct {
653632
};
654633

655634
pub fn getsockname(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t) usize {
656-
return arch.syscall3(arch.SYS_getsockname, usize(fd), @ptrToInt(addr), @ptrToInt(len));
635+
return syscall3(SYS_getsockname, usize(fd), @ptrToInt(addr), @ptrToInt(len));
657636
}
658637

659638
pub fn getpeername(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t) usize {
660-
return arch.syscall3(arch.SYS_getpeername, usize(fd), @ptrToInt(addr), @ptrToInt(len));
639+
return syscall3(SYS_getpeername, usize(fd), @ptrToInt(addr), @ptrToInt(len));
661640
}
662641

663642
pub fn socket(domain: i32, socket_type: i32, protocol: i32) usize {
664-
return arch.syscall3(arch.SYS_socket, usize(domain), usize(socket_type), usize(protocol));
643+
return syscall3(SYS_socket, usize(domain), usize(socket_type), usize(protocol));
665644
}
666645

667646
pub fn setsockopt(fd: i32, level: i32, optname: i32, optval: &const u8, optlen: socklen_t) usize {
668-
return arch.syscall5(arch.SYS_setsockopt, usize(fd), usize(level), usize(optname), usize(optval), @ptrToInt(optlen));
647+
return syscall5(SYS_setsockopt, usize(fd), usize(level), usize(optname), usize(optval), @ptrToInt(optlen));
669648
}
670649

671650
pub fn getsockopt(fd: i32, level: i32, optname: i32, noalias optval: &u8, noalias optlen: &socklen_t) usize {
672-
return arch.syscall5(arch.SYS_getsockopt, usize(fd), usize(level), usize(optname), @ptrToInt(optval), @ptrToInt(optlen));
651+
return syscall5(SYS_getsockopt, usize(fd), usize(level), usize(optname), @ptrToInt(optval), @ptrToInt(optlen));
673652
}
674653

675-
pub fn sendmsg(fd: i32, msg: &const arch.msghdr, flags: u32) usize {
676-
return arch.syscall3(arch.SYS_sendmsg, usize(fd), @ptrToInt(msg), flags);
654+
pub fn sendmsg(fd: i32, msg: &const msghdr, flags: u32) usize {
655+
return syscall3(SYS_sendmsg, usize(fd), @ptrToInt(msg), flags);
677656
}
678657

679658
pub fn connect(fd: i32, addr: &const sockaddr, len: socklen_t) usize {
680-
return arch.syscall3(arch.SYS_connect, usize(fd), @ptrToInt(addr), usize(len));
659+
return syscall3(SYS_connect, usize(fd), @ptrToInt(addr), usize(len));
681660
}
682661

683-
pub fn recvmsg(fd: i32, msg: &arch.msghdr, flags: u32) usize {
684-
return arch.syscall3(arch.SYS_recvmsg, usize(fd), @ptrToInt(msg), flags);
662+
pub fn recvmsg(fd: i32, msg: &msghdr, flags: u32) usize {
663+
return syscall3(SYS_recvmsg, usize(fd), @ptrToInt(msg), flags);
685664
}
686665

687666
pub fn recvfrom(fd: i32, noalias buf: &u8, len: usize, flags: u32,
688667
noalias addr: ?&sockaddr, noalias alen: ?&socklen_t) usize
689668
{
690-
return arch.syscall6(arch.SYS_recvfrom, usize(fd), @ptrToInt(buf), len, flags, @ptrToInt(addr), @ptrToInt(alen));
669+
return syscall6(SYS_recvfrom, usize(fd), @ptrToInt(buf), len, flags, @ptrToInt(addr), @ptrToInt(alen));
691670
}
692671

693672
pub fn shutdown(fd: i32, how: i32) usize {
694-
return arch.syscall2(arch.SYS_shutdown, usize(fd), usize(how));
673+
return syscall2(SYS_shutdown, usize(fd), usize(how));
695674
}
696675

697676
pub fn bind(fd: i32, addr: &const sockaddr, len: socklen_t) usize {
698-
return arch.syscall3(arch.SYS_bind, usize(fd), @ptrToInt(addr), usize(len));
677+
return syscall3(SYS_bind, usize(fd), @ptrToInt(addr), usize(len));
699678
}
700679

701680
pub fn listen(fd: i32, backlog: i32) usize {
702-
return arch.syscall2(arch.SYS_listen, usize(fd), usize(backlog));
681+
return syscall2(SYS_listen, usize(fd), usize(backlog));
703682
}
704683

705684
pub fn sendto(fd: i32, buf: &const u8, len: usize, flags: u32, addr: ?&const sockaddr, alen: socklen_t) usize {
706-
return arch.syscall6(arch.SYS_sendto, usize(fd), @ptrToInt(buf), len, flags, @ptrToInt(addr), usize(alen));
685+
return syscall6(SYS_sendto, usize(fd), @ptrToInt(buf), len, flags, @ptrToInt(addr), usize(alen));
707686
}
708687

709688
pub fn socketpair(domain: i32, socket_type: i32, protocol: i32, fd: [2]i32) usize {
710-
return arch.syscall4(arch.SYS_socketpair, usize(domain), usize(socket_type), usize(protocol), @ptrToInt(&fd[0]));
689+
return syscall4(SYS_socketpair, usize(domain), usize(socket_type), usize(protocol), @ptrToInt(&fd[0]));
711690
}
712691

713692
pub fn accept(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t) usize {
714693
return accept4(fd, addr, len, 0);
715694
}
716695

717696
pub fn accept4(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t, flags: u32) usize {
718-
return arch.syscall4(arch.SYS_accept4, usize(fd), @ptrToInt(addr), @ptrToInt(len), flags);
697+
return syscall4(SYS_accept4, usize(fd), @ptrToInt(addr), @ptrToInt(len), flags);
719698
}
720699

721700
// error NameTooLong;
@@ -746,11 +725,8 @@ pub fn accept4(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t, flags:
746725
// return ifr.ifr_ifindex;
747726
// }
748727

749-
pub const Stat = arch.Stat;
750-
pub const timespec = arch.timespec;
751-
752728
pub fn fstat(fd: i32, stat_buf: &Stat) usize {
753-
return arch.syscall2(arch.SYS_fstat, usize(fd), @ptrToInt(stat_buf));
729+
return syscall2(SYS_fstat, usize(fd), @ptrToInt(stat_buf));
754730
}
755731

756732
pub const epoll_data = extern union {
@@ -770,19 +746,19 @@ pub fn epoll_create() usize {
770746
}
771747

772748
pub fn epoll_create1(flags: usize) usize {
773-
return arch.syscall1(arch.SYS_epoll_create1, flags);
749+
return syscall1(SYS_epoll_create1, flags);
774750
}
775751

776752
pub fn epoll_ctl(epoll_fd: i32, op: i32, fd: i32, ev: &epoll_event) usize {
777-
return arch.syscall4(arch.SYS_epoll_ctl, usize(epoll_fd), usize(op), usize(fd), @ptrToInt(ev));
753+
return syscall4(SYS_epoll_ctl, usize(epoll_fd), usize(op), usize(fd), @ptrToInt(ev));
778754
}
779755

780756
pub fn epoll_wait(epoll_fd: i32, events: &epoll_event, maxevents: u32, timeout: i32) usize {
781-
return arch.syscall4(arch.SYS_epoll_wait, usize(epoll_fd), @ptrToInt(events), usize(maxevents), usize(timeout));
757+
return syscall4(SYS_epoll_wait, usize(epoll_fd), @ptrToInt(events), usize(maxevents), usize(timeout));
782758
}
783759

784760
pub fn timerfd_create(clockid: i32, flags: u32) usize {
785-
return arch.syscall2(arch.SYS_timerfd_create, usize(clockid), usize(flags));
761+
return syscall2(SYS_timerfd_create, usize(clockid), usize(flags));
786762
}
787763

788764
pub const itimerspec = extern struct {
@@ -791,11 +767,11 @@ pub const itimerspec = extern struct {
791767
};
792768

793769
pub fn timerfd_gettime(fd: i32, curr_value: &itimerspec) usize {
794-
return arch.syscall2(arch.SYS_timerfd_gettime, usize(fd), @ptrToInt(curr_value));
770+
return syscall2(SYS_timerfd_gettime, usize(fd), @ptrToInt(curr_value));
795771
}
796772

797773
pub fn timerfd_settime(fd: i32, flags: u32, new_value: &const itimerspec, old_value: ?&itimerspec) usize {
798-
return arch.syscall4(arch.SYS_timerfd_settime, usize(fd), usize(flags), @ptrToInt(new_value), @ptrToInt(old_value));
774+
return syscall4(SYS_timerfd_settime, usize(fd), usize(flags), @ptrToInt(new_value), @ptrToInt(old_value));
799775
}
800776

801777
test "import linux test" {

0 commit comments

Comments
 (0)
Please sign in to comment.