Breaks up sys_resource_req (XCC)
[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, 0);
8 }
9
10 int sys_getpid(void)
11 {
12          return ros_syscall(SYS_getpid, 0, 0, 0, 0, 0, 0);
13 }
14
15 size_t sys_getpcoreid(void)
16 {
17          return ros_syscall(SYS_getpcoreid, 0, 0, 0, 0, 0, 0);
18 }
19
20 ssize_t sys_cputs(const uint8_t *s, size_t len)
21 {
22     return ros_syscall(SYS_cputs, s,  len, 0, 0, 0, 0);
23 }
24
25 uint16_t sys_cgetc(void)
26 {
27     return ros_syscall(SYS_cgetc, 0, 0, 0, 0, 0, 0);
28 }
29
30 int sys_null(void)
31 {
32     return ros_syscall(SYS_null, 0, 0, 0, 0, 0, 0);
33 }
34
35 ssize_t sys_shared_page_alloc(void** addr, pid_t p2, 
36                               int p1_flags, int p2_flags
37                              ) 
38 {
39         return ros_syscall(SYS_shared_page_alloc, addr, 
40                        p2, p1_flags, p2_flags, 0, 0);
41 }
42
43 ssize_t sys_shared_page_free(void* addr, pid_t p2) 
44 {
45         return ros_syscall(SYS_shared_page_free, addr, p2, 0, 0, 0, 0);
46 }
47
48 //Write a buffer over the serial port
49 ssize_t sys_serial_write(void* buf, size_t len) 
50 {
51         return ros_syscall(SYS_serial_write, buf, len, 0, 0, 0, 0);
52 }
53
54 //Read a buffer over the serial port
55 ssize_t sys_serial_read(void* buf, size_t len) 
56 {
57         return ros_syscall(SYS_serial_read, buf, len, 0, 0, 0, 0);
58 }
59
60 //Write a buffer over ethernet
61 ssize_t sys_eth_write(void* buf, size_t len) 
62 {
63         if (len == 0)
64                 return 0;
65         
66         return ros_syscall(SYS_eth_write, buf, len, 0, 0, 0, 0);
67 }
68
69 //Read a buffer via ethernet
70 ssize_t sys_eth_read(void* buf, size_t len) 
71 {
72         if (len == 0)
73                 return 0;
74                 
75         return ros_syscall(SYS_eth_read, buf, len, 0, 0, 0, 0);
76 }
77
78 /* Request resources from the kernel.  Flags in ros/resource.h. */
79 ssize_t sys_resource_req(int type, size_t amt_max, size_t amt_min, uint32_t flags)
80 {
81         return ros_syscall(SYS_resource_req, type, amt_max, amt_min, flags, 0, 0);
82 }
83
84 void sys_reboot(void)
85 {
86         ros_syscall(SYS_reboot, 0, 0, 0, 0, 0, 0);
87 }
88
89 void sys_yield(bool being_nice)
90 {
91         ros_syscall(SYS_yield, being_nice, 0, 0, 0, 0, 0);
92 }
93
94 int sys_proc_create(char *path, size_t path_l, char *argv[], char *envp[])
95 {
96         struct procinfo pi;
97         if (procinfo_pack_args(&pi, argv, envp)) {
98                 errno = ENOMEM;
99                 return -1;
100         }
101         return ros_syscall(SYS_proc_create, path, path_l, &pi, 0, 0, 0);
102 }
103
104 int sys_proc_run(int pid)
105 {
106         return ros_syscall(SYS_proc_run, pid, 0, 0, 0, 0, 0);
107 }
108
109 void *CT(length) sys_mmap(void *SNT addr, size_t length, int prot, int flags,
110                           int fd, size_t offset)
111 {
112         return (void*)ros_syscall(SYS_mmap, addr, length, prot, flags, fd, offset);
113 }
114
115 int sys_notify(int pid, unsigned int ev_type, struct event_msg *u_msg)
116 {
117         return ros_syscall(SYS_notify, pid, ev_type, u_msg, 0, 0, 0);
118 }
119
120 int sys_self_notify(uint32_t vcoreid, unsigned int ev_type,
121                     struct event_msg *u_msg, bool priv)
122 {
123         return ros_syscall(SYS_self_notify, vcoreid, ev_type, u_msg, priv, 0, 0);
124 }
125
126 int sys_halt_core(unsigned int usec)
127 {
128         return ros_syscall(SYS_halt_core, usec, 0, 0, 0, 0, 0);
129 }
130
131 void* sys_init_arsc()
132 {
133         return (void*)ros_syscall(SYS_init_arsc, 0, 0, 0, 0, 0, 0);
134 }
135
136 int sys_block(unsigned int usec)
137 {
138         return ros_syscall(SYS_block, usec, 0, 0, 0, 0, 0);
139 }
140
141 /* enable_my_notif tells the kernel whether or not it is okay to turn on notifs
142  * when our calling vcore 'yields'.  This controls whether or not the vcore will
143  * get started from vcore_entry() or not, and whether or not remote cores need
144  * to sys_change_vcore to preempt-recover the calling vcore.  Only set this to
145  * FALSE if you are unable to handle starting fresh at vcore_entry().  One
146  * example of this is in mcs_pdr_locks */
147 void sys_change_vcore(uint32_t vcoreid, bool enable_my_notif)
148 {
149         ros_syscall(SYS_change_vcore, vcoreid, enable_my_notif, 0, 0, 0, 0);
150 }
151
152 int sys_change_to_m(void)
153 {
154         return ros_syscall(SYS_change_to_m, 0, 0, 0, 0, 0, 0);
155 }
156
157 int sys_poke_ksched(int res_type)
158 {
159         return ros_syscall(SYS_poke_ksched, res_type, 0, 0, 0, 0, 0);
160 }