1

我正在尝试在 Mach 上的两个进程之间发送消息（准确地说，这是带有 Mach 微内核的 D​​ebian GNU/Hurd），这是我拥有的代码：

#define _GNU_SOURCE

#include "machheader.h"

void 
send_integer( mach_port_t destination, int i )
{
    kern_return_t err;
    struct integer_message message;

    /* (i) Form the message : */

    /* (i.a) Fill the header fields : */
    message.head.msgh_bits = 
        MACH_MSGH_BITS_REMOTE(MACH_MSG_TYPE_MAKE_SEND);
    message.head.msgh_size = sizeof( struct integer_message );
    message.head.msgh_local_port = MACH_PORT_NULL;
    message.head.msgh_remote_port = destination;

    /* (i.b) Explain the message type ( an integer ) */
    message.type.msgt_name = MACH_MSG_TYPE_INTEGER_32;
    message.type.msgt_size = 32;
    message.type.msgt_number = 1;
    message.type.msgt_inline = TRUE;
    message.type.msgt_longform = FALSE;
    message.type.msgt_deallocate = FALSE;
    /* message.type.msgt_unused = 0; */ /* not needed, I think */

    /* (i.c) Fill the message with the given integer : */
    message.inline_integer = i;

    /* (ii) Send the message : */
    err = mach_msg( &(message.head), MACH_SEND_MSG, 
            message.head.msgh_size, 0, MACH_PORT_NULL, 
            MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL );

    /* (iii) Analysis of the error code; 
    if succes, print and acknowledge message and return */
    if( err == MACH_MSG_SUCCESS )
      {
        printf( "success: the message was queued\n" );
      }
    else
      {
        perror( "error: some unexpected error ocurred!\n");
        exit(err);
      }

    return;
}

/* receive_integer is a function that receives an integer from some 
   mach port; it also hides the complexity of using the mach_msg 
   primitive to the user.

   receive_integer takes two arguments; the port where the message is going
   to come from with an integer inside, and a pointer to an integer in where
   the integer contained in the mentioned message will be stored.
*/
void 
receive_integer( mach_port_t source, int *ip )
{
    kern_return_t err;

    struct integer_message message;

    /* (i) Fill the little thing we know about the message : */
    /* message.head.msgh_size = sizeof(struct integer_message ); */

    /* (ii) Receive the message : */
    err = mach_msg( &(message.head), MACH_RCV_MSG, 0, 
            message.head.msgh_size, source,
            MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL );

    if( err == MACH_MSG_SUCCESS )
      {
        printf( "success: the message was received\n" );
      }
    else
      {
        perror( "error: Some unexpected error ocurred\n" );
        exit(err);
      }

    *ip = message.inline_integer;

    return;
}

/* main function of the program; it does the following :

   (i) allocate a port for receiving a message
   (ii) send a message containing an integer; 
   it uses the send_integer function
   (iii) receive the message and display it;
   it uses the receive_integer function
   (iv) deallocate the port
*/
int 
main( void )
{       
    //int s, r; /* s -> int sent, r -> int received */ 
    //mach_port_t destination;    

    kern_return_t err;

    /* Allocate a port to receive the bootstrap message : */
    err = mach_port_allocate( mach_task_self(), MACH_PORT_RIGHT_RECEIVE,
        &destination );

    if( err != KERN_SUCCESS )
      {
        perror( "Error : could not allocate any port\n" );
        exit(err);
      }

    if(!fork()){
        s=7;
        send_integer( destination, s );
    }else{
        receive_integer( destination, &r );
        printf("The received integer is : %d\n", r );
    }   

    mach_port_deallocate( mach_task_self(), destination );

    return(r);
}

这是 machheader.h：

#include <mach.h>

#include <stdio.h>
#include <error.h>

#include <errno.h>
#include <stdlib.h>
#include <string.h>

struct integer_message
{
    mach_msg_header_t head;
    mach_msg_type_t type;

    int inline_integer;
};

int s, r;   /* s -> int sent, r -> int received */ 
mach_port_t destination;

当我运行应用程序时，它给了我：

success: the message was queued

这告诉我消息已成功排队，但停在那里并且不会继续从父进程的队列中读取。任何想法？

4

1 回答 1

1

由于 Hurd 在 fork() 期间处理 Mach 端口的方式，此代码不起作用。一个 Mach 端口只能有一个接收权限，因此在 fork() 期间复制具有接收权限的端口，而复制发送权限（如文件描述符）。在这种情况下，destination当你 fork() 时你有一个接收权，所以孩子得到一个全新的端口。然后每个进程对自己的端口都有接收权，并且两个端口之间没有连接。

我发现做你想做的最简单的方法是Kalle Niemitalo 的建议：使用 Hurd 的proc服务器，它拥有系统中每个进程的任务端口的发送权限，并将它们发送给任何具有匹配 UID 的进程。任务端口几乎可以让您对进程执行任何操作：修改其内存、启动和停止其线程……以及更改其端口空间。

因此，在这种情况下，您希望孩子向父母发送消息。子进程可以使用父进程的 PID 获取到父进程的任务端口，然后提取到父destination端口的发送权限，然后向该端口发送消息。像这样：

if(!fork()){
    /* fork allocated a receive right in the child process, but it's not
       for the same port as in the parent process.  Deallocate that.  */
    mach_port_mod_refs (mach_task_self(), destination,
                        MACH_PORT_RIGHT_RECEIVE, -1);

    /* get a send right to the parent's task port */
    pid_t parent_pid = getppid ();
    task_t parent_task = pid2task (parent_pid);

    /* extract a send right to the parent's destination port */
    mach_port_t send_right;
    mach_port_type_t send_type;

    mach_port_extract_right (parent_task, destination,
                             MACH_MSG_TYPE_MAKE_SEND,
                             &send_right, &send_type);

    /* transmit to "send_right", not "destination" */
    s=7;
    send_integer( send_right, s );
}else{
    receive_integer( destination, &r );
    printf("The received integer is : %d\n", r );
}

子进程可以像这样对父进程进行操作似乎有点奇怪；但这是赫德的一个特点。 proc是一个高权限的服务器；它允许访问，因为两个进程具有相同的 UID。

另一种方法是修改 Hurd 在 fork() 上的行为，但很少有应用程序交换原始 Mach 端口，我认为这没有意义。无论如何，Hurd 上的 fork() 不是一个简单的过程：您可以在此处找到详细信息。第 207-449 行是将端口权限复制到子节点的位置；只需看一眼，您就可以了解赫德的 fork() 有多复杂，以及为什么您最初的想法不起作用。

于 2016-11-11T23:25:18.653 回答