[BACK]Return to rump_syscalls.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / rump / librump / rumpkern

Annotation of src/sys/rump/librump/rumpkern/rump_syscalls.c, Revision 1.6

1.1       pooka       1: /* $NetBSD$ */
                      2:
                      3: /*
                      4:  * System call marshalling for rump.
                      5:  *
                      6:  * DO NOT EDIT-- this file is automatically generated.
1.6     ! ad          7:  * created from        NetBSD: syscalls.master,v 1.199 2008/04/21 12:56:31 ad Exp
1.1       pooka       8:  */
                      9:
                     10: #include <sys/cdefs.h>
                     11: __KERNEL_RCSID(0, "$NetBSD$");
                     12:
                     13: #include <sys/types.h>
                     14: #include <sys/param.h>
                     15: #include <sys/proc.h>
                     16: #include <sys/syscallargs.h>
                     17: #include "rump_syscalls.h"
                     18:
                     19: #if    BYTE_ORDER == BIG_ENDIAN
                     20: #define SPARG(p,k)     ((p)->k.be.datum)
                     21: #else /* LITTLE_ENDIAN, I hope dearly */
                     22: #define SPARG(p,k)     ((p)->k.le.datum)
                     23: #endif
                     24:
                     25: ssize_t
                     26: rump_sys_read(int fd, void * buf, size_t nbyte, int *error)
                     27: {
                     28:        register_t retval;
                     29:        struct sys_read_args arg;
                     30:
                     31:        SPARG(&arg, fd) = fd;
                     32:        SPARG(&arg, buf) = buf;
                     33:        SPARG(&arg, nbyte) = nbyte;
                     34:
                     35:        *error = sys_read(curlwp, &arg, &retval);
                     36:        return retval;
                     37: }
                     38:
                     39: ssize_t
                     40: rump_sys_write(int fd, const void * buf, size_t nbyte, int *error)
                     41: {
                     42:        register_t retval;
                     43:        struct sys_write_args arg;
                     44:
                     45:        SPARG(&arg, fd) = fd;
                     46:        SPARG(&arg, buf) = buf;
                     47:        SPARG(&arg, nbyte) = nbyte;
                     48:
                     49:        *error = sys_write(curlwp, &arg, &retval);
                     50:        return retval;
                     51: }
                     52:
                     53: int
                     54: rump_sys_open(const char * path, int flags, mode_t mode, int *error)
                     55: {
                     56:        register_t retval;
                     57:        struct sys_open_args arg;
                     58:
                     59:        SPARG(&arg, path) = path;
                     60:        SPARG(&arg, flags) = flags;
                     61:        SPARG(&arg, mode) = mode;
                     62:
                     63:        *error = sys_open(curlwp, &arg, &retval);
                     64:        return retval;
                     65: }
                     66:
                     67: int
                     68: rump_sys_close(int fd, int *error)
                     69: {
                     70:        register_t retval;
                     71:        struct sys_close_args arg;
                     72:
                     73:        SPARG(&arg, fd) = fd;
                     74:
                     75:        *error = sys_close(curlwp, &arg, &retval);
                     76:        return retval;
                     77: }
                     78:
                     79: int
                     80: rump_sys_link(const char * path, const char * link, int *error)
                     81: {
                     82:        register_t retval;
                     83:        struct sys_link_args arg;
                     84:
                     85:        SPARG(&arg, path) = path;
                     86:        SPARG(&arg, link) = link;
                     87:
                     88:        *error = sys_link(curlwp, &arg, &retval);
                     89:        return retval;
                     90: }
                     91:
                     92: int
                     93: rump_sys_unlink(const char * path, int *error)
                     94: {
                     95:        register_t retval;
                     96:        struct sys_unlink_args arg;
                     97:
                     98:        SPARG(&arg, path) = path;
                     99:
                    100:        *error = sys_unlink(curlwp, &arg, &retval);
                    101:        return retval;
                    102: }
                    103:
                    104: int
                    105: rump_sys_chdir(const char * path, int *error)
                    106: {
                    107:        register_t retval;
                    108:        struct sys_chdir_args arg;
                    109:
                    110:        SPARG(&arg, path) = path;
                    111:
                    112:        *error = sys_chdir(curlwp, &arg, &retval);
                    113:        return retval;
                    114: }
                    115:
                    116: int
                    117: rump_sys_fchdir(int fd, int *error)
                    118: {
                    119:        register_t retval;
                    120:        struct sys_fchdir_args arg;
                    121:
                    122:        SPARG(&arg, fd) = fd;
                    123:
                    124:        *error = sys_fchdir(curlwp, &arg, &retval);
                    125:        return retval;
                    126: }
                    127:
                    128: int
                    129: rump_sys_mknod(const char * path, mode_t mode, dev_t dev, int *error)
                    130: {
                    131:        register_t retval;
                    132:        struct sys_mknod_args arg;
                    133:
                    134:        SPARG(&arg, path) = path;
                    135:        SPARG(&arg, mode) = mode;
                    136:        SPARG(&arg, dev) = dev;
                    137:
                    138:        *error = sys_mknod(curlwp, &arg, &retval);
                    139:        return retval;
                    140: }
                    141:
                    142: int
                    143: rump_sys_chmod(const char * path, mode_t mode, int *error)
                    144: {
                    145:        register_t retval;
                    146:        struct sys_chmod_args arg;
                    147:
                    148:        SPARG(&arg, path) = path;
                    149:        SPARG(&arg, mode) = mode;
                    150:
                    151:        *error = sys_chmod(curlwp, &arg, &retval);
                    152:        return retval;
                    153: }
                    154:
                    155: int
                    156: rump_sys_chown(const char * path, uid_t uid, gid_t gid, int *error)
                    157: {
                    158:        register_t retval;
                    159:        struct sys_chown_args arg;
                    160:
                    161:        SPARG(&arg, path) = path;
                    162:        SPARG(&arg, uid) = uid;
                    163:        SPARG(&arg, gid) = gid;
                    164:
                    165:        *error = sys_chown(curlwp, &arg, &retval);
                    166:        return retval;
                    167: }
                    168:
                    169: int
                    170: rump_sys_unmount(const char * path, int flags, int *error)
                    171: {
                    172:        register_t retval;
                    173:        struct sys_unmount_args arg;
                    174:
                    175:        SPARG(&arg, path) = path;
                    176:        SPARG(&arg, flags) = flags;
                    177:
                    178:        *error = sys_unmount(curlwp, &arg, &retval);
                    179:        return retval;
                    180: }
                    181:
                    182: int
                    183: rump_sys_access(const char * path, int flags, int *error)
                    184: {
                    185:        register_t retval;
                    186:        struct sys_access_args arg;
                    187:
                    188:        SPARG(&arg, path) = path;
                    189:        SPARG(&arg, flags) = flags;
                    190:
                    191:        *error = sys_access(curlwp, &arg, &retval);
                    192:        return retval;
                    193: }
                    194:
                    195: int
                    196: rump_sys_chflags(const char * path, u_long flags, int *error)
                    197: {
                    198:        register_t retval;
                    199:        struct sys_chflags_args arg;
                    200:
                    201:        SPARG(&arg, path) = path;
                    202:        SPARG(&arg, flags) = flags;
                    203:
                    204:        *error = sys_chflags(curlwp, &arg, &retval);
                    205:        return retval;
                    206: }
                    207:
                    208: int
                    209: rump_sys_fchflags(int fd, u_long flags, int *error)
                    210: {
                    211:        register_t retval;
                    212:        struct sys_fchflags_args arg;
                    213:
                    214:        SPARG(&arg, fd) = fd;
                    215:        SPARG(&arg, flags) = flags;
                    216:
                    217:        *error = sys_fchflags(curlwp, &arg, &retval);
                    218:        return retval;
                    219: }
                    220:
                    221: void
                    222: rump_sys_sync(int *error)
                    223: {
                    224:        register_t retval;
                    225:
                    226:        *error = sys_sync(curlwp, NULL, &retval);
                    227: }
                    228:
                    229: int
                    230: rump_sys_symlink(const char * path, const char * link, int *error)
                    231: {
                    232:        register_t retval;
                    233:        struct sys_symlink_args arg;
                    234:
                    235:        SPARG(&arg, path) = path;
                    236:        SPARG(&arg, link) = link;
                    237:
                    238:        *error = sys_symlink(curlwp, &arg, &retval);
                    239:        return retval;
                    240: }
                    241:
                    242: ssize_t
                    243: rump_sys_readlink(const char * path, char * buf, size_t count, int *error)
                    244: {
                    245:        register_t retval;
                    246:        struct sys_readlink_args arg;
                    247:
                    248:        SPARG(&arg, path) = path;
                    249:        SPARG(&arg, buf) = buf;
                    250:        SPARG(&arg, count) = count;
                    251:
                    252:        *error = sys_readlink(curlwp, &arg, &retval);
                    253:        return retval;
                    254: }
                    255:
                    256: int
                    257: rump_sys_rename(const char * from, const char * to, int *error)
                    258: {
                    259:        register_t retval;
                    260:        struct sys_rename_args arg;
                    261:
                    262:        SPARG(&arg, from) = from;
                    263:        SPARG(&arg, to) = to;
                    264:
                    265:        *error = sys_rename(curlwp, &arg, &retval);
                    266:        return retval;
                    267: }
                    268:
                    269: int
                    270: rump_sys_mkdir(const char * path, mode_t mode, int *error)
                    271: {
                    272:        register_t retval;
                    273:        struct sys_mkdir_args arg;
                    274:
                    275:        SPARG(&arg, path) = path;
                    276:        SPARG(&arg, mode) = mode;
                    277:
                    278:        *error = sys_mkdir(curlwp, &arg, &retval);
                    279:        return retval;
                    280: }
                    281:
                    282: int
                    283: rump_sys_rmdir(const char * path, int *error)
                    284: {
                    285:        register_t retval;
                    286:        struct sys_rmdir_args arg;
                    287:
                    288:        SPARG(&arg, path) = path;
                    289:
                    290:        *error = sys_rmdir(curlwp, &arg, &retval);
                    291:        return retval;
                    292: }
                    293:
                    294: int
                    295: rump_sys_truncate(const char * path, int pad, off_t length, int *error)
                    296: {
                    297:        register_t retval;
                    298:        struct sys_truncate_args arg;
                    299:
                    300:        SPARG(&arg, path) = path;
                    301:        SPARG(&arg, pad) = pad;
                    302:        SPARG(&arg, length) = length;
                    303:
                    304:        *error = sys_truncate(curlwp, &arg, &retval);
                    305:        return retval;
                    306: }
                    307:
                    308: int
                    309: rump_sys_lchmod(const char * path, mode_t mode, int *error)
                    310: {
                    311:        register_t retval;
                    312:        struct sys_lchmod_args arg;
                    313:
                    314:        SPARG(&arg, path) = path;
                    315:        SPARG(&arg, mode) = mode;
                    316:
                    317:        *error = sys_lchmod(curlwp, &arg, &retval);
                    318:        return retval;
                    319: }
                    320:
                    321: int
                    322: rump_sys_lchown(const char * path, uid_t uid, gid_t gid, int *error)
                    323: {
                    324:        register_t retval;
                    325:        struct sys_lchown_args arg;
                    326:
                    327:        SPARG(&arg, path) = path;
                    328:        SPARG(&arg, uid) = uid;
                    329:        SPARG(&arg, gid) = gid;
                    330:
                    331:        *error = sys_lchown(curlwp, &arg, &retval);
                    332:        return retval;
                    333: }
                    334:

CVSweb <webmaster@jp.NetBSD.org>