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 vir_bytes 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 int fd; 719 int backlog; 720 721 u8_t padding[48]; 722 } mess_lc_vfs_listen; 723 _ASSERT_MSG_SIZE(mess_lc_vfs_listen); 724 725 typedef struct { 726 off_t offset; 727 728 int fd; 729 int whence; 730 731 uint8_t padding[40]; 732 } mess_lc_vfs_lseek; 733 _ASSERT_MSG_SIZE(mess_lc_vfs_lseek); 734 735 typedef struct { 736 dev_t device; 737 738 vir_bytes name; 739 size_t len; 740 mode_t mode; 741 742 uint8_t padding[36]; 743 } mess_lc_vfs_mknod; 744 _ASSERT_MSG_SIZE(mess_lc_vfs_mknod); 745 746 typedef struct { 747 int flags; 748 size_t devlen; 749 size_t pathlen; 750 size_t typelen; 751 size_t labellen; 752 vir_bytes dev; 753 vir_bytes path; 754 vir_bytes type; 755 vir_bytes label; 756 757 uint8_t padding[20]; 758 } mess_lc_vfs_mount; 759 _ASSERT_MSG_SIZE(mess_lc_vfs_mount); 760 761 typedef struct { 762 vir_bytes name; 763 size_t len; 764 int flags; 765 mode_t mode; 766 char buf[M_PATH_STRING_MAX]; 767 } mess_lc_vfs_path; 768 _ASSERT_MSG_SIZE(mess_lc_vfs_path); 769 770 typedef struct { 771 /* 772 * We are in the process of cleaning up this message, by moving the 773 * flags value from the third integer into the first. Once enough time 774 * has passed, we can get rid of the second and third integer fields. 775 */ 776 int flags; 777 int _unused; 778 int oflags; 779 780 uint8_t padding[44]; 781 } mess_lc_vfs_pipe2; 782 _ASSERT_MSG_SIZE(mess_lc_vfs_pipe2); 783 784 typedef struct { 785 vir_bytes name; /* const char * */ 786 size_t namelen; 787 vir_bytes buf; 788 size_t bufsize; 789 790 uint8_t padding[40]; 791 } mess_lc_vfs_readlink; 792 _ASSERT_MSG_SIZE(mess_lc_vfs_readlink); 793 794 typedef struct { 795 int fd; 796 vir_bytes buf; 797 size_t len; 798 799 uint8_t padding[44]; 800 } mess_lc_vfs_readwrite; 801 _ASSERT_MSG_SIZE(mess_lc_vfs_readwrite); 802 803 typedef struct { 804 uint32_t nfds; 805 fd_set *readfds; 806 fd_set *writefds; 807 fd_set *errorfds; 808 vir_bytes timeout; /* user-provided 'struct timeval *' */ 809 810 uint8_t padding[36]; 811 } mess_lc_vfs_select; 812 _ASSERT_MSG_SIZE(mess_lc_vfs_select); 813 814 typedef struct { 815 int fd; 816 vir_bytes buf; /* void * */ 817 size_t len; 818 int flags; 819 vir_bytes addr; /* struct sockaddr * */ 820 unsigned int addr_len; /* socklen_t */ 821 822 uint8_t padding[32]; 823 } mess_lc_vfs_sendrecv; 824 _ASSERT_MSG_SIZE(mess_lc_vfs_sendrecv); 825 826 typedef struct { 827 int fd; 828 int how; 829 830 uint8_t padding[48]; 831 } mess_lc_vfs_shutdown; 832 _ASSERT_MSG_SIZE(mess_lc_vfs_shutdown); 833 834 typedef struct { 835 int fd; 836 vir_bytes addr; /* struct sockaddr * */ 837 unsigned int addr_len; /* socklen_t */ 838 839 uint8_t padding[44]; 840 } mess_lc_vfs_sockaddr; 841 _ASSERT_MSG_SIZE(mess_lc_vfs_sockaddr); 842 843 typedef struct { 844 int domain; 845 int type; 846 int protocol; 847 848 uint8_t padding[44]; 849 } mess_lc_vfs_socket; 850 _ASSERT_MSG_SIZE(mess_lc_vfs_socket); 851 852 typedef struct { 853 int fd; 854 vir_bytes msgbuf; /* struct msghdr * */ 855 int flags; 856 857 uint8_t padding[44]; 858 } mess_lc_vfs_sockmsg; 859 _ASSERT_MSG_SIZE(mess_lc_vfs_sockmsg); 860 861 typedef struct { 862 int fd; 863 int level; 864 int name; 865 vir_bytes buf; /* void * */ 866 unsigned int len; /* socklen_t */ 867 868 uint8_t padding[36]; 869 } mess_lc_vfs_sockopt; 870 _ASSERT_MSG_SIZE(mess_lc_vfs_sockopt); 871 872 typedef struct { 873 size_t len; 874 vir_bytes name; /* const char * */ 875 vir_bytes buf; /* struct stat * */ 876 877 uint8_t padding[44]; 878 } mess_lc_vfs_stat; 879 _ASSERT_MSG_SIZE(mess_lc_vfs_stat); 880 881 typedef struct { 882 int fd; 883 int flags; 884 size_t len; 885 vir_bytes name; 886 vir_bytes buf; 887 888 uint8_t padding[36]; 889 } mess_lc_vfs_statvfs1; 890 _ASSERT_MSG_SIZE(mess_lc_vfs_statvfs1); 891 892 typedef struct { 893 off_t offset; 894 895 int fd; 896 vir_bytes name; 897 size_t len; 898 899 uint8_t padding[36]; 900 } mess_lc_vfs_truncate; 901 _ASSERT_MSG_SIZE(mess_lc_vfs_truncate); 902 903 typedef struct { 904 mode_t mask; 905 906 uint8_t padding[52]; 907 } mess_lc_vfs_umask; 908 _ASSERT_MSG_SIZE(mess_lc_vfs_umask); 909 910 typedef struct { 911 vir_bytes name; 912 size_t namelen; 913 vir_bytes label; 914 size_t labellen; 915 916 uint8_t padding[40]; 917 } mess_lc_vfs_umount; 918 _ASSERT_MSG_SIZE(mess_lc_vfs_umount); 919 920 typedef struct { 921 void *addr; 922 uint8_t padding[52]; 923 } mess_lc_vm_brk; 924 _ASSERT_MSG_SIZE(mess_lc_vm_brk); 925 926 typedef struct { 927 endpoint_t endpt; 928 void *addr; 929 void *ret_addr; 930 uint8_t padding[44]; 931 } mess_lc_vm_getphys; 932 _ASSERT_MSG_SIZE(mess_lc_vm_getphys); 933 934 typedef struct { 935 endpoint_t forwhom; 936 void *addr; 937 uint8_t padding[48]; 938 } mess_lc_vm_shm_unmap; 939 _ASSERT_MSG_SIZE(mess_lc_vm_shm_unmap); 940 941 typedef struct { 942 int status; 943 uint32_t id; /* should be cdev_id_t */ 944 945 uint8_t padding[48]; 946 } mess_lchardriver_vfs_reply; 947 _ASSERT_MSG_SIZE(mess_lchardriver_vfs_reply); 948 949 typedef struct { 950 int status; 951 int32_t minor; 952 953 uint8_t padding[48]; 954 } mess_lchardriver_vfs_sel1; 955 _ASSERT_MSG_SIZE(mess_lchardriver_vfs_sel1); 956 957 typedef struct { 958 int status; 959 int32_t minor; 960 961 uint8_t padding[48]; 962 } mess_lchardriver_vfs_sel2; 963 _ASSERT_MSG_SIZE(mess_lchardriver_vfs_sel2); 964 965 typedef struct { 966 endpoint_t endpt; 967 vir_bytes ptr; /* struct exec_info * */ 968 969 uint8_t padding[48]; 970 } mess_lexec_pm_exec_new; 971 _ASSERT_MSG_SIZE(mess_lexec_pm_exec_new); 972 973 typedef struct { 974 cp_grant_id_t grant; 975 976 uint8_t padding[52]; 977 } mess_li2cdriver_i2c_busc_i2c_exec; 978 _ASSERT_MSG_SIZE(mess_li2cdriver_i2c_busc_i2c_exec); 979 980 typedef struct { 981 uint16_t addr; /* FIXME: strictly speaking this is an i2c_addr_t, but 982 to get it I would need to include 983 sys/dev/i2c/i2c_io.h, which I am not sure is a good 984 idea to have everywhere. */ 985 986 uint8_t padding[54]; 987 } mess_li2cdriver_i2c_busc_i2c_reserve; 988 _ASSERT_MSG_SIZE(mess_li2cdriver_i2c_busc_i2c_reserve); 989 990 typedef struct { 991 int id; 992 int page; 993 int code; 994 int value; 995 int flags; 996 997 uint8_t padding[36]; 998 } mess_linputdriver_input_event; 999 _ASSERT_MSG_SIZE(mess_linputdriver_input_event); 1000 1001 typedef struct { 1002 cp_grant_id_t gid; 1003 size_t size; 1004 int subtype; 1005 1006 uint8_t padding[44]; 1007 } mess_lsys_fi_ctl; 1008 _ASSERT_MSG_SIZE(mess_lsys_fi_ctl); 1009 1010 typedef struct { 1011 int status; 1012 1013 uint8_t padding[52]; 1014 } mess_lsys_fi_reply; 1015 _ASSERT_MSG_SIZE(mess_lsys_fi_reply); 1016 1017 typedef struct { 1018 int what; 1019 vir_bytes where; 1020 size_t size; 1021 1022 uint8_t padding[44]; 1023 } mess_lsys_getsysinfo; 1024 _ASSERT_MSG_SIZE(mess_lsys_getsysinfo); 1025 1026 typedef struct { 1027 size_t size; 1028 phys_bytes addr; 1029 vir_bytes buf; 1030 1031 uint8_t padding[44]; 1032 } mess_lsys_krn_readbios; 1033 _ASSERT_MSG_SIZE(mess_lsys_krn_readbios); 1034 1035 typedef struct { 1036 endpoint_t from_to; 1037 cp_grant_id_t gid; 1038 size_t offset; 1039 void *address; 1040 size_t bytes; 1041 uint8_t padding[36]; 1042 } mess_lsys_kern_safecopy; 1043 _ASSERT_MSG_SIZE(mess_lsys_kern_safecopy); 1044 1045 typedef struct { 1046 uint32_t flags; 1047 endpoint_t endpoint; 1048 int priority; 1049 int quantum; 1050 int cpu; 1051 1052 uint8_t padding[36]; 1053 } mess_lsys_krn_schedctl; 1054 _ASSERT_MSG_SIZE(mess_lsys_krn_schedctl); 1055 1056 typedef struct { 1057 endpoint_t endpoint; 1058 int quantum; 1059 int priority; 1060 int cpu; 1061 int niced; 1062 1063 uint8_t padding[36]; 1064 } mess_lsys_krn_schedule; 1065 _ASSERT_MSG_SIZE(mess_lsys_krn_schedule); 1066 1067 typedef struct { 1068 int how; 1069 1070 uint8_t padding[52]; 1071 } mess_lsys_krn_sys_abort; 1072 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_abort); 1073 1074 typedef struct { 1075 endpoint_t endpt; 1076 1077 uint8_t padding[52]; 1078 } mess_lsys_krn_sys_clear; 1079 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_clear); 1080 1081 typedef struct { 1082 endpoint_t src_endpt; 1083 vir_bytes src_addr; 1084 endpoint_t dst_endpt; 1085 vir_bytes dst_addr; 1086 phys_bytes nr_bytes; 1087 int flags; 1088 1089 uint8_t padding[32]; 1090 } mess_lsys_krn_sys_copy; 1091 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_copy); 1092 1093 typedef struct { 1094 int request; 1095 int port; 1096 uint32_t value; 1097 1098 uint8_t padding[44]; 1099 } mess_lsys_krn_sys_devio; 1100 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_devio); 1101 1102 typedef struct { 1103 int code; 1104 vir_bytes buf; 1105 int len; 1106 endpoint_t endpt; 1107 1108 uint8_t padding[40]; 1109 } mess_lsys_krn_sys_diagctl; 1110 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_diagctl); 1111 1112 typedef struct { 1113 endpoint_t endpt; 1114 vir_bytes ip; 1115 vir_bytes stack; 1116 vir_bytes name; 1117 vir_bytes ps_str; 1118 1119 uint8_t padding[36]; 1120 } mess_lsys_krn_sys_exec; 1121 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_exec); 1122 1123 typedef struct { 1124 endpoint_t endpt; 1125 endpoint_t slot; 1126 uint32_t flags; 1127 1128 uint8_t padding[44]; 1129 } mess_lsys_krn_sys_fork; 1130 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_fork); 1131 1132 typedef struct { 1133 int request; 1134 endpoint_t endpt; 1135 vir_bytes val_ptr; 1136 int val_len; 1137 vir_bytes val_ptr2; 1138 int val_len2_e; 1139 1140 uint8_t padding[32]; 1141 } mess_lsys_krn_sys_getinfo; 1142 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_getinfo); 1143 1144 typedef struct { 1145 endpoint_t endpt; 1146 vir_bytes ctx_ptr; 1147 1148 uint8_t padding[48]; 1149 } mess_lsys_krn_sys_getmcontext; 1150 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_getmcontext); 1151 1152 typedef struct { 1153 endpoint_t endpt; 1154 1155 uint8_t padding[52]; 1156 } mess_lsys_krn_sys_iopenable; 1157 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_iopenable); 1158 1159 typedef struct { 1160 int request; 1161 int vector; 1162 int policy; 1163 int hook_id; 1164 1165 uint8_t padding[40]; 1166 } mess_lsys_krn_sys_irqctl; 1167 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_irqctl); 1168 1169 typedef struct { 1170 phys_bytes base; 1171 phys_bytes count; 1172 unsigned long pattern; 1173 endpoint_t process; 1174 1175 uint8_t padding[40]; 1176 } mess_lsys_krn_sys_memset; 1177 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_memset); 1178 1179 typedef struct { 1180 int request; 1181 endpoint_t endpt; 1182 vir_bytes arg_ptr; 1183 phys_bytes phys_start; 1184 phys_bytes phys_len; 1185 1186 uint8_t padding[36]; 1187 } mess_lsys_krn_sys_privctl; 1188 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_privctl); 1189 1190 typedef struct { 1191 int request; 1192 long int port; 1193 endpoint_t vec_endpt; 1194 phys_bytes vec_addr; 1195 vir_bytes vec_size; 1196 vir_bytes offset; 1197 1198 uint8_t padding[32]; 1199 } mess_lsys_krn_sys_sdevio; 1200 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_sdevio); 1201 1202 typedef struct { 1203 clock_t exp_time; 1204 clock_t time_left; 1205 clock_t uptime; 1206 int abs_time; 1207 1208 uint8_t padding[40]; 1209 } mess_lsys_krn_sys_setalarm; 1210 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_setalarm); 1211 1212 typedef struct { 1213 vir_bytes addr; /* cp_grant_t * */ 1214 int size; 1215 1216 uint8_t padding[48]; 1217 } mess_lsys_krn_sys_setgrant; 1218 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_setgrant); 1219 1220 typedef struct { 1221 endpoint_t endpt; 1222 vir_bytes ctx_ptr; 1223 1224 uint8_t padding[48]; 1225 } mess_lsys_krn_sys_setmcontext; 1226 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_setmcontext); 1227 1228 typedef struct { 1229 time_t sec; /* time in seconds since 1970 */ 1230 long int nsec; 1231 int now; /* non-zero for immediate, 0 for adjtime */ 1232 clockid_t clock_id; 1233 1234 uint8_t padding[36]; 1235 } mess_lsys_krn_sys_settime; 1236 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_settime); 1237 1238 typedef struct { 1239 int action; 1240 int freq; 1241 int intr_type; 1242 endpoint_t endpt; 1243 vir_bytes ctl_ptr; 1244 vir_bytes mem_ptr; 1245 size_t mem_size; 1246 1247 uint8_t padding[28]; 1248 } mess_lsys_krn_sys_sprof; 1249 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_sprof); 1250 1251 typedef struct { 1252 int request; 1253 void *address; 1254 int length; 1255 1256 uint8_t padding[44]; 1257 } mess_lsys_krn_sys_statectl; 1258 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_statectl); 1259 1260 typedef struct { 1261 time_t boot_time; 1262 1263 uint8_t padding[48]; 1264 } mess_lsys_krn_sys_stime; 1265 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_stime); 1266 1267 typedef struct { 1268 endpoint_t endpt; 1269 1270 uint8_t padding[52]; 1271 } mess_lsys_krn_sys_times; 1272 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_times); 1273 1274 typedef struct { 1275 int request; 1276 endpoint_t endpt; 1277 vir_bytes address; 1278 long int data; 1279 1280 uint8_t padding[40]; 1281 } mess_lsys_krn_sys_trace; 1282 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_trace); 1283 1284 typedef struct { 1285 endpoint_t src_endpt; 1286 int segment; 1287 vir_bytes src_addr; 1288 endpoint_t dst_endpt; 1289 int nr_bytes; 1290 1291 uint8_t padding[36]; 1292 } mess_lsys_krn_sys_umap; 1293 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_umap); 1294 1295 1296 typedef struct { 1297 int request; 1298 int vec_size; 1299 vir_bytes vec_addr; /* pv{b,w,l}_pair_t * */ 1300 1301 uint8_t padding[44]; 1302 } mess_lsys_krn_sys_vdevio; 1303 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_vdevio); 1304 1305 typedef struct { 1306 endpoint_t endpt; 1307 vir_bytes vaddr; /* struct vumap_vir * */ 1308 int vcount; 1309 vir_bytes paddr; /* struct vumap_phys * */ 1310 int pmax; 1311 int access; 1312 size_t offset; 1313 1314 uint8_t padding[28]; 1315 } mess_lsys_krn_sys_vumap; 1316 _ASSERT_MSG_SIZE(mess_lsys_krn_sys_vumap); 1317 1318 typedef struct { 1319 void *vec_addr; 1320 int vec_size; 1321 uint8_t padding[48]; 1322 } mess_lsys_kern_vsafecopy; 1323 _ASSERT_MSG_SIZE(mess_lsys_kern_vsafecopy); 1324 1325 typedef struct { 1326 uint32_t root_id; 1327 uint32_t flags; 1328 unsigned int csize; 1329 unsigned int clen; 1330 unsigned int miblen; 1331 int mib[CTL_SHORTNAME]; 1332 uint8_t padding[4]; 1333 } mess_lsys_mib_register; 1334 _ASSERT_MSG_SIZE(mess_lsys_mib_register); 1335 1336 typedef struct { 1337 uint32_t req_id; 1338 ssize_t status; 1339 uint8_t padding[48]; 1340 } mess_lsys_mib_reply; 1341 _ASSERT_MSG_SIZE(mess_lsys_mib_reply); 1342 1343 typedef struct { 1344 int devind; 1345 int port; 1346 1347 uint8_t padding[48]; 1348 } mess_lsys_pci_busc_get_bar; 1349 _ASSERT_MSG_SIZE(mess_lsys_pci_busc_get_bar); 1350 1351 typedef struct { 1352 endpoint_t endpt; 1353 1354 uint8_t padding[52]; 1355 } mess_lsys_pm_getepinfo; 1356 _ASSERT_MSG_SIZE(mess_lsys_pm_getepinfo); 1357 1358 typedef struct { 1359 pid_t pid; 1360 1361 uint8_t padding[52]; 1362 } mess_lsys_pm_getprocnr; 1363 _ASSERT_MSG_SIZE(mess_lsys_pm_getprocnr); 1364 1365 typedef struct { 1366 unsigned int mask; 1367 1368 uint8_t padding[52]; 1369 } mess_lsys_pm_proceventmask; 1370 _ASSERT_MSG_SIZE(mess_lsys_pm_proceventmask); 1371 1372 typedef struct { 1373 uid_t uid; 1374 gid_t gid; 1375 1376 uint8_t padding[48]; 1377 } mess_lsys_pm_srv_fork; 1378 _ASSERT_MSG_SIZE(mess_lsys_pm_srv_fork); 1379 1380 typedef struct { 1381 endpoint_t endpoint; 1382 endpoint_t parent; 1383 int maxprio; 1384 int quantum; 1385 1386 uint8_t padding[40]; 1387 } mess_lsys_sched_scheduling_start; 1388 _ASSERT_MSG_SIZE(mess_lsys_sched_scheduling_start); 1389 1390 typedef struct { 1391 endpoint_t endpoint; 1392 1393 uint8_t padding[52]; 1394 } mess_lsys_sched_scheduling_stop; 1395 _ASSERT_MSG_SIZE(mess_lsys_sched_scheduling_stop); 1396 1397 typedef struct { 1398 int request; 1399 int fkeys; 1400 int sfkeys; 1401 1402 uint8_t padding[44]; 1403 } mess_lsys_tty_fkey_ctl; 1404 _ASSERT_MSG_SIZE(mess_lsys_tty_fkey_ctl); 1405 1406 typedef struct { 1407 endpoint_t endpt; 1408 cp_grant_id_t grant; 1409 size_t count; 1410 1411 uint8_t padding[44]; 1412 } mess_lsys_vfs_checkperms; 1413 _ASSERT_MSG_SIZE(mess_lsys_vfs_checkperms); 1414 1415 typedef struct { 1416 endpoint_t endpt; 1417 int fd; 1418 int what; 1419 1420 uint8_t padding[44]; 1421 } mess_lsys_vfs_copyfd; 1422 _ASSERT_MSG_SIZE(mess_lsys_vfs_copyfd); 1423 1424 typedef struct { 1425 devmajor_t major; 1426 size_t labellen; 1427 vir_bytes label; 1428 1429 uint8_t padding[44]; 1430 } mess_lsys_vfs_mapdriver; 1431 _ASSERT_MSG_SIZE(mess_lsys_vfs_mapdriver); 1432 1433 typedef struct { 1434 endpoint_t endpt; 1435 void *addr; 1436 int retc; 1437 uint8_t padding[44]; 1438 } mess_lsys_vm_getref; 1439 _ASSERT_MSG_SIZE(mess_lsys_vm_getref); 1440 1441 typedef struct { 1442 int what; 1443 endpoint_t ep; 1444 int count; 1445 void *ptr; 1446 vir_bytes next; 1447 uint8_t padding[36]; 1448 } mess_lsys_vm_info; 1449 _ASSERT_MSG_SIZE(mess_lsys_vm_info); 1450 1451 typedef struct { 1452 endpoint_t ep; 1453 phys_bytes phaddr; 1454 size_t len; 1455 void *reply; 1456 uint8_t padding[40]; 1457 } mess_lsys_vm_map_phys; 1458 _ASSERT_MSG_SIZE(mess_lsys_vm_map_phys); 1459 1460 typedef struct { 1461 endpoint_t endpt; 1462 vir_bytes addr; 1463 int children; 1464 1465 uint8_t padding[44]; 1466 } mess_lsys_vm_rusage; 1467 _ASSERT_MSG_SIZE(mess_lsys_vm_rusage); 1468 1469 typedef struct { 1470 endpoint_t ep; 1471 void *vaddr; 1472 uint8_t padding[48]; 1473 } mess_lsys_vm_unmap_phys; 1474 _ASSERT_MSG_SIZE(mess_lsys_vm_unmap_phys); 1475 1476 typedef struct { 1477 endpoint_t src; 1478 endpoint_t dst; 1479 int flags; 1480 uint8_t padding[44]; 1481 } mess_lsys_vm_update; 1482 _ASSERT_MSG_SIZE(mess_lsys_vm_update); 1483 1484 typedef struct { 1485 endpoint_t destination; 1486 endpoint_t source; 1487 void *dest_addr; 1488 void *src_addr; 1489 size_t size; 1490 void *ret_addr; 1491 uint8_t padding[32]; 1492 } mess_lsys_vm_vmremap; 1493 _ASSERT_MSG_SIZE(mess_lsys_vm_vmremap); 1494 1495 typedef struct { 1496 size_t oldlen; 1497 uint8_t padding[52]; 1498 } mess_mib_lc_sysctl; 1499 _ASSERT_MSG_SIZE(mess_mib_lc_sysctl); 1500 1501 typedef struct { 1502 uint32_t req_id; 1503 uint32_t root_id; 1504 cp_grant_id_t name_grant; 1505 unsigned int name_len; 1506 cp_grant_id_t oldp_grant; 1507 size_t oldp_len; 1508 cp_grant_id_t newp_grant; 1509 size_t newp_len; 1510 endpoint_t user_endpt; 1511 uint32_t flags; 1512 uint32_t root_ver; 1513 uint32_t tree_ver; 1514 uint8_t padding[8]; 1515 } mess_mib_lsys_call; 1516 _ASSERT_MSG_SIZE(mess_mib_lsys_call); 1517 1518 typedef struct { 1519 uint32_t req_id; 1520 uint32_t root_id; 1521 cp_grant_id_t name_grant; 1522 size_t name_size; 1523 cp_grant_id_t desc_grant; 1524 size_t desc_size; 1525 uint8_t padding[32]; 1526 } mess_mib_lsys_info; 1527 _ASSERT_MSG_SIZE(mess_mib_lsys_info); 1528 1529 typedef struct { 1530 off_t offset; 1531 void *addr; 1532 size_t len; 1533 int prot; 1534 int flags; 1535 int fd; 1536 endpoint_t forwhom; 1537 void *retaddr; 1538 u32_t padding[5]; 1539 } mess_mmap; 1540 _ASSERT_MSG_SIZE(mess_mmap); 1541 1542 typedef struct { 1543 int mode; 1544 1545 uint8_t padding[52]; 1546 } mess_net_netdrv_dl_conf; 1547 _ASSERT_MSG_SIZE(mess_net_netdrv_dl_conf); 1548 1549 typedef struct { 1550 cp_grant_id_t grant; 1551 1552 uint8_t padding[52]; 1553 } mess_net_netdrv_dl_getstat_s; 1554 _ASSERT_MSG_SIZE(mess_net_netdrv_dl_getstat_s); 1555 1556 typedef struct { 1557 cp_grant_id_t grant; 1558 int count; 1559 1560 uint8_t padding[48]; 1561 } mess_net_netdrv_dl_readv_s; 1562 _ASSERT_MSG_SIZE(mess_net_netdrv_dl_readv_s); 1563 1564 typedef struct { 1565 cp_grant_id_t grant; 1566 int count; 1567 1568 uint8_t padding[48]; 1569 } mess_net_netdrv_dl_writev_s; 1570 _ASSERT_MSG_SIZE(mess_net_netdrv_dl_writev_s); 1571 1572 typedef struct { 1573 int stat; 1574 uint8_t hw_addr[6]; 1575 1576 uint8_t padding[46]; 1577 } mess_netdrv_net_dl_conf; 1578 _ASSERT_MSG_SIZE(mess_netdrv_net_dl_conf); 1579 1580 typedef struct { 1581 int count; 1582 uint32_t flags; 1583 1584 uint8_t padding[48]; 1585 } mess_netdrv_net_dl_task; 1586 _ASSERT_MSG_SIZE(mess_netdrv_net_dl_task); 1587 1588 typedef struct { 1589 u64_t timestamp; /* valid for every notify msg */ 1590 u64_t interrupts; /* raised interrupts; valid if from HARDWARE */ 1591 sigset_t sigset; /* raised signals; valid if from SYSTEM */ 1592 uint8_t padding[24]; 1593 } mess_notify; 1594 _ASSERT_MSG_SIZE(mess_notify); 1595 1596 typedef struct { 1597 int base; 1598 size_t size; 1599 uint32_t flags; 1600 1601 uint8_t padding[44]; 1602 } mess_pci_lsys_busc_get_bar; 1603 _ASSERT_MSG_SIZE(mess_pci_lsys_busc_get_bar); 1604 1605 typedef struct { 1606 uid_t egid; 1607 1608 uint8_t padding[52]; 1609 } mess_pm_lc_getgid; 1610 _ASSERT_MSG_SIZE(mess_pm_lc_getgid); 1611 1612 typedef struct { 1613 pid_t parent_pid; 1614 1615 uint8_t padding[52]; 1616 } mess_pm_lc_getpid; 1617 _ASSERT_MSG_SIZE(mess_pm_lc_getpid); 1618 1619 typedef struct { 1620 uid_t euid; 1621 1622 uint8_t padding[52]; 1623 } mess_pm_lc_getuid; 1624 _ASSERT_MSG_SIZE(mess_pm_lc_getuid); 1625 1626 typedef struct { 1627 long data; 1628 1629 uint8_t padding[52]; 1630 } mess_pm_lc_ptrace; 1631 _ASSERT_MSG_SIZE(mess_pm_lc_ptrace); 1632 1633 typedef struct { 1634 sigset_t set; 1635 1636 uint8_t padding[40]; 1637 } mess_pm_lc_sigset; 1638 _ASSERT_MSG_SIZE(mess_pm_lc_sigset); 1639 1640 typedef struct { 1641 time_t sec; 1642 1643 long nsec; 1644 1645 uint8_t padding[44]; 1646 } mess_pm_lc_time; 1647 _ASSERT_MSG_SIZE(mess_pm_lc_time); 1648 1649 typedef struct { 1650 int status; 1651 1652 uint8_t padding[52]; 1653 } mess_pm_lc_wait4; 1654 _ASSERT_MSG_SIZE(mess_pm_lc_wait4); 1655 1656 typedef struct { 1657 int suid; 1658 1659 uint8_t padding[52]; 1660 } mess_pm_lexec_exec_new; 1661 _ASSERT_MSG_SIZE(mess_pm_lexec_exec_new); 1662 1663 typedef struct { 1664 uid_t uid; 1665 gid_t gid; 1666 1667 uint8_t padding[48]; 1668 } mess_pm_lsys_getepinfo; 1669 _ASSERT_MSG_SIZE(mess_pm_lsys_getepinfo); 1670 1671 typedef struct { 1672 endpoint_t endpt; 1673 1674 uint8_t padding[52]; 1675 } mess_pm_lsys_getprocnr; 1676 _ASSERT_MSG_SIZE(mess_pm_lsys_getprocnr); 1677 1678 typedef struct { 1679 endpoint_t endpt; 1680 unsigned int event; 1681 1682 uint8_t padding[48]; 1683 } mess_pm_lsys_proc_event; 1684 _ASSERT_MSG_SIZE(mess_pm_lsys_proc_event); 1685 1686 typedef struct { 1687 int num; 1688 1689 uint8_t padding[52]; 1690 } mess_pm_lsys_sigs_signal; 1691 _ASSERT_MSG_SIZE(mess_pm_lsys_sigs_signal); 1692 1693 typedef struct { 1694 endpoint_t endpoint; 1695 uint32_t maxprio; 1696 1697 uint8_t padding[48]; 1698 } mess_pm_sched_scheduling_set_nice; 1699 _ASSERT_MSG_SIZE(mess_pm_sched_scheduling_set_nice); 1700 1701 typedef struct { 1702 dev_t dev; 1703 mode_t mode; 1704 uid_t uid; 1705 gid_t gid; 1706 uint32_t index; 1707 1708 uint8_t padding[32]; 1709 } mess_pty_ptyfs_req; 1710 _ASSERT_MSG_SIZE(mess_pty_ptyfs_req); 1711 1712 typedef struct { 1713 char name[20]; 1714 1715 uint8_t padding[36]; 1716 } mess_ptyfs_pty_name; 1717 _ASSERT_MSG_SIZE(mess_ptyfs_pty_name); 1718 1719 typedef struct { 1720 int status; 1721 1722 uint8_t padding[52]; 1723 } mess_readclock_lc_rtcdev; 1724 _ASSERT_MSG_SIZE(mess_readclock_lc_rtcdev); 1725 1726 typedef struct { 1727 int result; 1728 int type; 1729 cp_grant_id_t rproctab_gid; 1730 endpoint_t old_endpoint; 1731 int restarts; 1732 int flags; 1733 vir_bytes buff_addr; 1734 size_t buff_len; 1735 int prepare_state; 1736 uint8_t padding[20]; 1737 } mess_rs_init; 1738 _ASSERT_MSG_SIZE(mess_rs_init); 1739 1740 typedef struct { 1741 endpoint_t endpt; 1742 int result; 1743 vir_bytes pc; 1744 vir_bytes ps_str; 1745 1746 uint8_t padding[40]; 1747 } mess_rs_pm_exec_restart; 1748 _ASSERT_MSG_SIZE(mess_rs_pm_exec_restart); 1749 1750 typedef struct { 1751 pid_t pid; 1752 int nr; 1753 1754 uint8_t padding[48]; 1755 } mess_rs_pm_srv_kill; 1756 _ASSERT_MSG_SIZE(mess_rs_pm_srv_kill); 1757 1758 typedef struct { 1759 int len; 1760 int name_len; 1761 endpoint_t endpoint; 1762 void *addr; 1763 const char *name; 1764 int subtype; 1765 uint8_t padding[32]; 1766 } mess_rs_req; 1767 _ASSERT_MSG_SIZE(mess_rs_req); 1768 1769 typedef struct { 1770 int result; 1771 int state; 1772 int prepare_maxtime; 1773 int flags; 1774 gid_t state_data_gid; 1775 uint8_t padding[36]; 1776 } mess_rs_update; 1777 _ASSERT_MSG_SIZE(mess_rs_update); 1778 1779 typedef struct { 1780 endpoint_t scheduler; 1781 1782 uint8_t padding[52]; 1783 } mess_sched_lsys_scheduling_start; 1784 _ASSERT_MSG_SIZE(mess_sched_lsys_scheduling_start); 1785 1786 /* For SYS_GETKSIG, _ENDKSIG, _KILL, _SIGSEND, _SIGRETURN. */ 1787 typedef struct { 1788 sigset_t map; /* used to pass signal bit map */ 1789 endpoint_t endpt; /* process number for inform */ 1790 int sig; /* signal number to send */ 1791 void *sigctx; /* pointer to signal context */ 1792 uint8_t padding[28]; 1793 } mess_sigcalls; 1794 _ASSERT_MSG_SIZE(mess_sigcalls); 1795 1796 typedef struct { 1797 int fkeys; 1798 int sfkeys; 1799 1800 uint8_t padding[48]; 1801 } mess_tty_lsys_fkey_ctl; 1802 _ASSERT_MSG_SIZE(mess_tty_lsys_fkey_ctl); 1803 1804 typedef struct { 1805 dev_t device; 1806 off_t seek_pos; 1807 1808 cp_grant_id_t grant; 1809 size_t nbytes; 1810 1811 uint8_t data[32]; 1812 } mess_vfs_fs_breadwrite; 1813 _ASSERT_MSG_SIZE(mess_vfs_fs_breadwrite); 1814 1815 typedef struct { 1816 ino_t inode; 1817 1818 mode_t mode; 1819 1820 uint8_t data[44]; 1821 } mess_vfs_fs_chmod; 1822 _ASSERT_MSG_SIZE(mess_vfs_fs_chmod); 1823 1824 typedef struct { 1825 ino_t inode; 1826 1827 uid_t uid; 1828 gid_t gid; 1829 1830 uint8_t data[40]; 1831 } mess_vfs_fs_chown; 1832 _ASSERT_MSG_SIZE(mess_vfs_fs_chown); 1833 1834 typedef struct { 1835 ino_t inode; 1836 1837 mode_t mode; 1838 uid_t uid; 1839 gid_t gid; 1840 cp_grant_id_t grant; 1841 size_t path_len; 1842 1843 uint8_t data[28]; 1844 } mess_vfs_fs_create; 1845 _ASSERT_MSG_SIZE(mess_vfs_fs_create); 1846 1847 typedef struct { 1848 dev_t device; 1849 1850 uint8_t data[48]; 1851 } mess_vfs_fs_flush; 1852 _ASSERT_MSG_SIZE(mess_vfs_fs_flush); 1853 1854 typedef struct { 1855 ino_t inode; 1856 off_t trc_start; 1857 off_t trc_end; 1858 1859 uint8_t data[32]; 1860 } mess_vfs_fs_ftrunc; 1861 _ASSERT_MSG_SIZE(mess_vfs_fs_ftrunc); 1862 1863 typedef struct { 1864 ino_t inode; 1865 off_t seek_pos; 1866 1867 cp_grant_id_t grant; 1868 size_t mem_size; 1869 1870 uint8_t data[32]; 1871 } mess_vfs_fs_getdents; 1872 _ASSERT_MSG_SIZE(mess_vfs_fs_getdents); 1873 1874 typedef struct { 1875 ino_t inode; 1876 1877 uint8_t data[48]; 1878 } mess_vfs_fs_inhibread; 1879 _ASSERT_MSG_SIZE(mess_vfs_fs_inhibread); 1880 1881 typedef struct { 1882 ino_t inode; 1883 ino_t dir_ino; 1884 1885 cp_grant_id_t grant; 1886 size_t path_len; 1887 1888 uint8_t data[32]; 1889 } mess_vfs_fs_link; 1890 _ASSERT_MSG_SIZE(mess_vfs_fs_link); 1891 1892 typedef struct { 1893 ino_t dir_ino; 1894 ino_t root_ino; 1895 1896 uint32_t flags; 1897 size_t path_len; 1898 size_t path_size; 1899 size_t ucred_size; 1900 cp_grant_id_t grant_path; 1901 cp_grant_id_t grant_ucred; 1902 uid_t uid; 1903 gid_t gid; 1904 1905 uint8_t data[8]; 1906 } mess_vfs_fs_lookup; 1907 _ASSERT_MSG_SIZE(mess_vfs_fs_lookup); 1908 1909 typedef struct { 1910 ino_t inode; 1911 1912 mode_t mode; 1913 uid_t uid; 1914 gid_t gid; 1915 cp_grant_id_t grant; 1916 size_t path_len; 1917 1918 uint8_t data[28]; 1919 } mess_vfs_fs_mkdir; 1920 _ASSERT_MSG_SIZE(mess_vfs_fs_mkdir); 1921 1922 typedef struct { 1923 dev_t device; 1924 ino_t inode; 1925 1926 mode_t mode; 1927 uid_t uid; 1928 gid_t gid; 1929 cp_grant_id_t grant; 1930 size_t path_len; 1931 1932 uint8_t data[20]; 1933 } mess_vfs_fs_mknod; 1934 _ASSERT_MSG_SIZE(mess_vfs_fs_mknod); 1935 1936 typedef struct { 1937 ino_t inode; 1938 1939 uint8_t data[48]; 1940 } mess_vfs_fs_mountpoint; 1941 _ASSERT_MSG_SIZE(mess_vfs_fs_mountpoint); 1942 1943 typedef struct { 1944 dev_t device; 1945 1946 cp_grant_id_t grant; 1947 size_t path_len; 1948 1949 uint8_t data[40]; 1950 } mess_vfs_fs_new_driver; 1951 _ASSERT_MSG_SIZE(mess_vfs_fs_new_driver); 1952 1953 typedef struct { 1954 dev_t device; 1955 1956 mode_t mode; 1957 uid_t uid; 1958 gid_t gid; 1959 1960 uint8_t data[36]; 1961 } mess_vfs_fs_newnode; 1962 _ASSERT_MSG_SIZE(mess_vfs_fs_newnode); 1963 1964 typedef struct { 1965 ino_t inode; 1966 unsigned int count; 1967 1968 uint8_t data[44]; 1969 } mess_vfs_fs_putnode; 1970 _ASSERT_MSG_SIZE(mess_vfs_fs_putnode); 1971 1972 typedef struct { 1973 ino_t inode; 1974 1975 cp_grant_id_t grant; 1976 size_t mem_size; 1977 1978 uint8_t data[40]; 1979 } mess_vfs_fs_rdlink; 1980 _ASSERT_MSG_SIZE(mess_vfs_fs_rdlink); 1981 1982 typedef struct { 1983 dev_t device; 1984 1985 uint32_t flags; 1986 size_t path_len; 1987 cp_grant_id_t grant; 1988 1989 uint8_t data[36]; 1990 } mess_vfs_fs_readsuper; 1991 _ASSERT_MSG_SIZE(mess_vfs_fs_readsuper); 1992 1993 typedef struct { 1994 ino_t inode; 1995 off_t seek_pos; 1996 1997 cp_grant_id_t grant; 1998 size_t nbytes; 1999 2000 uint8_t data[32]; 2001 } mess_vfs_fs_readwrite; 2002 _ASSERT_MSG_SIZE(mess_vfs_fs_readwrite); 2003 2004 typedef struct { 2005 ino_t dir_old; 2006 ino_t dir_new; 2007 2008 size_t len_old; 2009 size_t len_new; 2010 cp_grant_id_t grant_old; 2011 cp_grant_id_t grant_new; 2012 2013 uint8_t data[24]; 2014 } mess_vfs_fs_rename; 2015 _ASSERT_MSG_SIZE(mess_vfs_fs_rename); 2016 2017 typedef struct { 2018 ino_t inode; 2019 2020 size_t path_len; 2021 size_t mem_size; 2022 cp_grant_id_t grant_path; 2023 cp_grant_id_t grant_target; 2024 uid_t uid; 2025 gid_t gid; 2026 2027 uint8_t data[24]; 2028 } mess_vfs_fs_slink; 2029 _ASSERT_MSG_SIZE(mess_vfs_fs_slink); 2030 2031 typedef struct { 2032 ino_t inode; 2033 2034 cp_grant_id_t grant; 2035 2036 uint8_t data[44]; 2037 } mess_vfs_fs_stat; 2038 _ASSERT_MSG_SIZE(mess_vfs_fs_stat); 2039 2040 typedef struct { 2041 cp_grant_id_t grant; 2042 2043 uint8_t data[52]; 2044 } mess_vfs_fs_statvfs; 2045 _ASSERT_MSG_SIZE(mess_vfs_fs_statvfs); 2046 2047 typedef struct { 2048 ino_t inode; 2049 2050 cp_grant_id_t grant; 2051 size_t path_len; 2052 2053 uint8_t data[40]; 2054 } mess_vfs_fs_unlink; 2055 _ASSERT_MSG_SIZE(mess_vfs_fs_unlink); 2056 2057 typedef struct { 2058 ino_t inode; 2059 time_t actime; 2060 time_t modtime; 2061 2062 uint32_t acnsec; 2063 uint32_t modnsec; 2064 2065 uint8_t data[24]; 2066 } mess_vfs_fs_utime; 2067 _ASSERT_MSG_SIZE(mess_vfs_fs_utime); 2068 2069 typedef struct { 2070 int fd0; 2071 int fd1; 2072 2073 uint8_t padding[48]; 2074 } mess_vfs_lc_fdpair; 2075 _ASSERT_MSG_SIZE(mess_vfs_lc_fdpair); 2076 2077 typedef struct { 2078 off_t offset; 2079 2080 uint8_t padding[48]; 2081 } mess_vfs_lc_lseek; 2082 _ASSERT_MSG_SIZE(mess_vfs_lc_lseek); 2083 2084 typedef struct { 2085 unsigned int len; /* socklen_t */ 2086 2087 uint8_t padding[52]; 2088 } mess_vfs_lc_socklen; 2089 _ASSERT_MSG_SIZE(mess_vfs_lc_socklen); 2090 2091 typedef struct { 2092 endpoint_t id; 2093 devminor_t minor; 2094 2095 uint8_t padding[48]; 2096 } mess_vfs_lchardriver_cancel; 2097 _ASSERT_MSG_SIZE(mess_vfs_lchardriver_cancel); 2098 2099 typedef struct { 2100 endpoint_t id; 2101 endpoint_t user; 2102 devminor_t minor; 2103 int access; 2104 2105 uint8_t padding[40]; 2106 } mess_vfs_lchardriver_openclose; 2107 _ASSERT_MSG_SIZE(mess_vfs_lchardriver_openclose); 2108 2109 typedef struct { 2110 off_t pos; 2111 cp_grant_id_t grant; 2112 size_t count; 2113 unsigned long request; 2114 int flags; 2115 endpoint_t id; 2116 endpoint_t user; 2117 devminor_t minor; 2118 2119 uint8_t padding[20]; 2120 } mess_vfs_lchardriver_readwrite; 2121 _ASSERT_MSG_SIZE(mess_vfs_lchardriver_readwrite); 2122 2123 typedef struct { 2124 devminor_t minor; 2125 int ops; 2126 2127 uint8_t padding[48]; 2128 } mess_vfs_lchardriver_select; 2129 _ASSERT_MSG_SIZE(mess_vfs_lchardriver_select); 2130 2131 typedef struct { 2132 time_t atime; 2133 time_t mtime; 2134 long ansec; 2135 long mnsec; 2136 size_t len; 2137 char *name; 2138 int fd; 2139 int flags; 2140 uint8_t padding[16]; 2141 } mess_vfs_utimens; 2142 _ASSERT_MSG_SIZE(mess_vfs_utimens); 2143 2144 typedef struct { 2145 off_t offset; 2146 dev_t dev; 2147 ino_t ino; 2148 endpoint_t who; 2149 u32_t vaddr; 2150 u32_t len; 2151 u32_t flags; 2152 u32_t fd; 2153 u16_t clearend; 2154 uint8_t padding[8]; 2155 } mess_vm_vfs_mmap; 2156 _ASSERT_MSG_SIZE(mess_vm_vfs_mmap); 2157 2158 typedef struct { 2159 dev_t dev; /* 64bits long. */ 2160 off_t dev_offset; 2161 off_t ino_offset; 2162 ino_t ino; 2163 void *block; 2164 u32_t *flags_ptr; 2165 u8_t pages; 2166 u8_t flags; 2167 uint8_t padding[12]; 2168 } mess_vmmcp; 2169 _ASSERT_MSG_SIZE(mess_vmmcp); 2170 2171 typedef struct { 2172 void *addr; 2173 u8_t flags; 2174 uint8_t padding[51]; 2175 } mess_vmmcp_reply; 2176 _ASSERT_MSG_SIZE(mess_vmmcp_reply); 2177 2178 typedef struct noxfer_message { 2179 endpoint_t m_source; /* who sent the message */ 2180 int m_type; /* what kind of message is it */ 2181 union { 2182 mess_u8 m_u8; 2183 mess_u16 m_u16; 2184 mess_u32 m_u32; 2185 mess_u64 m_u64; 2186 2187 mess_1 m_m1; 2188 mess_2 m_m2; 2189 mess_3 m_m3; 2190 mess_4 m_m4; 2191 mess_7 m_m7; 2192 mess_9 m_m9; 2193 mess_10 m_m10; 2194 2195 mess_ds_reply m_ds_reply; 2196 mess_ds_req m_ds_req; 2197 mess_fs_vfs_breadwrite m_fs_vfs_breadwrite; 2198 mess_fs_vfs_chmod m_fs_vfs_chmod; 2199 mess_fs_vfs_chown m_fs_vfs_chown; 2200 mess_fs_vfs_create m_fs_vfs_create; 2201 mess_fs_vfs_getdents m_fs_vfs_getdents; 2202 mess_fs_vfs_lookup m_fs_vfs_lookup; 2203 mess_fs_vfs_newnode m_fs_vfs_newnode; 2204 mess_fs_vfs_rdlink m_fs_vfs_rdlink; 2205 mess_fs_vfs_readsuper m_fs_vfs_readsuper; 2206 mess_fs_vfs_readwrite m_fs_vfs_readwrite; 2207 mess_i2c_li2cdriver_busc_i2c_exec m_i2c_li2cdriver_busc_i2c_exec; 2208 mess_i2c_li2cdriver_busc_i2c_reserve m_i2c_li2cdriver_busc_i2c_reserve; 2209 mess_input_linputdriver_input_conf m_input_linputdriver_input_conf; 2210 mess_input_linputdriver_setleds m_input_linputdriver_setleds; 2211 mess_input_tty_event m_input_tty_event; 2212 mess_krn_lsys_schedule m_krn_lsys_schedule; 2213 mess_krn_lsys_sys_devio m_krn_lsys_sys_devio; 2214 mess_krn_lsys_sys_fork m_krn_lsys_sys_fork; 2215 mess_krn_lsys_sys_getwhoami m_krn_lsys_sys_getwhoami; 2216 mess_krn_lsys_sys_irqctl m_krn_lsys_sys_irqctl; 2217 mess_krn_lsys_sys_times m_krn_lsys_sys_times; 2218 mess_krn_lsys_sys_trace m_krn_lsys_sys_trace; 2219 mess_krn_lsys_sys_umap m_krn_lsys_sys_umap; 2220 mess_krn_lsys_sys_vumap m_krn_lsys_sys_vumap; 2221 mess_lbdev_lblockdriver_msg m_lbdev_lblockdriver_msg; 2222 mess_lblockdriver_lbdev_reply m_lblockdriver_lbdev_reply; 2223 mess_lc_ipc_semctl m_lc_ipc_semctl; 2224 mess_lc_ipc_semget m_lc_ipc_semget; 2225 mess_lc_ipc_semop m_lc_ipc_semop; 2226 mess_lc_ipc_shmat m_lc_ipc_shmat; 2227 mess_lc_ipc_shmctl m_lc_ipc_shmctl; 2228 mess_lc_ipc_shmdt m_lc_ipc_shmdt; 2229 mess_lc_ipc_shmget m_lc_ipc_shmget; 2230 mess_lc_mib_sysctl m_lc_mib_sysctl; 2231 mess_lc_pm_exec m_lc_pm_exec; 2232 mess_lc_pm_exit m_lc_pm_exit; 2233 mess_lc_pm_getsid m_lc_pm_getsid; 2234 mess_lc_pm_groups m_lc_pm_groups; 2235 mess_lc_pm_itimer m_lc_pm_itimer; 2236 mess_lc_pm_mcontext m_lc_pm_mcontext; 2237 mess_lc_pm_priority m_lc_pm_priority; 2238 mess_lc_pm_ptrace m_lc_pm_ptrace; 2239 mess_lc_pm_reboot m_lc_pm_reboot; 2240 mess_lc_pm_rusage m_lc_pm_rusage; 2241 mess_lc_pm_setgid m_lc_pm_setgid; 2242 mess_lc_pm_setuid m_lc_pm_setuid; 2243 mess_lc_pm_sig m_lc_pm_sig; 2244 mess_lc_pm_sigset m_lc_pm_sigset; 2245 mess_lc_pm_sprof m_lc_pm_sprof; 2246 mess_lc_pm_sysuname m_lc_pm_sysuname; 2247 mess_lc_pm_time m_lc_pm_time; 2248 mess_lc_pm_wait4 m_lc_pm_wait4; 2249 mess_lc_readclock_rtcdev m_lc_readclock_rtcdev; 2250 mess_lc_svrctl m_lc_svrctl; 2251 mess_lc_vfs_chown m_lc_vfs_chown; 2252 mess_lc_vfs_close m_lc_vfs_close; 2253 mess_lc_vfs_creat m_lc_vfs_creat; 2254 mess_lc_vfs_fchdir m_lc_vfs_fchdir; 2255 mess_lc_vfs_fchmod m_lc_vfs_fchmod; 2256 mess_lc_vfs_fcntl m_lc_vfs_fcntl; 2257 mess_lc_vfs_fstat m_lc_vfs_fstat; 2258 mess_lc_vfs_fsync m_lc_vfs_fsync; 2259 mess_lc_vfs_gcov m_lc_vfs_gcov; 2260 mess_lc_vfs_getvfsstat m_lc_vfs_getvfsstat; 2261 mess_lc_vfs_ioctl m_lc_vfs_ioctl; 2262 mess_lc_vfs_link m_lc_vfs_link; 2263 mess_lc_vfs_listen m_lc_vfs_listen; 2264 mess_lc_vfs_lseek m_lc_vfs_lseek; 2265 mess_lc_vfs_mknod m_lc_vfs_mknod; 2266 mess_lc_vfs_mount m_lc_vfs_mount; 2267 mess_lc_vfs_path m_lc_vfs_path; 2268 mess_lc_vfs_pipe2 m_lc_vfs_pipe2; 2269 mess_lc_vfs_readlink m_lc_vfs_readlink; 2270 mess_lc_vfs_readwrite m_lc_vfs_readwrite; 2271 mess_lc_vfs_select m_lc_vfs_select; 2272 mess_lc_vfs_sendrecv m_lc_vfs_sendrecv; 2273 mess_lc_vfs_shutdown m_lc_vfs_shutdown; 2274 mess_lc_vfs_sockaddr m_lc_vfs_sockaddr; 2275 mess_lc_vfs_socket m_lc_vfs_socket; 2276 mess_lc_vfs_sockmsg m_lc_vfs_sockmsg; 2277 mess_lc_vfs_sockopt m_lc_vfs_sockopt; 2278 mess_lc_vfs_stat m_lc_vfs_stat; 2279 mess_lc_vfs_statvfs1 m_lc_vfs_statvfs1; 2280 mess_lc_vfs_truncate m_lc_vfs_truncate; 2281 mess_lc_vfs_umask m_lc_vfs_umask; 2282 mess_lc_vfs_umount m_lc_vfs_umount; 2283 mess_lc_vm_brk m_lc_vm_brk; 2284 mess_lc_vm_getphys m_lc_vm_getphys; 2285 mess_lc_vm_shm_unmap m_lc_vm_shm_unmap; 2286 mess_lchardriver_vfs_reply m_lchardriver_vfs_reply; 2287 mess_lchardriver_vfs_sel1 m_lchardriver_vfs_sel1; 2288 mess_lchardriver_vfs_sel2 m_lchardriver_vfs_sel2; 2289 mess_lexec_pm_exec_new m_lexec_pm_exec_new; 2290 mess_li2cdriver_i2c_busc_i2c_exec m_li2cdriver_i2c_busc_i2c_exec; 2291 mess_li2cdriver_i2c_busc_i2c_reserve m_li2cdriver_i2c_busc_i2c_reserve; 2292 mess_linputdriver_input_event m_linputdriver_input_event; 2293 mess_lsys_fi_ctl m_lsys_fi_ctl; 2294 mess_lsys_fi_reply m_lsys_fi_reply; 2295 mess_lsys_getsysinfo m_lsys_getsysinfo; 2296 mess_lsys_krn_readbios m_lsys_krn_readbios; 2297 mess_lsys_kern_safecopy m_lsys_kern_safecopy; 2298 mess_lsys_krn_schedctl m_lsys_krn_schedctl; 2299 mess_lsys_krn_schedule m_lsys_krn_schedule; 2300 mess_lsys_krn_sys_abort m_lsys_krn_sys_abort; 2301 mess_lsys_krn_sys_clear m_lsys_krn_sys_clear; 2302 mess_lsys_krn_sys_copy m_lsys_krn_sys_copy; 2303 mess_lsys_krn_sys_devio m_lsys_krn_sys_devio; 2304 mess_lsys_krn_sys_diagctl m_lsys_krn_sys_diagctl; 2305 mess_lsys_krn_sys_exec m_lsys_krn_sys_exec; 2306 mess_lsys_krn_sys_fork m_lsys_krn_sys_fork; 2307 mess_lsys_krn_sys_getinfo m_lsys_krn_sys_getinfo; 2308 mess_lsys_krn_sys_getmcontext m_lsys_krn_sys_getmcontext; 2309 mess_lsys_krn_sys_iopenable m_lsys_krn_sys_iopenable; 2310 mess_lsys_krn_sys_irqctl m_lsys_krn_sys_irqctl; 2311 mess_lsys_krn_sys_memset m_lsys_krn_sys_memset; 2312 mess_lsys_krn_sys_privctl m_lsys_krn_sys_privctl; 2313 mess_lsys_krn_sys_sdevio m_lsys_krn_sys_sdevio; 2314 mess_lsys_krn_sys_setalarm m_lsys_krn_sys_setalarm; 2315 mess_lsys_krn_sys_setgrant m_lsys_krn_sys_setgrant; 2316 mess_lsys_krn_sys_setmcontext m_lsys_krn_sys_setmcontext; 2317 mess_lsys_krn_sys_settime m_lsys_krn_sys_settime; 2318 mess_lsys_krn_sys_sprof m_lsys_krn_sys_sprof; 2319 mess_lsys_krn_sys_statectl m_lsys_krn_sys_statectl; 2320 mess_lsys_krn_sys_stime m_lsys_krn_sys_stime; 2321 mess_lsys_krn_sys_times m_lsys_krn_sys_times; 2322 mess_lsys_krn_sys_trace m_lsys_krn_sys_trace; 2323 mess_lsys_krn_sys_umap m_lsys_krn_sys_umap; 2324 mess_lsys_krn_sys_vdevio m_lsys_krn_sys_vdevio; 2325 mess_lsys_krn_sys_vumap m_lsys_krn_sys_vumap; 2326 mess_lsys_kern_vsafecopy m_lsys_kern_vsafecopy; 2327 mess_lsys_mib_register m_lsys_mib_register; 2328 mess_lsys_mib_reply m_lsys_mib_reply; 2329 mess_lsys_pci_busc_get_bar m_lsys_pci_busc_get_bar; 2330 mess_lsys_pm_getepinfo m_lsys_pm_getepinfo; 2331 mess_lsys_pm_getprocnr m_lsys_pm_getprocnr; 2332 mess_lsys_pm_proceventmask m_lsys_pm_proceventmask; 2333 mess_lsys_pm_srv_fork m_lsys_pm_srv_fork; 2334 mess_lsys_sched_scheduling_start m_lsys_sched_scheduling_start; 2335 mess_lsys_sched_scheduling_stop m_lsys_sched_scheduling_stop; 2336 mess_lsys_tty_fkey_ctl m_lsys_tty_fkey_ctl; 2337 mess_lsys_vfs_checkperms m_lsys_vfs_checkperms; 2338 mess_lsys_vfs_copyfd m_lsys_vfs_copyfd; 2339 mess_lsys_vfs_mapdriver m_lsys_vfs_mapdriver; 2340 mess_lsys_vm_getref m_lsys_vm_getref; 2341 mess_lsys_vm_info m_lsys_vm_info; 2342 mess_lsys_vm_map_phys m_lsys_vm_map_phys; 2343 mess_lsys_vm_rusage m_lsys_vm_rusage; 2344 mess_lsys_vm_unmap_phys m_lsys_vm_unmap_phys; 2345 mess_lsys_vm_update m_lsys_vm_update; 2346 mess_lsys_vm_vmremap m_lsys_vm_vmremap; 2347 mess_mib_lc_sysctl m_mib_lc_sysctl; 2348 mess_mib_lsys_call m_mib_lsys_call; 2349 mess_mib_lsys_info m_mib_lsys_info; 2350 mess_mmap m_mmap; 2351 mess_net_netdrv_dl_conf m_net_netdrv_dl_conf; 2352 mess_net_netdrv_dl_getstat_s m_net_netdrv_dl_getstat_s; 2353 mess_net_netdrv_dl_readv_s m_net_netdrv_dl_readv_s; 2354 mess_net_netdrv_dl_writev_s m_net_netdrv_dl_writev_s; 2355 mess_netdrv_net_dl_conf m_netdrv_net_dl_conf; 2356 mess_netdrv_net_dl_task m_netdrv_net_dl_task; 2357 mess_notify m_notify; 2358 mess_pci_lsys_busc_get_bar m_pci_lsys_busc_get_bar; 2359 mess_pm_lc_getgid m_pm_lc_getgid; 2360 mess_pm_lc_getpid m_pm_lc_getpid; 2361 mess_pm_lc_getuid m_pm_lc_getuid; 2362 mess_pm_lc_ptrace m_pm_lc_ptrace; 2363 mess_pm_lc_sigset m_pm_lc_sigset; 2364 mess_pm_lc_time m_pm_lc_time; 2365 mess_pm_lc_wait4 m_pm_lc_wait4; 2366 mess_pm_lexec_exec_new m_pm_lexec_exec_new; 2367 mess_pm_lsys_getepinfo m_pm_lsys_getepinfo; 2368 mess_pm_lsys_getprocnr m_pm_lsys_getprocnr; 2369 mess_pm_lsys_proc_event m_pm_lsys_proc_event; 2370 mess_pm_lsys_sigs_signal m_pm_lsys_sigs_signal; 2371 mess_pm_sched_scheduling_set_nice m_pm_sched_scheduling_set_nice; 2372 mess_pty_ptyfs_req m_pty_ptyfs_req; 2373 mess_ptyfs_pty_name m_ptyfs_pty_name; 2374 mess_readclock_lc_rtcdev m_readclock_lc_rtcdev; 2375 mess_rs_init m_rs_init; 2376 mess_rs_pm_exec_restart m_rs_pm_exec_restart; 2377 mess_rs_pm_srv_kill m_rs_pm_srv_kill; 2378 mess_rs_req m_rs_req; 2379 mess_rs_update m_rs_update; 2380 mess_sched_lsys_scheduling_start m_sched_lsys_scheduling_start; 2381 mess_sigcalls m_sigcalls; 2382 mess_tty_lsys_fkey_ctl m_tty_lsys_fkey_ctl; 2383 mess_vfs_fs_breadwrite m_vfs_fs_breadwrite; 2384 mess_vfs_fs_chmod m_vfs_fs_chmod; 2385 mess_vfs_fs_chown m_vfs_fs_chown; 2386 mess_vfs_fs_create m_vfs_fs_create; 2387 mess_vfs_fs_flush m_vfs_fs_flush; 2388 mess_vfs_fs_ftrunc m_vfs_fs_ftrunc; 2389 mess_vfs_fs_getdents m_vfs_fs_getdents; 2390 mess_vfs_fs_inhibread m_vfs_fs_inhibread; 2391 mess_vfs_fs_link m_vfs_fs_link; 2392 mess_vfs_fs_lookup m_vfs_fs_lookup; 2393 mess_vfs_fs_mkdir m_vfs_fs_mkdir; 2394 mess_vfs_fs_mknod m_vfs_fs_mknod; 2395 mess_vfs_fs_mountpoint m_vfs_fs_mountpoint; 2396 mess_vfs_fs_new_driver m_vfs_fs_new_driver; 2397 mess_vfs_fs_newnode m_vfs_fs_newnode; 2398 mess_vfs_fs_putnode m_vfs_fs_putnode; 2399 mess_vfs_fs_rdlink m_vfs_fs_rdlink; 2400 mess_vfs_fs_readsuper m_vfs_fs_readsuper; 2401 mess_vfs_fs_readwrite m_vfs_fs_readwrite; 2402 mess_vfs_fs_rename m_vfs_fs_rename; 2403 mess_vfs_fs_slink m_vfs_fs_slink; 2404 mess_vfs_fs_stat m_vfs_fs_stat; 2405 mess_vfs_fs_statvfs m_vfs_fs_statvfs; 2406 mess_vfs_fs_unlink m_vfs_fs_unlink; 2407 mess_vfs_fs_utime m_vfs_fs_utime; 2408 mess_vfs_lc_fdpair m_vfs_lc_fdpair; 2409 mess_vfs_lc_lseek m_vfs_lc_lseek; 2410 mess_vfs_lc_socklen m_vfs_lc_socklen; 2411 mess_vfs_lchardriver_cancel m_vfs_lchardriver_cancel; 2412 mess_vfs_lchardriver_openclose m_vfs_lchardriver_openclose; 2413 mess_vfs_lchardriver_readwrite m_vfs_lchardriver_readwrite; 2414 mess_vfs_lchardriver_select m_vfs_lchardriver_select; 2415 mess_vfs_utimens m_vfs_utimens; 2416 mess_vm_vfs_mmap m_vm_vfs_mmap; 2417 mess_vmmcp m_vmmcp; 2418 mess_vmmcp_reply m_vmmcp_reply; 2419 2420 u8_t size[56]; /* message payload may have 56 bytes at most */ 2421 }; 2422 } message __ALIGNED(16); 2423 2424 /* Ensure the complete union respects the IPC assumptions. */ 2425 typedef int _ASSERT_message[/* CONSTCOND */sizeof(message) == 64 ? 1 : -1]; 2426 2427 /* The following defines provide names for useful members. */ 2428 #define m1_i1 m_m1.m1i1 2429 #define m1_i2 m_m1.m1i2 2430 #define m1_i3 m_m1.m1i3 2431 #define m1_p1 m_m1.m1p1 2432 #define m1_p2 m_m1.m1p2 2433 #define m1_p3 m_m1.m1p3 2434 #define m1_p4 m_m1.m1p4 2435 #define m1_ull1 m_m1.m1ull1 2436 2437 #define m2_ll1 m_m2.m2ll1 2438 #define m2_i1 m_m2.m2i1 2439 #define m2_i2 m_m2.m2i2 2440 #define m2_i3 m_m2.m2i3 2441 #define m2_l1 m_m2.m2l1 2442 #define m2_l2 m_m2.m2l2 2443 #define m2_p1 m_m2.m2p1 2444 #define m2_sigset m_m2.sigset 2445 2446 #define m2_s1 m_m2.m2s1 2447 2448 #define m3_i1 m_m3.m3i1 2449 #define m3_i2 m_m3.m3i2 2450 #define m3_p1 m_m3.m3p1 2451 #define m3_ca1 m_m3.m3ca1 2452 2453 #define m4_ll1 m_m4.m4ll1 2454 #define m4_l1 m_m4.m4l1 2455 #define m4_l2 m_m4.m4l2 2456 #define m4_l3 m_m4.m4l3 2457 #define m4_l4 m_m4.m4l4 2458 #define m4_l5 m_m4.m4l5 2459 2460 #define m7_i1 m_m7.m7i1 2461 #define m7_i2 m_m7.m7i2 2462 #define m7_i3 m_m7.m7i3 2463 #define m7_i4 m_m7.m7i4 2464 #define m7_i5 m_m7.m7i5 2465 #define m7_p1 m_m7.m7p1 2466 #define m7_p2 m_m7.m7p2 2467 2468 #define m9_l1 m_m9.m9l1 2469 #define m9_l2 m_m9.m9l2 2470 #define m9_l3 m_m9.m9l3 2471 #define m9_l4 m_m9.m9l4 2472 #define m9_l5 m_m9.m9l5 2473 #define m9_s1 m_m9.m9s1 2474 #define m9_s2 m_m9.m9s2 2475 #define m9_s3 m_m9.m9s3 2476 #define m9_s4 m_m9.m9s4 2477 #define m9_ull1 m_m9.m9ull1 2478 #define m9_ull2 m_m9.m9ull2 2479 2480 #define m10_i1 m_m10.m10i1 2481 #define m10_i2 m_m10.m10i2 2482 #define m10_i3 m_m10.m10i3 2483 #define m10_i4 m_m10.m10i4 2484 #define m10_l1 m_m10.m10l1 2485 #define m10_l2 m_m10.m10l2 2486 #define m10_l3 m_m10.m10l3 2487 #define m10_ull1 m_m10.m10ull1 2488 2489 2490 /*==========================================================================* 2491 * Minix run-time system (IPC). * 2492 *==========================================================================*/ 2493 2494 /* Datastructure for asynchronous sends */ 2495 typedef struct asynmsg 2496 { 2497 unsigned flags; 2498 endpoint_t dst; 2499 int result; 2500 message msg; 2501 } asynmsg_t; 2502 2503 /* Defines for flags field */ 2504 #define AMF_EMPTY 000 /* slot is not inuse */ 2505 #define AMF_VALID 001 /* slot contains message */ 2506 #define AMF_DONE 002 /* Kernel has processed the message. The 2507 * result is stored in 'result' 2508 */ 2509 #define AMF_NOTIFY 004 /* Send a notification when AMF_DONE is set */ 2510 #define AMF_NOREPLY 010 /* Not a reply message for a SENDREC */ 2511 #define AMF_NOTIFY_ERR 020 /* Send a notification when AMF_DONE is set and 2512 * delivery of the message failed */ 2513 2514 int _ipc_send_intr(endpoint_t dest, message *m_ptr); 2515 int _ipc_receive_intr(endpoint_t src, message *m_ptr, int *status_ptr); 2516 int _ipc_sendrec_intr(endpoint_t src_dest, message *m_ptr); 2517 int _ipc_sendnb_intr(endpoint_t dest, message *m_ptr); 2518 int _ipc_notify_intr(endpoint_t dest); 2519 int _ipc_senda_intr(asynmsg_t *table, size_t count); 2520 2521 int _do_kernel_call_intr(message *m_ptr); 2522 2523 int ipc_minix_kerninfo(struct minix_kerninfo **); 2524 2525 /* Hide names to avoid name space pollution. */ 2526 #define ipc_notify _ipc_notify 2527 #define ipc_sendrec _ipc_sendrec 2528 #define ipc_receive _ipc_receive 2529 #define ipc_receivenb _ipc_receivenb 2530 #define ipc_send _ipc_send 2531 #define ipc_sendnb _ipc_sendnb 2532 #define ipc_senda _ipc_senda 2533 2534 #define do_kernel_call _do_kernel_call 2535 2536 struct minix_ipcvecs { 2537 int (*send)(endpoint_t dest, message *m_ptr); 2538 int (*receive)(endpoint_t src, message *m_ptr, int *st); 2539 int (*sendrec)(endpoint_t src_dest, message *m_ptr); 2540 int (*sendnb)(endpoint_t dest, message *m_ptr); 2541 int (*notify)(endpoint_t dest); 2542 int (*do_kernel_call)(message *m_ptr); 2543 int (*senda)(asynmsg_t *table, size_t count); 2544 }; 2545 2546 /* kernel-set IPC vectors retrieved by a constructor in 2547 * minix/lib/libc/sys/init.c */ 2548 extern struct minix_ipcvecs _minix_ipcvecs; 2549 2550 static inline int _ipc_send(endpoint_t dest, message *m_ptr) 2551 { 2552 return _minix_ipcvecs.send(dest, m_ptr); 2553 } 2554 2555 static inline int _ipc_receive(endpoint_t src, message *m_ptr, int *st) 2556 { 2557 return _minix_ipcvecs.receive(src, m_ptr, st); 2558 } 2559 2560 static inline int _ipc_sendrec(endpoint_t src_dest, message *m_ptr) 2561 { 2562 return _minix_ipcvecs.sendrec(src_dest, m_ptr); 2563 } 2564 2565 static inline int _ipc_sendnb(endpoint_t dest, message *m_ptr) 2566 { 2567 return _minix_ipcvecs.sendnb(dest, m_ptr); 2568 } 2569 2570 static inline int _ipc_notify(endpoint_t dest) 2571 { 2572 return _minix_ipcvecs.notify(dest); 2573 } 2574 2575 static inline int _do_kernel_call(message *m_ptr) 2576 { 2577 return _minix_ipcvecs.do_kernel_call(m_ptr); 2578 } 2579 2580 static inline int _ipc_senda(asynmsg_t *table, size_t count) 2581 { 2582 return _minix_ipcvecs.senda(table, count); 2583 } 2584 2585 #endif /* _IPC_H */ 2586