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