Question

我正在尝试在Mach上的两个进程之间发送消息（确切地说，这是使用Mach微内核的Debian 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

告诉我邮件已成功排队但停在那里并且没有继续从父进程的队列中读取。有什么想法吗？

Answer 1

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

我发现做你想做的最简单的方法是Kalle Niemitalo's suggestion：使用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。

另一种方法是在fork（）上修改Hurd的行为，但很少有应用程序交换原始Mach端口，我认为这没有意义。无论如何，Hurd上的fork（）不是一个简单的过程：你可以找到详细信息here。第207-449行是将港口权利复制到儿童的地方;只需简单的一瞥就可以了解赫德的fork（）有多复杂，以及为什么你的原创想法不起作用。

无法在两个进程Mach之间发送消息

1 个答案: