include/minix/ipc.h

   1 #ifndef _IPC_H
   2 #define _IPC_H
   3
   4 #include <minix/ipcconst.h>
   5 #include <minix/type.h>
   6 #include <minix/const.h>
   7 #include <sys/signal.h>
   8 #include <sys/types.h>
   9
  10 /*==========================================================================*
  11  * Types relating to messages.                                              *
  12  *==========================================================================*/
  13
  14 #define M1                 1
  15 #define M3                 3
  16 #define M4                 4
  17 #define M_PATH_STRING_MAX  40
  18
  19 typedef struct {
  20         uint8_t data[56];
  21 } mess_u8;
  22 _ASSERT_MSG_SIZE(mess_u8);
  23
  24 typedef struct {
  25         uint16_t data[28];
  26 } mess_u16;
  27 _ASSERT_MSG_SIZE(mess_u16);
  28
  29 typedef struct {
  30         uint32_t data[14];
  31 } mess_u32;
  32 _ASSERT_MSG_SIZE(mess_u32);
  33
  34 typedef struct {
  35         uint64_t data[7];
  36 } mess_u64;
  37 _ASSERT_MSG_SIZE(mess_u64);
  38
  39 typedef struct {
  40         uint64_t m1ull1;
  41         int m1i1, m1i2, m1i3;
  42         char *m1p1, *m1p2, *m1p3, *m1p4;
  43         uint8_t padding[20];
  44 } mess_1;
  45 _ASSERT_MSG_SIZE(mess_1);
  46
  47 typedef struct {
  48         int64_t m2ll1;
  49         int m2i1, m2i2, m2i3;
  50         long m2l1, m2l2;
  51         char *m2p1;
  52         sigset_t sigset;
  53         short m2s1;
  54         uint8_t padding[6];
  55 } mess_2;
  56 _ASSERT_MSG_SIZE(mess_2);
  57
  58 typedef struct {
  59         int m3i1, m3i2;
  60         char *m3p1;
  61         char m3ca1[44];
  62 } mess_3;
  63 _ASSERT_MSG_SIZE(mess_3);
  64
  65 typedef struct {
  66         int64_t m4ll1;
  67         long m4l1, m4l2, m4l3, m4l4, m4l5;
  68         uint8_t padding[28];
  69 } mess_4;
  70 _ASSERT_MSG_SIZE(mess_4);
  71
  72 typedef struct {
  73         short m5s1, m5s2;
  74         int m5i1, m5i2;
  75         long m5l1, m5l2, m5l3;
  76         uint8_t padding[32];
  77 } mess_5;
  78 _ASSERT_MSG_SIZE(mess_5);
  79
  80 typedef struct {
  81         int m7i1, m7i2, m7i3, m7i4, m7i5;
  82         char *m7p1, *m7p2;
  83         uint8_t padding[28];
  84 } mess_7;
  85 _ASSERT_MSG_SIZE(mess_7);
  86
  87 typedef struct {
  88         int m8i1, m8i2;
  89         char *m8p1, *m8p2, *m8p3, *m8p4;
  90         uint8_t padding[32];
  91 } mess_8;
  92 _ASSERT_MSG_SIZE(mess_8);
  93
  94 typedef struct {
  95         uint64_t m9ull1, m9ull2;
  96         long m9l1, m9l2, m9l3, m9l4, m9l5;
  97         short m9s1, m9s2, m9s3, m9s4;
  98         uint8_t padding[12];
  99 } mess_9;
 100 _ASSERT_MSG_SIZE(mess_9);
 101
 102 typedef struct {
 103         u64_t m10ull1;
 104         int m10i1, m10i2, m10i3, m10i4;
 105         long m10l1, m10l2, m10l3;
 106         uint8_t padding[20];
 107 } mess_10;
 108 _ASSERT_MSG_SIZE(mess_10);
 109
 110 typedef struct {
 111         int m11i1;
 112         short m11s1, m11s2, m11s3, m11s4;
 113         char *m11p1, *m11p2, *m11p3, *m11p4;
 114         uint8_t padding[28];
 115 } mess_11;
 116 _ASSERT_MSG_SIZE(mess_11);
 117
 118 typedef struct {
 119         off_t offset;
 120         void *addr;
 121         size_t len;
 122         int prot;
 123         int flags;
 124         int fd;
 125         endpoint_t forwhom;
 126         void *retaddr;
 127         u32_t padding[5];
 128 } mess_mmap;
 129 _ASSERT_MSG_SIZE(mess_mmap);
 130
 131 typedef struct {
 132         u64_t timestamp;        /* valid for every notify msg */
 133         u64_t interrupts;       /* raised interrupts; valid if from HARDWARE */
 134         sigset_t sigset;        /* raised signals; valid if from SYSTEM */
 135         uint8_t padding[24];
 136 } mess_notify;
 137 _ASSERT_MSG_SIZE(mess_notify);
 138
 139 /* For SYS_GETKSIG, _ENDKSIG, _KILL, _SIGSEND, _SIGRETURN. */
 140 typedef struct {
 141         sigset_t map;           /* used to pass signal bit map */
 142         endpoint_t endpt;       /* process number for inform */
 143         int sig;                /* signal number to send */
 144         void *sigctx;           /* pointer to signal context */
 145         uint8_t padding[28];
 146 } mess_sigcalls;
 147 _ASSERT_MSG_SIZE(mess_sigcalls);
 148
 149 typedef struct {
 150         int id;
 151         int page;
 152         int code;
 153         int value;
 154         int flags;
 155
 156         uint8_t padding[36];
 157 } mess_input_tty_event;
 158 _ASSERT_MSG_SIZE(mess_input_tty_event);
 159
 160 typedef struct {
 161         time_t acnt_queue;
 162
 163         unsigned long acnt_deqs;
 164         unsigned long acnt_ipc_sync;
 165         unsigned long acnt_ipc_async;
 166         unsigned long acnt_preempt;
 167         uint32_t acnt_cpu;
 168         uint32_t acnt_cpu_load;
 169
 170         uint8_t padding[24];
 171 } mess_krn_lsys_schedule;
 172 _ASSERT_MSG_SIZE(mess_krn_lsys_schedule);
 173
 174 typedef struct {
 175         endpoint_t endpoint;
 176         int quantum;
 177         int priority;
 178         int cpu;
 179
 180         uint8_t padding[40];
 181 } mess_lsys_krn_schedule;
 182 _ASSERT_MSG_SIZE(mess_lsys_krn_schedule);
 183
 184 typedef struct {
 185         vir_bytes name;
 186         size_t namelen;
 187         vir_bytes frame;
 188         size_t framelen;
 189         vir_bytes ps_str;
 190
 191         uint8_t padding[36];
 192 } mess_lc_pm_exec;
 193 _ASSERT_MSG_SIZE(mess_lc_pm_exec);
 194
 195 typedef struct {
 196         int status;
 197
 198         uint8_t padding[52];
 199 } mess_lc_pm_exit;
 200 _ASSERT_MSG_SIZE(mess_lc_pm_exit);
 201
 202 typedef struct {
 203         pid_t pid;
 204
 205         uint8_t padding[52];
 206 } mess_lc_pm_getsid;
 207 _ASSERT_MSG_SIZE(mess_lc_pm_getsid);
 208
 209 typedef struct {
 210         int num;
 211         vir_bytes ptr;          /* gid_t * */
 212
 213         uint8_t padding[48];
 214 } mess_lc_pm_groups;
 215 _ASSERT_MSG_SIZE(mess_lc_pm_groups);
 216
 217 typedef struct {
 218         int which;
 219         vir_bytes value;        /* const struct itimerval * */
 220         vir_bytes ovalue;       /* struct itimerval * */
 221
 222         uint8_t padding[44];
 223 } mess_lc_pm_itimer;
 224 _ASSERT_MSG_SIZE(mess_lc_pm_itimer);
 225
 226 typedef struct {
 227         vir_bytes ctx;          /* mcontext_t * */
 228
 229         uint8_t padding[52];
 230 } mess_lc_pm_mcontext;
 231 _ASSERT_MSG_SIZE(mess_lc_pm_mcontext);
 232
 233 typedef struct {
 234         int which;
 235         int who;
 236         int prio;
 237
 238         uint8_t padding[44];
 239 } mess_lc_pm_priority;
 240 _ASSERT_MSG_SIZE(mess_lc_pm_priority);
 241
 242 typedef struct {
 243         pid_t pid;
 244         int req;
 245         vir_bytes addr;
 246         long data;
 247
 248         uint8_t padding[40];
 249 } mess_lc_pm_ptrace;
 250 _ASSERT_MSG_SIZE(mess_lc_pm_ptrace);
 251
 252 typedef struct {
 253         long data;
 254
 255         uint8_t padding[52];
 256 } mess_pm_lc_ptrace;
 257 _ASSERT_MSG_SIZE(mess_pm_lc_ptrace);
 258
 259 typedef struct {
 260         int how;
 261
 262         uint8_t padding[52];
 263 } mess_lc_pm_reboot;
 264 _ASSERT_MSG_SIZE(mess_lc_pm_reboot);
 265
 266 typedef struct {
 267         endpoint_t who;
 268         vir_bytes addr;
 269
 270         uint8_t padding[48];
 271 } mess_lc_pm_rusage;
 272 _ASSERT_MSG_SIZE(mess_lc_pm_rusage);
 273
 274 typedef struct {
 275         gid_t gid;
 276
 277         uint8_t padding[52];
 278 } mess_lc_pm_setgid;
 279 _ASSERT_MSG_SIZE(mess_lc_pm_setgid);
 280
 281 typedef struct {
 282         uid_t uid;
 283
 284         uint8_t padding[52];
 285 } mess_lc_pm_setuid;
 286 _ASSERT_MSG_SIZE(mess_lc_pm_setuid);
 287
 288 typedef struct {
 289         int req;
 290         int field;
 291         size_t len;
 292         vir_bytes value;
 293
 294         uint8_t padding[40];
 295 } mess_lc_pm_sysuname;
 296 _ASSERT_MSG_SIZE(mess_lc_pm_sysuname);
 297
 298 typedef struct {
 299         pid_t pid;
 300         int nr;
 301         vir_bytes act;          /* const struct sigaction * */
 302         vir_bytes oact;         /* struct sigaction * */
 303         vir_bytes ret;          /* int (*)(void) */
 304
 305         uint8_t padding[36];
 306 } mess_lc_pm_sig;
 307 _ASSERT_MSG_SIZE(mess_lc_pm_sig);
 308
 309 typedef struct {
 310         int how;
 311         vir_bytes ctx;
 312         sigset_t set;
 313
 314         uint8_t padding[32];
 315 } mess_lc_pm_sigset;
 316 _ASSERT_MSG_SIZE(mess_lc_pm_sigset);
 317
 318 typedef struct {
 319         sigset_t set;
 320
 321         uint8_t padding[40];
 322 } mess_pm_lc_sigset;
 323 _ASSERT_MSG_SIZE(mess_pm_lc_sigset);
 324
 325 typedef struct {
 326         time_t sec;
 327
 328         clockid_t clk_id;
 329         int now;
 330         long nsec;
 331
 332         uint8_t padding[36];
 333 } mess_lc_pm_time;
 334 _ASSERT_MSG_SIZE(mess_lc_pm_time);
 335
 336 typedef struct {
 337         cp_grant_id_t grant;
 338         vir_bytes tm;                   /* struct tm * */
 339         int flags;
 340
 341         uint8_t padding[44];
 342 } mess_lc_readclock_rtcdev;
 343 _ASSERT_MSG_SIZE(mess_lc_readclock_rtcdev);
 344
 345 typedef struct {
 346         int status;
 347
 348         uint8_t padding[52];
 349 } mess_readclock_lc_rtcdev;
 350 _ASSERT_MSG_SIZE(mess_readclock_lc_rtcdev);
 351
 352 typedef struct {
 353         time_t sec;
 354
 355         long nsec;
 356
 357         uint8_t padding[44];
 358 } mess_pm_lc_time;
 359 _ASSERT_MSG_SIZE(mess_pm_lc_time);
 360
 361 typedef struct {
 362         pid_t pid;
 363         int options;
 364
 365         uint8_t padding[48];
 366 } mess_lc_pm_waitpid;
 367 _ASSERT_MSG_SIZE(mess_lc_pm_waitpid);
 368
 369 typedef struct {
 370         int status;
 371
 372         uint8_t padding[52];
 373 } mess_pm_lc_waitpid;
 374 _ASSERT_MSG_SIZE(mess_pm_lc_waitpid);
 375
 376 typedef struct {
 377         vir_bytes name;
 378         size_t len;
 379         int fd;
 380         uid_t owner;
 381         gid_t group;
 382
 383         uint8_t padding[36];
 384 } mess_lc_vfs_chown;
 385 _ASSERT_MSG_SIZE(mess_lc_vfs_chown);
 386
 387 typedef struct {
 388         int fd;
 389
 390         uint8_t padding[52];
 391 } mess_lc_vfs_close;
 392 _ASSERT_MSG_SIZE(mess_lc_vfs_close);
 393
 394 typedef struct {
 395         vir_bytes name;
 396         size_t len;
 397         int flags;
 398         mode_t mode;
 399
 400         uint8_t padding[40];
 401 } mess_lc_vfs_creat;
 402 _ASSERT_MSG_SIZE(mess_lc_vfs_creat);
 403
 404 typedef struct {
 405         int fd;
 406
 407         uint8_t padding[52];
 408 } mess_lc_vfs_fchdir;
 409 _ASSERT_MSG_SIZE(mess_lc_vfs_fchdir);
 410
 411 typedef struct {
 412         int fd;
 413         mode_t mode;
 414
 415         uint8_t padding[48];
 416 } mess_lc_vfs_fchmod;
 417 _ASSERT_MSG_SIZE(mess_lc_vfs_fchmod);
 418
 419 typedef struct {
 420         int fd;
 421         int cmd;
 422         int arg_int;
 423         vir_bytes arg_ptr;      /* struct flock * */
 424
 425         uint8_t padding[40];
 426 } mess_lc_vfs_fcntl;
 427 _ASSERT_MSG_SIZE(mess_lc_vfs_fcntl);
 428
 429 typedef struct {
 430         int fd;
 431         vir_bytes buf;          /* struct stat * */
 432
 433         uint8_t padding[48];
 434 } mess_lc_vfs_fstat;
 435 _ASSERT_MSG_SIZE(mess_lc_vfs_fstat);
 436
 437 typedef struct {
 438         int fd;
 439
 440         uint8_t padding[52];
 441 } mess_lc_vfs_fsync;
 442 _ASSERT_MSG_SIZE(mess_lc_vfs_fsync);
 443
 444 typedef struct {
 445         int32_t flags;
 446         size_t len;
 447         vir_bytes buf;          /* struct statvfs */
 448
 449         uint8_t padding[44];
 450 } mess_lc_vfs_getvfsstat;
 451 _ASSERT_MSG_SIZE(mess_lc_vfs_getvfsstat);
 452
 453 typedef struct {
 454         int fd;
 455         unsigned long req;
 456         vir_bytes arg;
 457
 458         uint8_t padding[44];
 459 } mess_lc_vfs_ioctl;
 460 _ASSERT_MSG_SIZE(mess_lc_vfs_ioctl);
 461
 462 typedef struct {
 463         vir_bytes name1;
 464         vir_bytes name2;
 465         size_t len1;
 466         size_t len2;
 467
 468         uint8_t padding[40];
 469 } mess_lc_vfs_link;
 470 _ASSERT_MSG_SIZE(mess_lc_vfs_link);
 471
 472 typedef struct {
 473         off_t offset;
 474
 475         int fd;
 476         int whence;
 477
 478         uint8_t padding[40];
 479 } mess_lc_vfs_lseek;
 480 _ASSERT_MSG_SIZE(mess_lc_vfs_lseek);
 481
 482 typedef struct {
 483         off_t offset;
 484
 485         uint8_t padding[48];
 486 } mess_vfs_lc_lseek;
 487 _ASSERT_MSG_SIZE(mess_vfs_lc_lseek);
 488
 489 typedef struct {
 490         dev_t device;
 491
 492         vir_bytes name;
 493         size_t len;
 494         mode_t mode;
 495
 496         uint8_t padding[36];
 497 } mess_lc_vfs_mknod;
 498 _ASSERT_MSG_SIZE(mess_lc_vfs_mknod);
 499
 500 typedef struct {
 501         int flags;
 502         size_t devlen;
 503         size_t pathlen;
 504         size_t typelen;
 505         size_t labellen;
 506         vir_bytes dev;
 507         vir_bytes path;
 508         vir_bytes type;
 509         vir_bytes label;
 510
 511         uint8_t padding[20];
 512 } mess_lc_vfs_mount;
 513 _ASSERT_MSG_SIZE(mess_lc_vfs_mount);
 514
 515 typedef struct {
 516         vir_bytes name;
 517         size_t len;
 518         int flags;
 519         mode_t mode;
 520         char buf[M_PATH_STRING_MAX];
 521 } mess_lc_vfs_path;
 522 _ASSERT_MSG_SIZE(mess_lc_vfs_path);
 523
 524 typedef struct {
 525         int fd0;
 526         int fd1;
 527         int flags;
 528
 529         uint8_t padding[44];
 530 } mess_lc_vfs_pipe2;
 531 _ASSERT_MSG_SIZE(mess_lc_vfs_pipe2);
 532
 533 typedef struct {
 534         vir_bytes name;         /* const char * */
 535         size_t namelen;
 536         vir_bytes buf;
 537         size_t bufsize;
 538
 539         uint8_t padding[40];
 540 } mess_lc_vfs_readlink;
 541 _ASSERT_MSG_SIZE(mess_lc_vfs_readlink);
 542
 543 typedef struct {
 544         int fd;
 545         vir_bytes buf;
 546         size_t len;
 547
 548         uint8_t padding[44];
 549 } mess_lc_vfs_readwrite;
 550 _ASSERT_MSG_SIZE(mess_lc_vfs_readwrite);
 551
 552 typedef struct {
 553         vir_bytes addr;
 554
 555         uint8_t padding[52];
 556 } mess_lc_vfs_rusage;
 557 _ASSERT_MSG_SIZE(mess_lc_vfs_rusage);
 558
 559 typedef struct {
 560         uint32_t nfds;
 561         fd_set *readfds;
 562         fd_set *writefds;
 563         fd_set *errorfds;
 564         vir_bytes timeout;      /* user-provided 'struct timeval *' */
 565
 566         uint8_t padding[36];
 567 } mess_lc_vfs_select;
 568 _ASSERT_MSG_SIZE(mess_lc_vfs_select);
 569
 570 typedef struct {
 571         size_t len;
 572         vir_bytes name;         /* const char * */
 573         vir_bytes buf;          /* struct stat * */
 574
 575         uint8_t padding[44];
 576 } mess_lc_vfs_stat;
 577 _ASSERT_MSG_SIZE(mess_lc_vfs_stat);
 578
 579 typedef struct {
 580         int fd;
 581         int flags;
 582         size_t len;
 583         vir_bytes name;
 584         vir_bytes buf;
 585
 586         uint8_t padding[36];
 587 } mess_lc_vfs_statvfs1;
 588 _ASSERT_MSG_SIZE(mess_lc_vfs_statvfs1);
 589
 590 typedef struct {
 591         off_t offset;
 592
 593         int fd;
 594         vir_bytes name;
 595         size_t len;
 596
 597         uint8_t padding[36];
 598 } mess_lc_vfs_truncate;
 599 _ASSERT_MSG_SIZE(mess_lc_vfs_truncate);
 600
 601 typedef struct {
 602         mode_t mask;
 603
 604         uint8_t padding[52];
 605 } mess_lc_vfs_umask;
 606 _ASSERT_MSG_SIZE(mess_lc_vfs_umask);
 607
 608 typedef struct {
 609         vir_bytes name;
 610         size_t namelen;
 611         vir_bytes label;
 612         size_t labellen;
 613
 614         uint8_t padding[40];
 615 } mess_lc_vfs_umount;
 616 _ASSERT_MSG_SIZE(mess_lc_vfs_umount);
 617
 618 typedef struct {
 619         vir_bytes addr;
 620
 621         uint8_t padding[52];
 622 } mess_lc_vm_rusage;
 623 _ASSERT_MSG_SIZE(mess_lc_vm_rusage);
 624
 625 typedef struct {
 626         endpoint_t endpt;
 627         vir_bytes ptr;          /* struct exec_info * */
 628
 629         uint8_t padding[48];
 630 } mess_lexec_pm_exec_new;
 631 _ASSERT_MSG_SIZE(mess_lexec_pm_exec_new);
 632
 633 typedef struct {
 634         int suid;
 635
 636         uint8_t padding[52];
 637 } mess_pm_lexec_exec_new;
 638 _ASSERT_MSG_SIZE(mess_pm_lexec_exec_new);
 639
 640 typedef struct {
 641         cp_grant_id_t grant;
 642
 643         uint8_t padding[52];
 644 } mess_li2cdriver_i2c_busc_i2c_exec;
 645 _ASSERT_MSG_SIZE(mess_li2cdriver_i2c_busc_i2c_exec);
 646
 647 typedef struct {
 648         uint8_t padding[56];
 649 } mess_i2c_li2cdriver_busc_i2c_exec;
 650 _ASSERT_MSG_SIZE(mess_i2c_li2cdriver_busc_i2c_exec);
 651
 652 typedef struct {
 653         uint16_t addr; /* FIXME: strictly speaking this is an i2c_addr_t, but
 654                           to get it I would need to include
 655                           sys/dev/i2c/i2c_io.h, which I am not sure is a good
 656                           idea to have everywhere. */
 657
 658         uint8_t padding[54];
 659 } mess_li2cdriver_i2c_busc_i2c_reserve;
 660 _ASSERT_MSG_SIZE(mess_li2cdriver_i2c_busc_i2c_reserve);
 661
 662 typedef struct {
 663         uint8_t padding[56];
 664 } mess_i2c_li2cdriver_busc_i2c_reserve;
 665 _ASSERT_MSG_SIZE(mess_i2c_li2cdriver_busc_i2c_reserve);
 666
 667 typedef struct {
 668         int kbd_id;
 669         int mouse_id;
 670         int rsvd1_id;
 671         int rsvd2_id;
 672
 673         uint8_t padding[40];
 674 } mess_input_linputdriver_input_conf;
 675 _ASSERT_MSG_SIZE(mess_input_linputdriver_input_conf);
 676
 677 typedef struct {
 678         uint32_t led_mask;
 679
 680         uint8_t padding[52];
 681 } mess_input_linputdriver_setleds;
 682 _ASSERT_MSG_SIZE(mess_input_linputdriver_setleds);
 683
 684 typedef struct {
 685         int id;
 686         int page;
 687         int code;
 688         int value;
 689         int flags;
 690
 691         uint8_t padding[36];
 692 } mess_linputdriver_input_event;
 693 _ASSERT_MSG_SIZE(mess_linputdriver_input_event);
 694
 695 typedef struct {
 696         cp_grant_id_t gid;
 697         size_t size;
 698
 699         uint8_t padding[48];
 700 } mess_lsys_fi_ctl;
 701 _ASSERT_MSG_SIZE(mess_lsys_fi_ctl);
 702
 703 typedef struct {
 704         int status;
 705
 706         uint8_t padding[52];
 707 } mess_lsys_fi_reply;
 708 _ASSERT_MSG_SIZE(mess_lsys_fi_reply);
 709
 710 typedef struct {
 711         int what;
 712         vir_bytes where;
 713         size_t size;
 714
 715         uint8_t padding[44];
 716 } mess_lsys_getsysinfo;
 717 _ASSERT_MSG_SIZE(mess_lsys_getsysinfo);
 718
 719 typedef struct {
 720         uint32_t flags;
 721         endpoint_t endpoint;
 722         int priority;
 723         int quantum;
 724         int cpu;
 725
 726         uint8_t padding[36];
 727 } mess_lsys_krn_schedctl;
 728 _ASSERT_MSG_SIZE(mess_lsys_krn_schedctl);
 729
 730 typedef struct {
 731         int how;
 732
 733         uint8_t padding[52];
 734 } mess_lsys_krn_sys_abort;
 735 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_abort);
 736
 737 typedef struct {
 738         endpoint_t endpt;
 739
 740         uint8_t padding[52];
 741 } mess_lsys_krn_sys_clear;
 742 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_clear);
 743
 744 typedef struct {
 745         endpoint_t src_endpt;
 746         vir_bytes src_addr;
 747         endpoint_t dst_endpt;
 748         vir_bytes dst_addr;
 749         phys_bytes nr_bytes;
 750         int flags;
 751
 752         uint8_t padding[32];
 753 } mess_lsys_krn_sys_copy;
 754 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_copy);
 755
 756 typedef struct {
 757         endpoint_t endpt;
 758         vir_bytes ip;
 759         vir_bytes stack;
 760         vir_bytes name;
 761         vir_bytes ps_str;
 762
 763         uint8_t padding[36];
 764 } mess_lsys_krn_sys_exec;
 765 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_exec);
 766
 767 typedef struct {
 768         endpoint_t endpt;
 769         endpoint_t slot;
 770         uint32_t flags;
 771
 772         uint8_t padding[44];
 773 } mess_lsys_krn_sys_fork;
 774 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_fork);
 775
 776 typedef struct {
 777         endpoint_t endpt;
 778         vir_bytes msgaddr;
 779
 780         uint8_t padding[48];
 781 } mess_krn_lsys_sys_fork;
 782 _ASSERT_MSG_SIZE(mess_krn_lsys_sys_fork);
 783
 784 typedef struct {
 785         int request;
 786         endpoint_t endpt;
 787         vir_bytes val_ptr;
 788         int val_len;
 789         vir_bytes val_ptr2;
 790         int val_len2_e;
 791
 792         uint8_t padding[32];
 793 } mess_lsys_krn_sys_getinfo;
 794 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_getinfo);
 795
 796 typedef struct {
 797         endpoint_t endpt;
 798         vir_bytes ctx_ptr;
 799
 800         uint8_t padding[48];
 801 } mess_lsys_krn_sys_getmcontext;
 802 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_getmcontext);
 803
 804 typedef struct {
 805         endpoint_t endpt;
 806         int privflags;
 807         char name[48];
 808
 809 } mess_krn_lsys_sys_getwhoami;
 810 _ASSERT_MSG_SIZE(mess_krn_lsys_sys_getwhoami);
 811
 812 typedef struct {
 813         endpoint_t endpt;
 814
 815         uint8_t padding[52];
 816 } mess_lsys_krn_sys_iopenable;
 817 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_iopenable);
 818
 819 typedef struct {
 820         int request;
 821         int vector;
 822         int policy;
 823         int hook_id;
 824
 825         uint8_t padding[40];
 826 } mess_lsys_krn_sys_irqctl;
 827 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_irqctl);
 828
 829 typedef struct {
 830         int hook_id;
 831
 832         uint8_t padding[52];
 833 } mess_krn_lsys_sys_irqctl;
 834 _ASSERT_MSG_SIZE(mess_krn_lsys_sys_irqctl);
 835
 836 typedef struct {
 837         int request;
 838         endpoint_t endpt;
 839         vir_bytes arg_ptr;
 840         phys_bytes phys_start;
 841         phys_bytes phys_len;
 842
 843         uint8_t padding[36];
 844 } mess_lsys_krn_sys_privctl;
 845 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_privctl);
 846
 847 typedef struct {
 848         int request;
 849         long int port;
 850         endpoint_t vec_endpt;
 851         phys_bytes vec_addr;
 852         vir_bytes vec_size;
 853         vir_bytes offset;
 854
 855         uint8_t padding[32];
 856 } mess_lsys_krn_sys_sdevio;
 857 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_sdevio);
 858
 859 typedef struct {
 860         clock_t exp_time;
 861         clock_t time_left;
 862         int abs_time;
 863
 864         uint8_t padding[44];
 865 } mess_lsys_krn_sys_setalarm;
 866 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_setalarm);
 867
 868 typedef struct {
 869         vir_bytes addr;                 /* cp_grant_t * */
 870         int size;
 871
 872         uint8_t padding[48];
 873 } mess_lsys_krn_sys_setgrant;
 874 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_setgrant);
 875
 876 typedef struct {
 877         endpoint_t endpt;
 878         vir_bytes ctx_ptr;
 879
 880         uint8_t padding[48];
 881 } mess_lsys_krn_sys_setmcontext;
 882 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_setmcontext);
 883
 884 typedef struct {
 885         int request;
 886
 887         uint8_t padding[52];
 888 } mess_lsys_krn_sys_statectl;
 889 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_statectl);
 890
 891 typedef struct {
 892         time_t boot_time;
 893
 894         uint8_t padding[48];
 895 } mess_lsys_krn_sys_stime;
 896 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_stime);
 897
 898 typedef struct {
 899         time_t sec;             /* time in seconds since 1970 */
 900         long int nsec;
 901         int now;                /* non-zero for immediate, 0 for adjtime */
 902         clockid_t clock_id;
 903
 904         uint8_t padding[36];
 905 } mess_lsys_krn_sys_settime;
 906 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_settime);
 907
 908 typedef struct {
 909         endpoint_t endpt;
 910
 911         uint8_t padding[52];
 912 } mess_lsys_krn_sys_times;
 913 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_times);
 914
 915 typedef struct {
 916         clock_t real_ticks;
 917         clock_t boot_ticks;
 918         clock_t boot_time;
 919         clock_t user_time;
 920         clock_t system_time;
 921
 922         uint8_t padding[36];
 923 } mess_krn_lsys_sys_times;
 924 _ASSERT_MSG_SIZE(mess_krn_lsys_sys_times);
 925
 926 typedef struct {
 927         int request;
 928         endpoint_t endpt;
 929         vir_bytes address;
 930         long int data;
 931
 932         uint8_t padding[40];
 933 } mess_lsys_krn_sys_trace;
 934 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_trace);
 935
 936 typedef struct {
 937         long int data;
 938
 939         uint8_t padding[52];
 940 } mess_krn_lsys_sys_trace;
 941 _ASSERT_MSG_SIZE(mess_krn_lsys_sys_trace);
 942
 943 typedef struct {
 944         endpoint_t src_endpt;
 945         int segment;
 946         vir_bytes src_addr;
 947         endpoint_t dst_endpt;
 948         int nr_bytes;
 949
 950         uint8_t padding[36];
 951 } mess_lsys_krn_sys_umap;
 952 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_umap);
 953
 954 typedef struct {
 955         phys_bytes dst_addr;
 956
 957         uint8_t padding[52];
 958 } mess_krn_lsys_sys_umap;
 959 _ASSERT_MSG_SIZE(mess_krn_lsys_sys_umap);
 960
 961 typedef struct {
 962         int request;
 963         int vec_size;
 964         vir_bytes vec_addr;             /* pv{b,w,l}_pair_t * */
 965
 966         uint8_t padding[44];
 967 } mess_lsys_krn_sys_vdevio;
 968 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_vdevio);
 969
 970 typedef struct {
 971         endpoint_t endpt;
 972         vir_bytes vaddr;                        /* struct vumap_vir * */
 973         int vcount;
 974         vir_bytes paddr;                        /* struct vumap_phys * */
 975         int pmax;
 976         int access;
 977         size_t offset;
 978
 979         uint8_t padding[28];
 980 } mess_lsys_krn_sys_vumap;
 981 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_vumap);
 982
 983 typedef struct {
 984         int pcount;
 985
 986         uint8_t padding[52];
 987 } mess_krn_lsys_sys_vumap;
 988 _ASSERT_MSG_SIZE(mess_krn_lsys_sys_vumap);
 989
 990 typedef struct {
 991         phys_bytes base;
 992         phys_bytes count;
 993         unsigned long pattern;
 994         endpoint_t process;
 995
 996         uint8_t padding[40];
 997 } mess_lsys_krn_sys_memset;
 998 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_memset);
 999
1000 typedef struct {
1001         int devind;
1002         int port;
1003
1004         uint8_t padding[48];
1005 } mess_lsys_pci_busc_get_bar;
1006 _ASSERT_MSG_SIZE(mess_lsys_pci_busc_get_bar);
1007
1008 typedef struct {
1009         int base;
1010         size_t size;
1011         uint32_t flags;
1012
1013         uint8_t padding[44];
1014 } mess_pci_lsys_busc_get_bar;
1015 _ASSERT_MSG_SIZE(mess_pci_lsys_busc_get_bar);
1016
1017 typedef struct {
1018         endpoint_t endpt;
1019
1020         uint8_t padding[52];
1021 } mess_lsys_pm_getepinfo;
1022 _ASSERT_MSG_SIZE(mess_lsys_pm_getepinfo);
1023
1024 typedef struct {
1025         uid_t uid;
1026         gid_t gid;
1027
1028         uint8_t padding[48];
1029 } mess_pm_lsys_getepinfo;
1030 _ASSERT_MSG_SIZE(mess_pm_lsys_getepinfo);
1031
1032 typedef struct {
1033         pid_t pid;
1034
1035         uint8_t padding[52];
1036 } mess_lsys_pm_getprocnr;
1037 _ASSERT_MSG_SIZE(mess_lsys_pm_getprocnr);
1038
1039 typedef struct {
1040         endpoint_t endpt;
1041
1042         uint8_t padding[52];
1043 } mess_pm_lsys_getprocnr;
1044 _ASSERT_MSG_SIZE(mess_pm_lsys_getprocnr);
1045
1046 typedef struct {
1047         uid_t uid;
1048         gid_t gid;
1049
1050         uint8_t padding[48];
1051 } mess_lsys_pm_srv_fork;
1052 _ASSERT_MSG_SIZE(mess_lsys_pm_srv_fork);
1053
1054 typedef struct {
1055         endpoint_t endpoint;
1056         endpoint_t parent;
1057         int maxprio;
1058         int quantum;
1059
1060         uint8_t padding[40];
1061 } mess_lsys_sched_scheduling_start;
1062 _ASSERT_MSG_SIZE(mess_lsys_sched_scheduling_start);
1063
1064 typedef struct {
1065         endpoint_t scheduler;
1066
1067         uint8_t padding[52];
1068 } mess_sched_lsys_scheduling_start;
1069 _ASSERT_MSG_SIZE(mess_sched_lsys_scheduling_start);
1070
1071 typedef struct {
1072         endpoint_t endpoint;
1073
1074         uint8_t padding[52];
1075 } mess_lsys_sched_scheduling_stop;
1076 _ASSERT_MSG_SIZE(mess_lsys_sched_scheduling_stop);
1077
1078 typedef struct {
1079         int request;
1080         vir_bytes arg;
1081
1082         uint8_t padding[48];
1083 } mess_lsys_svrctl;
1084 _ASSERT_MSG_SIZE(mess_lsys_svrctl);
1085
1086 typedef struct {
1087         int request;
1088         int fkeys;
1089         int sfkeys;
1090
1091         uint8_t padding[44];
1092 } mess_lsys_tty_fkey_ctl;
1093 _ASSERT_MSG_SIZE(mess_lsys_tty_fkey_ctl);
1094
1095 typedef struct {
1096         int fkeys;
1097         int sfkeys;
1098
1099         uint8_t padding[48];
1100 } mess_tty_lsys_fkey_ctl;
1101 _ASSERT_MSG_SIZE(mess_tty_lsys_fkey_ctl);
1102
1103 typedef struct {
1104         endpoint_t endpt;
1105         cp_grant_id_t grant;
1106         size_t count;
1107
1108         uint8_t padding[44];
1109 } mess_lsys_vfs_checkperms;
1110 _ASSERT_MSG_SIZE(mess_lsys_vfs_checkperms);
1111
1112 typedef struct {
1113         endpoint_t endpt;
1114         int fd;
1115         int what;
1116
1117         uint8_t padding[44];
1118 } mess_lsys_vfs_copyfd;
1119 _ASSERT_MSG_SIZE(mess_lsys_vfs_copyfd);
1120
1121 typedef struct {
1122         devmajor_t major;
1123         size_t labellen;
1124         vir_bytes label;
1125
1126         uint8_t padding[44];
1127 } mess_lsys_vfs_mapdriver;
1128 _ASSERT_MSG_SIZE(mess_lsys_vfs_mapdriver);
1129
1130 typedef struct {
1131         int mode;
1132
1133         uint8_t padding[52];
1134 } mess_net_netdrv_dl_conf;
1135 _ASSERT_MSG_SIZE(mess_net_netdrv_dl_conf);
1136
1137 typedef struct {
1138         int stat;
1139         uint8_t hw_addr[6];
1140
1141         uint8_t padding[46];
1142 } mess_netdrv_net_dl_conf;
1143 _ASSERT_MSG_SIZE(mess_netdrv_net_dl_conf);
1144
1145 typedef struct {
1146         cp_grant_id_t grant;
1147
1148         uint8_t padding[52];
1149 } mess_net_netdrv_dl_getstat_s;
1150 _ASSERT_MSG_SIZE(mess_net_netdrv_dl_getstat_s);
1151
1152 typedef struct {
1153         cp_grant_id_t grant;
1154         int count;
1155
1156         uint8_t padding[48];
1157 } mess_net_netdrv_dl_readv_s;
1158 _ASSERT_MSG_SIZE(mess_net_netdrv_dl_readv_s);
1159
1160 typedef struct {
1161         cp_grant_id_t grant;
1162         int count;
1163
1164         uint8_t padding[48];
1165 } mess_net_netdrv_dl_writev_s;
1166 _ASSERT_MSG_SIZE(mess_net_netdrv_dl_writev_s);
1167
1168 typedef struct {
1169         int count;
1170         uint32_t flags;
1171
1172         uint8_t padding[48];
1173 } mess_netdrv_net_dl_task;
1174 _ASSERT_MSG_SIZE(mess_netdrv_net_dl_task);
1175
1176 typedef struct {
1177         uid_t egid;
1178
1179         uint8_t padding[52];
1180 } mess_pm_lc_getgid;
1181 _ASSERT_MSG_SIZE(mess_pm_lc_getgid);
1182
1183 typedef struct {
1184         pid_t parent_pid;
1185
1186         uint8_t padding[52];
1187 } mess_pm_lc_getpid;
1188 _ASSERT_MSG_SIZE(mess_pm_lc_getpid);
1189
1190 typedef struct {
1191         uid_t euid;
1192
1193         uint8_t padding[52];
1194 } mess_pm_lc_getuid;
1195 _ASSERT_MSG_SIZE(mess_pm_lc_getuid);
1196
1197 typedef struct {
1198         endpoint_t endpoint;
1199         uint32_t maxprio;
1200
1201         uint8_t padding[48];
1202 } mess_pm_sched_scheduling_set_nice;
1203 _ASSERT_MSG_SIZE(mess_pm_sched_scheduling_set_nice);
1204
1205 typedef struct {
1206         endpoint_t endpt;
1207         int result;
1208         vir_bytes pc;
1209         vir_bytes ps_str;
1210
1211         uint8_t padding[40];
1212 } mess_rs_pm_exec_restart;
1213 _ASSERT_MSG_SIZE(mess_rs_pm_exec_restart);
1214
1215 typedef struct {
1216         pid_t pid;
1217         int nr;
1218
1219         uint8_t padding[48];
1220 } mess_rs_pm_srv_kill;
1221 _ASSERT_MSG_SIZE(mess_rs_pm_srv_kill);
1222
1223 typedef struct {
1224         dev_t device;
1225         off_t seek_pos;
1226
1227         cp_grant_id_t grant;
1228         size_t nbytes;
1229
1230         uint8_t data[32];
1231 } mess_vfs_fs_breadwrite;
1232 _ASSERT_MSG_SIZE(mess_vfs_fs_breadwrite);
1233
1234 typedef struct {
1235         off_t seek_pos;
1236
1237         size_t nbytes;
1238
1239         uint8_t data[44];
1240 } mess_fs_vfs_breadwrite;
1241 _ASSERT_MSG_SIZE(mess_fs_vfs_breadwrite);
1242
1243 typedef struct {
1244         ino_t inode;
1245
1246         mode_t mode;
1247
1248         uint8_t data[44];
1249 } mess_vfs_fs_chmod;
1250 _ASSERT_MSG_SIZE(mess_vfs_fs_chmod);
1251
1252 typedef struct {
1253         mode_t mode;
1254
1255         uint8_t data[52];
1256 } mess_fs_vfs_chmod;
1257 _ASSERT_MSG_SIZE(mess_fs_vfs_chmod);
1258
1259 typedef struct {
1260         ino_t inode;
1261
1262         uid_t uid;
1263         gid_t gid;
1264
1265         uint8_t data[40];
1266 } mess_vfs_fs_chown;
1267 _ASSERT_MSG_SIZE(mess_vfs_fs_chown);
1268
1269 typedef struct {
1270         mode_t mode;
1271
1272         uint8_t data[52];
1273 } mess_fs_vfs_chown;
1274 _ASSERT_MSG_SIZE(mess_fs_vfs_chown);
1275
1276 typedef struct {
1277         ino_t inode;
1278
1279         mode_t mode;
1280         uid_t uid;
1281         gid_t gid;
1282         cp_grant_id_t grant;
1283         size_t path_len;
1284
1285         uint8_t data[28];
1286 } mess_vfs_fs_create;
1287 _ASSERT_MSG_SIZE(mess_vfs_fs_create);
1288
1289 typedef struct {
1290         off_t file_size;
1291         ino_t inode;
1292
1293         mode_t mode;
1294         uid_t uid;
1295         gid_t gid;
1296
1297         uint8_t data[28];
1298 } mess_fs_vfs_create;
1299 _ASSERT_MSG_SIZE(mess_fs_vfs_create);
1300
1301 typedef struct {
1302         dev_t device;
1303
1304         uint8_t data[48];
1305 } mess_vfs_fs_flush;
1306 _ASSERT_MSG_SIZE(mess_vfs_fs_flush);
1307
1308 typedef struct {
1309         ino_t inode;
1310         off_t trc_start;
1311         off_t trc_end;
1312
1313         uint8_t data[32];
1314 } mess_vfs_fs_ftrunc;
1315 _ASSERT_MSG_SIZE(mess_vfs_fs_ftrunc);
1316
1317 typedef struct {
1318         ino_t inode;
1319         off_t seek_pos;
1320
1321         cp_grant_id_t grant;
1322         size_t mem_size;
1323
1324         uint8_t data[32];
1325 } mess_vfs_fs_getdents;
1326 _ASSERT_MSG_SIZE(mess_vfs_fs_getdents);
1327
1328 typedef struct {
1329         off_t seek_pos;
1330
1331         size_t nbytes;
1332
1333         uint8_t data[44];
1334 } mess_fs_vfs_getdents;
1335 _ASSERT_MSG_SIZE(mess_fs_vfs_getdents);
1336
1337 typedef struct {
1338         ino_t inode;
1339
1340         uint8_t data[48];
1341 } mess_vfs_fs_inhibread;
1342 _ASSERT_MSG_SIZE(mess_vfs_fs_inhibread);
1343
1344 typedef struct {
1345         ino_t inode;
1346         ino_t dir_ino;
1347
1348         cp_grant_id_t grant;
1349         size_t path_len;
1350
1351         uint8_t data[32];
1352 } mess_vfs_fs_link;
1353 _ASSERT_MSG_SIZE(mess_vfs_fs_link);
1354
1355 typedef struct {
1356         ino_t dir_ino;
1357         ino_t root_ino;
1358
1359         uint32_t flags;
1360         size_t path_len;
1361         size_t path_size;
1362         size_t ucred_size;
1363         cp_grant_id_t grant_path;
1364         cp_grant_id_t grant_ucred;
1365         uid_t uid;
1366         gid_t gid;
1367
1368         uint8_t data[8];
1369 } mess_vfs_fs_lookup;
1370 _ASSERT_MSG_SIZE(mess_vfs_fs_lookup);
1371
1372 typedef struct {
1373         off_t offset;
1374         off_t file_size;
1375         dev_t device;
1376         ino_t inode;
1377
1378         mode_t mode;
1379         uid_t uid;
1380         gid_t gid;
1381
1382         uint16_t symloop;
1383
1384         uint8_t data[10];
1385 } mess_fs_vfs_lookup;
1386 _ASSERT_MSG_SIZE(mess_fs_vfs_lookup);
1387
1388 typedef struct {
1389         ino_t inode;
1390
1391         mode_t mode;
1392         uid_t uid;
1393         gid_t gid;
1394         cp_grant_id_t grant;
1395         size_t path_len;
1396
1397         uint8_t data[28];
1398 } mess_vfs_fs_mkdir;
1399 _ASSERT_MSG_SIZE(mess_vfs_fs_mkdir);
1400
1401 typedef struct {
1402         dev_t device;
1403         ino_t inode;
1404
1405         mode_t mode;
1406         uid_t uid;
1407         gid_t gid;
1408         cp_grant_id_t grant;
1409         size_t path_len;
1410
1411         uint8_t data[20];
1412 } mess_vfs_fs_mknod;
1413 _ASSERT_MSG_SIZE(mess_vfs_fs_mknod);
1414
1415 typedef struct {
1416         ino_t inode;
1417
1418         uint8_t data[48];
1419 } mess_vfs_fs_mountpoint;
1420 _ASSERT_MSG_SIZE(mess_vfs_fs_mountpoint);
1421
1422 typedef struct {
1423         dev_t device;
1424
1425         cp_grant_id_t grant;
1426         size_t path_len;
1427
1428         uint8_t data[40];
1429 } mess_vfs_fs_new_driver;
1430 _ASSERT_MSG_SIZE(mess_vfs_fs_new_driver);
1431
1432 typedef struct {
1433         dev_t device;
1434
1435         mode_t mode;
1436         uid_t uid;
1437         gid_t gid;
1438
1439         uint8_t data[36];
1440 } mess_vfs_fs_newnode;
1441 _ASSERT_MSG_SIZE(mess_vfs_fs_newnode);
1442
1443 typedef struct {
1444         off_t file_size;
1445         dev_t device;
1446         ino_t inode;
1447
1448         mode_t mode;
1449         uid_t uid;
1450         gid_t gid;
1451
1452         uint8_t data[20];
1453 } mess_fs_vfs_newnode;
1454 _ASSERT_MSG_SIZE(mess_fs_vfs_newnode);
1455
1456 typedef struct {
1457         uint64_t count;
1458         ino_t inode;
1459
1460         uint8_t data[40];
1461 } mess_vfs_fs_putnode;
1462 _ASSERT_MSG_SIZE(mess_vfs_fs_putnode);
1463
1464 typedef struct {
1465         ino_t inode;
1466
1467         cp_grant_id_t grant;
1468         size_t mem_size;
1469
1470         uint8_t data[40];
1471 } mess_vfs_fs_rdlink;
1472 _ASSERT_MSG_SIZE(mess_vfs_fs_rdlink);
1473
1474 typedef struct {
1475         size_t nbytes;
1476
1477         uint8_t data[52];
1478 } mess_fs_vfs_rdlink;
1479 _ASSERT_MSG_SIZE(mess_fs_vfs_rdlink);
1480
1481 typedef struct {
1482         dev_t device;
1483
1484         uint32_t flags;
1485         size_t path_len;
1486         cp_grant_id_t grant;
1487
1488         uint8_t data[36];
1489 } mess_vfs_fs_readsuper;
1490 _ASSERT_MSG_SIZE(mess_vfs_fs_readsuper);
1491
1492 typedef struct {
1493         off_t file_size;
1494         dev_t device;
1495         ino_t inode;
1496
1497         uint32_t flags;
1498         mode_t mode;
1499         uid_t uid;
1500         gid_t gid;
1501
1502         uint16_t con_reqs;
1503
1504         uint8_t data[14];
1505 } mess_fs_vfs_readsuper;
1506 _ASSERT_MSG_SIZE(mess_fs_vfs_readsuper);
1507
1508 typedef struct {
1509         ino_t inode;
1510         off_t seek_pos;
1511
1512         cp_grant_id_t grant;
1513         size_t nbytes;
1514
1515         uint8_t data[32];
1516 } mess_vfs_fs_readwrite;
1517 _ASSERT_MSG_SIZE(mess_vfs_fs_readwrite);
1518
1519 typedef struct {
1520         off_t seek_pos;
1521
1522         size_t nbytes;
1523
1524         uint8_t data[44];
1525 } mess_fs_vfs_readwrite;
1526 _ASSERT_MSG_SIZE(mess_fs_vfs_readwrite);
1527
1528 typedef struct {
1529         ino_t dir_old;
1530         ino_t dir_new;
1531
1532         size_t len_old;
1533         size_t len_new;
1534         cp_grant_id_t grant_old;
1535         cp_grant_id_t grant_new;
1536
1537         uint8_t data[24];
1538 } mess_vfs_fs_rename;
1539 _ASSERT_MSG_SIZE(mess_vfs_fs_rename);
1540
1541 typedef struct {
1542         ino_t inode;
1543
1544         size_t path_len;
1545         size_t mem_size;
1546         cp_grant_id_t grant_path;
1547         cp_grant_id_t grant_target;
1548         uid_t uid;
1549         gid_t gid;
1550
1551         uint8_t data[24];
1552 } mess_vfs_fs_slink;
1553 _ASSERT_MSG_SIZE(mess_vfs_fs_slink);
1554
1555 typedef struct {
1556         ino_t inode;
1557
1558         cp_grant_id_t grant;
1559
1560         uint8_t data[44];
1561 } mess_vfs_fs_stat;
1562 _ASSERT_MSG_SIZE(mess_vfs_fs_stat);
1563
1564 typedef struct {
1565         cp_grant_id_t grant;
1566
1567         uint8_t data[52];
1568 } mess_vfs_fs_statvfs;
1569 _ASSERT_MSG_SIZE(mess_vfs_fs_statvfs);
1570
1571 typedef struct {
1572         ino_t inode;
1573
1574         cp_grant_id_t grant;
1575         size_t path_len;
1576
1577         uint8_t data[40];
1578 } mess_vfs_fs_unlink;
1579 _ASSERT_MSG_SIZE(mess_vfs_fs_unlink);
1580
1581 typedef struct {
1582         ino_t inode;
1583         time_t actime;
1584         time_t modtime;
1585
1586         uint32_t acnsec;
1587         uint32_t modnsec;
1588
1589         uint8_t data[24];
1590 } mess_vfs_fs_utime;
1591 _ASSERT_MSG_SIZE(mess_vfs_fs_utime);
1592
1593 typedef struct {
1594         endpoint_t id;
1595         devminor_t minor;
1596
1597         uint8_t padding[48];
1598 } mess_vfs_lchardriver_cancel;
1599 _ASSERT_MSG_SIZE(mess_vfs_lchardriver_cancel);
1600
1601 typedef struct {
1602         endpoint_t id;
1603         endpoint_t user;
1604         devminor_t minor;
1605         int access;
1606
1607         uint8_t padding[40];
1608 } mess_vfs_lchardriver_openclose;
1609 _ASSERT_MSG_SIZE(mess_vfs_lchardriver_openclose);
1610
1611 typedef struct {
1612         off_t pos;
1613         cp_grant_id_t grant;
1614         size_t count;
1615         int request;
1616         int flags;
1617         endpoint_t id;
1618         endpoint_t user;
1619         devminor_t minor;
1620
1621         uint8_t padding[20];
1622 } mess_vfs_lchardriver_readwrite;
1623 _ASSERT_MSG_SIZE(mess_vfs_lchardriver_readwrite);
1624
1625 typedef struct {
1626         devminor_t minor;
1627         int ops;
1628
1629         uint8_t padding[48];
1630 } mess_vfs_lchardriver_select;
1631 _ASSERT_MSG_SIZE(mess_vfs_lchardriver_select);
1632
1633 typedef struct {
1634         int status;
1635         uint32_t id;            /* should be cdev_id_t */
1636
1637         uint8_t padding[48];
1638 } mess_lchardriver_vfs_reply;
1639 _ASSERT_MSG_SIZE(mess_lchardriver_vfs_reply);
1640
1641 typedef struct {
1642         int status;
1643         int32_t minor;
1644
1645         uint8_t padding[48];
1646 } mess_lchardriver_vfs_sel1;
1647 _ASSERT_MSG_SIZE(mess_lchardriver_vfs_sel1);
1648
1649 typedef struct {
1650         int status;
1651         int32_t minor;
1652
1653         uint8_t padding[48];
1654 } mess_lchardriver_vfs_sel2;
1655 _ASSERT_MSG_SIZE(mess_lchardriver_vfs_sel2);
1656
1657 typedef struct {
1658         time_t atime;
1659         time_t mtime;
1660         long ansec;
1661         long mnsec;
1662         size_t len;
1663         char *name;
1664         int fd;
1665         int flags;
1666         uint8_t padding[16];
1667 } mess_vfs_utimens;
1668 _ASSERT_MSG_SIZE(mess_vfs_utimens);
1669
1670 typedef struct {
1671         off_t offset;
1672         dev_t dev;
1673         ino_t ino;
1674         endpoint_t who;
1675         u32_t vaddr;
1676         u32_t len;
1677         u32_t flags;
1678         u32_t fd;
1679         u16_t clearend;
1680         uint8_t padding[8];
1681 } mess_vm_vfs_mmap;
1682 _ASSERT_MSG_SIZE(mess_vm_vfs_mmap);
1683
1684 typedef struct {
1685         dev_t dev;      /* 64bits long. */
1686         off_t dev_offset;
1687         off_t ino_offset;
1688         ino_t ino;
1689         void *block;
1690         u32_t *flags_ptr;
1691         u8_t pages;
1692         u8_t flags;
1693         uint8_t padding[12];
1694 } mess_vmmcp;
1695 _ASSERT_MSG_SIZE(mess_vmmcp);
1696
1697 typedef struct {
1698         void *addr;
1699         u8_t flags;
1700         uint8_t padding[51];
1701 } mess_vmmcp_reply;
1702 _ASSERT_MSG_SIZE(mess_vmmcp_reply);
1703
1704 typedef struct {
1705         endpoint_t      destination;
1706         endpoint_t      source;
1707         void            *dest_addr;
1708         void            *src_addr;
1709         size_t          size;
1710         void            *ret_addr;
1711         uint8_t         padding[32];
1712 } mess_lsys_vm_vmremap;
1713 _ASSERT_MSG_SIZE(mess_lsys_vm_vmremap);
1714
1715 typedef struct {
1716         endpoint_t      forwhom;
1717         void            *addr;
1718         uint8_t         padding[48];
1719 } mess_lc_vm_shm_unmap;
1720 _ASSERT_MSG_SIZE(mess_lc_vm_shm_unmap);
1721
1722 typedef struct {
1723         endpoint_t      endpt;
1724         void            *addr;
1725         void            *ret_addr;
1726         uint8_t         padding[44];
1727 } mess_lc_vm_getphys;
1728 _ASSERT_MSG_SIZE(mess_lc_vm_getphys);
1729
1730 typedef struct {
1731         endpoint_t      endpt;
1732         void            *addr;
1733         int             retc;
1734         uint8_t         padding[44];
1735 } mess_lsys_vm_getref;
1736 _ASSERT_MSG_SIZE(mess_lsys_vm_getref);
1737
1738 typedef struct {
1739         endpoint_t      ret_pt;
1740         int             is_more;
1741         uint8_t         padding[48];
1742 } mess_lsys_vm_query_exit;
1743 _ASSERT_MSG_SIZE(mess_lsys_vm_query_exit);
1744
1745 typedef struct {
1746         int             what;
1747         endpoint_t      ep;
1748         int             count;
1749         void            *ptr;
1750         vir_bytes       next;
1751         uint8_t         padding[36];
1752 } mess_lsys_vm_info;
1753 _ASSERT_MSG_SIZE(mess_lsys_vm_info);
1754
1755 typedef struct {
1756         endpoint_t src;
1757         endpoint_t dst;
1758         uint8_t         padding[48];
1759 } mess_lsys_vm_update;
1760 _ASSERT_MSG_SIZE(mess_lsys_vm_update);
1761
1762 typedef struct {
1763         endpoint_t      ep;
1764         uint8_t         padding[52];
1765 } mess_lsys_vm_watch_exit;
1766 _ASSERT_MSG_SIZE(mess_lsys_vm_watch_exit);
1767
1768 typedef struct {
1769         key_t           key;
1770         size_t          size;
1771         int             flag;
1772         int             retid;
1773         uint8_t         padding[40];
1774 } mess_lc_ipc_shmget;
1775 _ASSERT_MSG_SIZE(mess_lc_ipc_shmget);
1776
1777 typedef struct {
1778         endpoint_t m_source;            /* who sent the message */
1779         int m_type;                     /* what kind of message is it */
1780         union {
1781                 mess_u8                 m_u8;
1782                 mess_u16                m_u16;
1783                 mess_u32                m_u32;
1784                 mess_u64                m_u64;
1785
1786                 mess_1                  m_m1;
1787                 mess_2                  m_m2;
1788                 mess_3                  m_m3;
1789                 mess_4                  m_m4;
1790                 mess_5                  m_m5;
1791                 mess_7                  m_m7;
1792                 mess_8                  m_m8;
1793                 mess_9                  m_m9;
1794                 mess_10                 m_m10;
1795                 mess_11                 m_m11;
1796                 mess_mmap               m_mmap;
1797                 mess_notify             m_notify;
1798                 mess_sigcalls           m_sigcalls;
1799
1800                 mess_input_tty_event    m_input_tty_event;
1801
1802                 mess_krn_lsys_schedule  m_krn_lsys_schedule;
1803                 mess_krn_lsys_sys_fork m_krn_lsys_sys_fork;
1804                 mess_krn_lsys_sys_getwhoami m_krn_lsys_sys_getwhoami;
1805                 mess_krn_lsys_sys_irqctl m_krn_lsys_sys_irqctl;
1806                 mess_krn_lsys_sys_times m_krn_lsys_sys_times;
1807                 mess_krn_lsys_sys_trace m_krn_lsys_sys_trace;
1808                 mess_krn_lsys_sys_umap  m_krn_lsys_sys_umap;
1809                 mess_krn_lsys_sys_vumap m_krn_lsys_sys_vumap;
1810
1811                 mess_fs_vfs_breadwrite  m_fs_vfs_breadwrite;
1812                 mess_fs_vfs_chmod       m_fs_vfs_chmod;
1813                 mess_fs_vfs_chown       m_fs_vfs_chown;
1814                 mess_fs_vfs_create      m_fs_vfs_create;
1815                 mess_fs_vfs_getdents    m_fs_vfs_getdents;
1816                 mess_fs_vfs_lookup      m_fs_vfs_lookup;
1817                 mess_fs_vfs_newnode     m_fs_vfs_newnode;
1818                 mess_fs_vfs_rdlink      m_fs_vfs_rdlink;
1819                 mess_fs_vfs_readsuper   m_fs_vfs_readsuper;
1820                 mess_fs_vfs_readwrite   m_fs_vfs_readwrite;
1821
1822                 mess_i2c_li2cdriver_busc_i2c_exec m_i2c_li2cdriver_busc_i2c_exec;
1823                 mess_i2c_li2cdriver_busc_i2c_reserve m_i2c_li2cdriver_busc_i2c_reserve;
1824
1825                 mess_input_linputdriver_input_conf m_input_linputdriver_input_conf;
1826                 mess_input_linputdriver_setleds m_input_linputdriver_setleds;
1827
1828                 mess_lc_pm_exec         m_lc_pm_exec;
1829                 mess_lc_pm_exit         m_lc_pm_exit;
1830                 mess_lc_pm_getsid       m_lc_pm_getsid;
1831                 mess_lc_pm_groups       m_lc_pm_groups;
1832                 mess_lc_pm_itimer       m_lc_pm_itimer;
1833                 mess_lc_pm_mcontext     m_lc_pm_mcontext;
1834                 mess_lc_pm_priority     m_lc_pm_priority;
1835                 mess_lc_pm_ptrace       m_lc_pm_ptrace;
1836                 mess_lc_pm_reboot       m_lc_pm_reboot;
1837                 mess_lc_pm_rusage       m_lc_pm_rusage;
1838                 mess_lc_pm_setgid       m_lc_pm_setgid;
1839                 mess_lc_pm_setuid       m_lc_pm_setuid;
1840                 mess_lc_pm_sig          m_lc_pm_sig;
1841                 mess_lc_pm_sigset       m_lc_pm_sigset;
1842                 mess_lc_pm_sysuname     m_lc_pm_sysuname;
1843                 mess_lc_pm_time         m_lc_pm_time;
1844                 mess_lc_pm_waitpid      m_lc_pm_waitpid;
1845                 mess_lc_readclock_rtcdev m_lc_readclock_rtcdev;
1846
1847                 mess_lc_vfs_chown       m_lc_vfs_chown;
1848                 mess_lc_vfs_close       m_lc_vfs_close;
1849                 mess_lc_vfs_creat       m_lc_vfs_creat;
1850                 mess_lc_vfs_fchdir      m_lc_vfs_fchdir;
1851                 mess_lc_vfs_fchmod      m_lc_vfs_fchmod;
1852                 mess_lc_vfs_fcntl       m_lc_vfs_fcntl;
1853                 mess_lc_vfs_fstat       m_lc_vfs_fstat;
1854                 mess_lc_vfs_fsync       m_lc_vfs_fsync;
1855                 mess_lc_vfs_getvfsstat  m_lc_vfs_getvfsstat;
1856                 mess_lc_vfs_ioctl       m_lc_vfs_ioctl;
1857                 mess_lc_vfs_link        m_lc_vfs_link;
1858                 mess_lc_vfs_lseek       m_lc_vfs_lseek;
1859                 mess_lc_vfs_mknod       m_lc_vfs_mknod;
1860                 mess_lc_vfs_mount       m_lc_vfs_mount;
1861                 mess_lc_vfs_path        m_lc_vfs_path;
1862                 mess_lc_vfs_pipe2       m_lc_vfs_pipe2;
1863                 mess_lc_vfs_readlink    m_lc_vfs_readlink;
1864                 mess_lc_vfs_readwrite   m_lc_vfs_readwrite;
1865                 mess_lc_vfs_rusage      m_lc_vfs_rusage;
1866                 mess_lc_vfs_select      m_lc_vfs_select;
1867                 mess_lc_vfs_stat        m_lc_vfs_stat;
1868                 mess_lc_vfs_statvfs1    m_lc_vfs_statvfs1;
1869                 mess_lc_vfs_truncate    m_lc_vfs_truncate;
1870                 mess_lc_vfs_umask       m_lc_vfs_umask;
1871                 mess_lc_vfs_umount      m_lc_vfs_umount;
1872
1873                 mess_lc_vm_rusage       m_lc_vm_rusage;
1874
1875                 mess_lchardriver_vfs_reply m_lchardriver_vfs_reply;
1876                 mess_lchardriver_vfs_sel1 m_lchardriver_vfs_sel1;
1877                 mess_lchardriver_vfs_sel2 m_lchardriver_vfs_sel2;
1878
1879                 mess_lexec_pm_exec_new  m_lexec_pm_exec_new;
1880
1881                 mess_li2cdriver_i2c_busc_i2c_exec m_li2cdriver_i2c_busc_i2c_exec;
1882                 mess_li2cdriver_i2c_busc_i2c_reserve m_li2cdriver_i2c_busc_i2c_reserve;
1883
1884                 mess_linputdriver_input_event m_linputdriver_input_event;
1885
1886                 mess_lsys_getsysinfo    m_lsys_getsysinfo;
1887                 mess_lsys_fi_ctl        m_lsys_fi_ctl;
1888                 mess_lsys_fi_reply      m_lsys_fi_reply;
1889
1890                 mess_lsys_krn_schedctl  m_lsys_krn_schedctl;
1891                 mess_lsys_krn_schedule  m_lsys_krn_schedule;
1892                 mess_lsys_krn_sys_abort m_lsys_krn_sys_abort;
1893                 mess_lsys_krn_sys_clear m_lsys_krn_sys_clear;
1894                 mess_lsys_krn_sys_copy  m_lsys_krn_sys_copy;
1895                 mess_lsys_krn_sys_exec  m_lsys_krn_sys_exec;
1896                 mess_lsys_krn_sys_fork  m_lsys_krn_sys_fork;
1897                 mess_lsys_krn_sys_getinfo m_lsys_krn_sys_getinfo;
1898                 mess_lsys_krn_sys_getmcontext m_lsys_krn_sys_getmcontext;
1899                 mess_lsys_krn_sys_iopenable m_lsys_krn_sys_iopenable;
1900                 mess_lsys_krn_sys_irqctl m_lsys_krn_sys_irqctl;
1901                 mess_lsys_krn_sys_memset m_lsys_krn_sys_memset;
1902                 mess_lsys_krn_sys_privctl m_lsys_krn_sys_privctl;
1903                 mess_lsys_krn_sys_sdevio m_lsys_krn_sys_sdevio;
1904                 mess_lsys_krn_sys_setalarm m_lsys_krn_sys_setalarm;
1905                 mess_lsys_krn_sys_setgrant m_lsys_krn_sys_setgrant;
1906                 mess_lsys_krn_sys_setmcontext m_lsys_krn_sys_setmcontext;
1907                 mess_lsys_krn_sys_statectl m_lsys_krn_sys_statectl;
1908                 mess_lsys_krn_sys_stime m_lsys_krn_sys_stime;
1909                 mess_lsys_krn_sys_settime m_lsys_krn_sys_settime;
1910                 mess_lsys_krn_sys_times m_lsys_krn_sys_times;
1911                 mess_lsys_krn_sys_trace m_lsys_krn_sys_trace;
1912                 mess_lsys_krn_sys_umap  m_lsys_krn_sys_umap;
1913                 mess_lsys_krn_sys_vdevio m_lsys_krn_sys_vdevio;
1914                 mess_lsys_krn_sys_vumap m_lsys_krn_sys_vumap;
1915
1916                 mess_lsys_pci_busc_get_bar m_lsys_pci_busc_get_bar;
1917
1918                 mess_lsys_pm_getepinfo  m_lsys_pm_getepinfo;
1919                 mess_lsys_pm_getprocnr  m_lsys_pm_getprocnr;
1920                 mess_lsys_pm_srv_fork   m_lsys_pm_srv_fork;
1921
1922                 mess_lsys_sched_scheduling_start m_lsys_sched_scheduling_start;
1923                 mess_lsys_sched_scheduling_stop m_lsys_sched_scheduling_stop;
1924
1925                 mess_lsys_svrctl        m_lsys_svrctl;
1926
1927                 mess_lsys_tty_fkey_ctl  m_lsys_tty_fkey_ctl;
1928
1929                 mess_lsys_vfs_checkperms m_lsys_vfs_checkperms;
1930                 mess_lsys_vfs_copyfd    m_lsys_vfs_copyfd;
1931                 mess_lsys_vfs_mapdriver m_lsys_vfs_mapdriver;
1932
1933                 mess_net_netdrv_dl_conf m_net_netdrv_dl_conf;
1934                 mess_net_netdrv_dl_getstat_s m_net_netdrv_dl_getstat_s;
1935                 mess_net_netdrv_dl_readv_s m_net_netdrv_dl_readv_s;
1936                 mess_net_netdrv_dl_writev_s m_net_netdrv_dl_writev_s;
1937
1938                 mess_netdrv_net_dl_conf m_netdrv_net_dl_conf;
1939                 mess_netdrv_net_dl_task m_netdrv_net_dl_task;
1940
1941                 mess_pci_lsys_busc_get_bar m_pci_lsys_busc_get_bar;
1942
1943                 mess_pm_lexec_exec_new  m_pm_lexec_exec_new;
1944
1945                 mess_pm_lc_getgid       m_pm_lc_getgid;
1946                 mess_pm_lc_getpid       m_pm_lc_getpid;
1947                 mess_pm_lc_getuid       m_pm_lc_getuid;
1948                 mess_pm_lc_ptrace       m_pm_lc_ptrace;
1949                 mess_pm_lc_sigset       m_pm_lc_sigset;
1950                 mess_pm_lc_time         m_pm_lc_time;
1951                 mess_pm_lc_waitpid      m_pm_lc_waitpid;
1952
1953                 mess_pm_lsys_getepinfo  m_pm_lsys_getepinfo;
1954                 mess_pm_lsys_getprocnr  m_pm_lsys_getprocnr;
1955
1956                 mess_pm_sched_scheduling_set_nice m_pm_sched_scheduling_set_nice;
1957
1958                 mess_readclock_lc_rtcdev m_readclock_lc_rtcdev;
1959
1960                 mess_rs_pm_exec_restart m_rs_pm_exec_restart;
1961                 mess_rs_pm_srv_kill     m_rs_pm_srv_kill;
1962
1963                 mess_sched_lsys_scheduling_start m_sched_lsys_scheduling_start;
1964
1965                 mess_tty_lsys_fkey_ctl  m_tty_lsys_fkey_ctl;
1966
1967                 mess_vfs_fs_breadwrite  m_vfs_fs_breadwrite;
1968                 mess_vfs_fs_chmod       m_vfs_fs_chmod;
1969                 mess_vfs_fs_chown       m_vfs_fs_chown;
1970                 mess_vfs_fs_create      m_vfs_fs_create;
1971                 mess_vfs_fs_flush       m_vfs_fs_flush;
1972                 mess_vfs_fs_ftrunc      m_vfs_fs_ftrunc;
1973                 mess_vfs_fs_getdents    m_vfs_fs_getdents;
1974                 mess_vfs_fs_inhibread   m_vfs_fs_inhibread;
1975                 mess_vfs_fs_link        m_vfs_fs_link;
1976                 mess_vfs_fs_lookup      m_vfs_fs_lookup;
1977                 mess_vfs_fs_mkdir       m_vfs_fs_mkdir;
1978                 mess_vfs_fs_mknod       m_vfs_fs_mknod;
1979                 mess_vfs_fs_mountpoint  m_vfs_fs_mountpoint;
1980                 mess_vfs_fs_newnode     m_vfs_fs_newnode;
1981                 mess_vfs_fs_new_driver  m_vfs_fs_new_driver;
1982                 mess_vfs_fs_putnode     m_vfs_fs_putnode;
1983                 mess_vfs_fs_rdlink      m_vfs_fs_rdlink;
1984                 mess_vfs_fs_readsuper   m_vfs_fs_readsuper;
1985                 mess_vfs_fs_rename      m_vfs_fs_rename;
1986                 mess_vfs_fs_readwrite   m_vfs_fs_readwrite;
1987                 mess_vfs_fs_slink       m_vfs_fs_slink;
1988                 mess_vfs_fs_stat        m_vfs_fs_stat;
1989                 mess_vfs_fs_statvfs     m_vfs_fs_statvfs;
1990                 mess_vfs_fs_unlink      m_vfs_fs_unlink;
1991                 mess_vfs_fs_utime       m_vfs_fs_utime;
1992
1993                 mess_vfs_lc_lseek       m_vfs_lc_lseek;
1994
1995                 mess_lsys_vm_vmremap    m_lsys_vm_vmremap;
1996                 mess_lsys_vm_getref     m_lsys_vm_getref;
1997                 mess_lc_vm_getphys      m_lc_vm_getphys;
1998                 mess_lc_vm_shm_unmap    m_lc_vm_shm_unmap;
1999                 mess_lsys_vm_query_exit m_lsys_vm_query_exit;
2000                 mess_lsys_vm_info       m_lsys_vm_info;
2001                 mess_lsys_vm_update     m_lsys_vm_update;
2002                 mess_lsys_vm_watch_exit m_lsys_vm_watch_exit;
2003                 mess_lc_ipc_shmget      m_lc_ipc_shmget;
2004
2005                 mess_vfs_lchardriver_cancel     m_vfs_lchardriver_cancel;
2006                 mess_vfs_lchardriver_openclose  m_vfs_lchardriver_openclose;
2007                 mess_vfs_lchardriver_readwrite  m_vfs_lchardriver_readwrite;
2008                 mess_vfs_lchardriver_select     m_vfs_lchardriver_select;
2009
2010                 mess_vfs_utimens        m_vfs_utimens;
2011                 mess_vm_vfs_mmap        m_vm_vfs_mmap;
2012                 mess_vmmcp              m_vmmcp;
2013                 mess_vmmcp_reply        m_vmmcp_reply;
2014
2015                 u8_t size[56];  /* message payload may have 56 bytes at most */
2016         };
2017 } message __aligned(16);
2018
2019 /* Ensure the complete union respects the IPC assumptions. */
2020 typedef int _ASSERT_message[/* CONSTCOND */sizeof(message) == 64 ? 1 : -1];
2021
2022 /* The following defines provide names for useful members. */
2023 #define m1_i1  m_m1.m1i1
2024 #define m1_i2  m_m1.m1i2
2025 #define m1_i3  m_m1.m1i3
2026 #define m1_p1  m_m1.m1p1
2027 #define m1_p2  m_m1.m1p2
2028 #define m1_p3  m_m1.m1p3
2029 #define m1_p4  m_m1.m1p4
2030 #define m1_ull1  m_m1.m1ull1
2031
2032 #define m2_ll1  m_m2.m2ll1
2033 #define m2_i1  m_m2.m2i1
2034 #define m2_i2  m_m2.m2i2
2035 #define m2_i3  m_m2.m2i3
2036 #define m2_l1  m_m2.m2l1
2037 #define m2_l2  m_m2.m2l2
2038 #define m2_p1  m_m2.m2p1
2039 #define m2_sigset  m_m2.sigset
2040
2041 #define m2_s1  m_m2.m2s1
2042
2043 #define m3_i1  m_m3.m3i1
2044 #define m3_i2  m_m3.m3i2
2045 #define m3_p1  m_m3.m3p1
2046 #define m3_ca1 m_m3.m3ca1
2047
2048 #define m4_ll1  m_m4.m4ll1
2049 #define m4_l1  m_m4.m4l1
2050 #define m4_l2  m_m4.m4l2
2051 #define m4_l3  m_m4.m4l3
2052 #define m4_l4  m_m4.m4l4
2053 #define m4_l5  m_m4.m4l5
2054
2055 #define m5_s1  m_m5.m5s1
2056 #define m5_s2  m_m5.m5s2
2057 #define m5_i1  m_m5.m5i1
2058 #define m5_i2  m_m5.m5i2
2059 #define m5_l1  m_m5.m5l1
2060 #define m5_l2  m_m5.m5l2
2061 #define m5_l3  m_m5.m5l3
2062
2063 #define m7_i1  m_m7.m7i1
2064 #define m7_i2  m_m7.m7i2
2065 #define m7_i3  m_m7.m7i3
2066 #define m7_i4  m_m7.m7i4
2067 #define m7_i5  m_m7.m7i5
2068 #define m7_p1  m_m7.m7p1
2069 #define m7_p2  m_m7.m7p2
2070
2071 #define m8_i1  m_m8.m8i1
2072 #define m8_i2  m_m8.m8i2
2073 #define m8_p1  m_m8.m8p1
2074 #define m8_p2  m_m8.m8p2
2075 #define m8_p3  m_m8.m8p3
2076 #define m8_p4  m_m8.m8p4
2077
2078 #define m9_l1  m_m9.m9l1
2079 #define m9_l2  m_m9.m9l2
2080 #define m9_l3  m_m9.m9l3
2081 #define m9_l4  m_m9.m9l4
2082 #define m9_l5  m_m9.m9l5
2083 #define m9_s1  m_m9.m9s1
2084 #define m9_s2  m_m9.m9s2
2085 #define m9_s3  m_m9.m9s3
2086 #define m9_s4  m_m9.m9s4
2087 #define m9_ull1  m_m9.m9ull1
2088 #define m9_ull2  m_m9.m9ull2
2089
2090 #define m10_i1 m_m10.m10i1
2091 #define m10_i2 m_m10.m10i2
2092 #define m10_i3 m_m10.m10i3
2093 #define m10_i4 m_m10.m10i4
2094 #define m10_l1 m_m10.m10l1
2095 #define m10_l2 m_m10.m10l2
2096 #define m10_l3 m_m10.m10l3
2097 #define m10_ull1 m_m10.m10ull1
2098
2099 #define m11_i1 m_m11.m11i1
2100 #define m11_s1 m_m11.m11s1
2101 #define m11_s2 m_m11.m11s2
2102 #define m11_s3 m_m11.m11s3
2103 #define m11_s4 m_m11.m11s4
2104 #define m11_p1 m_m11.m11p1
2105 #define m11_p2 m_m11.m11p2
2106 #define m11_p3 m_m11.m11p3
2107 #define m11_p4 m_m11.m11p4
2108
2109 /*==========================================================================*
2110  * Minix run-time system (IPC).                                             *
2111  *==========================================================================*/
2112
2113 /* Datastructure for asynchronous sends */
2114 typedef struct asynmsg
2115 {
2116         unsigned flags;
2117         endpoint_t dst;
2118         int result;
2119         message msg;
2120 } asynmsg_t;
2121
2122 /* Defines for flags field */
2123 #define AMF_EMPTY       000     /* slot is not inuse */
2124 #define AMF_VALID       001     /* slot contains message */
2125 #define AMF_DONE        002     /* Kernel has processed the message. The
2126                                  * result is stored in 'result'
2127                                  */
2128 #define AMF_NOTIFY      004     /* Send a notification when AMF_DONE is set */
2129 #define AMF_NOREPLY     010     /* Not a reply message for a SENDREC */
2130 #define AMF_NOTIFY_ERR  020     /* Send a notification when AMF_DONE is set and
2131                                  * delivery of the message failed */
2132
2133 int _ipc_send_intr(endpoint_t dest, message *m_ptr);
2134 int _ipc_receive_intr(endpoint_t src, message *m_ptr, int *status_ptr);
2135 int _ipc_sendrec_intr(endpoint_t src_dest, message *m_ptr);
2136 int _ipc_sendnb_intr(endpoint_t dest, message *m_ptr);
2137 int _ipc_notify_intr(endpoint_t dest);
2138 int _ipc_senda_intr(asynmsg_t *table, size_t count);
2139
2140 int _do_kernel_call_intr(message *m_ptr);
2141
2142 int get_minix_kerninfo(struct minix_kerninfo **);
2143
2144 /* Hide names to avoid name space pollution. */
2145 #define ipc_notify      _ipc_notify
2146 #define ipc_sendrec     _ipc_sendrec
2147 #define ipc_receive     _ipc_receive
2148 #define ipc_receivenb   _ipc_receivenb
2149 #define ipc_send        _ipc_send
2150 #define ipc_sendnb      _ipc_sendnb
2151 #define ipc_senda       _ipc_senda
2152
2153 #define do_kernel_call  _do_kernel_call
2154
2155 struct minix_ipcvecs {
2156         int (*send)(endpoint_t dest, message *m_ptr);
2157         int (*receive)(endpoint_t src, message *m_ptr, int *st);
2158         int (*sendrec)(endpoint_t src_dest, message *m_ptr);
2159         int (*sendnb)(endpoint_t dest, message *m_ptr);
2160         int (*notify)(endpoint_t dest);
2161         int (*do_kernel_call)(message *m_ptr);
2162         int (*senda)(asynmsg_t *table, size_t count);
2163 };
2164
2165 /* kernel-set IPC vectors retrieved by a constructor in libc/sys-minix/init.c */
2166 extern struct minix_ipcvecs _minix_ipcvecs;
2167
2168 static inline int _ipc_send(endpoint_t dest, message *m_ptr)
2169 {
2170         return _minix_ipcvecs.send(dest, m_ptr);
2171 }
2172
2173 static inline int _ipc_receive(endpoint_t src, message *m_ptr, int *st)
2174 {
2175         return _minix_ipcvecs.receive(src, m_ptr, st);
2176 }
2177
2178 static inline int _ipc_sendrec(endpoint_t src_dest, message *m_ptr)
2179 {
2180         return _minix_ipcvecs.sendrec(src_dest, m_ptr);
2181 }
2182
2183 static inline int _ipc_sendnb(endpoint_t dest, message *m_ptr)
2184 {
2185         return _minix_ipcvecs.sendnb(dest, m_ptr);
2186 }
2187
2188 static inline int _ipc_notify(endpoint_t dest)
2189 {
2190         return _minix_ipcvecs.notify(dest);
2191 }
2192
2193 static inline int _do_kernel_call(message *m_ptr)
2194 {
2195         return _minix_ipcvecs.do_kernel_call(m_ptr);
2196 }
2197
2198 static inline int _ipc_senda(asynmsg_t *table, size_t count)
2199 {
2200         return _minix_ipcvecs.senda(table, count);
2201 }
2202
2203 #endif /* _IPC_H */