8000 minix/minix/include/minix/ipc.h at R3.3.0 · krackou/minix · GitHub
[go: up one dir, main page]

Skip to content

Latest commit

 

History

History
2420 lines (1948 loc) · 48.4 KB

ipc.h

File metadata and controls

2420 lines (1948 loc) · 48.4 KB
#ifndef _IPC_H
#define _IPC_H
#include <minix/ipcconst.h>
#include <minix/type.h>
#include <minix/const.h>
#include <sys/signal.h>
#include <sys/types.h>
/*==========================================================================*
* Types relating to messages. *
*==========================================================================*/
#define M_PATH_STRING_MAX 40
typedef struct {
uint8_t data[56];
} mess_u8;
_ASSERT_MSG_SIZE(mess_u8);
typedef struct {
uint16_t data[28];
} mess_u16;
_ASSERT_MSG_SIZE(mess_u16);
typedef struct {
uint32_t data[14];
} mess_u32;
_ASSERT_MSG_SIZE(mess_u32);
typedef struct {
uint64_t data[7];
} mess_u64;
_ASSERT_MSG_SIZE(mess_u64);
typedef struct {
uint64_t m1ull1;
int m1i1, m1i2, m1i3;
char *m1p1, *m1p2, *m1p3, *m1p4;
uint8_t padding[20];
} mess_1;
_ASSERT_MSG_SIZE(mess_1);
typedef struct {
int64_t m2ll1;
int m2i1, m2i2, m2i3;
long m2l1, m2l2;
char *m2p1;
sigset_t sigset;
short m2s1;
uint8_t padding[6];
} mess_2;
_ASSERT_MSG_SIZE(mess_2);
typedef struct {
int m3i1, m3i2;
char *m3p1;
char m3ca1[44];
} mess_3;
_ASSERT_MSG_SIZE(mess_3);
typedef struct {
int64_t m4ll1;
long m4l1, m4l2, m4l3, m4l4, m4l5;
uint8_t padding[28];
} mess_4;
_ASSERT_MSG_SIZE(mess_4);
typedef struct {
int m7i1, m7i2, m7i3, m7i4, m7i5;
char *m7p1, *m7p2;
uint8_t padding[28];
} mess_7;
_ASSERT_MSG_SIZE(mess_7);
typedef struct {
uint64_t m9ull1, m9ull2;
long m9l1, m9l2, m9l3, m9l4, m9l5;
short m9s1, m9s2, m9s3, m9s4;
uint8_t padding[12];
} mess_9;
_ASSERT_MSG_SIZE(mess_9);
typedef struct {
u64_t m10ull1;
int m10i1, m10i2, m10i3, m10i4;
long m10l1, m10l2, m10l3;
uint8_t padding[20];
} mess_10;
_ASSERT_MSG_SIZE(mess_10);
/* Helper union for DS messages */
union ds_val {
cp_grant_id_t grant;
u32_t u32;
endpoint_t ep;
};
typedef struct {
union ds_val val_out;
int val_len;
uint8_t padding[48];
} mess_ds_reply;
_ASSERT_MSG_SIZE(mess_ds_reply);
typedef struct {
cp_grant_id_t key_grant;
int key_len;
int flags;
union ds_val val_in;
int val_len;
endpoint_t owner;
uint8_t padding[32];
} mess_ds_req;
_ASSERT_MSG_SIZE(mess_ds_req);
typedef struct {
off_t seek_pos;
size_t nbytes;
uint8_t data[44];
} mess_fs_vfs_breadwrite;
_ASSERT_MSG_SIZE(mess_fs_vfs_breadwrite);
typedef struct {
mode_t mode;
uint8_t data[52];
} mess_fs_vfs_chmod;
_ASSERT_MSG_SIZE(mess_fs_vfs_chmod);
typedef struct {
mode_t mode;
uint8_t data[52];
} mess_fs_vfs_chown;
_ASSERT_MSG_SIZE(mess_fs_vfs_chown);
typedef struct {
off_t file_size;
ino_t inode;
mode_t mode;
uid_t uid;
gid_t gid;
uint8_t data[28];
} mess_fs_vfs_create;
_ASSERT_MSG_SIZE(mess_fs_vfs_create);
typedef struct {
off_t seek_pos;
size_t nbytes;
uint8_t data[44];
} mess_fs_vfs_getdents;
_ASSERT_MSG_SIZE(mess_fs_vfs_getdents);
typedef struct {
off_t offset;
off_t file_size;
dev_t device;
ino_t inode;
mode_t mode;
uid_t uid;
gid_t gid;
uint16_t symloop;
uint8_t data[10];
} mess_fs_vfs_lookup;
_ASSERT_MSG_SIZE(mess_fs_vfs_lookup);
typedef struct {
off_t file_size;
dev_t device;
ino_t inode;
mode_t mode;
uid_t uid;
gid_t gid;
uint8_t data[20];
} mess_fs_vfs_newnode;
_ASSERT_MSG_SIZE(mess_fs_vfs_newnode);
typedef struct {
size_t nbytes;
uint8_t data[52];
} mess_fs_vfs_rdlink;
_ASSERT_MSG_SIZE(mess_fs_vfs_rdlink);
typedef struct {
off_t file_size;
dev_t device;
ino_t inode;
uint32_t flags;
mode_t mode;
uid_t uid;
gid_t gid;
uint16_t con_reqs;
uint8_t data[14];
} mess_fs_vfs_readsuper;
_ASSERT_MSG_SIZE(mess_fs_vfs_readsuper);
typedef struct {
off_t seek_pos;
size_t nbytes;
uint8_t data[44];
} mess_fs_vfs_readwrite;
_ASSERT_MSG_SIZE(mess_fs_vfs_readwrite);
typedef struct {
uint8_t padding[56];
} mess_i2c_li2cdriver_busc_i2c_exec;
_ASSERT_MSG_SIZE(mess_i2c_li2cdriver_busc_i2c_exec);
typedef struct {
uint8_t padding[56];
} mess_i2c_li2cdriver_busc_i2c_reserve;
_ASSERT_MSG_SIZE(mess_i2c_li2cdriver_busc_i2c_reserve);
typedef struct {
int kbd_id;
int mouse_id;
int rsvd1_id;
int rsvd2_id;
uint8_t padding[40];
} mess_input_linputdriver_input_conf;
_ASSERT_MSG_SIZE(mess_input_linputdriver_input_conf);
typedef struct {
uint32_t led_mask;
uint8_t padding[52];
} mess_input_linputdriver_setleds;
_ASSERT_MSG_SIZE(mess_input_linputdriver_setleds);
typedef struct {
int id;
int page;
int code;
int value;
int flags;
uint8_t padding[36];
} mess_input_tty_event;
_ASSERT_MSG_SIZE(mess_input_tty_event);
typedef struct {
time_t acnt_queue;
unsigned long acnt_deqs;
unsigned long acnt_ipc_sync;
unsigned long acnt_ipc_async;
unsigned long acnt_preempt;
uint32_t acnt_cpu;
uint32_t acnt_cpu_load;
uint8_t padding[24];
} mess_krn_lsys_schedule;
_ASSERT_MSG_SIZE(mess_krn_lsys_schedule);
typedef struct {
uint32_t value;
uint8_t padding[52];
} mess_krn_lsys_sys_devio;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_devio);
typedef struct {
endpoint_t endpt;
vir_bytes msgaddr;
uint8_t padding[48];
} mess_krn_lsys_sys_fork;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_fork);
typedef struct {
endpoint_t endpt;
int privflags;
char name[48];
} mess_krn_lsys_sys_getwhoami;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_getwhoami);
typedef struct {
int hook_id;
uint8_t padding[52];
} mess_krn_lsys_sys_irqctl;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_irqctl);
typedef struct {
clock_t real_ticks;
clock_t boot_ticks;
clock_t boot_time;
clock_t user_time;
clock_t system_time;
uint8_t padding[36];
} mess_krn_lsys_sys_times;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_times);
typedef struct {
long int data;
uint8_t padding[52];
} mess_krn_lsys_sys_trace;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_trace);
typedef struct {
phys_bytes dst_addr;
uint8_t padding[52];
} mess_krn_lsys_sys_umap;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_umap);
typedef struct {
int pcount;
uint8_t padding[52];
} mess_krn_lsys_sys_vumap;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_vumap);
typedef struct {
off_t pos;
int minor;
int id;
int access;
int count;
cp_grant_id_t grant;
int flags;
endpoint_t user;
int request;
uint8_t padding[16];
} mess_lbdev_lblockdriver_msg;
_ASSERT_MSG_SIZE(mess_lbdev_lblockdriver_msg);
typedef struct {
int status;
int id;
uint8_t padding[48];
} mess_lblockdriver_lbdev_reply;
_ASSERT_MSG_SIZE(mess_lblockdriver_lbdev_reply);
typedef struct {
int id;
int num;
int cmd;
int opt;
int ret;
uint8_t padding[36];
} mess_lc_ipc_semctl;
_ASSERT_MSG_SIZE(mess_lc_ipc_semctl);
typedef struct {
key_t key;
int nr;
int flag;
int retid;
uint8_t padding[40];
} mess_lc_ipc_semget;
_ASSERT_MSG_SIZE(mess_lc_ipc_semget);
typedef struct {
int id;
void *ops;
unsigned int size;
uint8_t padding[42];
} mess_lc_ipc_semop;
_ASSERT_MSG_SIZE(mess_lc_ipc_semop);
typedef struct {
int id;
const void *addr;
int flag;
void *retaddr;
uint8_t padding[40];
} mess_lc_ipc_shmat;
_ASSERT_MSG_SIZE(mess_lc_ipc_shmat);
typedef struct {
int id;
int cmd;
void *buf;
int ret;
uint8_t padding[40];
} mess_lc_ipc_shmctl;
_ASSERT_MSG_SIZE(mess_lc_ipc_shmctl);
typedef struct {
const void *addr;
uint8_t padding[52];
} mess_lc_ipc_shmdt;
_ASSERT_MSG_SIZE(mess_lc_ipc_shmdt);
typedef struct {
key_t key;
size_t size;
int flag;
int retid;
uint8_t padding[40];
} mess_lc_ipc_shmget;
_ASSERT_MSG_SIZE(mess_lc_ipc_shmget);
typedef struct {
int action;
vir_bytes ctl_ptr;
vir_bytes mem_ptr;
size_t mem_size;
uint8_t padding[40];
} mess_lc_pm_cprof;
_ASSERT_MSG_SIZE(mess_lc_pm_cprof);
typedef struct {
vir_bytes name;
size_t namelen;
vir_bytes frame;
size_t framelen;
vir_bytes ps_str;
uint8_t padding[36];
10BC8
} mess_lc_pm_exec;
_ASSERT_MSG_SIZE(mess_lc_pm_exec);
typedef struct {
int status;
uint8_t padding[52];
} mess_lc_pm_exit;
_ASSERT_MSG_SIZE(mess_lc_pm_exit);
typedef struct {
pid_t pid;
uint8_t padding[52];
} mess_lc_pm_getsid;
_ASSERT_MSG_SIZE(mess_lc_pm_getsid);
typedef struct {
int num;
vir_bytes ptr; /* gid_t * */
uint8_t padding[48];
} mess_lc_pm_groups;
_ASSERT_MSG_SIZE(mess_lc_pm_groups);
typedef struct {
int which;
vir_bytes value; /* const struct itimerval * */
vir_bytes ovalue; /* struct itimerval * */
uint8_t padding[44];
} mess_lc_pm_itimer;
_ASSERT_MSG_SIZE(mess_lc_pm_itimer);
typedef struct {
vir_bytes ctx; /* mcontext_t * */
uint8_t padding[52];
} mess_lc_pm_mcontext;
_ASSERT_MSG_SIZE(mess_lc_pm_mcontext);
typedef struct {
int which;
int who;
int prio;
uint8_t padding[44];
} mess_lc_pm_priority;
_ASSERT_MSG_SIZE(mess_lc_pm_priority);
typedef struct {
pid_t pid;
int req;
vir_bytes addr;
long data;
uint8_t padding[40];
} mess_lc_pm_ptrace;
_ASSERT_MSG_SIZE(mess_lc_pm_ptrace);
typedef struct {
int how;
uint8_t padding[52];
} mess_lc_pm_reboot;
_ASSERT_MSG_SIZE(mess_lc_pm_reboot);
typedef struct {
endpoint_t who;
vir_bytes addr;
uint8_t padding[48];
} mess_lc_pm_rusage;
_ASSERT_MSG_SIZE(mess_lc_pm_rusage);
typedef struct {
gid_t gid;
uint8_t padding[52];
} mess_lc_pm_setgid;
_ASSERT_MSG_SIZE(mess_lc_pm_setgid);
typedef struct {
uid_t uid;
uint8_t padding[52];
} mess_lc_pm_setuid;
_ASSERT_MSG_SIZE(mess_lc_pm_setuid);
typedef struct {
pid_t pid;
int nr;
vir_bytes act; /* const struct sigaction * */
vir_bytes oact; /* struct sigaction * */
vir_bytes ret; /* int (*)(void) */
uint8_t padding[36];
} mess_lc_pm_sig;
_ASSERT_MSG_SIZE(mess_lc_pm_sig);
typedef struct {
int how;
vir_bytes ctx;
sigset_t set;
uint8_t padding[32];
} mess_lc_pm_sigset;
_ASSERT_MSG_SIZE(mess_lc_pm_sigset);
typedef struct {
int action;
int freq;
int intr_type;
vir_bytes ctl_ptr;
vir_bytes mem_ptr;
size_t mem_size;
uint8_t padding[32];
} mess_lc_pm_sprof;
_ASSERT_MSG_SIZE(mess_lc_pm_sprof);
typedef struct {
int req;
int field;
size_t len;
vir_bytes value;
uint8_t padding[40];
} mess_lc_pm_sysuname;
_ASSERT_MSG_SIZE(mess_lc_pm_sysuname);
typedef struct {
time_t sec;
clockid_t clk_id;
int now;
long nsec;
uint8_t padding[36];
} mess_lc_pm_time;
_ASSERT_MSG_SIZE(mess_lc_pm_time);
typedef struct {
pid_t pid;
int options;
uint8_t padding[48];
} mess_lc_pm_waitpid;
_ASSERT_MSG_SIZE(mess_lc_pm_waitpid);
typedef struct {
cp_grant_id_t grant;
vir_bytes tm; /* struct tm * */
int flags;
uint8_t padding[44];
} mess_lc_readclock_rtcdev;
_ASSERT_MSG_SIZE(mess_lc_readclock_rtcdev);
typedef struct {
vir_bytes name;
size_t len;
int fd;
uid_t owner;
gid_t group;
uint8_t padding[36];
} mess_lc_vfs_chown;
_ASSERT_MSG_SIZE(mess_lc_vfs_chown);
typedef struct {
int fd;
uint8_t padding[52];
} mess_lc_vfs_close;
_ASSERT_MSG_SIZE(mess_lc_vfs_close);
typedef struct {
vir_bytes name;
size_t len;
int flags;
mode_t mode;
uint8_t padding[40];
} mess_lc_vfs_creat;
_ASSERT_MSG_SIZE(mess_lc_vfs_creat);
typedef struct {
int fd;
uint8_t padding[52];
} mess_lc_vfs_fchdir;
_ASSERT_MSG_SIZE(mess_lc_vfs_fchdir);
typedef struct {
int fd;
mode_t mode;
uint8_t padding[48];
} mess_lc_vfs_fchmod;
_ASSERT_MSG_SIZE(mess_lc_vfs_fchmod);
typedef struct {
int fd;
int cmd;
int arg_int;
vir_bytes arg_ptr; /* struct flock * */
uint8_t padding[40];
} mess_lc_vfs_fcntl;
_ASSERT_MSG_SIZE(mess_lc_vfs_fcntl);
typedef struct {
int fd;
vir_bytes buf; /* struct stat * */
uint8_t padding[48];
} mess_lc_vfs_fstat;
_ASSERT_MSG_SIZE(mess_lc_vfs_fstat);
typedef struct {
int fd;
uint8_t padding[52];
} mess_lc_vfs_fsync;
_ASSERT_MSG_SIZE(mess_lc_vfs_fsync);
typedef struct {
cp_grant_id_t grant;
int pid;
vir_bytes buff_p;
size_t buff_sz;
uint8_t padding[40];
} mess_lc_vfs_gcov;
_ASSERT_MSG_SIZE(mess_lc_vfs_gcov);
typedef struct {
int32_t flags;
size_t len;
vir_bytes buf; /* struct statvfs */
uint8_t padding[44];
} mess_lc_vfs_getvfsstat;
_ASSERT_MSG_SIZE(mess_lc_vfs_getvfsstat);
typedef struct {
int fd;
unsigned long req;
vir_bytes arg;
uint8_t padding[44];
} mess_lc_vfs_ioctl;
_ASSERT_MSG_SIZE(mess_lc_vfs_ioctl);
typedef struct {
vir_bytes name1;
vir_bytes name2;
size_t len1;
size_t len2;
uint8_t padding[40];
} mess_lc_vfs_link;
_ASSERT_MSG_SIZE(mess_lc_vfs_link);
typedef struct {
off_t offset;
int fd;
int whence;
uint8_t padding[40];
} mess_lc_vfs_lseek;
_ASSERT_MSG_SIZE(mess_lc_vfs_lseek);
typedef struct {
dev_t device;
vir_bytes name;
size_t len;
mode_t mode;
uint8_t padding[36];
} mess_lc_vfs_mknod;
_ASSERT_MSG_SIZE(mess_lc_vfs_mknod);
typedef struct {
int flags;
size_t devlen;
size_t pathlen;
size_t typelen;
size_t labellen;
vir_bytes dev;
vir_bytes path;
vir_bytes type;
vir_bytes label;
uint8_t padding[20];
} mess_lc_vfs_mount;
_ASSERT_MSG_SIZE(mess_lc_vfs_mount);
typedef struct {
vir_bytes name;
size_t len;
int flags;
mode_t mode;
char buf[M_PATH_STRING_MAX];
} mess_lc_vfs_path;
_ASSERT_MSG_SIZE(mess_lc_vfs_path);
typedef struct {
int fd0;
int fd1;
int flags;
uint8_t padding[44];
} mess_lc_vfs_pipe2;
_ASSERT_MSG_SIZE(mess_lc_vfs_pipe2);
typedef struct {
vir_bytes name; /* const char * */
size_t namelen;
vir_bytes buf;
size_t bufsize;
uint8_t padding[40];
} mess_lc_vfs_readlink;
_ASSERT_MSG_SIZE(mess_lc_vfs_readlink);
typedef struct {
int fd;
vir_bytes buf;
size_t len;
uint8_t padding[44];
} mess_lc_vfs_readwrite;
_ASSERT_MSG_SIZE(mess_lc_vfs_readwrite);
typedef struct {
vir_bytes addr;
uint8_t padding[52];
} mess_lc_vfs_rusage;
_ASSERT_MSG_SIZE(mess_lc_vfs_rusage);
typedef struct {
uint32_t nfds;
fd_set *readfds;
fd_set *writefds;
fd_set *errorfds;
vir_bytes timeout; /* user-provided 'struct timeval *' */
uint8_t padding[36];
} mess_lc_vfs_select;
_ASSERT_MSG_SIZE(mess_lc_vfs_select);
typedef struct {
size_t len;
vir_bytes name; /* const char * */
vir_bytes buf; /* struct stat * */
uint8_t padding[44];
} mess_lc_vfs_stat;
_ASSERT_MSG_SIZE(mess_lc_vfs_stat);
typedef struct {
int fd;
int flags;
size_t len;
vir_bytes name;
vir_bytes buf;
uint8_t padding[36];
} mess_lc_vfs_statvfs1;
_ASSERT_MSG_SIZE(mess_lc_vfs_statvfs1);
typedef struct {
off_t offset;
int fd;
vir_bytes name;
size_t len;
uint8_t padding[36];
} mess_lc_vfs_truncate;
_ASSERT_MSG_SIZE(mess_lc_vfs_truncate);
typedef struct {
mode_t mask;
uint8_t padding[52];
} mess_lc_vfs_umask;
_ASSERT_MSG_SIZE(mess_lc_vfs_umask);
typedef struct {
vir_bytes name;
size_t namelen;
vir_bytes label;
size_t labellen;
uint8_t padding[40];
} mess_lc_vfs_umount;
_ASSERT_MSG_SIZE(mess_lc_vfs_umount);
typedef struct {
void *addr;
uint8_t padding[52];
} mess_lc_vm_brk;
_ASSERT_MSG_SIZE(mess_lc_vm_brk);
typedef struct {
endpoint_t endpt;
void *addr;
void *ret_addr;
uint8_t padding[44];
} mess_lc_vm_getphys;
_ASSERT_MSG_SIZE(mess_lc_vm_getphys);
typedef struct {
vir_bytes addr;
uint8_t padding[52];
} mess_lc_vm_rusage;
_ASSERT_MSG_SIZE(mess_lc_vm_rusage);
typedef struct {
endpoint_t forwhom;
void *addr;
uint8_t padding[48];
} mess_lc_vm_shm_unmap;
_ASSERT_MSG_SIZE(mess_lc_vm_shm_unmap);
typedef struct {
int status;
uint32_t id; /* should be cdev_id_t */
uint8_t padding[48];
} mess_lchardriver_vfs_reply;
_ASSERT_MSG_SIZE(mess_lchardriver_vfs_reply);
typedef struct {
int status;
int32_t minor;
uint8_t padding[48];
} mess_lchardriver_vfs_sel1;
_ASSERT_MSG_SIZE(mess_lchardriver_vfs_sel1);
typedef struct {
int status;
int32_t minor;
uint8_t padding[48];
} mess_lchardriver_vfs_sel2;
_ASSERT_MSG_SIZE(mess_lchardriver_vfs_sel2);
typedef struct {
endpoint_t endpt;
vir_bytes ptr; /* struct exec_info * */
uint8_t padding[48];
} mess_lexec_pm_exec_new;
_ASSERT_MSG_SIZE(mess_lexec_pm_exec_new);
typedef struct {
cp_grant_id_t grant;
uint8_t padding[52];
} mess_li2cdriver_i2c_busc_i2c_exec;
_ASSERT_MSG_SIZE(mess_li2cdriver_i2c_busc_i2c_exec);
typedef struct {
uint16_t addr; /* FIXME: strictly speaking this is an i2c_addr_t, but
to get it I would need to include
sys/dev/i2c/i2c_io.h, which I am not sure is a good
idea to have everywhere. */
uint8_t padding[54];
} mess_li2cdriver_i2c_busc_i2c_reserve;
_ASSERT_MSG_SIZE(mess_li2cdriver_i2c_busc_i2c_reserve);
typedef struct {
int id;
int page;
int code;
int value;
int flags;
uint8_t padding[36];
} mess_linputdriver_input_event;
_ASSERT_MSG_SIZE(mess_linputdriver_input_event);
typedef struct {
cp_grant_id_t gid;
size_t size;
uint8_t padding[48];
} mess_lsys_fi_ctl;
_ASSERT_MSG_SIZE(mess_lsys_fi_ctl);
typedef struct {
int status;
uint8_t padding[52];
} mess_lsys_fi_reply;
_ASSERT_MSG_SIZE(mess_lsys_fi_reply);
typedef struct {
int what;
vir_bytes where;
size_t size;
uint8_t padding[44];
} mess_lsys_getsysinfo;
_ASSERT_MSG_SIZE(mess_lsys_getsysinfo);
typedef struct {
size_t size;
phys_bytes addr;
vir_bytes buf;
uint8_t padding[44];
} mess_lsys_krn_readbios;
_ASSERT_MSG_SIZE(mess_lsys_krn_readbios);
typedef struct {
endpoint_t from_to;
cp_grant_id_t gid;
size_t offset;
void *address;
size_t bytes;
uint8_t padding[36];
} mess_lsys_kern_safecopy;
_ASSERT_MSG_SIZE(mess_lsys_kern_safecopy);
typedef struct {
uint32_t flags;
endpoint_t endpoint;
int priority;
int quantum;
int cpu;
uint8_t padding[36];
} mess_lsys_krn_schedctl;
_ASSERT_MSG_SIZE(mess_lsys_krn_schedctl);
typedef struct {
endpoint_t endpoint;
int quantum;
int priority;
int cpu;
uint8_t padding[40];
} mess_lsys_krn_schedule;
_ASSERT_MSG_SIZE(mess_lsys_krn_schedule);
typedef struct {
int how;
uint8_t padding[52];
} mess_lsys_krn_sys_abort;
0