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