Wed Mar 18 17:30:25 2009 UTC ()
regen: arg -> callarg


(pooka)
diff -r1.30 -r1.31 src/sys/rump/librump/rumpkern/rump_syscalls.c
cvs diff -r1.30 -r1.31 src/sys/rump/librump/rumpkern/rump_syscalls.c (expand / switch to unified diff)

--- src/sys/rump/librump/rumpkern/rump_syscalls.c 2009/03/18 10:22:44 1.30
+++ src/sys/rump/librump/rumpkern/rump_syscalls.c 2009/03/18 17:30:25 1.31
@@ -1,426 +1,426 @@ @@ -1,426 +1,426 @@
1/* $NetBSD: rump_syscalls.c,v 1.30 2009/03/18 10:22:44 cegger Exp $ */ 1/* $NetBSD: rump_syscalls.c,v 1.31 2009/03/18 17:30:25 pooka Exp $ */
2 2
3/* 3/*
4 * System call vector and marshalling for rump. 4 * System call vector and marshalling for rump.
5 * 5 *
6 * DO NOT EDIT-- this file is automatically generated. 6 * DO NOT EDIT-- this file is automatically generated.
7 * created from NetBSD: syscalls.master,v 1.223 2009/02/13 22:41:04 apb Exp 7 * created from NetBSD: syscalls.master,v 1.223 2009/02/13 22:41:04 apb Exp
8 */ 8 */
9 9
10#include <sys/cdefs.h> 10#include <sys/cdefs.h>
11__KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.30 2009/03/18 10:22:44 cegger Exp $"); 11__KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.31 2009/03/18 17:30:25 pooka Exp $");
12 12
13#include <sys/types.h> 13#include <sys/types.h>
14#include <sys/param.h> 14#include <sys/param.h>
15#include <sys/proc.h> 15#include <sys/proc.h>
16#include <sys/syscall.h> 16#include <sys/syscall.h>
17#include <sys/syscallargs.h> 17#include <sys/syscallargs.h>
18#include <rump/rumpuser.h> 18#include <rump/rumpuser.h>
19#include "rump_private.h" 19#include "rump_private.h"
20 20
21#if BYTE_ORDER == BIG_ENDIAN 21#if BYTE_ORDER == BIG_ENDIAN
22#define SPARG(p,k) ((p)->k.be.datum) 22#define SPARG(p,k) ((p)->k.be.datum)
23#else /* LITTLE_ENDIAN, I hope dearly */ 23#else /* LITTLE_ENDIAN, I hope dearly */
24#define SPARG(p,k) ((p)->k.le.datum) 24#define SPARG(p,k) ((p)->k.le.datum)
25#endif 25#endif
26 26
27int rump_enosys(void); 27int rump_enosys(void);
28int 28int
29rump_enosys(void) 29rump_enosys()
30{ 30{
31 31
32 return ENOSYS; 32 return ENOSYS;
33} 33}
34 34
35ssize_t rump_sys_read(int, void *, size_t); 35ssize_t rump_sys_read(int, void *, size_t);
36ssize_t 36ssize_t
37rump_sys_read(int fd, void * buf, size_t nbyte) 37rump_sys_read(int fd, void * buf, size_t nbyte)
38{ 38{
39 register_t retval = 0; 39 register_t retval = 0;
40 int error = 0; 40 int error = 0;
41 struct sys_read_args arg; 41 struct sys_read_args callarg;
42 42
43 SPARG(&arg, fd) = fd; 43 SPARG(&callarg, fd) = fd;
44 SPARG(&arg, buf) = buf; 44 SPARG(&callarg, buf) = buf;
45 SPARG(&arg, nbyte) = nbyte; 45 SPARG(&callarg, nbyte) = nbyte;
46 46
47 error = rump_sysproxy(SYS_read, rump_sysproxy_arg, 47 error = rump_sysproxy(SYS_read, rump_sysproxy_arg,
48 (uint8_t *)&arg, sizeof(arg), &retval); 48 (uint8_t *)&callarg, sizeof(callarg), &retval);
49 if (error) { 49 if (error) {
50 retval = -1; 50 retval = -1;
51 rumpuser_seterrno(error); 51 rumpuser_seterrno(error);
52 } 52 }
53 return retval; 53 return retval;
54} 54}
55__weak_alias(sys_read,rump_enosys); 55__weak_alias(sys_read,rump_enosys);
56 56
57ssize_t rump_sys_write(int, const void *, size_t); 57ssize_t rump_sys_write(int, const void *, size_t);
58ssize_t 58ssize_t
59rump_sys_write(int fd, const void * buf, size_t nbyte) 59rump_sys_write(int fd, const void * buf, size_t nbyte)
60{ 60{
61 register_t retval = 0; 61 register_t retval = 0;
62 int error = 0; 62 int error = 0;
63 struct sys_write_args arg; 63 struct sys_write_args callarg;
64 64
65 SPARG(&arg, fd) = fd; 65 SPARG(&callarg, fd) = fd;
66 SPARG(&arg, buf) = buf; 66 SPARG(&callarg, buf) = buf;
67 SPARG(&arg, nbyte) = nbyte; 67 SPARG(&callarg, nbyte) = nbyte;
68 68
69 error = rump_sysproxy(SYS_write, rump_sysproxy_arg, 69 error = rump_sysproxy(SYS_write, rump_sysproxy_arg,
70 (uint8_t *)&arg, sizeof(arg), &retval); 70 (uint8_t *)&callarg, sizeof(callarg), &retval);
71 if (error) { 71 if (error) {
72 retval = -1; 72 retval = -1;
73 rumpuser_seterrno(error); 73 rumpuser_seterrno(error);
74 } 74 }
75 return retval; 75 return retval;
76} 76}
77__weak_alias(sys_write,rump_enosys); 77__weak_alias(sys_write,rump_enosys);
78 78
79int rump_sys_open(const char *, int, mode_t); 79int rump_sys_open(const char *, int, mode_t);
80int 80int
81rump_sys_open(const char * path, int flags, mode_t mode) 81rump_sys_open(const char * path, int flags, mode_t mode)
82{ 82{
83 register_t retval = 0; 83 register_t retval = 0;
84 int error = 0; 84 int error = 0;
85 struct sys_open_args arg; 85 struct sys_open_args callarg;
86 86
87 SPARG(&arg, path) = path; 87 SPARG(&callarg, path) = path;
88 SPARG(&arg, flags) = flags; 88 SPARG(&callarg, flags) = flags;
89 SPARG(&arg, mode) = mode; 89 SPARG(&callarg, mode) = mode;
90 90
91 error = rump_sysproxy(SYS_open, rump_sysproxy_arg, 91 error = rump_sysproxy(SYS_open, rump_sysproxy_arg,
92 (uint8_t *)&arg, sizeof(arg), &retval); 92 (uint8_t *)&callarg, sizeof(callarg), &retval);
93 if (error) { 93 if (error) {
94 retval = -1; 94 retval = -1;
95 rumpuser_seterrno(error); 95 rumpuser_seterrno(error);
96 } 96 }
97 return retval; 97 return retval;
98} 98}
99__weak_alias(sys_open,rump_enosys); 99__weak_alias(sys_open,rump_enosys);
100 100
101int rump_sys_close(int); 101int rump_sys_close(int);
102int 102int
103rump_sys_close(int fd) 103rump_sys_close(int fd)
104{ 104{
105 register_t retval = 0; 105 register_t retval = 0;
106 int error = 0; 106 int error = 0;
107 struct sys_close_args arg; 107 struct sys_close_args callarg;
108 108
109 SPARG(&arg, fd) = fd; 109 SPARG(&callarg, fd) = fd;
110 110
111 error = rump_sysproxy(SYS_close, rump_sysproxy_arg, 111 error = rump_sysproxy(SYS_close, rump_sysproxy_arg,
112 (uint8_t *)&arg, sizeof(arg), &retval); 112 (uint8_t *)&callarg, sizeof(callarg), &retval);
113 if (error) { 113 if (error) {
114 retval = -1; 114 retval = -1;
115 rumpuser_seterrno(error); 115 rumpuser_seterrno(error);
116 } 116 }
117 return retval; 117 return retval;
118} 118}
119__weak_alias(sys_close,rump_enosys); 119__weak_alias(sys_close,rump_enosys);
120 120
121int rump_sys_link(const char *, const char *); 121int rump_sys_link(const char *, const char *);
122int 122int
123rump_sys_link(const char * path, const char * link) 123rump_sys_link(const char * path, const char * link)
124{ 124{
125 register_t retval = 0; 125 register_t retval = 0;
126 int error = 0; 126 int error = 0;
127 struct sys_link_args arg; 127 struct sys_link_args callarg;
128 128
129 SPARG(&arg, path) = path; 129 SPARG(&callarg, path) = path;
130 SPARG(&arg, link) = link; 130 SPARG(&callarg, link) = link;
131 131
132 error = rump_sysproxy(SYS_link, rump_sysproxy_arg, 132 error = rump_sysproxy(SYS_link, rump_sysproxy_arg,
133 (uint8_t *)&arg, sizeof(arg), &retval); 133 (uint8_t *)&callarg, sizeof(callarg), &retval);
134 if (error) { 134 if (error) {
135 retval = -1; 135 retval = -1;
136 rumpuser_seterrno(error); 136 rumpuser_seterrno(error);
137 } 137 }
138 return retval; 138 return retval;
139} 139}
140__weak_alias(sys_link,rump_enosys); 140__weak_alias(sys_link,rump_enosys);
141 141
142int rump_sys_unlink(const char *); 142int rump_sys_unlink(const char *);
143int 143int
144rump_sys_unlink(const char * path) 144rump_sys_unlink(const char * path)
145{ 145{
146 register_t retval = 0; 146 register_t retval = 0;
147 int error = 0; 147 int error = 0;
148 struct sys_unlink_args arg; 148 struct sys_unlink_args callarg;
149 149
150 SPARG(&arg, path) = path; 150 SPARG(&callarg, path) = path;
151 151
152 error = rump_sysproxy(SYS_unlink, rump_sysproxy_arg, 152 error = rump_sysproxy(SYS_unlink, rump_sysproxy_arg,
153 (uint8_t *)&arg, sizeof(arg), &retval); 153 (uint8_t *)&callarg, sizeof(callarg), &retval);
154 if (error) { 154 if (error) {
155 retval = -1; 155 retval = -1;
156 rumpuser_seterrno(error); 156 rumpuser_seterrno(error);
157 } 157 }
158 return retval; 158 return retval;
159} 159}
160__weak_alias(sys_unlink,rump_enosys); 160__weak_alias(sys_unlink,rump_enosys);
161 161
162int rump_sys_chdir(const char *); 162int rump_sys_chdir(const char *);
163int 163int
164rump_sys_chdir(const char * path) 164rump_sys_chdir(const char * path)
165{ 165{
166 register_t retval = 0; 166 register_t retval = 0;
167 int error = 0; 167 int error = 0;
168 struct sys_chdir_args arg; 168 struct sys_chdir_args callarg;
169 169
170 SPARG(&arg, path) = path; 170 SPARG(&callarg, path) = path;
171 171
172 error = rump_sysproxy(SYS_chdir, rump_sysproxy_arg, 172 error = rump_sysproxy(SYS_chdir, rump_sysproxy_arg,
173 (uint8_t *)&arg, sizeof(arg), &retval); 173 (uint8_t *)&callarg, sizeof(callarg), &retval);
174 if (error) { 174 if (error) {
175 retval = -1; 175 retval = -1;
176 rumpuser_seterrno(error); 176 rumpuser_seterrno(error);
177 } 177 }
178 return retval; 178 return retval;
179} 179}
180__weak_alias(sys_chdir,rump_enosys); 180__weak_alias(sys_chdir,rump_enosys);
181 181
182int rump_sys_fchdir(int); 182int rump_sys_fchdir(int);
183int 183int
184rump_sys_fchdir(int fd) 184rump_sys_fchdir(int fd)
185{ 185{
186 register_t retval = 0; 186 register_t retval = 0;
187 int error = 0; 187 int error = 0;
188 struct sys_fchdir_args arg; 188 struct sys_fchdir_args callarg;
189 189
190 SPARG(&arg, fd) = fd; 190 SPARG(&callarg, fd) = fd;
191 191
192 error = rump_sysproxy(SYS_fchdir, rump_sysproxy_arg, 192 error = rump_sysproxy(SYS_fchdir, rump_sysproxy_arg,
193 (uint8_t *)&arg, sizeof(arg), &retval); 193 (uint8_t *)&callarg, sizeof(callarg), &retval);
194 if (error) { 194 if (error) {
195 retval = -1; 195 retval = -1;
196 rumpuser_seterrno(error); 196 rumpuser_seterrno(error);
197 } 197 }
198 return retval; 198 return retval;
199} 199}
200__weak_alias(sys_fchdir,rump_enosys); 200__weak_alias(sys_fchdir,rump_enosys);
201 201
202int rump_sys_chmod(const char *, mode_t); 202int rump_sys_chmod(const char *, mode_t);
203int 203int
204rump_sys_chmod(const char * path, mode_t mode) 204rump_sys_chmod(const char * path, mode_t mode)
205{ 205{
206 register_t retval = 0; 206 register_t retval = 0;
207 int error = 0; 207 int error = 0;
208 struct sys_chmod_args arg; 208 struct sys_chmod_args callarg;
209 209
210 SPARG(&arg, path) = path; 210 SPARG(&callarg, path) = path;
211 SPARG(&arg, mode) = mode; 211 SPARG(&callarg, mode) = mode;
212 212
213 error = rump_sysproxy(SYS_chmod, rump_sysproxy_arg, 213 error = rump_sysproxy(SYS_chmod, rump_sysproxy_arg,
214 (uint8_t *)&arg, sizeof(arg), &retval); 214 (uint8_t *)&callarg, sizeof(callarg), &retval);
215 if (error) { 215 if (error) {
216 retval = -1; 216 retval = -1;
217 rumpuser_seterrno(error); 217 rumpuser_seterrno(error);
218 } 218 }
219 return retval; 219 return retval;
220} 220}
221__weak_alias(sys_chmod,rump_enosys); 221__weak_alias(sys_chmod,rump_enosys);
222 222
223int rump_sys_chown(const char *, uid_t, gid_t); 223int rump_sys_chown(const char *, uid_t, gid_t);
224int 224int
225rump_sys_chown(const char * path, uid_t uid, gid_t gid) 225rump_sys_chown(const char * path, uid_t uid, gid_t gid)
226{ 226{
227 register_t retval = 0; 227 register_t retval = 0;
228 int error = 0; 228 int error = 0;
229 struct sys_chown_args arg; 229 struct sys_chown_args callarg;
230 230
231 SPARG(&arg, path) = path; 231 SPARG(&callarg, path) = path;
232 SPARG(&arg, uid) = uid; 232 SPARG(&callarg, uid) = uid;
233 SPARG(&arg, gid) = gid; 233 SPARG(&callarg, gid) = gid;
234 234
235 error = rump_sysproxy(SYS_chown, rump_sysproxy_arg, 235 error = rump_sysproxy(SYS_chown, rump_sysproxy_arg,
236 (uint8_t *)&arg, sizeof(arg), &retval); 236 (uint8_t *)&callarg, sizeof(callarg), &retval);
237 if (error) { 237 if (error) {
238 retval = -1; 238 retval = -1;
239 rumpuser_seterrno(error); 239 rumpuser_seterrno(error);
240 } 240 }
241 return retval; 241 return retval;
242} 242}
243__weak_alias(sys_chown,rump_enosys); 243__weak_alias(sys_chown,rump_enosys);
244 244
245int rump_sys_unmount(const char *, int); 245int rump_sys_unmount(const char *, int);
246int 246int
247rump_sys_unmount(const char * path, int flags) 247rump_sys_unmount(const char * path, int flags)
248{ 248{
249 register_t retval = 0; 249 register_t retval = 0;
250 int error = 0; 250 int error = 0;
251 struct sys_unmount_args arg; 251 struct sys_unmount_args callarg;
252 252
253 SPARG(&arg, path) = path; 253 SPARG(&callarg, path) = path;
254 SPARG(&arg, flags) = flags; 254 SPARG(&callarg, flags) = flags;
255 255
256 error = rump_sysproxy(SYS_unmount, rump_sysproxy_arg, 256 error = rump_sysproxy(SYS_unmount, rump_sysproxy_arg,
257 (uint8_t *)&arg, sizeof(arg), &retval); 257 (uint8_t *)&callarg, sizeof(callarg), &retval);
258 if (error) { 258 if (error) {
259 retval = -1; 259 retval = -1;
260 rumpuser_seterrno(error); 260 rumpuser_seterrno(error);
261 } 261 }
262 return retval; 262 return retval;
263} 263}
264__weak_alias(sys_unmount,rump_enosys); 264__weak_alias(sys_unmount,rump_enosys);
265 265
266ssize_t rump_sys_recvmsg(int, struct msghdr *, int); 266ssize_t rump_sys_recvmsg(int, struct msghdr *, int);
267ssize_t 267ssize_t
268rump_sys_recvmsg(int s, struct msghdr * msg, int flags) 268rump_sys_recvmsg(int s, struct msghdr * msg, int flags)
269{ 269{
270 register_t retval = 0; 270 register_t retval = 0;
271 int error = 0; 271 int error = 0;
272 struct sys_recvmsg_args arg; 272 struct sys_recvmsg_args callarg;
273 273
274 SPARG(&arg, s) = s; 274 SPARG(&callarg, s) = s;
275 SPARG(&arg, msg) = msg; 275 SPARG(&callarg, msg) = msg;
276 SPARG(&arg, flags) = flags; 276 SPARG(&callarg, flags) = flags;
277 277
278 error = rump_sysproxy(SYS_recvmsg, rump_sysproxy_arg, 278 error = rump_sysproxy(SYS_recvmsg, rump_sysproxy_arg,
279 (uint8_t *)&arg, sizeof(arg), &retval); 279 (uint8_t *)&callarg, sizeof(callarg), &retval);
280 if (error) { 280 if (error) {
281 retval = -1; 281 retval = -1;
282 rumpuser_seterrno(error); 282 rumpuser_seterrno(error);
283 } 283 }
284 return retval; 284 return retval;
285} 285}
286__weak_alias(sys_recvmsg,rump_enosys); 286__weak_alias(sys_recvmsg,rump_enosys);
287 287
288ssize_t rump_sys_sendmsg(int, const struct msghdr *, int); 288ssize_t rump_sys_sendmsg(int, const struct msghdr *, int);
289ssize_t 289ssize_t
290rump_sys_sendmsg(int s, const struct msghdr * msg, int flags) 290rump_sys_sendmsg(int s, const struct msghdr * msg, int flags)
291{ 291{
292 register_t retval = 0; 292 register_t retval = 0;
293 int error = 0; 293 int error = 0;
294 struct sys_sendmsg_args arg; 294 struct sys_sendmsg_args callarg;
295 295
296 SPARG(&arg, s) = s; 296 SPARG(&callarg, s) = s;
297 SPARG(&arg, msg) = msg; 297 SPARG(&callarg, msg) = msg;
298 SPARG(&arg, flags) = flags; 298 SPARG(&callarg, flags) = flags;
299 299
300 error = rump_sysproxy(SYS_sendmsg, rump_sysproxy_arg, 300 error = rump_sysproxy(SYS_sendmsg, rump_sysproxy_arg,
301 (uint8_t *)&arg, sizeof(arg), &retval); 301 (uint8_t *)&callarg, sizeof(callarg), &retval);
302 if (error) { 302 if (error) {
303 retval = -1; 303 retval = -1;
304 rumpuser_seterrno(error); 304 rumpuser_seterrno(error);
305 } 305 }
306 return retval; 306 return retval;
307} 307}
308__weak_alias(sys_sendmsg,rump_enosys); 308__weak_alias(sys_sendmsg,rump_enosys);
309 309
310ssize_t rump_sys_recvfrom(int, void *, size_t, int, struct sockaddr *, unsigned int *); 310ssize_t rump_sys_recvfrom(int, void *, size_t, int, struct sockaddr *, unsigned int *);
311ssize_t 311ssize_t
312rump_sys_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, unsigned int * fromlenaddr) 312rump_sys_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, unsigned int * fromlenaddr)
313{ 313{
314 register_t retval = 0; 314 register_t retval = 0;
315 int error = 0; 315 int error = 0;
316 struct sys_recvfrom_args arg; 316 struct sys_recvfrom_args callarg;
317 317
318 SPARG(&arg, s) = s; 318 SPARG(&callarg, s) = s;
319 SPARG(&arg, buf) = buf; 319 SPARG(&callarg, buf) = buf;
320 SPARG(&arg, len) = len; 320 SPARG(&callarg, len) = len;
321 SPARG(&arg, flags) = flags; 321 SPARG(&callarg, flags) = flags;
322 SPARG(&arg, from) = from; 322 SPARG(&callarg, from) = from;
323 SPARG(&arg, fromlenaddr) = fromlenaddr; 323 SPARG(&callarg, fromlenaddr) = fromlenaddr;
324 324
325 error = rump_sysproxy(SYS_recvfrom, rump_sysproxy_arg, 325 error = rump_sysproxy(SYS_recvfrom, rump_sysproxy_arg,
326 (uint8_t *)&arg, sizeof(arg), &retval); 326 (uint8_t *)&callarg, sizeof(callarg), &retval);
327 if (error) { 327 if (error) {
328 retval = -1; 328 retval = -1;
329 rumpuser_seterrno(error); 329 rumpuser_seterrno(error);
330 } 330 }
331 return retval; 331 return retval;
332} 332}
333__weak_alias(sys_recvfrom,rump_enosys); 333__weak_alias(sys_recvfrom,rump_enosys);
334 334
335int rump_sys_accept(int, struct sockaddr *, unsigned int *); 335int rump_sys_accept(int, struct sockaddr *, unsigned int *);
336int 336int
337rump_sys_accept(int s, struct sockaddr * name, unsigned int * anamelen) 337rump_sys_accept(int s, struct sockaddr * name, unsigned int * anamelen)
338{ 338{
339 register_t retval = 0; 339 register_t retval = 0;
340 int error = 0; 340 int error = 0;
341 struct sys_accept_args arg; 341 struct sys_accept_args callarg;
342 342
343 SPARG(&arg, s) = s; 343 SPARG(&callarg, s) = s;
344 SPARG(&arg, name) = name; 344 SPARG(&callarg, name) = name;
345 SPARG(&arg, anamelen) = anamelen; 345 SPARG(&callarg, anamelen) = anamelen;
346 346
347 error = rump_sysproxy(SYS_accept, rump_sysproxy_arg, 347 error = rump_sysproxy(SYS_accept, rump_sysproxy_arg,
348 (uint8_t *)&arg, sizeof(arg), &retval); 348 (uint8_t *)&callarg, sizeof(callarg), &retval);
349 if (error) { 349 if (error) {
350 retval = -1; 350 retval = -1;
351 rumpuser_seterrno(error); 351 rumpuser_seterrno(error);
352 } 352 }
353 return retval; 353 return retval;
354} 354}
355__weak_alias(sys_accept,rump_enosys); 355__weak_alias(sys_accept,rump_enosys);
356 356
357int rump_sys_getpeername(int, struct sockaddr *, unsigned int *); 357int rump_sys_getpeername(int, struct sockaddr *, unsigned int *);
358int 358int
359rump_sys_getpeername(int fdes, struct sockaddr * asa, unsigned int * alen) 359rump_sys_getpeername(int fdes, struct sockaddr * asa, unsigned int * alen)
360{ 360{
361 register_t retval = 0; 361 register_t retval = 0;
362 int error = 0; 362 int error = 0;
363 struct sys_getpeername_args arg; 363 struct sys_getpeername_args callarg;
364 364
365 SPARG(&arg, fdes) = fdes; 365 SPARG(&callarg, fdes) = fdes;
366 SPARG(&arg, asa) = asa; 366 SPARG(&callarg, asa) = asa;
367 SPARG(&arg, alen) = alen; 367 SPARG(&callarg, alen) = alen;
368 368
369 error = rump_sysproxy(SYS_getpeername, rump_sysproxy_arg, 369 error = rump_sysproxy(SYS_getpeername, rump_sysproxy_arg,
370 (uint8_t *)&arg, sizeof(arg), &retval); 370 (uint8_t *)&callarg, sizeof(callarg), &retval);
371 if (error) { 371 if (error) {
372 retval = -1; 372 retval = -1;
373 rumpuser_seterrno(error); 373 rumpuser_seterrno(error);
374 } 374 }
375 return retval; 375 return retval;
376} 376}
377__weak_alias(sys_getpeername,rump_enosys); 377__weak_alias(sys_getpeername,rump_enosys);
378 378
379int rump_sys_getsockname(int, struct sockaddr *, unsigned int *); 379int rump_sys_getsockname(int, struct sockaddr *, unsigned int *);
380int 380int
381rump_sys_getsockname(int fdes, struct sockaddr * asa, unsigned int * alen) 381rump_sys_getsockname(int fdes, struct sockaddr * asa, unsigned int * alen)
382{ 382{
383 register_t retval = 0; 383 register_t retval = 0;
384 int error = 0; 384 int error = 0;
385 struct sys_getsockname_args arg; 385 struct sys_getsockname_args callarg;
386 386
387 SPARG(&arg, fdes) = fdes; 387 SPARG(&callarg, fdes) = fdes;
388 SPARG(&arg, asa) = asa; 388 SPARG(&callarg, asa) = asa;
389 SPARG(&arg, alen) = alen; 389 SPARG(&callarg, alen) = alen;
390 390
391 error = rump_sysproxy(SYS_getsockname, rump_sysproxy_arg, 391 error = rump_sysproxy(SYS_getsockname, rump_sysproxy_arg,
392 (uint8_t *)&arg, sizeof(arg), &retval); 392 (uint8_t *)&callarg, sizeof(callarg), &retval);
393 if (error) { 393 if (error) {
394 retval = -1; 394 retval = -1;
395 rumpuser_seterrno(error); 395 rumpuser_seterrno(error);
396 } 396 }
397 return retval; 397 return retval;
398} 398}
399__weak_alias(sys_getsockname,rump_enosys); 399__weak_alias(sys_getsockname,rump_enosys);
400 400
401int rump_sys_chflags(const char *, u_long); 401int rump_sys_chflags(const char *, u_long);
402int 402int
403rump_sys_chflags(const char * path, u_long flags) 403rump_sys_chflags(const char * path, u_long flags)
404{ 404{
405 register_t retval = 0; 405 register_t retval = 0;
406 int error = 0; 406 int error = 0;
407 struct sys_chflags_args arg; 407 struct sys_chflags_args callarg;
408 408
409 SPARG(&arg, path) = path; 409 SPARG(&callarg, path) = path;
410 SPARG(&arg, flags) = flags; 410 SPARG(&callarg, flags) = flags;
411 411
412 error = rump_sysproxy(SYS_chflags, rump_sysproxy_arg, 412 error = rump_sysproxy(SYS_chflags, rump_sysproxy_arg,
413 (uint8_t *)&arg, sizeof(arg), &retval); 413 (uint8_t *)&callarg, sizeof(callarg), &retval);
414 if (error) { 414 if (error) {
415 retval = -1; 415 retval = -1;
416 rumpuser_seterrno(error); 416 rumpuser_seterrno(error);
417 } 417 }
418 return retval; 418 return retval;
419} 419}
420__weak_alias(sys_chflags,rump_enosys); 420__weak_alias(sys_chflags,rump_enosys);
421 421
422void rump_sys_sync(void); 422void rump_sys_sync(void);
423void 423void
424rump_sys_sync(void ) 424rump_sys_sync(void )
425{ 425{
426 register_t retval = 0; 426 register_t retval = 0;
@@ -430,714 +430,714 @@ rump_sys_sync(void ) @@ -430,714 +430,714 @@ rump_sys_sync(void )
430 (uint8_t *)NULL, 0, &retval); 430 (uint8_t *)NULL, 0, &retval);
431 if (error) { 431 if (error) {
432 retval = -1; 432 retval = -1;
433 } 433 }
434} 434}
435__weak_alias(sys_sync,rump_enosys); 435__weak_alias(sys_sync,rump_enosys);
436 436
437int rump_sys_ioctl(int, u_long, void *); 437int rump_sys_ioctl(int, u_long, void *);
438int 438int
439rump_sys_ioctl(int fd, u_long com, void * data) 439rump_sys_ioctl(int fd, u_long com, void * data)
440{ 440{
441 register_t retval = 0; 441 register_t retval = 0;
442 int error = 0; 442 int error = 0;
443 struct sys_ioctl_args arg; 443 struct sys_ioctl_args callarg;
444 444
445 SPARG(&arg, fd) = fd; 445 SPARG(&callarg, fd) = fd;
446 SPARG(&arg, com) = com; 446 SPARG(&callarg, com) = com;
447 SPARG(&arg, data) = data; 447 SPARG(&callarg, data) = data;
448 448
449 error = rump_sysproxy(SYS_ioctl, rump_sysproxy_arg, 449 error = rump_sysproxy(SYS_ioctl, rump_sysproxy_arg,
450 (uint8_t *)&arg, sizeof(arg), &retval); 450 (uint8_t *)&callarg, sizeof(callarg), &retval);
451 if (error) { 451 if (error) {
452 retval = -1; 452 retval = -1;
453 rumpuser_seterrno(error); 453 rumpuser_seterrno(error);
454 } 454 }
455 return retval; 455 return retval;
456} 456}
457__weak_alias(sys_ioctl,rump_enosys); 457__weak_alias(sys_ioctl,rump_enosys);
458 458
459int rump_sys_symlink(const char *, const char *); 459int rump_sys_symlink(const char *, const char *);
460int 460int
461rump_sys_symlink(const char * path, const char * link) 461rump_sys_symlink(const char * path, const char * link)
462{ 462{
463 register_t retval = 0; 463 register_t retval = 0;
464 int error = 0; 464 int error = 0;
465 struct sys_symlink_args arg; 465 struct sys_symlink_args callarg;
466 466
467 SPARG(&arg, path) = path; 467 SPARG(&callarg, path) = path;
468 SPARG(&arg, link) = link; 468 SPARG(&callarg, link) = link;
469 469
470 error = rump_sysproxy(SYS_symlink, rump_sysproxy_arg, 470 error = rump_sysproxy(SYS_symlink, rump_sysproxy_arg,
471 (uint8_t *)&arg, sizeof(arg), &retval); 471 (uint8_t *)&callarg, sizeof(callarg), &retval);
472 if (error) { 472 if (error) {
473 retval = -1; 473 retval = -1;
474 rumpuser_seterrno(error); 474 rumpuser_seterrno(error);
475 } 475 }
476 return retval; 476 return retval;
477} 477}
478__weak_alias(sys_symlink,rump_enosys); 478__weak_alias(sys_symlink,rump_enosys);
479 479
480ssize_t rump_sys_readlink(const char *, char *, size_t); 480ssize_t rump_sys_readlink(const char *, char *, size_t);
481ssize_t 481ssize_t
482rump_sys_readlink(const char * path, char * buf, size_t count) 482rump_sys_readlink(const char * path, char * buf, size_t count)
483{ 483{
484 register_t retval = 0; 484 register_t retval = 0;
485 int error = 0; 485 int error = 0;
486 struct sys_readlink_args arg; 486 struct sys_readlink_args callarg;
487 487
488 SPARG(&arg, path) = path; 488 SPARG(&callarg, path) = path;
489 SPARG(&arg, buf) = buf; 489 SPARG(&callarg, buf) = buf;
490 SPARG(&arg, count) = count; 490 SPARG(&callarg, count) = count;
491 491
492 error = rump_sysproxy(SYS_readlink, rump_sysproxy_arg, 492 error = rump_sysproxy(SYS_readlink, rump_sysproxy_arg,
493 (uint8_t *)&arg, sizeof(arg), &retval); 493 (uint8_t *)&callarg, sizeof(callarg), &retval);
494 if (error) { 494 if (error) {
495 retval = -1; 495 retval = -1;
496 rumpuser_seterrno(error); 496 rumpuser_seterrno(error);
497 } 497 }
498 return retval; 498 return retval;
499} 499}
500__weak_alias(sys_readlink,rump_enosys); 500__weak_alias(sys_readlink,rump_enosys);
501 501
502int rump_sys_fsync(int); 502int rump_sys_fsync(int);
503int 503int
504rump_sys_fsync(int fd) 504rump_sys_fsync(int fd)
505{ 505{
506 register_t retval = 0; 506 register_t retval = 0;
507 int error = 0; 507 int error = 0;
508 struct sys_fsync_args arg; 508 struct sys_fsync_args callarg;
509 509
510 SPARG(&arg, fd) = fd; 510 SPARG(&callarg, fd) = fd;
511 511
512 error = rump_sysproxy(SYS_fsync, rump_sysproxy_arg, 512 error = rump_sysproxy(SYS_fsync, rump_sysproxy_arg,
513 (uint8_t *)&arg, sizeof(arg), &retval); 513 (uint8_t *)&callarg, sizeof(callarg), &retval);
514 if (error) { 514 if (error) {
515 retval = -1; 515 retval = -1;
516 rumpuser_seterrno(error); 516 rumpuser_seterrno(error);
517 } 517 }
518 return retval; 518 return retval;
519} 519}
520__weak_alias(sys_fsync,rump_enosys); 520__weak_alias(sys_fsync,rump_enosys);
521 521
522int rump_sys_connect(int, const struct sockaddr *, unsigned int); 522int rump_sys_connect(int, const struct sockaddr *, unsigned int);
523int 523int
524rump_sys_connect(int s, const struct sockaddr * name, unsigned int namelen) 524rump_sys_connect(int s, const struct sockaddr * name, unsigned int namelen)
525{ 525{
526 register_t retval = 0; 526 register_t retval = 0;
527 int error = 0; 527 int error = 0;
528 struct sys_connect_args arg; 528 struct sys_connect_args callarg;
529 529
530 SPARG(&arg, s) = s; 530 SPARG(&callarg, s) = s;
531 SPARG(&arg, name) = name; 531 SPARG(&callarg, name) = name;
532 SPARG(&arg, namelen) = namelen; 532 SPARG(&callarg, namelen) = namelen;
533 533
534 error = rump_sysproxy(SYS_connect, rump_sysproxy_arg, 534 error = rump_sysproxy(SYS_connect, rump_sysproxy_arg,
535 (uint8_t *)&arg, sizeof(arg), &retval); 535 (uint8_t *)&callarg, sizeof(callarg), &retval);
536 if (error) { 536 if (error) {
537 retval = -1; 537 retval = -1;
538 rumpuser_seterrno(error); 538 rumpuser_seterrno(error);
539 } 539 }
540 return retval; 540 return retval;
541} 541}
542__weak_alias(sys_connect,rump_enosys); 542__weak_alias(sys_connect,rump_enosys);
543 543
544int rump_sys_bind(int, const struct sockaddr *, unsigned int); 544int rump_sys_bind(int, const struct sockaddr *, unsigned int);
545int 545int
546rump_sys_bind(int s, const struct sockaddr * name, unsigned int namelen) 546rump_sys_bind(int s, const struct sockaddr * name, unsigned int namelen)
547{ 547{
548 register_t retval = 0; 548 register_t retval = 0;
549 int error = 0; 549 int error = 0;
550 struct sys_bind_args arg; 550 struct sys_bind_args callarg;
551 551
552 SPARG(&arg, s) = s; 552 SPARG(&callarg, s) = s;
553 SPARG(&arg, name) = name; 553 SPARG(&callarg, name) = name;
554 SPARG(&arg, namelen) = namelen; 554 SPARG(&callarg, namelen) = namelen;
555 555
556 error = rump_sysproxy(SYS_bind, rump_sysproxy_arg, 556 error = rump_sysproxy(SYS_bind, rump_sysproxy_arg,
557 (uint8_t *)&arg, sizeof(arg), &retval); 557 (uint8_t *)&callarg, sizeof(callarg), &retval);
558 if (error) { 558 if (error) {
559 retval = -1; 559 retval = -1;
560 rumpuser_seterrno(error); 560 rumpuser_seterrno(error);
561 } 561 }
562 return retval; 562 return retval;
563} 563}
564__weak_alias(sys_bind,rump_enosys); 564__weak_alias(sys_bind,rump_enosys);
565 565
566int rump_sys_setsockopt(int, int, int, const void *, unsigned int); 566int rump_sys_setsockopt(int, int, int, const void *, unsigned int);
567int 567int
568rump_sys_setsockopt(int s, int level, int name, const void * val, unsigned int valsize) 568rump_sys_setsockopt(int s, int level, int name, const void * val, unsigned int valsize)
569{ 569{
570 register_t retval = 0; 570 register_t retval = 0;
571 int error = 0; 571 int error = 0;
572 struct sys_setsockopt_args arg; 572 struct sys_setsockopt_args callarg;
573 573
574 SPARG(&arg, s) = s; 574 SPARG(&callarg, s) = s;
575 SPARG(&arg, level) = level; 575 SPARG(&callarg, level) = level;
576 SPARG(&arg, name) = name; 576 SPARG(&callarg, name) = name;
577 SPARG(&arg, val) = val; 577 SPARG(&callarg, val) = val;
578 SPARG(&arg, valsize) = valsize; 578 SPARG(&callarg, valsize) = valsize;
579 579
580 error = rump_sysproxy(SYS_setsockopt, rump_sysproxy_arg, 580 error = rump_sysproxy(SYS_setsockopt, rump_sysproxy_arg,
581 (uint8_t *)&arg, sizeof(arg), &retval); 581 (uint8_t *)&callarg, sizeof(callarg), &retval);
582 if (error) { 582 if (error) {
583 retval = -1; 583 retval = -1;
584 rumpuser_seterrno(error); 584 rumpuser_seterrno(error);
585 } 585 }
586 return retval; 586 return retval;
587} 587}
588__weak_alias(sys_setsockopt,rump_enosys); 588__weak_alias(sys_setsockopt,rump_enosys);
589 589
590int rump_sys_listen(int, int); 590int rump_sys_listen(int, int);
591int 591int
592rump_sys_listen(int s, int backlog) 592rump_sys_listen(int s, int backlog)
593{ 593{
594 register_t retval = 0; 594 register_t retval = 0;
595 int error = 0; 595 int error = 0;
596 struct sys_listen_args arg; 596 struct sys_listen_args callarg;
597 597
598 SPARG(&arg, s) = s; 598 SPARG(&callarg, s) = s;
599 SPARG(&arg, backlog) = backlog; 599 SPARG(&callarg, backlog) = backlog;
600 600
601 error = rump_sysproxy(SYS_listen, rump_sysproxy_arg, 601 error = rump_sysproxy(SYS_listen, rump_sysproxy_arg,
602 (uint8_t *)&arg, sizeof(arg), &retval); 602 (uint8_t *)&callarg, sizeof(callarg), &retval);
603 if (error) { 603 if (error) {
604 retval = -1; 604 retval = -1;
605 rumpuser_seterrno(error); 605 rumpuser_seterrno(error);
606 } 606 }
607 return retval; 607 return retval;
608} 608}
609__weak_alias(sys_listen,rump_enosys); 609__weak_alias(sys_listen,rump_enosys);
610 610
611int rump_sys_getsockopt(int, int, int, void *, unsigned int *); 611int rump_sys_getsockopt(int, int, int, void *, unsigned int *);
612int 612int
613rump_sys_getsockopt(int s, int level, int name, void * val, unsigned int * avalsize) 613rump_sys_getsockopt(int s, int level, int name, void * val, unsigned int * avalsize)
614{ 614{
615 register_t retval = 0; 615 register_t retval = 0;
616 int error = 0; 616 int error = 0;
617 struct sys_getsockopt_args arg; 617 struct sys_getsockopt_args callarg;
618 618
619 SPARG(&arg, s) = s; 619 SPARG(&callarg, s) = s;
620 SPARG(&arg, level) = level; 620 SPARG(&callarg, level) = level;
621 SPARG(&arg, name) = name; 621 SPARG(&callarg, name) = name;
622 SPARG(&arg, val) = val; 622 SPARG(&callarg, val) = val;
623 SPARG(&arg, avalsize) = avalsize; 623 SPARG(&callarg, avalsize) = avalsize;
624 624
625 error = rump_sysproxy(SYS_getsockopt, rump_sysproxy_arg, 625 error = rump_sysproxy(SYS_getsockopt, rump_sysproxy_arg,
626 (uint8_t *)&arg, sizeof(arg), &retval); 626 (uint8_t *)&callarg, sizeof(callarg), &retval);
627 if (error) { 627 if (error) {
628 retval = -1; 628 retval = -1;
629 rumpuser_seterrno(error); 629 rumpuser_seterrno(error);
630 } 630 }
631 return retval; 631 return retval;
632} 632}
633__weak_alias(sys_getsockopt,rump_enosys); 633__weak_alias(sys_getsockopt,rump_enosys);
634 634
635int rump_sys_rename(const char *, const char *); 635int rump_sys_rename(const char *, const char *);
636int 636int
637rump_sys_rename(const char * from, const char * to) 637rump_sys_rename(const char * from, const char * to)
638{ 638{
639 register_t retval = 0; 639 register_t retval = 0;
640 int error = 0; 640 int error = 0;
641 struct sys_rename_args arg; 641 struct sys_rename_args callarg;
642 642
643 SPARG(&arg, from) = from; 643 SPARG(&callarg, from) = from;
644 SPARG(&arg, to) = to; 644 SPARG(&callarg, to) = to;
645 645
646 error = rump_sysproxy(SYS_rename, rump_sysproxy_arg, 646 error = rump_sysproxy(SYS_rename, rump_sysproxy_arg,
647 (uint8_t *)&arg, sizeof(arg), &retval); 647 (uint8_t *)&callarg, sizeof(callarg), &retval);
648 if (error) { 648 if (error) {
649 retval = -1; 649 retval = -1;
650 rumpuser_seterrno(error); 650 rumpuser_seterrno(error);
651 } 651 }
652 return retval; 652 return retval;
653} 653}
654__weak_alias(sys_rename,rump_enosys); 654__weak_alias(sys_rename,rump_enosys);
655 655
656int rump_sys_mkfifo(const char *, mode_t); 656int rump_sys_mkfifo(const char *, mode_t);
657int 657int
658rump_sys_mkfifo(const char * path, mode_t mode) 658rump_sys_mkfifo(const char * path, mode_t mode)
659{ 659{
660 register_t retval = 0; 660 register_t retval = 0;
661 int error = 0; 661 int error = 0;
662 struct sys_mkfifo_args arg; 662 struct sys_mkfifo_args callarg;
663 663
664 SPARG(&arg, path) = path; 664 SPARG(&callarg, path) = path;
665 SPARG(&arg, mode) = mode; 665 SPARG(&callarg, mode) = mode;
666 666
667 error = rump_sysproxy(SYS_mkfifo, rump_sysproxy_arg, 667 error = rump_sysproxy(SYS_mkfifo, rump_sysproxy_arg,
668 (uint8_t *)&arg, sizeof(arg), &retval); 668 (uint8_t *)&callarg, sizeof(callarg), &retval);
669 if (error) { 669 if (error) {
670 retval = -1; 670 retval = -1;
671 rumpuser_seterrno(error); 671 rumpuser_seterrno(error);
672 } 672 }
673 return retval; 673 return retval;
674} 674}
675__weak_alias(sys_mkfifo,rump_enosys); 675__weak_alias(sys_mkfifo,rump_enosys);
676 676
677ssize_t rump_sys_sendto(int, const void *, size_t, int, const struct sockaddr *, unsigned int); 677ssize_t rump_sys_sendto(int, const void *, size_t, int, const struct sockaddr *, unsigned int);
678ssize_t 678ssize_t
679rump_sys_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, unsigned int tolen) 679rump_sys_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, unsigned int tolen)
680{ 680{
681 register_t retval = 0; 681 register_t retval = 0;
682 int error = 0; 682 int error = 0;
683 struct sys_sendto_args arg; 683 struct sys_sendto_args callarg;
684 684
685 SPARG(&arg, s) = s; 685 SPARG(&callarg, s) = s;
686 SPARG(&arg, buf) = buf; 686 SPARG(&callarg, buf) = buf;
687 SPARG(&arg, len) = len; 687 SPARG(&callarg, len) = len;
688 SPARG(&arg, flags) = flags; 688 SPARG(&callarg, flags) = flags;
689 SPARG(&arg, to) = to; 689 SPARG(&callarg, to) = to;
690 SPARG(&arg, tolen) = tolen; 690 SPARG(&callarg, tolen) = tolen;
691 691
692 error = rump_sysproxy(SYS_sendto, rump_sysproxy_arg, 692 error = rump_sysproxy(SYS_sendto, rump_sysproxy_arg,
693 (uint8_t *)&arg, sizeof(arg), &retval); 693 (uint8_t *)&callarg, sizeof(callarg), &retval);
694 if (error) { 694 if (error) {
695 retval = -1; 695 retval = -1;
696 rumpuser_seterrno(error); 696 rumpuser_seterrno(error);
697 } 697 }
698 return retval; 698 return retval;
699} 699}
700__weak_alias(sys_sendto,rump_enosys); 700__weak_alias(sys_sendto,rump_enosys);
701 701
702int rump_sys_shutdown(int, int); 702int rump_sys_shutdown(int, int);
703int 703int
704rump_sys_shutdown(int s, int how) 704rump_sys_shutdown(int s, int how)
705{ 705{
706 register_t retval = 0; 706 register_t retval = 0;
707 int error = 0; 707 int error = 0;
708 struct sys_shutdown_args arg; 708 struct sys_shutdown_args callarg;
709 709
710 SPARG(&arg, s) = s; 710 SPARG(&callarg, s) = s;
711 SPARG(&arg, how) = how; 711 SPARG(&callarg, how) = how;
712 712
713 error = rump_sysproxy(SYS_shutdown, rump_sysproxy_arg, 713 error = rump_sysproxy(SYS_shutdown, rump_sysproxy_arg,
714 (uint8_t *)&arg, sizeof(arg), &retval); 714 (uint8_t *)&callarg, sizeof(callarg), &retval);
715 if (error) { 715 if (error) {
716 retval = -1; 716 retval = -1;
717 rumpuser_seterrno(error); 717 rumpuser_seterrno(error);
718 } 718 }
719 return retval; 719 return retval;
720} 720}
721__weak_alias(sys_shutdown,rump_enosys); 721__weak_alias(sys_shutdown,rump_enosys);
722 722
723int rump_sys_socketpair(int, int, int, int *); 723int rump_sys_socketpair(int, int, int, int *);
724int 724int
725rump_sys_socketpair(int domain, int type, int protocol, int * rsv) 725rump_sys_socketpair(int domain, int type, int protocol, int * rsv)
726{ 726{
727 register_t retval = 0; 727 register_t retval = 0;
728 int error = 0; 728 int error = 0;
729 struct sys_socketpair_args arg; 729 struct sys_socketpair_args callarg;
730 730
731 SPARG(&arg, domain) = domain; 731 SPARG(&callarg, domain) = domain;
732 SPARG(&arg, type) = type; 732 SPARG(&callarg, type) = type;
733 SPARG(&arg, protocol) = protocol; 733 SPARG(&callarg, protocol) = protocol;
734 SPARG(&arg, rsv) = rsv; 734 SPARG(&callarg, rsv) = rsv;
735 735
736 error = rump_sysproxy(SYS_socketpair, rump_sysproxy_arg, 736 error = rump_sysproxy(SYS_socketpair, rump_sysproxy_arg,
737 (uint8_t *)&arg, sizeof(arg), &retval); 737 (uint8_t *)&callarg, sizeof(callarg), &retval);
738 if (error) { 738 if (error) {
739 retval = -1; 739 retval = -1;
740 rumpuser_seterrno(error); 740 rumpuser_seterrno(error);
741 } 741 }
742 return retval; 742 return retval;
743} 743}
744__weak_alias(sys_socketpair,rump_enosys); 744__weak_alias(sys_socketpair,rump_enosys);
745 745
746int rump_sys_mkdir(const char *, mode_t); 746int rump_sys_mkdir(const char *, mode_t);
747int 747int
748rump_sys_mkdir(const char * path, mode_t mode) 748rump_sys_mkdir(const char * path, mode_t mode)
749{ 749{
750 register_t retval = 0; 750 register_t retval = 0;
751 int error = 0; 751 int error = 0;
752 struct sys_mkdir_args arg; 752 struct sys_mkdir_args callarg;
753 753
754 SPARG(&arg, path) = path; 754 SPARG(&callarg, path) = path;
755 SPARG(&arg, mode) = mode; 755 SPARG(&callarg, mode) = mode;
756 756
757 error = rump_sysproxy(SYS_mkdir, rump_sysproxy_arg, 757 error = rump_sysproxy(SYS_mkdir, rump_sysproxy_arg,
758 (uint8_t *)&arg, sizeof(arg), &retval); 758 (uint8_t *)&callarg, sizeof(callarg), &retval);
759 if (error) { 759 if (error) {
760 retval = -1; 760 retval = -1;
761 rumpuser_seterrno(error); 761 rumpuser_seterrno(error);
762 } 762 }
763 return retval; 763 return retval;
764} 764}
765__weak_alias(sys_mkdir,rump_enosys); 765__weak_alias(sys_mkdir,rump_enosys);
766 766
767int rump_sys_rmdir(const char *); 767int rump_sys_rmdir(const char *);
768int 768int
769rump_sys_rmdir(const char * path) 769rump_sys_rmdir(const char * path)
770{ 770{
771 register_t retval = 0; 771 register_t retval = 0;
772 int error = 0; 772 int error = 0;
773 struct sys_rmdir_args arg; 773 struct sys_rmdir_args callarg;
774 774
775 SPARG(&arg, path) = path; 775 SPARG(&callarg, path) = path;
776 776
777 error = rump_sysproxy(SYS_rmdir, rump_sysproxy_arg, 777 error = rump_sysproxy(SYS_rmdir, rump_sysproxy_arg,
778 (uint8_t *)&arg, sizeof(arg), &retval); 778 (uint8_t *)&callarg, sizeof(callarg), &retval);
779 if (error) { 779 if (error) {
780 retval = -1; 780 retval = -1;
781 rumpuser_seterrno(error); 781 rumpuser_seterrno(error);
782 } 782 }
783 return retval; 783 return retval;
784} 784}
785__weak_alias(sys_rmdir,rump_enosys); 785__weak_alias(sys_rmdir,rump_enosys);
786 786
787int rump_sys_nfssvc(int, void *); 787int rump_sys_nfssvc(int, void *);
788int 788int
789rump_sys_nfssvc(int flag, void * argp) 789rump_sys_nfssvc(int flag, void * argp)
790{ 790{
791 register_t retval = 0; 791 register_t retval = 0;
792 int error = 0; 792 int error = 0;
793 struct sys_nfssvc_args arg; 793 struct sys_nfssvc_args callarg;
794 794
795 SPARG(&arg, flag) = flag; 795 SPARG(&callarg, flag) = flag;
796 SPARG(&arg, argp) = argp; 796 SPARG(&callarg, argp) = argp;
797 797
798 error = rump_sysproxy(SYS_nfssvc, rump_sysproxy_arg, 798 error = rump_sysproxy(SYS_nfssvc, rump_sysproxy_arg,
799 (uint8_t *)&arg, sizeof(arg), &retval); 799 (uint8_t *)&callarg, sizeof(callarg), &retval);
800 if (error) { 800 if (error) {
801 retval = -1; 801 retval = -1;
802 rumpuser_seterrno(error); 802 rumpuser_seterrno(error);
803 } 803 }
804 return retval; 804 return retval;
805} 805}
806__weak_alias(sys_nfssvc,rump_enosys); 806__weak_alias(sys_nfssvc,rump_enosys);
807 807
808ssize_t rump_sys_pread(int, void *, size_t, int, off_t); 808ssize_t rump_sys_pread(int, void *, size_t, int, off_t);
809ssize_t 809ssize_t
810rump_sys_pread(int fd, void * buf, size_t nbyte, int pad, off_t offset) 810rump_sys_pread(int fd, void * buf, size_t nbyte, int pad, off_t offset)
811{ 811{
812 register_t retval = 0; 812 register_t retval = 0;
813 int error = 0; 813 int error = 0;
814 struct sys_pread_args arg; 814 struct sys_pread_args callarg;
815 815
816 SPARG(&arg, fd) = fd; 816 SPARG(&callarg, fd) = fd;
817 SPARG(&arg, buf) = buf; 817 SPARG(&callarg, buf) = buf;
818 SPARG(&arg, nbyte) = nbyte; 818 SPARG(&callarg, nbyte) = nbyte;
819 SPARG(&arg, pad) = pad; 819 SPARG(&callarg, pad) = pad;
820 SPARG(&arg, offset) = offset; 820 SPARG(&callarg, offset) = offset;
821 821
822 error = rump_sysproxy(SYS_pread, rump_sysproxy_arg, 822 error = rump_sysproxy(SYS_pread, rump_sysproxy_arg,
823 (uint8_t *)&arg, sizeof(arg), &retval); 823 (uint8_t *)&callarg, sizeof(callarg), &retval);
824 if (error) { 824 if (error) {
825 retval = -1; 825 retval = -1;
826 rumpuser_seterrno(error); 826 rumpuser_seterrno(error);
827 } 827 }
828 return retval; 828 return retval;
829} 829}
830__weak_alias(sys_pread,rump_enosys); 830__weak_alias(sys_pread,rump_enosys);
831 831
832ssize_t rump_sys_pwrite(int, const void *, size_t, int, off_t); 832ssize_t rump_sys_pwrite(int, const void *, size_t, int, off_t);
833ssize_t 833ssize_t
834rump_sys_pwrite(int fd, const void * buf, size_t nbyte, int pad, off_t offset) 834rump_sys_pwrite(int fd, const void * buf, size_t nbyte, int pad, off_t offset)
835{ 835{
836 register_t retval = 0; 836 register_t retval = 0;
837 int error = 0; 837 int error = 0;
838 struct sys_pwrite_args arg; 838 struct sys_pwrite_args callarg;
839 839
840 SPARG(&arg, fd) = fd; 840 SPARG(&callarg, fd) = fd;
841 SPARG(&arg, buf) = buf; 841 SPARG(&callarg, buf) = buf;
842 SPARG(&arg, nbyte) = nbyte; 842 SPARG(&callarg, nbyte) = nbyte;
843 SPARG(&arg, pad) = pad; 843 SPARG(&callarg, pad) = pad;
844 SPARG(&arg, offset) = offset; 844 SPARG(&callarg, offset) = offset;
845 845
846 error = rump_sysproxy(SYS_pwrite, rump_sysproxy_arg, 846 error = rump_sysproxy(SYS_pwrite, rump_sysproxy_arg,
847 (uint8_t *)&arg, sizeof(arg), &retval); 847 (uint8_t *)&callarg, sizeof(callarg), &retval);
848 if (error) { 848 if (error) {
849 retval = -1; 849 retval = -1;
850 rumpuser_seterrno(error); 850 rumpuser_seterrno(error);
851 } 851 }
852 return retval; 852 return retval;
853} 853}
854__weak_alias(sys_pwrite,rump_enosys); 854__weak_alias(sys_pwrite,rump_enosys);
855 855
856int rump_sys_truncate(const char *, int, off_t); 856int rump_sys_truncate(const char *, int, off_t);
857int 857int
858rump_sys_truncate(const char * path, int pad, off_t length) 858rump_sys_truncate(const char * path, int pad, off_t length)
859{ 859{
860 register_t retval = 0; 860 register_t retval = 0;
861 int error = 0; 861 int error = 0;
862 struct sys_truncate_args arg; 862 struct sys_truncate_args callarg;
863 863
864 SPARG(&arg, path) = path; 864 SPARG(&callarg, path) = path;
865 SPARG(&arg, pad) = pad; 865 SPARG(&callarg, pad) = pad;
866 SPARG(&arg, length) = length; 866 SPARG(&callarg, length) = length;
867 867
868 error = rump_sysproxy(SYS_truncate, rump_sysproxy_arg, 868 error = rump_sysproxy(SYS_truncate, rump_sysproxy_arg,
869 (uint8_t *)&arg, sizeof(arg), &retval); 869 (uint8_t *)&callarg, sizeof(callarg), &retval);
870 if (error) { 870 if (error) {
871 retval = -1; 871 retval = -1;
872 rumpuser_seterrno(error); 872 rumpuser_seterrno(error);
873 } 873 }
874 return retval; 874 return retval;
875} 875}
876__weak_alias(sys_truncate,rump_enosys); 876__weak_alias(sys_truncate,rump_enosys);
877 877
878int rump_sys___sysctl(const int *, u_int, void *, size_t *, const void *, size_t); 878int rump_sys___sysctl(const int *, u_int, void *, size_t *, const void *, size_t);
879int 879int
880rump_sys___sysctl(const int * name, u_int namelen, void * old, size_t * oldlenp, const void * new, size_t newlen) 880rump_sys___sysctl(const int * name, u_int namelen, void * old, size_t * oldlenp, const void * new, size_t newlen)
881{ 881{
882 register_t retval = 0; 882 register_t retval = 0;
883 int error = 0; 883 int error = 0;
884 struct sys___sysctl_args arg; 884 struct sys___sysctl_args callarg;
885 885
886 SPARG(&arg, name) = name; 886 SPARG(&callarg, name) = name;
887 SPARG(&arg, namelen) = namelen; 887 SPARG(&callarg, namelen) = namelen;
888 SPARG(&arg, old) = old; 888 SPARG(&callarg, old) = old;
889 SPARG(&arg, oldlenp) = oldlenp; 889 SPARG(&callarg, oldlenp) = oldlenp;
890 SPARG(&arg, new) = new; 890 SPARG(&callarg, new) = new;
891 SPARG(&arg, newlen) = newlen; 891 SPARG(&callarg, newlen) = newlen;
892 892
893 error = rump_sysproxy(SYS___sysctl, rump_sysproxy_arg, 893 error = rump_sysproxy(SYS___sysctl, rump_sysproxy_arg,
894 (uint8_t *)&arg, sizeof(arg), &retval); 894 (uint8_t *)&callarg, sizeof(callarg), &retval);
895 if (error) { 895 if (error) {
896 retval = -1; 896 retval = -1;
897 rumpuser_seterrno(error); 897 rumpuser_seterrno(error);
898 } 898 }
899 return retval; 899 return retval;
900} 900}
901__weak_alias(sys___sysctl,rump_enosys); 901__weak_alias(sys___sysctl,rump_enosys);
902 902
903int rump_sys_lchmod(const char *, mode_t); 903int rump_sys_lchmod(const char *, mode_t);
904int 904int
905rump_sys_lchmod(const char * path, mode_t mode) 905rump_sys_lchmod(const char * path, mode_t mode)
906{ 906{
907 register_t retval = 0; 907 register_t retval = 0;
908 int error = 0; 908 int error = 0;
909 struct sys_lchmod_args arg; 909 struct sys_lchmod_args callarg;
910 910
911 SPARG(&arg, path) = path; 911 SPARG(&callarg, path) = path;
912 SPARG(&arg, mode) = mode; 912 SPARG(&callarg, mode) = mode;
913 913
914 error = rump_sysproxy(SYS_lchmod, rump_sysproxy_arg, 914 error = rump_sysproxy(SYS_lchmod, rump_sysproxy_arg,
915 (uint8_t *)&arg, sizeof(arg), &retval); 915 (uint8_t *)&callarg, sizeof(callarg), &retval);
916 if (error) { 916 if (error) {
917 retval = -1; 917 retval = -1;
918 rumpuser_seterrno(error); 918 rumpuser_seterrno(error);
919 } 919 }
920 return retval; 920 return retval;
921} 921}
922__weak_alias(sys_lchmod,rump_enosys); 922__weak_alias(sys_lchmod,rump_enosys);
923 923
924int rump_sys_lchown(const char *, uid_t, gid_t); 924int rump_sys_lchown(const char *, uid_t, gid_t);
925int 925int
926rump_sys_lchown(const char * path, uid_t uid, gid_t gid) 926rump_sys_lchown(const char * path, uid_t uid, gid_t gid)
927{ 927{
928 register_t retval = 0; 928 register_t retval = 0;
929 int error = 0; 929 int error = 0;
930 struct sys_lchown_args arg; 930 struct sys_lchown_args callarg;
931 931
932 SPARG(&arg, path) = path; 932 SPARG(&callarg, path) = path;
933 SPARG(&arg, uid) = uid; 933 SPARG(&callarg, uid) = uid;
934 SPARG(&arg, gid) = gid; 934 SPARG(&callarg, gid) = gid;
935 935
936 error = rump_sysproxy(SYS_lchown, rump_sysproxy_arg, 936 error = rump_sysproxy(SYS_lchown, rump_sysproxy_arg,
937 (uint8_t *)&arg, sizeof(arg), &retval); 937 (uint8_t *)&callarg, sizeof(callarg), &retval);
938 if (error) { 938 if (error) {
939 retval = -1; 939 retval = -1;
940 rumpuser_seterrno(error); 940 rumpuser_seterrno(error);
941 } 941 }
942 return retval; 942 return retval;
943} 943}
944__weak_alias(sys_lchown,rump_enosys); 944__weak_alias(sys_lchown,rump_enosys);
945 945
946int rump_sys_lchflags(const char *, u_long); 946int rump_sys_lchflags(const char *, u_long);
947int 947int
948rump_sys_lchflags(const char * path, u_long flags) 948rump_sys_lchflags(const char * path, u_long flags)
949{ 949{
950 register_t retval = 0; 950 register_t retval = 0;
951 int error = 0; 951 int error = 0;
952 struct sys_lchflags_args arg; 952 struct sys_lchflags_args callarg;
953 953
954 SPARG(&arg, path) = path; 954 SPARG(&callarg, path) = path;
955 SPARG(&arg, flags) = flags; 955 SPARG(&callarg, flags) = flags;
956 956
957 error = rump_sysproxy(SYS_lchflags, rump_sysproxy_arg, 957 error = rump_sysproxy(SYS_lchflags, rump_sysproxy_arg,
958 (uint8_t *)&arg, sizeof(arg), &retval); 958 (uint8_t *)&callarg, sizeof(callarg), &retval);
959 if (error) { 959 if (error) {
960 retval = -1; 960 retval = -1;
961 rumpuser_seterrno(error); 961 rumpuser_seterrno(error);
962 } 962 }
963 return retval; 963 return retval;
964} 964}
965__weak_alias(sys_lchflags,rump_enosys); 965__weak_alias(sys_lchflags,rump_enosys);
966 966
967int rump_sys_statvfs1(const char *, struct statvfs *, int); 967int rump_sys_statvfs1(const char *, struct statvfs *, int);
968int 968int
969rump_sys_statvfs1(const char * path, struct statvfs * buf, int flags) 969rump_sys_statvfs1(const char * path, struct statvfs * buf, int flags)
970{ 970{
971 register_t retval = 0; 971 register_t retval = 0;
972 int error = 0; 972 int error = 0;
973 struct sys_statvfs1_args arg; 973 struct sys_statvfs1_args callarg;
974 974
975 SPARG(&arg, path) = path; 975 SPARG(&callarg, path) = path;
976 SPARG(&arg, buf) = buf; 976 SPARG(&callarg, buf) = buf;
977 SPARG(&arg, flags) = flags; 977 SPARG(&callarg, flags) = flags;
978 978
979 error = rump_sysproxy(SYS_statvfs1, rump_sysproxy_arg, 979 error = rump_sysproxy(SYS_statvfs1, rump_sysproxy_arg,
980 (uint8_t *)&arg, sizeof(arg), &retval); 980 (uint8_t *)&callarg, sizeof(callarg), &retval);
981 if (error) { 981 if (error) {
982 retval = -1; 982 retval = -1;
983 rumpuser_seterrno(error); 983 rumpuser_seterrno(error);
984 } 984 }
985 return retval; 985 return retval;
986} 986}
987__weak_alias(sys_statvfs1,rump_enosys); 987__weak_alias(sys_statvfs1,rump_enosys);
988 988
989int rump_sys___socket30(int, int, int); 989int rump_sys___socket30(int, int, int);
990int 990int
991rump_sys___socket30(int domain, int type, int protocol) 991rump_sys___socket30(int domain, int type, int protocol)
992{ 992{
993 register_t retval = 0; 993 register_t retval = 0;
994 int error = 0; 994 int error = 0;
995 struct sys___socket30_args arg; 995 struct sys___socket30_args callarg;
996 996
997 SPARG(&arg, domain) = domain; 997 SPARG(&callarg, domain) = domain;
998 SPARG(&arg, type) = type; 998 SPARG(&callarg, type) = type;
999 SPARG(&arg, protocol) = protocol; 999 SPARG(&callarg, protocol) = protocol;
1000 1000
1001 error = rump_sysproxy(SYS___socket30, rump_sysproxy_arg, 1001 error = rump_sysproxy(SYS___socket30, rump_sysproxy_arg,
1002 (uint8_t *)&arg, sizeof(arg), &retval); 1002 (uint8_t *)&callarg, sizeof(callarg), &retval);
1003 if (error) { 1003 if (error) {
1004 retval = -1; 1004 retval = -1;
1005 rumpuser_seterrno(error); 1005 rumpuser_seterrno(error);
1006 } 1006 }
1007 return retval; 1007 return retval;
1008} 1008}
1009__weak_alias(sys___socket30,rump_enosys); 1009__weak_alias(sys___socket30,rump_enosys);
1010 1010
1011int rump_sys___getfh30(const char *, void *, size_t *); 1011int rump_sys___getfh30(const char *, void *, size_t *);
1012int 1012int
1013rump_sys___getfh30(const char * fname, void * fhp, size_t * fh_size) 1013rump_sys___getfh30(const char * fname, void * fhp, size_t * fh_size)
1014{ 1014{
1015 register_t retval = 0; 1015 register_t retval = 0;
1016 int error = 0; 1016 int error = 0;
1017 struct sys___getfh30_args arg; 1017 struct sys___getfh30_args callarg;
1018 1018
1019 SPARG(&arg, fname) = fname; 1019 SPARG(&callarg, fname) = fname;
1020 SPARG(&arg, fhp) = fhp; 1020 SPARG(&callarg, fhp) = fhp;
1021 SPARG(&arg, fh_size) = fh_size; 1021 SPARG(&callarg, fh_size) = fh_size;
1022 1022
1023 error = rump_sysproxy(SYS___getfh30, rump_sysproxy_arg, 1023 error = rump_sysproxy(SYS___getfh30, rump_sysproxy_arg,
1024 (uint8_t *)&arg, sizeof(arg), &retval); 1024 (uint8_t *)&callarg, sizeof(callarg), &retval);
1025 if (error) { 1025 if (error) {
1026 retval = -1; 1026 retval = -1;
1027 rumpuser_seterrno(error); 1027 rumpuser_seterrno(error);
1028 } 1028 }
1029 return retval; 1029 return retval;
1030} 1030}
1031__weak_alias(sys___getfh30,rump_enosys); 1031__weak_alias(sys___getfh30,rump_enosys);
1032 1032
1033int rump_sys___utimes50(const char *, const struct timeval *); 1033int rump_sys___utimes50(const char *, const struct timeval *);
1034int 1034int
1035rump_sys___utimes50(const char * path, const struct timeval * tptr) 1035rump_sys___utimes50(const char * path, const struct timeval * tptr)
1036{ 1036{
1037 register_t retval = 0; 1037 register_t retval = 0;
1038 int error = 0; 1038 int error = 0;
1039 struct sys___utimes50_args arg; 1039 struct sys___utimes50_args callarg;
1040 1040
1041 SPARG(&arg, path) = path; 1041 SPARG(&callarg, path) = path;
1042 SPARG(&arg, tptr) = tptr; 1042 SPARG(&callarg, tptr) = tptr;
1043 1043
1044 error = rump_sysproxy(SYS___utimes50, rump_sysproxy_arg, 1044 error = rump_sysproxy(SYS___utimes50, rump_sysproxy_arg,
1045 (uint8_t *)&arg, sizeof(arg), &retval); 1045 (uint8_t *)&callarg, sizeof(callarg), &retval);
1046 if (error) { 1046 if (error) {
1047 retval = -1; 1047 retval = -1;
1048 rumpuser_seterrno(error); 1048 rumpuser_seterrno(error);
1049 } 1049 }
1050 return retval; 1050 return retval;
1051} 1051}
1052__weak_alias(sys___utimes50,rump_enosys); 1052__weak_alias(sys___utimes50,rump_enosys);
1053 1053
1054int rump_sys___lutimes50(const char *, const struct timeval *); 1054int rump_sys___lutimes50(const char *, const struct timeval *);
1055int 1055int
1056rump_sys___lutimes50(const char * path, const struct timeval * tptr) 1056rump_sys___lutimes50(const char * path, const struct timeval * tptr)
1057{ 1057{
1058 register_t retval = 0; 1058 register_t retval = 0;
1059 int error = 0; 1059 int error = 0;
1060 struct sys___lutimes50_args arg; 1060 struct sys___lutimes50_args callarg;
1061 1061
1062 SPARG(&arg, path) = path; 1062 SPARG(&callarg, path) = path;
1063 SPARG(&arg, tptr) = tptr; 1063 SPARG(&callarg, tptr) = tptr;
1064 1064
1065 error = rump_sysproxy(SYS___lutimes50, rump_sysproxy_arg, 1065 error = rump_sysproxy(SYS___lutimes50, rump_sysproxy_arg,
1066 (uint8_t *)&arg, sizeof(arg), &retval); 1066 (uint8_t *)&callarg, sizeof(callarg), &retval);
1067 if (error) { 1067 if (error) {
1068 retval = -1; 1068 retval = -1;
1069 rumpuser_seterrno(error); 1069 rumpuser_seterrno(error);
1070 } 1070 }
1071 return retval; 1071 return retval;
1072} 1072}
1073__weak_alias(sys___lutimes50,rump_enosys); 1073__weak_alias(sys___lutimes50,rump_enosys);
1074 1074
1075int rump_sys___stat50(const char *, struct stat *); 1075int rump_sys___stat50(const char *, struct stat *);
1076int 1076int
1077rump_sys___stat50(const char * path, struct stat * ub) 1077rump_sys___stat50(const char * path, struct stat * ub)
1078{ 1078{
1079 register_t retval = 0; 1079 register_t retval = 0;
1080 int error = 0; 1080 int error = 0;
1081 struct sys___stat50_args arg; 1081 struct sys___stat50_args callarg;
1082 1082
1083 SPARG(&arg, path) = path; 1083 SPARG(&callarg, path) = path;
1084 SPARG(&arg, ub) = ub; 1084 SPARG(&callarg, ub) = ub;
1085 1085
1086 error = rump_sysproxy(SYS___stat50, rump_sysproxy_arg, 1086 error = rump_sysproxy(SYS___stat50, rump_sysproxy_arg,
1087 (uint8_t *)&arg, sizeof(arg), &retval); 1087 (uint8_t *)&callarg, sizeof(callarg), &retval);
1088 if (error) { 1088 if (error) {
1089 retval = -1; 1089 retval = -1;
1090 rumpuser_seterrno(error); 1090 rumpuser_seterrno(error);
1091 } 1091 }
1092 return retval; 1092 return retval;
1093} 1093}
1094__weak_alias(sys___stat50,rump_enosys); 1094__weak_alias(sys___stat50,rump_enosys);
1095 1095
1096int rump_sys___lstat50(const char *, struct stat *); 1096int rump_sys___lstat50(const char *, struct stat *);
1097int 1097int
1098rump_sys___lstat50(const char * path, struct stat * ub) 1098rump_sys___lstat50(const char * path, struct stat * ub)
1099{ 1099{
1100 register_t retval = 0; 1100 register_t retval = 0;
1101 int error = 0; 1101 int error = 0;
1102 struct sys___lstat50_args arg; 1102 struct sys___lstat50_args callarg;
1103 1103
1104 SPARG(&arg, path) = path; 1104 SPARG(&callarg, path) = path;
1105 SPARG(&arg, ub) = ub; 1105 SPARG(&callarg, ub) = ub;
1106 1106
1107 error = rump_sysproxy(SYS___lstat50, rump_sysproxy_arg, 1107 error = rump_sysproxy(SYS___lstat50, rump_sysproxy_arg,
1108 (uint8_t *)&arg, sizeof(arg), &retval); 1108 (uint8_t *)&callarg, sizeof(callarg), &retval);
1109 if (error) { 1109 if (error) {
1110 retval = -1; 1110 retval = -1;
1111 rumpuser_seterrno(error); 1111 rumpuser_seterrno(error);
1112 } 1112 }
1113 return retval; 1113 return retval;
1114} 1114}
1115__weak_alias(sys___lstat50,rump_enosys); 1115__weak_alias(sys___lstat50,rump_enosys);
1116 1116
1117int rump_sys___mknod50(const char *, mode_t, dev_t); 1117int rump_sys___mknod50(const char *, mode_t, dev_t);
1118int 1118int
1119rump_sys___mknod50(const char * path, mode_t mode, dev_t dev) 1119rump_sys___mknod50(const char * path, mode_t mode, dev_t dev)
1120{ 1120{
1121 register_t retval = 0; 1121 register_t retval = 0;
1122 int error = 0; 1122 int error = 0;
1123 struct sys___mknod50_args arg; 1123 struct sys___mknod50_args callarg;
1124 1124
1125 SPARG(&arg, path) = path; 1125 SPARG(&callarg, path) = path;
1126 SPARG(&arg, mode) = mode; 1126 SPARG(&callarg, mode) = mode;
1127 SPARG(&arg, dev) = dev; 1127 SPARG(&callarg, dev) = dev;
1128 1128
1129 error = rump_sysproxy(SYS___mknod50, rump_sysproxy_arg, 1129 error = rump_sysproxy(SYS___mknod50, rump_sysproxy_arg,
1130 (uint8_t *)&arg, sizeof(arg), &retval); 1130 (uint8_t *)&callarg, sizeof(callarg), &retval);
1131 if (error) { 1131 if (error) {
1132 retval = -1; 1132 retval = -1;
1133 rumpuser_seterrno(error); 1133 rumpuser_seterrno(error);
1134 } 1134 }
1135 return retval; 1135 return retval;
1136} 1136}
1137__weak_alias(sys___mknod50,rump_enosys); 1137__weak_alias(sys___mknod50,rump_enosys);
1138 1138
1139#define s(type) sizeof(type) 1139#define s(type) sizeof(type)
1140#define n(type) (sizeof(type)/sizeof (register_t)) 1140#define n(type) (sizeof(type)/sizeof (register_t))
1141#define ns(type) n(type), s(type) 1141#define ns(type) n(type), s(type)
1142 1142
1143struct sysent rump_sysent[] = { 1143struct sysent rump_sysent[] = {