_M procs start up at _start/hart_entry for vcore0
[akaros.git] / user / parlib / syscall.c
1 // System call stubs.
2
3 #include <parlib.h>
4
5 int sys_proc_destroy(int pid, int exitcode)
6 {
7         return ros_syscall(SYS_proc_destroy, pid, exitcode, 0, 0, 0);
8 }
9
10 void* sys_brk(void* addr)
11 {
12         return (void*)ros_syscall(SYS_brk, addr, 0, 0, 0, 0);
13 }
14
15 int sys_getpid(void)
16 {
17          return ros_syscall(SYS_getpid, 0, 0, 0, 0, 0);
18 }
19
20 size_t sys_getcpuid(void)
21 {
22          return ros_syscall(SYS_getcpuid, 0, 0, 0, 0, 0);
23 }
24
25 ssize_t sys_cputs(const uint8_t *s, size_t len)
26 {
27     return ros_syscall(SYS_cputs, s,  len, 0, 0, 0);
28 }
29
30 uint16_t sys_cgetc(void)
31 {
32     return ros_syscall(SYS_cgetc, 0, 0, 0, 0, 0);
33 }
34
35 int sys_null(void)
36 {
37     return ros_syscall(SYS_null, 0, 0, 0, 0, 0);
38 }
39
40 ssize_t sys_shared_page_alloc(void** addr, pid_t p2, 
41                               int p1_flags, int p2_flags
42                              ) 
43 {
44         return ros_syscall(SYS_shared_page_alloc, addr, 
45                        p2, p1_flags, p2_flags, 0);
46 }
47
48 ssize_t sys_shared_page_free(void* addr, pid_t p2) 
49 {
50         return ros_syscall(SYS_shared_page_free, addr, p2, 0,0,0);
51 }
52
53 //Write a buffer over the serial port
54 ssize_t sys_serial_write(void* buf, size_t len) 
55 {
56         return ros_syscall(SYS_serial_write, buf, len, 0, 0, 0);
57 }
58
59 //Read a buffer over the serial port
60 ssize_t sys_serial_read(void* buf, size_t len) 
61 {
62         return ros_syscall(SYS_serial_read, buf, len, 0, 0, 0);
63 }
64
65 //Run a binary loaded at the specificed address with the specified arguments
66 ssize_t sys_run_binary(void* binary_buf, size_t len,
67                        const procinfo_t* pi, size_t num_colors) 
68 {
69         return ros_syscall(SYS_run_binary, binary_buf, len,
70                                        pi,num_colors,0);
71 }
72
73 //Write a buffer over ethernet
74 ssize_t sys_eth_write(void* buf, size_t len) 
75 {
76         if (len == 0)
77                 return 0;
78         
79         return ros_syscall(SYS_eth_write, buf, len, 0, 0, 0);
80 }
81
82 //Read a buffer via ethernet
83 ssize_t sys_eth_read(void* buf, size_t len) 
84 {
85         if (len == 0)
86                 return 0;
87                 
88         return ros_syscall(SYS_eth_read, buf, len, 0, 0, 0);
89 }
90
91 /* Request resources from the kernel.  Flags in ros/resource.h. */
92 ssize_t sys_resource_req(int type, size_t amt_max, size_t amt_min, uint32_t flags)
93 {
94 #ifdef __i386__
95         return syscall_trap(SYS_resource_req, type, amt_max, amt_min, flags, 0);
96 #else
97         return ros_syscall(SYS_resource_req, type, amt_max, amt_min, flags, 0);
98 #endif
99 }
100
101 void sys_reboot()
102 {
103         ros_syscall(SYS_reboot,0,0,0,0,0);
104 }
105
106 void sys_yield()
107 {
108         ros_syscall(SYS_yield,0,0,0,0,0);
109 }
110
111 int sys_proc_create(char* path)
112 {
113         return ros_syscall(SYS_proc_create, (uintreg_t)path, 0, 0, 0, 0);
114 }
115
116 int sys_proc_run(int pid)
117 {
118         return ros_syscall(SYS_proc_run, pid, 0, 0, 0, 0);
119 }
120
121 /* We need to do some hackery to pass 6 arguments.  Arg4 pts to the real arg4,
122  * arg5, and arg6.  Keep this in sync with kern/src/syscall.c.
123  * TODO: consider a syscall_multi that can take more args, and keep it in sync
124  * with the kernel.  Maybe wait til we fix sysenter to have 5 or 6 args. */
125 void *CT(length) sys_mmap(void *SNT addr, size_t length, int prot, int flags,
126                           int fd, size_t offset)
127 {
128         struct args {
129                 int _flags;
130                 int _fd;
131                 size_t _offset;
132         } extra_args;
133         extra_args._flags = flags;
134         extra_args._fd = fd;
135         extra_args._offset = offset;
136         // TODO: deputy bitches about this
137         return (void*CT(length))TC(ros_syscall(SYS_mmap, addr, length,
138                                                prot, &extra_args, 0));
139 }
140
141 int sys_notify(int pid, unsigned int notif, struct notif_event *ne)
142 {
143         return ros_syscall(SYS_notify, pid, notif, ne, 0, 0);
144 }
145
146 int sys_self_notify(uint32_t vcoreid, unsigned int notif,
147                     struct notif_event *ne)
148 {
149         return ros_syscall(SYS_self_notify, vcoreid, notif, ne, 0, 0);
150 }