What is GNU Hurd
The specific timeline has been described in detail on the official wiki page [0], I will briefly describe it here. In 1983, Richard Stallman launched the GNU project with the goal of creating a free operating system [1]. Various software has been in place in the following development, including the compiler GNU Compiler Collection, editor Emacs, C library GNU C Library, debugger GNU Debugger, and a complete list can be viewed.This link. I believe that most Linux-based distributions have more or less installed these software, although not many people may have noticed it. The most important question is what should these applications run on, and the answer is GNU Hurd. As the official Wiki said[0], After the project was announced in 1983, the kernel that GNU was preparing to use was not determined for a long time, and then in 1991, a more detailed plan was established: it decided to use the Mach microkernel developed by CMU and write the Hurd system on it [0]。
A little off topic: At that time, it was actually expected that it would reach the scale of Linux systems today, one is FreeBSD and the other is GNU Hurd. But FreeBSD was caught in legal disputes for a while, while GNU Hurd was slow in development. The source of the information in the previous sentence: The author remembers correctly is from "UNIX Programming Art". Linus also said, "If the GNU kernel could already be used in production in the spring of 1991, he would not have started the Linux project: but the fact is not."[3]
Microkernel
In simple terms, the microkernel puts most of the functions in userspace. Take Linux as an exampleThis linkA driver code pointing to RTC (Real-Time Clock), and for GNU Hurd, Mach is its kernel, and code with similar functions to Linux's RTC driver code [2] does not belong to Mach, that is, it is not in kernel space but in user space. One of the benefits can be seen is that if there is a bug in the RTC driver, it will cause a crash. In Hurd, only the process running the RTC driver code will crash, while Linux will directly crash. This is also one of the commonly believed benefits of microkernels. The benefits of microkernels are because I think my ears are getting callused, so I won’t say too much here. Let’s talk about the disadvantages next. What I hear most often is the performance degradation caused by frequent context switches due to frequent use of IPCs. This problem isThis paperIt is mentioned that although the paper uses the second generation microkernel of L4 instead of the first generation microkernel member of Mach to compare with single kernel, L4 has made very powerful optimizations in process communication (IPC), so the author believes that it will better reflect the performance gap between single kernel and microkernel than Mach. The experiment used L4-based Linux, namely L4Linux, and pure Linux, for performance comparison, and concluded that the performance drop caused by the microkernel to the application is about 5% to 10%.
Something goes awkward: Because I don’t have a deep understanding of microkernels, but I found this one very good one.article, tells the characteristics of the three generations of microkernels. Recommended to interested readers.
Multi-servers and process communication (IPC)
As introduced in the Hurd main interface, Hurd is a series of servers (servers) running on Mach, and these servers implement the functions that are possessed by file systems, network protocols, and other Unix kernels or similar kernels. Take the RTC driver mentioned in the previous paragraph as an example. This RTC driver is run by a process like a server. After a message (information) is sent to the RTC driver server process, the RTC server will read or write to the RTC hardware according to the information requirements. If it is read, it will send back the read. The important task of passing information (i.e. Inter-Process Communication) is to be accomplished by the microkernel Mach.
Mach Interface Generator (Mach Interface Generator)
Mach has its own interface to allow other programs to use IPC functions, because Mach's interface needs to take into account most of the situations as much as possible, so it is actually relatively complicated to use directly. To alleviate this problem, the Mach Interface Generator is generally used by the development company [5]. It can hide the complexity of constructing message(information). However, the reason for writing this article is the following link:
/pub/people/neal/papers/hurd-misc/
The goal of this exercise is to write a program that uses Mach to complete information transmission and then get a return without using MIG. It is used to deepen the impression of Mach IPC.
For readers who want to tinker with themselves, the author will put the links useful for practice here. The search bar of GNU Hurd's official website is very useful. Please make good use of it:
/~hurd-web/
/~hurd-web/microkernel/mach/documentation/
/afs/cs/project/mach/public/doc/osf/kernel_principles.ps
/afs/cs/project/mach/public/doc/osf/kernel_interface.ps
/afs/cs/project/mach/public/doc/osf/server_writer.ps
Running GNU Hurd in a virtual machine
GNU Hurd can run on real hardware, but due to insufficient device drivers, the current GNU Hurd can only run on several older Thinkpad notebooks [6]. It is perfectly enough for the virtual machine to experience or complete this exercise.
The relatively stable distribution at present is Debian. The 64-bit system is not very complete yet, so we first use the 32-bit one. Can beThis linkView all available Images in . We can run the following instructions to get a 32-bit Debian GNU Hurd Image.
wget /cdimage/ports/latest/hurd-i386/current/
Then unzip the file:
gzip -d
The author usesqemu, so use this instruction to run:
qemu-system-i386 -enable-kvm -m 2G -drive \
format=raw,cache=writeback,file= \
-nic user,hostfwd=tcp::2222-:22 -display curses -vga std
After startup is completed, you will see
Debian GNU/Hurd 12 debian tty3
login:
Direct inputrootThenEnterYou can enterbashNow. usepasswdGiverootAdd a password. useexitExit and use it againdemoLog in and then use itpasswdChange password[7]. usevimOr open the editor you like/etc/ssh/ssh_configBundlePasswordAuthentication yesThat's OK#Remove. Next we can open a new terminal and use itsshCome and operate on GNU Hurd:
ssh -p 2222 demo@localhost
Then all the preparations are completed, and you can start researching and practicing.
Mach IPC without MIG
The goal of the exercise is to create two threads in a process, one is the client and the other is the server. The client needs to send a message to the server and receive a response from a server. The information transmission requires the use of the Mach microkernel interface.
Two threads
Let's write out two threads first.
#include <>
#include <>
int
server (void *arg)
{
printf ("I'm server\n");
}
int
client (void *arg)
{
printf ("I'm client\n");
}
int
main (void)
{
thrd_t server_thrd, client_thrd;
thrd_create (&server_thrd, server, NULL);
thrd_create (&client_thrd, client, NULL);
thrd_join (server_thrd, NULL);
thrd_join (client_thrd, NULL);
return 0;
}
Use this instruction when compiling:
gcc -lpthread -o main
Ports
What we compiledmainThe executable file will be run by a thread at the beginning, and will be run to twothrd_createTwo more threads will be generated, so there will be three threads running our code in total. Of course, the route (routine) is different, one ismain(), one isserver()And the rest isclient(). As Mach 3 Kernel Principles[9As described in ], these three threads belong to the sametaskof. EachtaskThere will be oneport name space, eachport nameRepresents aport right，port nameIt is seen in user space, andport rightIt is managed by Mach, just like a file descriptor. Eachport rightIt represents againportandright。portIt is a unidirectional communication channel.rightIt representstaskCan followrightTogetherportOperations performed.rightTypes include receive rights, send rights, send rights, send-once rights, etc. [10]. Simply put, if you want to communicate with Mach, you need to have oneport. We can usemach_port_allocateCome to get oneport。
git diff：
diff --git a/ b/
index f73724a..2eb9f38 100644
--- a/
+++ b/
@@ -1,5 +1,8 @@
#include <>
#include <>
+#include <>
+
+static mach_port_t port;
int
server (void *arg)
@@ -17,6 +20,7 @@ int
main (void)
{
thrd_t server_thrd, client_thrd;
+ mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_RECEIVE, &port);
thrd_create (&server_thrd, server, NULL);
thrd_create (&client_thrd, client, NULL);
In this way we get one in our owntaskIn-houseport, and we are about thisportThen have the right to receive. Readers may want to ask whyclientandserverPut it in the sametask2. Instead of being separated. As described in the exercises[8], put in the sametaskThis is to simplify implementation, otherwise another topic about central name server will be involved.
Message
The structure of information is mentioned in the exercise description[8]：
Inline messages have the following general structure:
[ [mach_msg_header_t] [[mach_msg_type_t][data]] [[mach_msg_type_t][data]]... ]
^ ^ ^^ ^ ^
| | || | \- Second set of arguments
| | || \- First set of arguments
| \- Message header |\- Header for first set of arguments
\- Message \- Pay load
When data is marked out of line, the data section is detached.
We intend to have the Client send:"Alice\0"Give the Server and ask the Server to reply"Hello Alice\0", we can create a structure like this:git diff
diff --git a/ b/
index 2eb9f38..2307de1 100644
--- a/
+++ b/
@@ -2,6 +2,13 @@
#include <>
#include <>
+struct message
+{
+ mach_msg_header_t msg_header;
+ mach_msg_type_t first_header;
+ char string[100];
+};
+
static mach_port_t port;
int
@@ -13,6 +20,7 @@ server (void *arg)
int
client (void *arg)
{
+ struct message m;
printf ("I'm client\n");
}
Client
You can see it in the Mach kernel interfacemach_msgIt will be used to send and receivemessageThe interface function is now. The header file declaration ishere：
extern mach_msg_return_t
mach_msg
(mach_msg_header_t *msg,
mach_msg_option_t option,
mach_msg_size_t send_size,
mach_msg_size_t rcv_size,
mach_port_name_t rcv_name,
mach_msg_timeout_t timeout,
mach_port_name_t notify);
It can be seen that there are quite a lot of parameters, and the parameters are introduced in the Mach 3 Kernel Interface. I will boldly translate them here:
msg: A message buffer.
That is, this variable points to the area where the information header is stored. In our current code, it is&(m.msg_header). (The author thinks this is very similar to the message header in the network protocol)
option: Message options are bit values, combined with bitwise-or. One or both of MACH_SEND_MSG and MACH_RCV_MSG should be used.
As stated abovemach_msgIt can be sent and used for reception, and readers may be curiousMACH_SEND_MSG | MACH_RCV_MSGWhat does it mean. It means that after sending the message, you will also expect a message to be returned, and it is exactly what we want to use in the Client.
send_size: When sending a message, specifies the size of the message buffer. Otherwise zero should be supplied.
Please note that themessageNot"Alice\0"orHello Alice\0, but the one mentioned in the previous sectionmessage. So it'ssizeof (struct message)。
rcv_size: When receiving a message, specifies the size of the message buffer. Otherwise zero should be supplied.
Because we are also planning to receive a response, the value we want to fill in issizeof (struct message)。
rcv_name: When receiving a message, specifies the port or port set. Otherwise MACH_PORT_NULL should be supplied.
We will start from variablesportReceive information, so fill it out.
timeout and notify
We didn't care much during this exercise so we filled it outMACH_MSG_TIMEOUT_NONEandMACH_PORT_NULL。
So we're inClientUsed inmach_msgIt will look like this:
mach_msg (&(m.msg_header), MACH_SEND_MSG | MACH_RCV_MSG, sizeof (struct message), sizeof (struct message), port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
Of course, before this, variables need to be addedmsome initializations.
First recorded on page 327 of Mach 3 Kernel Interfacemach_msg_header：
typedef struct mach_msg_header {
mach_msg_bits_t msgh_bits;
mach_msg_size_t msgh_size;
mach_port_t msgh_remote_port;
mach_port_t msgh_local_port;
mach_port_seqno_t msgh_seqno;
mach_msg_id_t msgh_id;
} mach_msg_header_t;
There are many parameters that can be seen.
msgh_bits
Remember we aremainThe assigned one inrightIs that a send permission, and as mentioned in the exercise:
Mach ports: how to allocate send and receive rights (the former implicitly in mach_msg and the latter directly via mach_port_allocate).
We will be inmsgh_bitsAssign send permissions in the We'll givemsgh_bitsfillMACH_MSGH_BITS (MACH_MSG_TYPE_MAKE_SEND, 0). This operation means that after putting a variablemsgh_remote_portThe mentionedportSend permission tomessagemiddle. Yes, permissions can be transmitted through IPC in Mach, which is also the embodiment of capability-based. Because in frontmach_msgFilled inportThe recipient is still ourstask, so we can get a send permission. Of course, there is a prerequisite for sharing permissions, you can see it in the source codeMACH_MSG_TYPE_MAKE_SENDThe premise is to hold send permissions, and we are already inmainGet send permission[12]。
msgh_size
Fill insizeof (struct message)Just do it.
msgh_remote_port: When sending, specifies the destination port of the message. The field must carry a legitimate send or send-once right for a port. When received, this field is swapped with msgh_local_port.
In this exercise, it's variablesport. Because we aremsgh_bitsIn the operation in, we will have a send permission.
msgh_local_port: When sending, specifies an auxiliary port right, which is conventionally used as a reply port by the recipient of the message. ......
take overportLet's fill in itMACH_PORT_NULL。
msgh_seqno: The sequence number of this message relative to the port from which it is received. This field is ignored on sent messages.
Because it's just onemessage, fill in 0.
msgh_id: Not set or read by the mach_msg call. ......
We can't use it, so we don't care.
So the result will be as follows:
m.msg_header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0);
m.msg_header.msgh_size = sizeof (struct message);
m.msg_header.msgh_remote_port = port;
m.msg_header.msgh_local_port = MACH_PORT_NULL;
m.msg_header.msgh_seqno = 0;
Next ism.first_header, described in Mach 3 Kernel Interface 330 pages.
typedef struct {
unsigned int msgt_name : 8,
msgt_size : 8,
msgt_number : 12,
msgt_inline : 1,
msgt_longform : 1,
msgt_deallocate : 1,
msgt_unused : 1;
} mach_msg_type_t
msgt_name
The data we want to transmit is"Alice\0"and"Hello Alice\0", so it isMACH_MSG_TYPE_STRING_C。
msgt_size: Specifies the size of each datum, in bits.
onecharIt is one byte, that is, 8 bits, so it is 8.
msgt_number: Specifies how many data elements comprise the data item.
We chose 100.
msgt_inline: When FALSE, specifies that the data actucally resides in an out-of-line region. ......
Our information is short and can exist directlymessageSo it'strue。
msgt_longform: Specifies, when TRUE, that this type descriptor is a mach_msg_type_long_t instead of a mach_msg_type_t.
we aremach_msg_type_tSo it'sfalse。
msgt_unused: Not used, should be zero.
That's 0.
So the result is as follows:
m.first_header.msgt_name = MACH_MSG_TYPE_STRING_C;
m.first_header.msgt_size = 8;
m.first_header.msgt_number = 100;
m.first_header.msgt_inline = true;
m.first_header.msgt_longform = false;
m.first_header.msgt_unused = 0;
Finally, let's integrate:git diff
diff --git a/ b/
index 2307de1..fcea63d 100644
--- a/
+++ b/
@@ -1,6 +1,8 @@
#include <>
#include <>
#include <>
+#include <>
+#include <>
struct message
{
@@ -21,7 +23,28 @@ int
client (void *arg)
{
struct message m;
- printf ("I'm client\n");
+ mach_msg_return_t err;
+
+ m.msg_header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0);
+ m.msg_header.msgh_size = sizeof (struct message);
+ m.msg_header.msgh_remote_port = port;
+ m.msg_header.msgh_local_port = MACH_PORT_NULL;
+ m.msg_header.msgh_seqno = 0;
+
+ m.first_header.msgt_name = MACH_MSG_TYPE_STRING_C;
+ m.first_header.msgt_size = 8;
+ m.first_header.msgt_number = 100;
+ m.first_header.msgt_inline = true;
+ m.first_header.msgt_longform = false;
+ m.first_header.msgt_unused = 0;
+
+ strcpy (, "Alice\0");
+
+ err = mach_msg (&(m.msg_header), MACH_SEND_MSG | MACH_RCV_MSG, sizeof (struct message), sizeof (struct message), port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+
+ printf ("Client error code: %d\n", err);
+
+ printf ("From Server: %s\n", );
}
int
The author added oneerrCheck variablesmach_msgWhether it is successful, if it is run after compilation, you should see the following output:
I'm server
Client error code: 0
From Server: Alice
errThe value of 0 means that it is successful. Of course, this is not what we want in the end, we still have to put it intoServerI wrote it, the reason for this output isClientReceived it myselfmessagesomach_msgSuccessfully and printed"Alice\0"。
Server
The more difficult stage has passed, and the next operations are written as beforeClientIt was related.ServerReceive information first, so justMACH_RCV_MSGInsteadMACH_SEND_MSG | MACH_RCV_MSG。
git diff:
diff --git a/ b/
index fcea63d..8200286 100644
--- a/
+++ b/
@@ -16,7 +16,13 @@ static mach_port_t port;
int
server (void *arg)
{
- printf ("I'm server\n");
+ struct message m;
+ mach_msg_return_t err;
+
+ err = mach_msg (&(m.msg_header), MACH_RCV_MSG, sizeof (struct message), sizeof (struct message), port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+
+ printf ("Server receive error code: %d\n", err);
+ printf ("Server: from client: %s\n", );
}
int
Now if you compile and run it, we will see:
Server receive error code: 0
Server: from client: Alice
<Stuck here>Celebrate first! This meansServerSuccessfully fromClientReceived a message and stuck with the descriptionClientWaiting for coming fromServerReply. certainlyClientI will never wait for its reply in my life because we haven't written it yet. ThenCtrl-CEnd the process and write the last step up.
In fact, just copy the restClientJust send the method:git diff
diff --git a/ b/
index 8200286..03ed4e2 100644
--- a/
+++ b/
@@ -18,11 +18,32 @@ server (void *arg)
{
struct message m;
mach_msg_return_t err;
+ char s[100];
err = mach_msg (&(m.msg_header), MACH_RCV_MSG, sizeof (struct message), sizeof (struct message), port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
printf ("Server receive error code: %d\n", err);
printf ("Server: from client: %s\n", );
+
+ m.msg_header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0);
+ m.msg_header.msgh_size = sizeof (struct message);
+ m.msg_header.msgh_remote_port = port;
+ m.msg_header.msgh_local_port = MACH_PORT_NULL;
+ m.msg_header.msgh_seqno = 0;
+
+ m.first_header.msgt_name = MACH_MSG_TYPE_STRING_C;
+ m.first_header.msgt_size = 8;
+ m.first_header.msgt_number = 100;
+ m.first_header.msgt_inline = true;
+ m.first_header.msgt_longform = false;
+ m.first_header.msgt_unused = 0;
+
+ sprintf (s, "Hello %s\n\0", );
+ strcpy (, s);
+
+ err = mach_msg (&(m.msg_header), MACH_SEND_MSG, sizeof (struct message), sizeof (struct message), port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+
+ printf ("Server send error code: %d\n", err);
}
int
Finally compile and run the output:
Server receive error code: 0
Server: from client: Alice
Server send error code: 0
Server send error code: 0
Client error code: 0
From Server: Hello Alice
ClientSuccessfully receivedServerReply! Success! I just don't know why it happened twiceServer send error code: 0. But at least it was successful.
Finally, let's put a complete code:
#include <>
#include <>
#include <>
#include <>
#include <>
struct message
{
mach_msg_header_t msg_header;
mach_msg_type_t first_header;
char string[100];
};
static mach_port_t port;
int
server (void *arg)
{
struct message m;
mach_msg_return_t err;
char s[100];
err = mach_msg (&(m.msg_header), MACH_RCV_MSG, sizeof (struct message), sizeof (struct message), port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
printf ("Server receive error code: %d\n", err);
printf ("Server: from client: %s\n", );
m.msg_header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0);
m.msg_header.msgh_size = sizeof (struct message);
m.msg_header.msgh_remote_port = port;
m.msg_header.msgh_local_port = MACH_PORT_NULL;
m.msg_header.msgh_seqno = 0;
m.first_header.msgt_name = MACH_MSG_TYPE_STRING_C;
m.first_header.msgt_size = 8;
m.first_header.msgt_number = 100;
m.first_header.msgt_inline = true;
m.first_header.msgt_longform = false;
m.first_header.msgt_unused = 0;
sprintf (s, "Hello %s\n\0", );
strcpy (, s);
err = mach_msg (&(m.msg_header), MACH_SEND_MSG, sizeof (struct message), sizeof (struct message), port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
printf ("Server send error code: %d\n", err);
}
int
client (void *arg)
{
struct message m;
mach_msg_return_t err;
m.msg_header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0);
m.msg_header.msgh_size = sizeof (struct message);
m.msg_header.msgh_remote_port = port;
m.msg_header.msgh_local_port = MACH_PORT_NULL;
m.msg_header.msgh_seqno = 0;
m.first_header.msgt_name = MACH_MSG_TYPE_STRING_C;
m.first_header.msgt_size = 8;
m.first_header.msgt_number = 100;
m.first_header.msgt_inline = true;
m.first_header.msgt_longform = false;
m.first_header.msgt_unused = 0;
strcpy (, "Alice\0");
err = mach_msg (&(m.msg_header), MACH_SEND_MSG | MACH_RCV_MSG, sizeof (struct message), sizeof (struct message), port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
printf ("Client error code: %d\n", err);
printf ("From Server: %s\n", );
}
int
main (void)
{
thrd_t server_thrd, client_thrd;
mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_RECEIVE, &port);
thrd_create (&server_thrd, server, NULL);
thrd_create (&client_thrd, client, NULL);
thrd_join (server_thrd, NULL);
thrd_join (client_thrd, NULL);
return 0;
}
Summarize
You can see that MIG still helps developers reduce a lot of troubles. During the exercise, you can also feel more clearly what the IPC of the microkernel is. I would like to thank Hurd developers and the author of the practice for their efforts. Any incorrectness is welcome to point it out.
Author: chenw1
Link:/chenw1/p/18768256
This article comes from Blog Park and is welcome to reprint it, but please indicate the original link and retain this statement, otherwise the right to pursue legal liability is reserved.
All right reserved.