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