xnu-6153.81.5.tar.gz

[apple/xnu.git] / osfmk / kern / mach_node.c

diff --git a/osfmk/kern/mach_node.c b/osfmk/kern/mach_node.c
index 4a0d96dc8903d918d5398fe9ea77e870d0065574..d0d03cf62d783a088480b5d778cc3a6d45f2f853 100644 (file)
--- a/osfmk/kern/mach_node.c
+++ b/osfmk/kern/mach_node.c
@@ -58,36 +58,36 @@
 
 #include <ipc/flipc.h>
 
 
 #include <ipc/flipc.h>
 

-#include <libkern/OSAtomic.h>          // OSAddAtomic64(), OSCompareAndSwap()
+#include <libkern/OSAtomic.h>           // OSAddAtomic64(), OSCompareAndSwap()

 #include <libkern/OSByteOrder.h>    // OSHostByteOrder()
 
 #pragma pack(4)
 
 #include <libkern/OSByteOrder.h>    // OSHostByteOrder()
 
 #pragma pack(4)
 

-#define MNL_NAME_TABLE_SIZE    (256)   // Hash is evenly distributed, so ^2 is ok
-#define MNL_NAME_HASH(name)    (name % MNL_NAME_TABLE_SIZE)
+#define MNL_NAME_TABLE_SIZE     (256)   // Hash is evenly distributed, so ^2 is ok
+#define MNL_NAME_HASH(name)     (name % MNL_NAME_TABLE_SIZE)

 
 /*** Visible outside mach_node layer ***/
 
 /*** Visible outside mach_node layer ***/

-mach_node_id_t                 localnode_id = -1;      // This node's FLIPC id.
+mach_node_id_t                  localnode_id = -1;      // This node's FLIPC id.

 #if MACH_FLIPC
 #if MACH_FLIPC

-mach_node_t                            localnode;                      // This node's mach_node_t struct
+mach_node_t                             localnode;                      // This node's mach_node_t struct

 
 
 /*** Private to mach_node layer ***/
 
 
 /*** Private to mach_node layer ***/

-static int                             mach_nodes_to_publish;
-static mach_node_t             mach_node_table[MACH_NODES_MAX];
+static int                              mach_nodes_to_publish;
+static mach_node_t              mach_node_table[MACH_NODES_MAX];

 static lck_spin_t       mach_node_table_lock_data;
 #define MACH_NODE_TABLE_LOCK()      lck_spin_lock(&mach_node_table_lock_data)
 #define MACH_NODE_TABLE_UNLOCK()    lck_spin_unlock(&mach_node_table_lock_data)
 #define MACH_NODE_TABLE_LOCK_INIT() lck_spin_init(&mach_node_table_lock_data, \
 static lck_spin_t       mach_node_table_lock_data;
 #define MACH_NODE_TABLE_LOCK()      lck_spin_lock(&mach_node_table_lock_data)
 #define MACH_NODE_TABLE_UNLOCK()    lck_spin_unlock(&mach_node_table_lock_data)
 #define MACH_NODE_TABLE_LOCK_INIT() lck_spin_init(&mach_node_table_lock_data, \

-                                                  &ipc_lck_grp, &ipc_lck_attr)
+                                                 &ipc_lck_grp, &ipc_lck_attr)

 
 

-static volatile SInt64 mnl_name_next;
-static queue_head_t            mnl_name_table[MNL_NAME_TABLE_SIZE];
+static volatile SInt64  mnl_name_next;
+static queue_head_t             mnl_name_table[MNL_NAME_TABLE_SIZE];

 static lck_spin_t       mnl_name_table_lock_data;
 #define MNL_NAME_TABLE_LOCK()       lck_spin_lock(&mnl_name_table_lock_data)
 #define MNL_NAME_TABLE_UNLOCK()     lck_spin_unlock(&mnl_name_table_lock_data)
 #define MNL_NAME_TABLE_LOCK_INIT()  lck_spin_init(&mnl_name_table_lock_data, \
 static lck_spin_t       mnl_name_table_lock_data;
 #define MNL_NAME_TABLE_LOCK()       lck_spin_lock(&mnl_name_table_lock_data)
 #define MNL_NAME_TABLE_UNLOCK()     lck_spin_unlock(&mnl_name_table_lock_data)
 #define MNL_NAME_TABLE_LOCK_INIT()  lck_spin_init(&mnl_name_table_lock_data, \

-                                                &ipc_lck_grp, &ipc_lck_attr)
+                                               &ipc_lck_grp, &ipc_lck_attr)

 
 static void mach_node_init(void);
 static void mnl_name_table_init(void);
 
 static void mach_node_init(void);
 static void mnl_name_table_init(void);


@@ -105,43 +105,43 @@ static kern_return_t mach_node_register(mach_node_t node);
 void
 mach_node_init(void)
 {
 void
 mach_node_init(void)
 {

-       mach_node_id_t node_id = 0;     // TODO: Read from device tree?
+       mach_node_id_t node_id = 0;     // TODO: Read from device tree?

        if (OSCompareAndSwap((UInt32)(HOST_LOCAL_NODE),
        if (OSCompareAndSwap((UInt32)(HOST_LOCAL_NODE),

-                         (UInt32)node_id,
-                         &localnode_id)) {
+           (UInt32)node_id,
+           &localnode_id)) {

                printf("mach_node_init(): localnode_id=%d of %d\n",
                printf("mach_node_init(): localnode_id=%d of %d\n",

-                         localnode_id, MACH_NODES_MAX);
+                   localnode_id, MACH_NODES_MAX);

                mach_node_table_init();
                mnl_name_table_init();
                flipc_init();
                mach_node_table_init();
                mnl_name_table_init();
                flipc_init();

-    } // TODO: else block until init is finished (init completion race)
+       } // TODO: else block until init is finished (init completion race)

 }
 
 void
 mach_node_table_init(void)
 {
 }
 
 void
 mach_node_table_init(void)
 {

-    MACH_NODE_TABLE_LOCK_INIT();
-    MACH_NODE_TABLE_LOCK();
+       MACH_NODE_TABLE_LOCK_INIT();
+       MACH_NODE_TABLE_LOCK();

 
 

-    /* Start with an enpty node table. */
-    bzero(mach_node_table, sizeof(mach_node_t) * MACH_NODES_MAX);
-    mach_nodes_to_publish = 0;
+       /* Start with an enpty node table. */
+       bzero(mach_node_table, sizeof(mach_node_t) * MACH_NODES_MAX);
+       mach_nodes_to_publish = 0;

 
 

-    /* Allocate localnode's struct */
-    localnode = mach_node_for_id_locked(localnode_id, 1, 1);
-    assert(MACH_NODE_VALID(localnode));
+       /* Allocate localnode's struct */
+       localnode = mach_node_for_id_locked(localnode_id, 1, 1);
+       assert(MACH_NODE_VALID(localnode));

 
 

-    MACH_NODE_TABLE_UNLOCK();
+       MACH_NODE_TABLE_UNLOCK();

 
 

-    /* Set up localnode's struct */
-    bzero(localnode, sizeof(localnode));
-    localnode->info.datamodel       = LOCAL_DATA_MODEL;
-    localnode->info.byteorder       = OSHostByteOrder();
-    localnode->info.proto_vers_min     = MNL_PROTOCOL_V1;
-    localnode->info.proto_vers_max     = MNL_PROTOCOL_V1;
-    localnode->proto_vers           = MNL_PROTOCOL_V1;
-    localnode->published            = 0;
-    localnode->active               = 1;
+       /* Set up localnode's struct */
+       bzero(localnode, sizeof(localnode));
+       localnode->info.datamodel       = LOCAL_DATA_MODEL;
+       localnode->info.byteorder       = OSHostByteOrder();
+       localnode->info.proto_vers_min      = MNL_PROTOCOL_V1;
+       localnode->info.proto_vers_max      = MNL_PROTOCOL_V1;
+       localnode->proto_vers           = MNL_PROTOCOL_V1;
+       localnode->published            = 0;
+       localnode->active               = 1;

 
        MACH_NODE_UNLOCK(localnode);
 }
 
        MACH_NODE_UNLOCK(localnode);
 }


@@ -156,46 +156,46 @@ mach_node_table_init(void)
 void
 mach_node_publish(mach_node_t node)
 {
 void
 mach_node_publish(mach_node_t node)
 {

-    kern_return_t kr;
-
-    if (!MACH_NODE_VALID(node) || (!node->active) || (node->published))
-        return; // node is invalid or not suitable for publication
-
-    ipc_port_t bs_port = localnode->bootstrap_port;
-    if (!IP_VALID(bs_port))
-        return; // No bootstrap server to notify!
-
-    /* Node is suitable and server is present, so make registration message */
-    struct mach_node_server_register_msg   msg;
-
-    msg.node_header.header.msgh_remote_port = bs_port;
-    msg.node_header.header.msgh_size = sizeof(msg);
-    msg.node_header.header.msgh_local_port = MACH_PORT_NULL;
-    msg.node_header.header.msgh_voucher_port = MACH_PORT_NULL;
-    msg.node_header.header.msgh_id = MACH_NODE_SERVER_MSG_ID;
-    msg.node_header.node_id = node->info.node_id;
-    msg.node_header.options = 0;
-    msg.datamodel = node->info.datamodel;
-    msg.byteorder = node->info.byteorder;
-
-    if (node == localnode) {
-        msg.node_header.identifier = MACH_NODE_SM_REG_LOCAL;
-        msg.node_header.header.msgh_bits =
-        MACH_MSGH_BITS_SET(MACH_MSG_TYPE_COPY_SEND, 0, 0, 0);
-    } else {
-        msg.node_header.identifier = MACH_NODE_SM_REG_REMOTE;
-        msg.node_header.header.msgh_local_port = node->bootstrap_port;
-        msg.node_header.header.msgh_bits = MACH_MSGH_BITS_SET
-        (MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND, 0, 0);
-    }
-
-    kr = mach_msg_send_from_kernel_proper(&msg.node_header.header,
-                                          sizeof (msg));
-    if (kr == KERN_SUCCESS) {
-        node->published = 1;
-        mach_nodes_to_publish--;
-    }
-    printf("mach_node_publish(%d)=%d\n", node->info.node_id, kr);
+       kern_return_t kr;
+
+       if (!MACH_NODE_VALID(node) || (!node->active) || (node->published)) {
+               return; // node is invalid or not suitable for publication
+       }
+       ipc_port_t bs_port = localnode->bootstrap_port;
+       if (!IP_VALID(bs_port)) {
+               return; // No bootstrap server to notify!
+       }
+       /* Node is suitable and server is present, so make registration message */
+       struct mach_node_server_register_msg   msg;
+
+       msg.node_header.header.msgh_remote_port = bs_port;
+       msg.node_header.header.msgh_size = sizeof(msg);
+       msg.node_header.header.msgh_local_port = MACH_PORT_NULL;
+       msg.node_header.header.msgh_voucher_port = MACH_PORT_NULL;
+       msg.node_header.header.msgh_id = MACH_NODE_SERVER_MSG_ID;
+       msg.node_header.node_id = node->info.node_id;
+       msg.node_header.options = 0;
+       msg.datamodel = node->info.datamodel;
+       msg.byteorder = node->info.byteorder;
+
+       if (node == localnode) {
+               msg.node_header.identifier = MACH_NODE_SM_REG_LOCAL;
+               msg.node_header.header.msgh_bits =
+                   MACH_MSGH_BITS_SET(MACH_MSG_TYPE_COPY_SEND, 0, 0, 0);
+       } else {
+               msg.node_header.identifier = MACH_NODE_SM_REG_REMOTE;
+               msg.node_header.header.msgh_local_port = node->bootstrap_port;
+               msg.node_header.header.msgh_bits = MACH_MSGH_BITS_SET
+                   (MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND, 0, 0);
+       }
+
+       kr = mach_msg_send_from_kernel_proper(&msg.node_header.header,
+           sizeof(msg));
+       if (kr == KERN_SUCCESS) {
+               node->published = 1;
+               mach_nodes_to_publish--;
+       }
+       printf("mach_node_publish(%d)=%d\n", node->info.node_id, kr);

 }
 
 /* Called whenever the node special port changes */
 }
 
 /* Called whenever the node special port changes */


@@ -203,49 +203,52 @@ void
 mach_node_port_changed(void)
 {
        ipc_port_t bs_port;
 mach_node_port_changed(void)
 {
        ipc_port_t bs_port;

-       
+

        mach_node_init(); // Lazy init of mach_node layer
        mach_node_init(); // Lazy init of mach_node layer

-       
+

        /* Cleanup previous bootstrap port if necessary */
        /* Cleanup previous bootstrap port if necessary */

-    MACH_NODE_LOCK(localnode);
-    flipc_node_retire(localnode);
+       MACH_NODE_LOCK(localnode);
+       flipc_node_retire(localnode);

        bs_port = localnode->bootstrap_port;
        if (IP_VALID(bs_port)) {
                localnode->bootstrap_port = IP_NULL;
                // TODO: destroy send right to outgoing bs_port
        }
        bs_port = localnode->bootstrap_port;
        if (IP_VALID(bs_port)) {
                localnode->bootstrap_port = IP_NULL;
                // TODO: destroy send right to outgoing bs_port
        }

-       
+

        kernel_get_special_port(host_priv_self(), HOST_NODE_PORT, &bs_port);
        assert(IP_VALID(bs_port));
        kernel_get_special_port(host_priv_self(), HOST_NODE_PORT, &bs_port);
        assert(IP_VALID(bs_port));

-    localnode->bootstrap_port = bs_port;
-    flipc_node_prepare(localnode);
-    MACH_NODE_UNLOCK(localnode);
+       localnode->bootstrap_port = bs_port;
+       flipc_node_prepare(localnode);
+       MACH_NODE_UNLOCK(localnode);

 
        /* Cleanup the publication state of all nodes in the table */
        MACH_NODE_TABLE_LOCK();
        // TODO:  Signup for bootstrap port death notifications
        localnode->active = 1;
 
        /* Cleanup the publication state of all nodes in the table */
        MACH_NODE_TABLE_LOCK();
        // TODO:  Signup for bootstrap port death notifications
        localnode->active = 1;

-       
+

        mach_nodes_to_publish = 0;
        mach_nodes_to_publish = 0;

-       
+

        int n;
        int n;

-       for (n=0; n<MACH_NODES_MAX; n++) {
-        mach_node_t np = mach_node_table[n];
+       for (n = 0; n < MACH_NODES_MAX; n++) {
+               mach_node_t np = mach_node_table[n];

                // Publish all active nodes (except the local node)
                // Publish all active nodes (except the local node)

-               if (!MACH_NODE_VALID(np))
+               if (!MACH_NODE_VALID(np)) {

                        continue;
                        continue;

+               }

                np->published = 0;
                np->published = 0;

-               if (np->active == 1)
+               if (np->active == 1) {

                        mach_nodes_to_publish++;
                        mach_nodes_to_publish++;

+               }

        }
        }

-       
+

        mach_node_publish(localnode); // Always publish local node first
        mach_node_publish(localnode); // Always publish local node first

-       
-       for (n=0; n<MACH_NODES_MAX; n++)
-        mach_node_publish(mach_node_table[n]);

 
 

-    MACH_NODE_TABLE_UNLOCK();
-       
+       for (n = 0; n < MACH_NODES_MAX; n++) {
+               mach_node_publish(mach_node_table[n]);
+       }
+
+       MACH_NODE_TABLE_UNLOCK();
+

        // TODO: notify all active nodes we are bootstrapped
 }
 
        // TODO: notify all active nodes we are bootstrapped
 }
 


@@ -255,13 +258,13 @@ mach_node_port_changed(void)
 mach_node_t
 mach_node_alloc_init(mach_node_id_t node_id)
 {
 mach_node_t
 mach_node_alloc_init(mach_node_id_t node_id)
 {

-    mach_node_t node = MACH_NODE_ALLOC();
-    if (MACH_NODE_VALID(node)) {
-        bzero(node, sizeof(struct mach_node));
-        MACH_NODE_LOCK_INIT(node);
-        node->info.node_id = node_id;
-    }
-    return node;
+       mach_node_t node = MACH_NODE_ALLOC();
+       if (MACH_NODE_VALID(node)) {
+               bzero(node, sizeof(struct mach_node));
+               MACH_NODE_LOCK_INIT(node);
+               node->info.node_id = node_id;
+       }
+       return node;

 }
 
 
 }
 
 


@@ -269,131 +272,136 @@ mach_node_alloc_init(mach_node_id_t node_id)
  *  registers it with the mach_node and flipc (if flipc is enabled) layers.
  */
 kern_return_t
  *  registers it with the mach_node and flipc (if flipc is enabled) layers.
  */
 kern_return_t

-mach_node_register(mach_node_t node)
-{
-    assert(MACH_NODE_VALID(node));
-    mach_node_id_t nid = node->info.node_id;
-    assert(MACH_NODE_ID_VALID(nid));
-
-    kern_return_t kr;
-    ipc_space_t proxy_space = IS_NULL;
-    ipc_pset_t  pp_set = IPS_NULL;          // pset for proxy ports
-    ipc_port_t  bs_port = MACH_PORT_NULL;
-    ipc_port_t  ack_port = MACH_PORT_NULL;
-
-    printf("mach_node_register(%d)\n", nid);
-
-    /* TODO: Support non-native byte order and data models */
-    if ((node->info.byteorder != OSHostByteOrder()) ||
-        (node->info.datamodel != LOCAL_DATA_MODEL)) {
-        printf("mach_node_register: unsupported byte order (%d) or width (%d)",
-                node->info.byteorder, node->info.datamodel);
-        return KERN_INVALID_ARGUMENT;
-    }
-
-    /* Create the space that holds all local rights assigned to <nid> */
-    kr = ipc_space_create_special(&proxy_space);
-    if (kr != KERN_SUCCESS)
-        goto out;
-    proxy_space->is_node_id = nid;
-
-    /* Create the bootstrap proxy port for this remote node */
-    bs_port = ipc_port_alloc_special(proxy_space);
-    if (bs_port == MACH_PORT_NULL) {
-        kr = KERN_RESOURCE_SHORTAGE;
-        goto out;
-    }
-
-    /* Create the control (ack) port for this remote node */
-    ack_port = ipc_port_alloc_special(proxy_space);
-    if (ack_port == MACH_PORT_NULL) {
-        kr = KERN_RESOURCE_SHORTAGE;
-        goto out;
-    }
-
-    /* Create the set that holds all proxy ports for this remote node */
-    pp_set = ipc_pset_alloc_special(proxy_space);
-    if (pp_set == IPS_NULL) {
-        kr = KERN_RESOURCE_SHORTAGE;
-        goto out;
-    }
-
-    /* Add the bootstrap port to the proxy port set */
-    uint64_t wq_link_id = waitq_link_reserve(NULL);
-    uint64_t wq_reserved_prepost = waitq_prepost_reserve(NULL, 10,
-                                                         WAITQ_DONT_LOCK);
-    ips_lock(pp_set);
-    ip_lock(bs_port);
-    ipc_pset_add(pp_set,
-                 bs_port,
-                 &wq_link_id,
-                 &wq_reserved_prepost);
-    ip_unlock(bs_port);
-    ips_unlock(pp_set);
-
-    waitq_link_release(wq_link_id);
-    waitq_prepost_release_reserve(wq_reserved_prepost);
-
-    /* Add the control port to the proxy port set */
-    wq_link_id = waitq_link_reserve(NULL);
-    wq_reserved_prepost = waitq_prepost_reserve(NULL, 10,
-                                                WAITQ_DONT_LOCK);
-    ips_lock(pp_set);
-    ip_lock(ack_port);
-    ipc_pset_add(pp_set,
-                 ack_port,
-                 &wq_link_id,
-                 &wq_reserved_prepost);
-    ip_unlock(ack_port);
-    ips_unlock(pp_set);
-
-    waitq_link_release(wq_link_id);
-    waitq_prepost_release_reserve(wq_reserved_prepost);
-
-    // Setup mach_node struct
-    node->published         = 0;
-    node->active                       = 1;
-    node->proxy_space          = proxy_space;
-    node->proxy_port_set       = pp_set;
-    node->bootstrap_port       = bs_port;
-    node->proto_vers        = node->info.proto_vers_max;
-    node->control_port      = ack_port;
-
-    // Place new mach_node struct into node table
-    MACH_NODE_TABLE_LOCK();
-
-    mach_node_t old_node = mach_node_table[nid];
-    if (!MACH_NODE_VALID(old_node) || (old_node->dead)) {
-        node->antecedent = old_node;
-        flipc_node_prepare(node);
-        mach_node_table[nid] = node;
-        mach_nodes_to_publish++;
-        mach_node_publish(node);
-        kr = KERN_SUCCESS;
-    } else {
-        printf("mach_node_register: id %d already active!", nid);
-        kr = KERN_FAILURE;
-    }
-    MACH_NODE_TABLE_UNLOCK();
+mach_node_register(mach_node_t  node)
+{
+       assert(MACH_NODE_VALID(node));
+       mach_node_id_t nid = node->info.node_id;
+       assert(MACH_NODE_ID_VALID(nid));
+
+       kern_return_t kr;
+       ipc_space_t proxy_space = IS_NULL;
+       ipc_pset_t  pp_set = IPS_NULL;      // pset for proxy ports
+       ipc_port_t  bs_port = MACH_PORT_NULL;
+       ipc_port_t  ack_port = MACH_PORT_NULL;
+
+       printf("mach_node_register(%d)\n", nid);
+
+       /* TODO: Support non-native byte order and data models */
+       if ((node->info.byteorder != OSHostByteOrder()) ||
+           (node->info.datamodel != LOCAL_DATA_MODEL)) {
+               printf("mach_node_register: unsupported byte order (%d) or width (%d)",
+                   node->info.byteorder, node->info.datamodel);
+               return KERN_INVALID_ARGUMENT;
+       }
+
+       /* Create the space that holds all local rights assigned to <nid> */
+       kr = ipc_space_create_special(&proxy_space);
+       if (kr != KERN_SUCCESS) {
+               goto out;
+       }
+       proxy_space->is_node_id = nid;
+
+       /* Create the bootstrap proxy port for this remote node */
+       bs_port = ipc_port_alloc_special(proxy_space, IPC_PORT_INIT_MESSAGE_QUEUE);
+       if (bs_port == MACH_PORT_NULL) {
+               kr = KERN_RESOURCE_SHORTAGE;
+               goto out;
+       }
+
+       /* Create the control (ack) port for this remote node */
+       ack_port = ipc_port_alloc_special(proxy_space, IPC_PORT_INIT_MESSAGE_QUEUE);
+       if (ack_port == MACH_PORT_NULL) {
+               kr = KERN_RESOURCE_SHORTAGE;
+               goto out;
+       }
+
+       /* Create the set that holds all proxy ports for this remote node */
+       pp_set = ipc_pset_alloc_special(proxy_space);
+       if (pp_set == IPS_NULL) {
+               kr = KERN_RESOURCE_SHORTAGE;
+               goto out;
+       }
+
+       waitq_set_lazy_init_link(pp_set);
+       /* Add the bootstrap port to the proxy port set */
+       uint64_t wq_link_id = waitq_link_reserve(NULL);
+       uint64_t wq_reserved_prepost = waitq_prepost_reserve(NULL, 10,
+           WAITQ_DONT_LOCK);
+       ips_lock(pp_set);
+       ip_lock(bs_port);
+       ipc_pset_add(pp_set,
+           bs_port,
+           &wq_link_id,
+           &wq_reserved_prepost);
+       ip_unlock(bs_port);
+       ips_unlock(pp_set);
+
+       waitq_link_release(wq_link_id);
+       waitq_prepost_release_reserve(wq_reserved_prepost);
+
+       /* Add the control port to the proxy port set */
+       wq_link_id = waitq_link_reserve(NULL);
+       wq_reserved_prepost = waitq_prepost_reserve(NULL, 10,
+           WAITQ_DONT_LOCK);
+       ips_lock(pp_set);
+       ip_lock(ack_port);
+       ipc_pset_add(pp_set,
+           ack_port,
+           &wq_link_id,
+           &wq_reserved_prepost);
+       ip_unlock(ack_port);
+       ips_unlock(pp_set);
+
+       waitq_link_release(wq_link_id);
+       waitq_prepost_release_reserve(wq_reserved_prepost);
+
+       // Setup mach_node struct
+       node->published         = 0;
+       node->active                        = 1;
+       node->proxy_space           = proxy_space;
+       node->proxy_port_set        = pp_set;
+       node->bootstrap_port        = bs_port;
+       node->proto_vers        = node->info.proto_vers_max;
+       node->control_port      = ack_port;
+
+       // Place new mach_node struct into node table
+       MACH_NODE_TABLE_LOCK();
+
+       mach_node_t old_node = mach_node_table[nid];
+       if (!MACH_NODE_VALID(old_node) || (old_node->dead)) {
+               node->antecedent = old_node;
+               flipc_node_prepare(node);
+               mach_node_table[nid] = node;
+               mach_nodes_to_publish++;
+               mach_node_publish(node);
+               kr = KERN_SUCCESS;
+       } else {
+               printf("mach_node_register: id %d already active!", nid);
+               kr = KERN_FAILURE;
+       }
+       MACH_NODE_TABLE_UNLOCK();

 
 out:
 
 out:

-    if (kr != KERN_SUCCESS) {   // Dispose of whatever we allocated
-        if (pp_set) {
-            ips_lock(pp_set);
-            ipc_pset_destroy(pp_set);
-        }
+       if (kr != KERN_SUCCESS) { // Dispose of whatever we allocated
+               if (pp_set) {
+                       ips_lock(pp_set);
+                       ipc_pset_destroy(proxy_space, pp_set);
+               }

 
 

-        if (bs_port)
-            ipc_port_dealloc_special(bs_port, proxy_space);
+               if (bs_port) {
+                       ipc_port_dealloc_special(bs_port, proxy_space);
+               }

 
 

-        if (ack_port)
-            ipc_port_dealloc_special(ack_port, proxy_space);
+               if (ack_port) {
+                       ipc_port_dealloc_special(ack_port, proxy_space);
+               }

 
 

-        if (proxy_space)
-            ipc_space_terminate(proxy_space);
-    }
+               if (proxy_space) {
+                       ipc_space_terminate(proxy_space);
+               }
+       }

 
 

-    return kr;
+       return kr;

 }
 
 
 }
 
 


@@ -408,27 +416,29 @@ out:
  *  Note:  This function must be called with the node table lock held!
  */
 mach_node_t
  *  Note:  This function must be called with the node table lock held!
  */
 mach_node_t

-mach_node_for_id_locked(mach_node_id_t node_id,
-                                               boolean_t               alloc_if_dead,
-                                               boolean_t               alloc_if_absent)
+mach_node_for_id_locked(mach_node_id_t  node_id,
+    boolean_t               alloc_if_dead,
+    boolean_t               alloc_if_absent)

 {
 {

-       if ((node_id < 0) || (node_id >= MACH_NODES_MAX))
+       if ((node_id < 0) || (node_id >= MACH_NODES_MAX)) {

                return MACH_NODE_NULL;
                return MACH_NODE_NULL;

+       }

 
        mach_node_t node = mach_node_table[node_id];
 
        mach_node_t node = mach_node_table[node_id];

-       
-       if ( (!MACH_NODE_VALID(node) && alloc_if_absent) ||
-                (MACH_NODE_VALID(node) && node->dead && alloc_if_dead) ) {
+
+       if ((!MACH_NODE_VALID(node) && alloc_if_absent) ||
+           (MACH_NODE_VALID(node) && node->dead && alloc_if_dead)) {

                node = mach_node_alloc_init(node_id);
                if (MACH_NODE_VALID(node)) {
                        node->antecedent = mach_node_table[node_id];
                        mach_node_table[node_id] = node;
                }
        }
                node = mach_node_alloc_init(node_id);
                if (MACH_NODE_VALID(node)) {
                        node->antecedent = mach_node_table[node_id];
                        mach_node_table[node_id] = node;
                }
        }

-       
-       if (MACH_NODE_VALID(node))
+
+       if (MACH_NODE_VALID(node)) {

                MACH_NODE_LOCK(node);
                MACH_NODE_LOCK(node);

-               
+       }
+

        return node;
 }
 
        return node;
 }
 


@@ -452,7 +462,7 @@ mnl_name_alloc(void)
 void
 mnl_name_free(mnl_name_t name __unused)
 {
 void
 mnl_name_free(mnl_name_t name __unused)
 {

-       ;       // Nothing to do for now since we don't recycle mnl names.
+       ;       // Nothing to do for now since we don't recycle mnl names.

 }
 
 
 }
 
 


@@ -461,15 +471,16 @@ mnl_name_free(mnl_name_t name __unused)
 void
 mnl_name_table_init(void)
 {
 void
 mnl_name_table_init(void)
 {

-    MNL_NAME_TABLE_LOCK_INIT();
-    MNL_NAME_TABLE_LOCK();
-       
+       MNL_NAME_TABLE_LOCK_INIT();
+       MNL_NAME_TABLE_LOCK();
+

        // Set the first name to this node's bootstrap name
        mnl_name_next = localnode_id + MACH_NODES_MAX;
        // Set the first name to this node's bootstrap name
        mnl_name_next = localnode_id + MACH_NODES_MAX;

-       
-       for (int i=0; i<MNL_NAME_TABLE_SIZE; i++)
+
+       for (int i = 0; i < MNL_NAME_TABLE_SIZE; i++) {

                queue_head_init(mnl_name_table[i]);
                queue_head_init(mnl_name_table[i]);

-       
+       }
+

        MNL_NAME_TABLE_UNLOCK();
 }
 
        MNL_NAME_TABLE_UNLOCK();
 }
 


@@ -493,11 +504,12 @@ mnl_obj_t
 mnl_obj_lookup(mnl_name_t name)
 {
        mnl_obj_t obj = MNL_OBJ_NULL;
 mnl_obj_lookup(mnl_name_t name)
 {
        mnl_obj_t obj = MNL_OBJ_NULL;

-       
+

        if (name != MNL_NAME_NULL) {
                qe_foreach_element(obj, &mnl_name_table[MNL_NAME_HASH(name)], links) {
        if (name != MNL_NAME_NULL) {
                qe_foreach_element(obj, &mnl_name_table[MNL_NAME_HASH(name)], links) {

-                       if (obj->name == name)
+                       if (obj->name == name) {

                                break;
                                break;

+                       }

                }
        }
        return obj;
                }
        }
        return obj;


@@ -513,11 +525,12 @@ mnl_obj_t
 mnl_obj_remove(mnl_name_t name)
 {
        mnl_obj_t obj = MNL_OBJ_NULL;
 mnl_obj_remove(mnl_name_t name)
 {
        mnl_obj_t obj = MNL_OBJ_NULL;

-       
+

        if (name != MNL_NAME_NULL) {
                qe_foreach_element_safe(obj, &mnl_name_table[MNL_NAME_HASH(name)], links) {
        if (name != MNL_NAME_NULL) {
                qe_foreach_element_safe(obj, &mnl_name_table[MNL_NAME_HASH(name)], links) {

-                       if (obj->name == name)
+                       if (obj->name == name) {

                                remqueue(&obj->links);
                                remqueue(&obj->links);

+                       }

                }
        }
        return obj;
                }
        }
        return obj;


@@ -527,28 +540,30 @@ mnl_obj_remove(mnl_name_t name)
 /*     Insert an object into the local node's hash table.  If the name of the
  *  provided object is MNL_NAME_NULL then a new mnl_name is allocated and
  *  assigned to the object.
 /*     Insert an object into the local node's hash table.  If the name of the
  *  provided object is MNL_NAME_NULL then a new mnl_name is allocated and
  *  assigned to the object.

- *     Returns KERN_SUCCESS if obj was added to hash table
- *     Returns KERN_INVALID_ARGUMENT if obj is invalid
- *     Returns KERN_NAME_EXISTS if obj's name already exists in hash table
+ *      Returns KERN_SUCCESS if obj was added to hash table
+ *      Returns KERN_INVALID_ARGUMENT if obj is invalid
+ *      Returns KERN_NAME_EXISTS if obj's name already exists in hash table

  */
 kern_return_t
 mnl_obj_insert(mnl_obj_t obj)
 {
  */
 kern_return_t
 mnl_obj_insert(mnl_obj_t obj)
 {

-       if (!MNL_OBJ_VALID(obj))
+       if (!MNL_OBJ_VALID(obj)) {

                return KERN_INVALID_ARGUMENT;
                return KERN_INVALID_ARGUMENT;

-       
+       }
+

        MNL_NAME_TABLE_LOCK();
        MNL_NAME_TABLE_LOCK();

-       
+

        if (!MNL_NAME_VALID(obj->name)) {
                // obj is unnammed, so lets allocate a fresh one
                obj->name = mnl_name_alloc();
        }
        if (!MNL_NAME_VALID(obj->name)) {
                // obj is unnammed, so lets allocate a fresh one
                obj->name = mnl_name_alloc();
        }

-       
+

        enqueue(&mnl_name_table[MNL_NAME_HASH(obj->name)], &obj->links);
        MNL_NAME_TABLE_UNLOCK();
 
        enqueue(&mnl_name_table[MNL_NAME_HASH(obj->name)], &obj->links);
        MNL_NAME_TABLE_UNLOCK();
 

-       if(obj->name >= (MACH_NODES_MAX<<1))
+       if (obj->name >= (MACH_NODES_MAX << 1)) {

                panic("Unexpected MNL_NAME %lld in obj %p", obj->name, obj);
                panic("Unexpected MNL_NAME %lld in obj %p", obj->name, obj);

+       }

 
        return KERN_SUCCESS;
 }
 
        return KERN_SUCCESS;
 }


@@ -570,7 +585,7 @@ mnl_obj_insert(mnl_obj_t obj)
  */
 mnl_msg_t
 mnl_msg_alloc(int       payload,
  */
 mnl_msg_t
 mnl_msg_alloc(int       payload,

-              uint32_t  flags   __unused)
+    uint32_t  flags   __unused)

 {
        mnl_msg_t msg = kalloc(MNL_MSG_SIZE + payload);
 
 {
        mnl_msg_t msg = kalloc(MNL_MSG_SIZE + payload);
 


@@ -591,10 +606,11 @@ mnl_msg_alloc(int       payload,
  */
 void
 mnl_msg_free(mnl_msg_t  msg,
  */
 void
 mnl_msg_free(mnl_msg_t  msg,

-             uint32_t   flags   __unused)
+    uint32_t   flags   __unused)

 {
 {

-       if (MNL_MSG_VALID(msg))
+       if (MNL_MSG_VALID(msg)) {

                kfree(msg, MNL_MSG_SIZE + msg->size);
                kfree(msg, MNL_MSG_SIZE + msg->size);

+       }

 }
 
 
 }
 
 


@@ -614,14 +630,15 @@ mnl_msg_free(mnl_msg_t  msg,
  */
 mnl_node_info_t
 mnl_instantiate(mach_node_id_t  nid,
  */
 mnl_node_info_t
 mnl_instantiate(mach_node_id_t  nid,

-                uint32_t        flags   __unused)
+    uint32_t        flags   __unused)

 {
 {

-    mach_node_init(); // Lazy init of mach_node layer
+       mach_node_init(); // Lazy init of mach_node layer

 
 

-    if ((nid==localnode_id) || !MACH_NODE_ID_VALID(nid))
-        return MNL_NODE_NULL;
+       if ((nid == localnode_id) || !MACH_NODE_ID_VALID(nid)) {
+               return MNL_NODE_NULL;
+       }

 
 

-    return (mnl_node_info_t)mach_node_alloc_init(nid);
+       return (mnl_node_info_t)mach_node_alloc_init(nid);

 }
 
 /*  The link driver calls mnl_register() to complete the node registration
 }
 
 /*  The link driver calls mnl_register() to complete the node registration


@@ -639,12 +656,13 @@ mnl_instantiate(mach_node_id_t  nid,
  */
 kern_return_t
 mnl_register(mnl_node_info_t    node,
  */
 kern_return_t
 mnl_register(mnl_node_info_t    node,

-             uint32_t           flags   __unused)
+    uint32_t           flags   __unused)

 {
 {

-    if (MNL_NODE_VALID(node) && (node->node_id != localnode_id))
-        return mach_node_register((mach_node_t)node);
+       if (MNL_NODE_VALID(node) && (node->node_id != localnode_id)) {
+               return mach_node_register((mach_node_t)node);
+       }

 
 

-    return KERN_INVALID_ARGUMENT;
+       return KERN_INVALID_ARGUMENT;

 }
 
 
 }
 
 


@@ -666,25 +684,25 @@ mnl_register(mnl_node_info_t    node,
  */
 kern_return_t
 mnl_set_link_state(mnl_node_info_t  node,
  */
 kern_return_t
 mnl_set_link_state(mnl_node_info_t  node,

-                   int              link,
-                   uint32_t         flags   __unused)
+    int              link,
+    uint32_t         flags   __unused)

 {
 {

-    kern_return_t kr;
+       kern_return_t kr;

        mach_node_t mnode = (mach_node_t)node;
 
        mach_node_t mnode = (mach_node_t)node;
 

-       if (!MACH_NODE_VALID(mnode) || !(link & MNL_LINK_UP) || (link & mnode->link))
-               return KERN_INVALID_ARGUMENT;   // bad node, or bad link argument
-
-    MACH_NODE_LOCK(mnode);
+       if (!MACH_NODE_VALID(mnode) || !(link & MNL_LINK_UP) || (link & mnode->link)) {
+               return KERN_INVALID_ARGUMENT;   // bad node, or bad link argument
+       }
+       MACH_NODE_LOCK(mnode);

 
 

-    if (mnode->dead) {
+       if (mnode->dead) {

                kr = KERN_NODE_DOWN;
                kr = KERN_NODE_DOWN;

-    } else {
-        mnode->link |= link;
-        kr = KERN_SUCCESS;
-    }
+       } else {
+               mnode->link |= link;
+               kr = KERN_SUCCESS;
+       }

 
 

-    MACH_NODE_UNLOCK(mnode);
+       MACH_NODE_UNLOCK(mnode);

 
        return kr;
 }
 
        return kr;
 }


@@ -708,17 +726,17 @@ mnl_set_link_state(mnl_node_info_t  node,
  */
 kern_return_t
 mnl_terminate(mnl_node_info_t   node,
  */
 kern_return_t
 mnl_terminate(mnl_node_info_t   node,

-              uint32_t          flags   __unused)
+    uint32_t          flags   __unused)

 {
        kern_return_t kr = KERN_SUCCESS;
        mach_node_t mnode = (mach_node_t)node;
 
 {
        kern_return_t kr = KERN_SUCCESS;
        mach_node_t mnode = (mach_node_t)node;
 

-       if (!MACH_NODE_VALID(mnode))
-               return KERN_INVALID_ARGUMENT;   // bad node
-       
+       if (!MACH_NODE_VALID(mnode)) {
+               return KERN_INVALID_ARGUMENT;   // bad node
+       }

        MACH_NODE_LOCK(mnode);
        if (mnode->dead) {
        MACH_NODE_LOCK(mnode);
        if (mnode->dead) {

-               kr = KERN_NODE_DOWN;                    // node is already terminated
+               kr = KERN_NODE_DOWN;                    // node is already terminated

                goto unlock;
        }
 
                goto unlock;
        }
 


@@ -729,12 +747,12 @@ mnl_terminate(mnl_node_info_t   node,
 
        flipc_node_retire(mnode);
 
 
        flipc_node_retire(mnode);
 

-    // Wake any threads sleeping on the proxy port set
-    if (mnode->proxy_port_set != IPS_NULL) {
-        ips_lock(mnode->proxy_port_set);
-        ipc_pset_destroy(mnode->proxy_port_set);
-        mnode->proxy_port_set = IPS_NULL;
-    }
+       // Wake any threads sleeping on the proxy port set
+       if (mnode->proxy_port_set != IPS_NULL) {
+               ips_lock(mnode->proxy_port_set);
+               ipc_pset_destroy(mnode->proxy_space, mnode->proxy_port_set);
+               mnode->proxy_port_set = IPS_NULL;
+       }

 
        // TODO: Inform node name server (if registered) of termination
 
 
        // TODO: Inform node name server (if registered) of termination
 


@@ -755,8 +773,8 @@ unlock:
  */
 void
 mnl_msg_from_node(mnl_node_info_t   node    __unused,
  */
 void
 mnl_msg_from_node(mnl_node_info_t   node    __unused,

-                  mnl_msg_t         msg,
-                  uint32_t          flags   __unused)
+    mnl_msg_t         msg,
+    uint32_t          flags   __unused)

 {
        assert(MNL_MSG_VALID(msg));
        assert(MACH_NODE_ID_VALID(msg->node_id));
 {
        assert(MNL_MSG_VALID(msg));
        assert(MACH_NODE_ID_VALID(msg->node_id));


@@ -769,16 +787,15 @@ mnl_msg_from_node(mnl_node_info_t   node    __unused,
         */
 
        switch (msg->sub) {
         */
 
        switch (msg->sub) {

+       case MACH_NODE_SUB_FLIPC:
+               flipc_msg_from_node((mach_node_t)node, msg, flags);
+               break;

 
 

-               case MACH_NODE_SUB_FLIPC:
-                       flipc_msg_from_node((mach_node_t)node, msg, flags);
-                       break;
-
-               default:
+       default:

 #if DEBUG
 #if DEBUG

-                       PE_enter_debugger("mnl_msg_from_node(): Invalid subsystem");
+               PE_enter_debugger("mnl_msg_from_node(): Invalid subsystem");

 #endif
 #endif

-                       break;
+               break;

        }
 }
 
        }
 }
 


@@ -795,12 +812,12 @@ mnl_msg_from_node(mnl_node_info_t   node    __unused,
  */
 mnl_msg_t
 mnl_msg_to_node(mnl_node_info_t node    __unused,
  */
 mnl_msg_t
 mnl_msg_to_node(mnl_node_info_t node    __unused,

-                uint32_t        flags   __unused)
+    uint32_t        flags   __unused)

 {
        assert(MNL_NODE_VALID(node));
 
 #if DEBUG
 {
        assert(MNL_NODE_VALID(node));
 
 #if DEBUG

-    thread_set_thread_name(current_thread(), "MNL_Link");
+       thread_set_thread_name(current_thread(), "MNL_Link");

 #endif
 
        return flipc_msg_to_remote_node((mach_node_t)node, 0);
 #endif
 
        return flipc_msg_to_remote_node((mach_node_t)node, 0);


@@ -817,24 +834,24 @@ mnl_msg_to_node(mnl_node_info_t node    __unused,
  */
 void
 mnl_msg_complete(mnl_node_info_t    node    __unused,
  */
 void
 mnl_msg_complete(mnl_node_info_t    node    __unused,

-                 mnl_msg_t          msg,
-                 uint32_t           flags)
+    mnl_msg_t          msg,
+    uint32_t           flags)

 {
 {

-    switch (msg->sub) {
-        case MACH_NODE_SUB_NODE:
-            mnl_msg_free(msg, flags);
-            break;
+       switch (msg->sub) {
+       case MACH_NODE_SUB_NODE:
+               mnl_msg_free(msg, flags);
+               break;

 
 

-        case MACH_NODE_SUB_FLIPC:
-            flipc_msg_free(msg, flags);
-            break;
+       case MACH_NODE_SUB_FLIPC:
+               flipc_msg_free(msg, flags);
+               break;

 
 

-        default:
+       default:

 #if DEBUG
 #if DEBUG

-            PE_enter_debugger("mnl_msg_complete(): Invalid subsystem");
+               PE_enter_debugger("mnl_msg_complete(): Invalid subsystem");

 #endif
 #endif

-            break;
-    }
+               break;
+       }

 }
 
 #else // MACH_FLIPC not configured, so provide KPI stubs
 }
 
 #else // MACH_FLIPC not configured, so provide KPI stubs


@@ -842,61 +859,61 @@ mnl_msg_complete(mnl_node_info_t    node    __unused,
 mnl_msg_t
 mnl_msg_alloc(int payload __unused, uint32_t flags __unused)
 {
 mnl_msg_t
 mnl_msg_alloc(int payload __unused, uint32_t flags __unused)
 {

-    return MNL_MSG_NULL;
+       return MNL_MSG_NULL;

 }
 
 void
 mnl_msg_free(mnl_msg_t msg __unused, uint32_t flags __unused)
 {
 }
 
 void
 mnl_msg_free(mnl_msg_t msg __unused, uint32_t flags __unused)
 {

-    return;
+       return;

 }
 
 mnl_node_info_t
 mnl_instantiate(mach_node_id_t nid __unused, uint32_t flags __unused)
 {
 }
 
 mnl_node_info_t
 mnl_instantiate(mach_node_id_t nid __unused, uint32_t flags __unused)
 {

-    return MNL_NODE_NULL;
+       return MNL_NODE_NULL;

 }
 
 kern_return_t
 mnl_register(mnl_node_info_t node  __unused, uint32_t flags __unused)
 {
 }
 
 kern_return_t
 mnl_register(mnl_node_info_t node  __unused, uint32_t flags __unused)
 {

-    return KERN_FAILURE;
+       return KERN_FAILURE;

 }
 
 kern_return_t
 mnl_set_link_state(mnl_node_info_t  node    __unused,
 }
 
 kern_return_t
 mnl_set_link_state(mnl_node_info_t  node    __unused,

-                   int              link    __unused,
-                   uint32_t         flags   __unused)
+    int              link    __unused,
+    uint32_t         flags   __unused)

 {
 {

-    return KERN_FAILURE;
+       return KERN_FAILURE;

 }
 
 kern_return_t
 mnl_terminate(mnl_node_info_t node __unused, uint32_t flags __unused)
 {
 }
 
 kern_return_t
 mnl_terminate(mnl_node_info_t node __unused, uint32_t flags __unused)
 {

-    return KERN_FAILURE;
+       return KERN_FAILURE;

 }
 
 void
 mnl_msg_from_node(mnl_node_info_t   node    __unused,
 }
 
 void
 mnl_msg_from_node(mnl_node_info_t   node    __unused,

-                  mnl_msg_t         msg     __unused,
-                  uint32_t          flags   __unused)
+    mnl_msg_t         msg     __unused,
+    uint32_t          flags   __unused)

 {
 {

-    return;
+       return;

 }
 
 mnl_msg_t
 mnl_msg_to_node(mnl_node_info_t node __unused, uint32_t flags __unused)
 {
 }
 
 mnl_msg_t
 mnl_msg_to_node(mnl_node_info_t node __unused, uint32_t flags __unused)
 {

-    return MNL_MSG_NULL;
+       return MNL_MSG_NULL;

 }
 
 void
 mnl_msg_complete(mnl_node_info_t    node    __unused,
 }
 
 void
 mnl_msg_complete(mnl_node_info_t    node    __unused,

-                 mnl_msg_t          msg     __unused,
-                 uint32_t           flags   __unused)
+    mnl_msg_t          msg     __unused,
+    uint32_t           flags   __unused)

 {
 {

-    return;
+       return;

 }
 
 #endif // MACH_FLIPC
 }
 
 #endif // MACH_FLIPC