Xeon Phi Manager: cleanup
authorReto Achermann <acreto@student.ethz.ch>
Wed, 2 Jul 2014 09:52:40 +0000 (11:52 +0200)
committerStefan Kaestle <stefan.kaestle@inf.ethz.ch>
Wed, 20 Aug 2014 21:38:18 +0000 (23:38 +0200)
Cleaned up Xeon Phi Manager domain and the xeon_phi_manager_client
library.

- Redesign of interface to avoid dynamic arrays in Flounder
- Introduced error codes for possible failures
- Adding of comments and some code formatting.

errors/errno.fugu
if/xeon_phi_manager.if
include/xeon_phi/xeon_phi_manager_client.h
lib/xeon_phi/xeon_phi_manager_client.c
usr/xeon_phi_manager/cardmanager.c
usr/xeon_phi_manager/cardmanager.h
usr/xeon_phi_manager/main.c
usr/xeon_phi_manager/service.c
usr/xeon_phi_manager/service.h

index 6ffdf03..811c3c8 100755 (executable)
@@ -107,7 +107,7 @@ errors kernel SYS_ERR_ {
     // VMKit specific errors
     failure VMKIT_UNAVAIL               "Virtualization extensions are unavailable",
     failure VMKIT_VMCB                  "Error setting VMCB for dispatcher",
-    failure VMKIT_VMCB_INVALID                 "Invalid frame capability passed for VMCB",
+    failure VMKIT_VMCB_INVALID             "Invalid frame capability passed for VMCB",
     failure VMKIT_CTRL                  "Error setting control area for dispatcher",
     failure VMKIT_CTRL_INVALID          "Invalid frame capability passed for control structure",
     failure VMKIT_ENDPOINT              "Error setting monitor endpoint for dispatcher",
@@ -118,13 +118,13 @@ errors kernel SYS_ERR_ {
     failure SERIAL_PORT_UNAVAILABLE     "Serial port unavailable",
 
     // Performance monitoring errors
-    failure PERFMON_NOT_AVAILABLE      "Performance monitoring feature unavailable",
+    failure PERFMON_NOT_AVAILABLE    "Performance monitoring feature unavailable",
 
     // Time synchronization errors
-    failure SYNC_MISS                  "Missed synchronization phase",
+    failure SYNC_MISS            "Missed synchronization phase",
 
     // SCC driver errors
-    failure CROSS_MC                   "Frame crosses memory controllers",
+    failure CROSS_MC            "Frame crosses memory controllers",
 
     // ID capability
     failure ID_SPACE_EXHAUSTED  "ID space exhausted",
@@ -325,14 +325,14 @@ errors libbarrelfish LIB_ERR_ {
     failure BIND_MULTIHOP_SAME_CORE "Cannot create a multihop channel to service on the same core",
 
     // Bulk transfer
-    failure BULK_UNKNOWN_ID    "Unknown bulk transfer block ID",
+    failure BULK_UNKNOWN_ID    "Unknown bulk transfer block ID",
 
     // Domain
     failure NO_SPANNED_DISP       "There is no spanned dispatcher on the given core",
     failure SEND_RUN_FUNC_REQUEST "Failure in trying to send run_func_request",
-    failure SEND_CAP_REQUEST     "Failure in trying to send capability",
-    failure CAP_COPY_FAIL        "cap_copy failed",
-    failure CAP_DELETE_FAIL      "cap_delete failed",
+    failure SEND_CAP_REQUEST      "Failure in trying to send capability",
+    failure CAP_COPY_FAIL      "cap_copy failed",
+    failure CAP_DELETE_FAIL      "cap_delete failed",
 
     // Initialisation
     failure RAM_ALLOC_SET          "Failure in ram_alloc_set()",
@@ -349,9 +349,9 @@ errors libbarrelfish LIB_ERR_ {
 
     // Threads package
     failure THREAD_CREATE       "A version of thread create failed",
-    failure THREAD_JOIN                "Joining more than once not allowed",
-    failure THREAD_JOIN_DETACHED       "Tried to join with a detached thread",
-    failure THREAD_DETACHED    "Thread is already detached",
+    failure THREAD_JOIN        "Joining more than once not allowed",
+    failure THREAD_JOIN_DETACHED    "Tried to join with a detached thread",
+    failure THREAD_DETACHED    "Thread is already detached",
 
     // Waitset/event code
     failure CHAN_ALREADY_REGISTERED "Attempt to register for an event on a channel which is already registered",
@@ -399,11 +399,11 @@ errors chips CHIPS_ERR_ {
     failure GET_SERVICE_REFERENCE "Error getting service reference from name service",
     failure GET_SERVICE_IREF      "Error getting IREF from name service",
     failure UNKNOWN_NAME          "Lookup failed: unknown name",
-    failure EXISTS               "Entry already exists",
-    failure GET_CAP              "Error getting a capability from store",
-    failure PUT_CAP              "Error putting a capability to store",
+    failure EXISTS          "Entry already exists",
+    failure GET_CAP          "Error getting a capability from store",
+    failure PUT_CAP          "Error putting a capability to store",
     failure REMOVE_CAP            "Error removing a capability from store",
-    failure OUT_OF_SEMAPHORES    "Out of semaphores",
+    failure OUT_OF_SEMAPHORES      "Out of semaphores",
 };
 
 // errors generated by bcast library
@@ -467,10 +467,10 @@ errors monitor MON_ERR_ {
     failure INCOMPLETE_ROUTE    "(Portion of) routing table not present",
 
     // Resource controller
-    failure RSRC_ALLOC         "Out of resource domains",
-    failure RSRC_MEMBER_LIMIT  "Reached member limit of resource domain",
-    failure RSRC_ILL_MANIFEST  "Illegal manifest",
-    failure RSRC_NOT_FOUND     "Resource domain not found on this core",
+    failure RSRC_ALLOC        "Out of resource domains",
+    failure RSRC_MEMBER_LIMIT    "Reached member limit of resource domain",
+    failure RSRC_ILL_MANIFEST    "Illegal manifest",
+    failure RSRC_NOT_FOUND    "Resource domain not found on this core",
 };
 
 // errors related to the routing library
@@ -502,18 +502,18 @@ errors spawn SPAWN_ERR_ {
     failure VSPACE_MAP          "Nested failure in spawn_vspace_map",
     failure GET_CMDLINE_ARGS    "Failure in get_cmdline_args",
     failure SETUP_ENV           "Failure in spawn_setup_env",
-    failure UNKNOWN_TARGET_ARCH        "Unknown target architecture type",
-    failure UNSUPPORTED_TARGET_ARCH     "Unsupported target architecture type",
+    failure UNKNOWN_TARGET_ARCH    "Unknown target architecture type",
+    failure UNSUPPORTED_TARGET_ARCH     "Unsupported target architecture type",
 
-    failure SETUP_CSPACE       "Failure in spawn_setup_cspace",
-    failure DETERMINE_CPUTYPE  "Failure in spawn_determine_cputype",
-    failure VSPACE_INIT        "Failure in spawn_vspace_init",
-    failure SETUP_DISPATCHER   "Failure in spawn_setup_dispatcher",
-    failure ELF_MAP            "Failure in spawn_elf_map",
+    failure SETUP_CSPACE    "Failure in spawn_setup_cspace",
+    failure DETERMINE_CPUTYPE    "Failure in spawn_determine_cputype",
+    failure VSPACE_INIT     "Failure in spawn_vspace_init",
+    failure SETUP_DISPATCHER     "Failure in spawn_setup_dispatcher",
+    failure ELF_MAP         "Failure in spawn_elf_map",
 
-    failure SET_CAPS           "Failure in set_special_caps",
-    failure MONITOR_CLIENT             "Failure in monitor_client_setup",
-    failure FREE               "Failure in spawn_free",
+    failure SET_CAPS         "Failure in set_special_caps",
+    failure MONITOR_CLIENT         "Failure in monitor_client_setup",
+    failure FREE             "Failure in spawn_free",
 
     // spawn_cspace
     failure CREATE_ROOTCN       "Failure creating root CNode",
@@ -575,15 +575,15 @@ errors spawn SPAWN_ERR_ {
     failure COPY_MODULECN       "Error copying module CNode cap",
     failure COPY_IRQ_CAP        "Error copying IRQ cap",
     failure COPY_IO_CAP         "Error copying IO cap",
-    failure COPY_PERF_MON      "Error copying performance monitoring cap",
+    failure COPY_PERF_MON    "Error copying performance monitoring cap",
 
     // make_runnable
-    failure DISPATCHER_SETUP   "Dispatcher setup",
+    failure DISPATCHER_SETUP    "Dispatcher setup",
 
     // domain management
-    failure DOMAIN_ALLOCATE    "No more domain descriptors",
-    failure DOMAIN_NOTFOUND    "Domain not found",
-    failure DOMAIN_RUNNING     "Domain is running",
+    failure DOMAIN_ALLOCATE    "No more domain descriptors",
+    failure DOMAIN_NOTFOUND    "Domain not found",
+    failure DOMAIN_RUNNING    "Domain is running",
 };
 
 // errors from ELF library
@@ -797,7 +797,7 @@ errors vfs VFS_ERR_ {
     failure IN_STAT             "Nested error in vfs_stat()",
     failure IN_READ             "Nested error in vfs_read()",
 
-    failure BCACHE_LIMIT       "Number of buffer cache connections exceeded",
+    failure BCACHE_LIMIT    "Number of buffer cache connections exceeded",
 };
 
 // NFS client errors
@@ -869,8 +869,8 @@ errors lwip LWIP_ERR_ {
 
 // DIST library errors
 errors dist DIST_ERR_ {
-     failure NS_REG     "Name service register failed.",
-     failure NS_LOOKUP  "Name service lookup failed.",
+     failure NS_REG     "Name service register failed.",
+     failure NS_LOOKUP     "Name service lookup failed.",
 };
 
 // octopus library errors
@@ -908,18 +908,18 @@ errors thc THC_ {
 
 // errors generated by memory server
 errors ms MS_ERR_ {
-    failure SKB                        "Invalid data from SKB",
-    failure INIT_PEERS         "Could not initialise peer data structures",
+    failure SKB            "Invalid data from SKB",
+    failure INIT_PEERS        "Could not initialise peer data structures",
 };
 
 // errors generated by startd
 errors startd STARTD_ERR_ {
-    failure BOOTMODULES                "Invalid bootmodules file",
+    failure BOOTMODULES        "Invalid bootmodules file",
 };
 
 errors lox LOX_ERR_ {
-    failure INIT_LOCKS         "Failure initialising locks",
-    failure NO_LOCKS           "No more locks available",
+    failure INIT_LOCKS        "Failure initialising locks",
+    failure NO_LOCKS        "No more locks available",
 };
 
 // errors generated by VBE framebuffer driver
@@ -1042,8 +1042,11 @@ errors virtio VIRTIO_ERR_ {
 };
 
 errors xeon_phi XEON_PHI_ERR_ {
+    failure MGR_REGISTER_FAILED  "Registration with the Xeon Phi Manager failed",
+    failure MGR_MAX_CARDS        "There are too much drivers connected",
+    failure DMA_NOT_INITIALIZED  "DMA library has not been initialized",
     failure DMA_ID_NOT_EXISTS    "The DMA transfer with that ID does not exist ",
-    failure DMA_BUSY              "All DMA channels are busy",
+    failure DMA_BUSY             "All DMA channels are busy",
     failure DMA_IDLE             "All DMA channels are idle",
     failure DMA_MEM_REGISTERED   "The memory has not been registered",
     failure DMA_MEM_ALIGN        "The address / bytes has a wrong alignment",
index 266a63d..d717652 100644 (file)
 
 interface xeon_phi_manager "Xeon Phi Manager Interface" {
     
+    /**
+     * array of irefs to other Xeon Phi Driver services
+     */
+    typedef struct {
+        uint8 num;
+        iref card0;
+        iref card1;
+        iref card2;
+        iref card3;
+        iref card4;
+        iref card5;
+        iref card6;
+        iref card7;
+    } cards;
+        
+    /**
+     * \brief register RPC to initiate the registration protocol of the Xeon Phi
+     *        driver with the Xeon Phi manager.
+     * 
+     * \param svc    own exported Xeon Phi Driver interface
+     * \param id     returned Xeon Phi ID assigned by the manager
+     * \param irefs  array of irefs to other Xeon Phi driver services
+     * \param msgerr error code from Xeon Phi manager
+     */
+    rpc register(in iref svc, out uint8 id, out cards irefs, out errval msgerr);
     
-    rpc register(in iref svc, out uint8 id, out uint8 cards[n], out errval msgerr);
-    
+    /*
+     * 
+     */
     rpc terminate();
 };
\ No newline at end of file
index 6bc22e6..1535c89 100644 (file)
 #ifndef XEON_PHI_MANAGER_CLIENT_H
 #define XEON_PHI_MANAGER_CLIENT_H
 
-#define XEON_PHI_MANAGER_SERVICE_NAME "xeon_phi_manager"
+/*
+ * ----------------------------------------------------------------------------
+ * This library is to be used solely by the Xeon Phi drivers to talk to the
+ * Xeon Phi manager domain in order to setup the Xeon Phi IDs and the
+ * inter-Xeon Phi driver connections.
+ * ----------------------------------------------------------------------------
+ */
 
-#define DEBUG_XPMC(x...) debug_printf(" XPMC | " x)
 
 /**
- * \brief   registers the Xeon Phi driver card with the Xeon Phi Manager
- *          this function blocks until we have a connection to the manager
+ * \brief registers the Xeon Phi driver card with the Xeon Phi Manager
  *
- * \param   svc_iref    the iref of the drivers service
- * \param   id          the own card id
- * \param   num         returns the number of returned irefs / number of cards
- * \param   cards       returns the array of irefs
+ * \param svc_iref  iref of the own exported Xeon Phi driver interface
+ * \param id        returns the assigned Xeon Phi card ID
+ * \param num       returns the size of the cards array
+ * \param irefs     returns array of irefs to the other cards
  *
- * \return SYS_ERR_OK on success
+ * NOTE: this is a blocking function. The function will only return after
+ *       the Xeon Phi manager connection has been fully established and the
+ *       registration protocol has been executed.
+ *
+ * \returns SYS_ERR_OK on success
+ *          errval on failure
  */
 errval_t xeon_phi_manager_client_register(iref_t svc_iref,
                                           uint8_t *id,
                                           uint8_t *num,
-                                          iref_t **cards);
+                                          iref_t **irefs);
 
 /**
- * \brief   deregisters the Xeon Phi driver with the Xeon Phi Manager
+ * \brief  deregisters the Xeon Phi driver with the Xeon Phi Manager
  *
  * \return SYS_ERR_OK on success
+ *         errval on failure
  */
 errval_t xeon_phi_manager_client_deregister(void);
 
index 0d8b8e3..4b8a21c 100644 (file)
@@ -7,7 +7,6 @@
  * ETH Zurich D-INFK, Universitaetsstrasse 6, CH-8092 Zurich. Attn: Systems Group.
  */
 
-#include <string.h>
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/nameservice_client.h>
 
 
 #include <if/xeon_phi_manager_defs.h>
 
+/// the name of the Xeon Phi Manager service
+#define XEON_PHI_MANAGER_SERVICE_NAME "xeon_phi_manager"
+
+/// Enabling the debug output of the Xeon Phi Manager client
+#ifdef XEON_PHI_DEBUG_MANAGER
+#define DEBUG_XPMC(x...) debug_printf(" [xpmc] " x)
+#else
+#define DEBUG_XPMC(x...)
+#endif
+
+/**
+ * represents the connection state of the Xeon Phi Manager client with the
+ * Xeon Phi Manager
+ */
 enum xpm_state
 {
+    XPM_STATE_INVALID = 0,
     XPM_STATE_NSLOOKUP,
     XPM_STATE_BINDING,
     XPM_STATE_BIND_OK,
     XPM_STATE_BIND_FAIL,
     XPM_STATE_REGISTERING,
     XPM_STATE_REGISTER_OK,
-    XPM_STATE_REGISTER_FAIL
+    XPM_STATE_REGISTER_FAIL,
+    XPM_STATE_CONNECTED
 };
 
+/// iref of the Xeon Phi manager service
 static iref_t xpm_iref = 0;
-struct xeon_phi_manager_binding *xpm_binding = NULL;
 
-enum xpm_state conn_state = XPM_STATE_NSLOOKUP;
+/// Flounder binind go the Xeon Phi manager
+static struct xeon_phi_manager_binding *xpm_binding = NULL;
+
+/// connection state
+static enum xpm_state conn_state = XPM_STATE_INVALID;
 
 /*
  * --------------------------------------------------------------------------
  * Registration Protocol
+ * ----------------------------------------------------------------------------
  */
 
+/**
+ * contains the necessary data for the Xeon Phi manager connection
+ */
 struct xpm_register_data
 {
-    uint8_t id;
-    iref_t *cards;
-    uint8_t num;
-};
-
-static struct xpm_register_data reg_data;
+    iref_t svc_iref;                  ///< our exported service iref
+    errval_t err;                     ///< error code of the registration
+    uint8_t id;                       ///< our own Xeon Phi ID.
+    xeon_phi_manager_cards_t irefs;   ///< irefs to the other Xeon Phi drivers
+} xpm_reg_data;
 
-static void xpm_recv_register_response(struct xeon_phi_manager_binding *_binding,
+/**
+ * \brief callback function for register response messages
+ *
+ * \param binding  Xeon Phi Manager Flounder Binding
+ * \param id       Assigned Xeon Phi ID
+ * \param irefs    Returned irefs to the other Xeon Phi drivers
+ * \param msgerr   Error code of teh operation
+ */
+static void xpm_recv_register_response(struct xeon_phi_manager_binding *binding,
                                        uint8_t id,
-                                       uint8_t *cards,
-                                       size_t n,
+                                       xeon_phi_manager_cards_t irefs,
                                        xeon_phi_manager_errval_t msgerr)
 {
-    DEBUG_XPMC("Registration response: ID=0x%x, num=0x%lx, err=0x%lx\n",
-               id,
-               n / sizeof(iref_t),
-               msgerr);
+    assert(binding == xpm_binding);
+
+    xpm_reg_data.err = msgerr;
 
     if (err_is_fail(msgerr)) {
+        DEBUG_XPMC("register: received response FAILURE.\n");
         conn_state = XPM_STATE_REGISTER_FAIL;
         return;
     }
 
-    if (n % sizeof(iref_t)) {
-        // the data seems to be corrupt
-        conn_state = XPM_STATE_REGISTER_FAIL;
-    }
+    DEBUG_XPMC("register: received response: id=%u, #irefs=%u\n", id, irefs.num);
 
-    reg_data.id = id;
-    reg_data.num = n / sizeof(iref_t);
-    reg_data.cards = (iref_t *) cards;
+    assert(xpm_reg_data.svc_iref == ((iref_t *)&irefs.card0)[irefs.num-1]);
 
-    xpm_binding->st = &reg_data;
+    xpm_reg_data.id = id;
+    xpm_reg_data.irefs = irefs;
 
-    conn_state = XPM_STATE_REGISTER_OK;
-}
-
-static void xpm_send_register_request_cb(void *a)
-{
+    xpm_binding->st = &xpm_reg_data;
 
+    conn_state = XPM_STATE_REGISTER_OK;
 }
 
-static void xpm_send_register_request(void *a)
+/**
+ * \brief sends the registration message to the Xeon Phi Manager service
+ *
+ * \param st send state (NULL)
+ */
+static void xpm_send_register_request(void *st)
 {
     errval_t err;
-    iref_t *svc_iref = a;
 
     conn_state = XPM_STATE_REGISTERING;
 
-    DEBUG_XPMC("Registering with Xeon Phi manager...\n");
+    DEBUG_XPMC("register: sending request. iref=%u\n", xpm_reg_data.svc_iref);
 
-    struct event_closure txcont = MKCONT(xpm_send_register_request_cb, NULL);
-
-    err = xeon_phi_manager_register_call__tx(xpm_binding, txcont, *svc_iref);
+    struct event_closure txcont = NOP_CONT;
 
+    err = xeon_phi_manager_register_call__tx(xpm_binding, txcont, xpm_reg_data.svc_iref);
     if (err_is_fail(err)) {
         if (err_no(err) == FLOUNDER_ERR_TX_BUSY) {
             txcont = MKCONT(xpm_send_register_request, xpm_binding);
@@ -101,48 +126,54 @@ static void xpm_send_register_request(void *a)
                                              txcont);
             if (err_is_fail(err)) {
                 conn_state = XPM_STATE_REGISTER_FAIL;
+                xpm_reg_data.err = err;
             }
         }
     }
 }
 
+/// receive vtbl
 struct xeon_phi_manager_rx_vtbl xpm_rx_vtbl = {
     .register_response = xpm_recv_register_response
 };
 
 /*
- * --------------------------------------------------------------------------
- * Xeon Phi Manager Binding
+ * ----------------------------------------------------------------------------
+ * Xeon Phi Manager binding functions
+ * ----------------------------------------------------------------------------
  */
 
 /**
- * \brief
+ * \brief Flounder bind callback
  *
- * \param
- * \param
- * \param
+ * \param st      state associated with the binding
+ * \param err     error code of the binding attempt
+ * \param binding Xeon Phi Manager Flounder binding
  */
 static void xpm_bind_cb(void *st,
                         errval_t err,
-                        struct xeon_phi_manager_binding *b)
+                        struct xeon_phi_manager_binding *binding)
 {
 
     if (err_is_fail(err)) {
         conn_state = XPM_STATE_BIND_FAIL;
+        xpm_reg_data.err = err;
         return;
     }
 
-    xpm_binding = b;
-
+    xpm_binding = binding;
     xpm_binding->rx_vtbl = xpm_rx_vtbl;
 
-    DEBUG_XPMC("Binding ok.\n");
-
     conn_state = XPM_STATE_BIND_OK;
+
+    DEBUG_XPMC("binding to "XEON_PHI_MANAGER_SERVICE_NAME" succeeded\n");
 }
 
 /**
- * \brief
+ * \brief binds to the Xeon Phi Manager service
+ *
+ * \returns SYS_ERR_OK on success
+ *          FLOUNDER_ERR_* on failure
  */
 static errval_t xpm_bind(void)
 {
@@ -152,7 +183,11 @@ static errval_t xpm_bind(void)
         return SYS_ERR_OK;
     }
 
-    DEBUG_XPMC("Nameservice lookup: "XEON_PHI_MANAGER_SERVICE_NAME"\n");
+    assert(conn_state== XPM_STATE_INVALID);
+
+    conn_state = XPM_STATE_NSLOOKUP;
+
+    DEBUG_XPMC("nameservice lookup: "XEON_PHI_MANAGER_SERVICE_NAME"\n");
     err = nameservice_blocking_lookup(XEON_PHI_MANAGER_SERVICE_NAME, &xpm_iref);
     if (err_is_fail(err)) {
         return err;
@@ -160,42 +195,50 @@ static errval_t xpm_bind(void)
 
     conn_state = XPM_STATE_BINDING;
 
-    DEBUG_XPMC("binding... \n");
+    DEBUG_XPMC("binding: "XEON_PHI_MANAGER_SERVICE_NAME" @ iref:%u\n", xpm_iref);
+
     err = xeon_phi_manager_bind(xpm_iref,
                                 xpm_bind_cb,
                                 NULL,
                                 get_default_waitset(),
                                 IDC_BIND_FLAGS_DEFAULT);
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    return SYS_ERR_OK;
+    return err;
 }
 
 /*
- * --------------------------------------------------------------------------
+ * ----------------------------------------------------------------------------
  * Public Interface
+ * ----------------------------------------------------------------------------
  */
 
 /**
- * \brief   registers the Xeon Phi driver card with the Xeon Phi Manager
- *          this function blocks until we have a connection to the manager
+ * \brief registers the Xeon Phi driver card with the Xeon Phi Manager
  *
- * \param   svc_iref    the iref of the drivers service
- * \param   id          the own card id
- * \param   num         returns the number of returned irefs / number of cards
- * \param   cards       returns the array of irefs
+ * \param svc_iref  iref of the own exported Xeon Phi driver interface
+ * \param id        returns the assigned Xeon Phi card ID
+ * \param num       returns the size of the cards array
+ * \param irefs     returns array of irefs to the other cards
  *
- * \return SYS_ERR_OK on success
+ * NOTE: this is a blocking function. The function will only return after
+ *       the Xeon Phi manager connection has been fully established and the
+ *       registration protocol has been executed.
+ *
+ * \returns SYS_ERR_OK on success
+ *          errval on failure
  */
 errval_t xeon_phi_manager_client_register(iref_t svc_iref,
                                           uint8_t *id,
                                           uint8_t *num,
-                                          iref_t **cards)
+                                          iref_t **irefs)
 {
-    DEBUG_XPMC("Registring with Xeon Phi Manager\n");
     errval_t err;
+
+    if (conn_state >= XPM_STATE_REGISTER_OK) {
+        return SYS_ERR_OK;
+    }
+
+    DEBUG_XPMC("Registration with Xeon Phi Manager service.\n");
+
     err = xpm_bind();
     if (err_is_fail(err)) {
         return err;
@@ -209,24 +252,23 @@ errval_t xeon_phi_manager_client_register(iref_t svc_iref,
         return FLOUNDER_ERR_BIND;
     }
 
-    xpm_send_register_request(&svc_iref);
+    xpm_reg_data.svc_iref = svc_iref;
+
+    xpm_send_register_request(NULL);
 
     while (conn_state == XPM_STATE_REGISTERING) {
         messages_wait_and_handle_next();
     }
 
     if (conn_state == XPM_STATE_REGISTER_FAIL) {
-        // TODO ERROR CODE
-        DEBUG_XPMC("Registration failed.\n");
-        return -1;
+        return xpm_reg_data.err;
     }
 
-    assert(xpm_binding->st == &reg_data);
+    assert(xpm_binding->st == &xpm_reg_data);
 
-    struct xpm_register_data *rd = xpm_binding->st;
-    *id = rd->id;
-    *num = rd->num;
-    *cards = rd->cards;
+    *id = xpm_reg_data.id;
+    *num = xpm_reg_data.irefs.num;
+    *irefs = &xpm_reg_data.irefs.card0;
 
     xpm_binding->st = NULL;
 
@@ -240,5 +282,6 @@ errval_t xeon_phi_manager_client_register(iref_t svc_iref,
  */
 errval_t xeon_phi_manager_client_deregister(void)
 {
+    assert(!"NYI");
     return SYS_ERR_OK;
 }
index 2489983..cbd4d76 100644 (file)
@@ -6,7 +6,6 @@
  * If you do not find this file, copies can be found by writing to:
  * ETH Zurich D-INFK, Universitaetsstrasse 6, CH-8092 Zurich. Attn: Systems Group.
  */
-#include <stdio.h>
 
 #include <barrelfish/barrelfish.h>
 #include <xeon_phi/xeon_phi.h>
 
 #include "cardmanager.h"
 
+#ifdef XEON_PHI_DEBUG_MANAGER
+#define DEBUG_CM(x...) debug_printf(" cm  | " x)
+#else
+#define DEBUG_CM(x...)
+#endif
+
+/**
+ * state stored with the Xeon Phi driver
+ *
+ * XXX: this could be extended to serve as a kind of load balancing i.e.
+ *      domains always obtain the service irefs via Xeon Phi manager and
+ *      not via nameservice lookup
+ */
 struct xeon_phi_card {
     struct xeon_phi_manager_binding *binding;
     iref_t driver_iref;
 };
 
-
+/// the number of currently registered cards.
 static uint8_t num_cards = 0;
 
+/// irefs of the cards Xeon Phi driver interface
 static iref_t  driver_irefs[XEON_PHI_NUM_MAX];
 
+/// per-card state
 static struct xeon_phi_card xeon_phis[XEON_PHI_NUM_MAX];
 
 /**
@@ -41,9 +55,11 @@ errval_t cm_new_xeon_phi(struct xeon_phi_manager_binding *binding,
 {
     if (num_cards == XEON_PHI_NUM_MAX) {
         // TODO: ERROR CODE
-        return -1;
+        return XEON_PHI_ERR_MGR_MAX_CARDS;
     }
 
+    DEBUG_CM("assigning id:%u to card @ iref:%u\n", num_cards, driver);
+
     struct xeon_phi_card *card = xeon_phis+num_cards;
 
     card->driver_iref = driver;
@@ -61,25 +77,21 @@ errval_t cm_new_xeon_phi(struct xeon_phi_manager_binding *binding,
     return SYS_ERR_OK;
 }
 
-
 /**
- * \brief  returns an array of irefs with the assciated xeon phi drivers
+ * \brief returns an array of irefs with the associated xeon phi drivers
  *
- * \param  iref the iref array
- * \param  num  the number of irefs in the iref array
+ * \param iref the iref array
+ * \param num  the number of irefs in the iref array
  *
  * \return SYS_ERR_OK
  */
-errval_t cm_get_irefs(iref_t **iref, uint8_t *num)
+errval_t cm_get_irefs(iref_t *iref, uint8_t *num)
 {
     if (iref) {
-        *iref = driver_irefs;
+        memcpy(iref, driver_irefs, num_cards * sizeof(*iref));
     }
     if (num) {
         *num = num_cards;
     }
     return SYS_ERR_OK;
 }
-
-
-
index b70d985..57a9be1 100644 (file)
@@ -32,6 +32,6 @@ errval_t cm_new_xeon_phi(struct xeon_phi_manager_binding *binding,
  *
  * \return SYS_ERR_OK
  */
-errval_t cm_get_irefs(iref_t **iref, uint8_t *num);
+errval_t cm_get_irefs(iref_t *iref, uint8_t *num);
 
-#endif /* SERVICE_H_ */
+#endif /* XEON_PHI_MANAGER_CARDS_H_ */
index 9fd68d4..f41d730 100644 (file)
@@ -6,11 +6,9 @@
  * If you do not find this file, copies can be found by writing to:
  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
  */
+
 #include <barrelfish/barrelfish.h>
 
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
 
 #include "service.h"
 
index 707e38a..0a883eb 100644 (file)
@@ -6,18 +6,30 @@
  * If you do not find this file, copies can be found by writing to:
  * ETH Zurich D-INFK, Universitaetsstrasse 6, CH-8092 Zurich. Attn: Systems Group.
  */
-#include <stdio.h>
+
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/nameservice_client.h>
-#include <xeon_phi/xeon_phi_manager_client.h>
 
 #include <if/xeon_phi_manager_defs.h>
 
 #include "service.h"
 #include "cardmanager.h"
 
+#define XEON_PHI_MANAGER_SERVICE_NAME "xeon_phi_manager"
+
+#ifdef XEON_PHI_DEBUG_MANAGER
+#define DEBUG_SVC(x...) debug_printf(" svc | " x)
+#else
+#define DEBUG_SVC(x...)
+#endif
+
+#define PRINTF_SVC(x...) debug_printf(" svc | " x)
+
+
+/// enumeration of possible service state
 enum xpm_svc_state
 {
+    XPM_SVC_STATE_INVALID = 0,
     XPM_SVC_STATE_EXPORTING,
     XPM_SVC_STATE_EXPORT_OK,
     XPM_SVC_STATE_EXPORT_FAIL,
@@ -27,8 +39,10 @@ enum xpm_svc_state
     XPM_SVC_STATE_RUNNING
 };
 
-static enum xpm_svc_state svc_state = XPM_SVC_STATE_EXPORTING;
+/// service state
+static enum xpm_svc_state svc_state = XPM_SVC_STATE_INVALID;
 
+/// our exported iref
 static iref_t manager_iref;
 
 /**
@@ -40,8 +54,7 @@ struct reg_data
 {
     errval_t err;
     uint8_t id;
-    iref_t *cards;
-    uint8_t num;
+    xeon_phi_manager_cards_t irefs;
     struct xeon_phi_manager_binding *b;
 };
 
@@ -63,26 +76,22 @@ static void register_response_send(void *a)
 
     struct reg_data *rd = a;
 
-    DEBUG_SVC("Registration response: id=%x, num=%x\n", rd->id, rd->num);
+    DEBUG_SVC("Registration response: id=%u, #irefs=%u\n", rd->id, rd->irefs.num);
 
     struct event_closure txcont = MKCONT(register_response_sent_cb, a);
-    size_t n = rd->num * sizeof(iref_t);
-    uint8_t *irefs = (uint8_t *) rd->cards;
+
     err = xeon_phi_manager_register_response__tx(rd->b,
                                                  txcont,
                                                  rd->id,
-                                                 irefs,
-                                                 n,
+                                                 rd->irefs,
                                                  rd->err);
     if (err_is_fail(err)) {
         if (err_no(err) == FLOUNDER_ERR_TX_BUSY) {
             txcont = MKCONT(register_response_send, a);
-        }
-        struct waitset *ws = get_default_waitset();
-        err = rd->b->register_send(rd->b, ws, txcont);
-        if (err_is_fail(err)) {
-            DEBUG_ERR(err, "register_send on binding failed!");
-            register_response_sent_cb(a);
+            err = rd->b->register_send(rd->b, get_default_waitset(), txcont);
+            if (err_is_fail(err)) {
+                USER_PANIC_ERR(err, "register_send on binding failed!");
+            }
         }
     }
 }
@@ -90,22 +99,23 @@ static void register_response_send(void *a)
 static void register_call_recv(struct xeon_phi_manager_binding *_binding,
                                iref_t svc)
 {
-    DEBUG_SVC("New registration: iref=%x\n", svc);
+    PRINTF_SVC("New registration request: iref=%u\n", svc);
 
     struct reg_data *reply = malloc(sizeof(struct reg_data));
     if (!reply) {
+        reg_data_fail.err = LIB_ERR_MALLOC_FAIL;
+        reg_data_fail.b = _binding;
         register_response_send(&reg_data_fail);
+        return;
     }
     reply->b = _binding;
     reply->err = cm_new_xeon_phi(_binding, svc, &reply->id);
     if (err_is_fail(reply->err)) {
         register_response_send(reply);
+        return;
     }
 
-    reply->err = cm_get_irefs(&reply->cards, &reply->num);
-    if (err_is_fail(reply->err)) {
-        register_response_send(reply);
-    }
+    reply->err = cm_get_irefs(&reply->irefs.card0, &reply->irefs.num);
 
     register_response_send(reply);
 }
@@ -122,7 +132,8 @@ static struct xeon_phi_manager_rx_vtbl xpm_rx_vtbl = {
 static errval_t svc_connect_cb(void *st,
                                struct xeon_phi_manager_binding *b)
 {
-    DEBUG_SVC("connect request\n");
+    DEBUG_SVC("New connection from a Xeon Phi Driver\n");
+
     b->rx_vtbl = xpm_rx_vtbl;
 
     return SYS_ERR_OK;
@@ -135,46 +146,48 @@ static void svc_export_cb(void *st,
                           errval_t err,
                           iref_t iref)
 {
-    DEBUG_SVC("exported\n");
     if (err_is_fail(err)) {
         svc_state = XPM_SVC_STATE_EXPORT_FAIL;
         return;
     }
 
     manager_iref = iref;
-
     svc_state = XPM_SVC_STATE_NS_REGISTERING;
 
+    DEBUG_SVC("registering "XEON_PHI_MANAGER_SERVICE_NAME" with iref:%u\n", iref);
+
     err = nameservice_register(XEON_PHI_MANAGER_SERVICE_NAME, iref);
     if (err_is_fail(err)) {
         svc_state = XPM_SVC_STATE_NS_REGISTER_FAIL;
     }
-    DEBUG_SVC("ns registered\n");
     svc_state = XPM_SVC_STATE_NS_REGISTER_OK;
 }
 
 /**
  * \brief   starts Xeon Phi manager service
  *
- * \return  SYS_ERR_OK on succes
+ * \returns  SYS_ERR_OK on success
+ *           errval on failure
+ *
+ * NOTE: this function should not return.
  */
 errval_t service_start(void)
 {
-    DEBUG_SVC("starting service...\n");
     errval_t err;
 
-    struct waitset *ws = get_default_waitset();
+    DEBUG_SVC("starting service {"XEON_PHI_MANAGER_SERVICE_NAME"}\n");
 
     err = xeon_phi_manager_export(NULL,
                                   svc_export_cb,
                                   svc_connect_cb,
-                                  ws,
+                                  get_default_waitset(),
                                   IDC_EXPORT_FLAGS_DEFAULT);
     if (err_is_fail(err)) {
         return err;
     }
 
-    while (svc_state == XPM_SVC_STATE_EXPORTING) {
+    while (svc_state == XPM_SVC_STATE_EXPORTING || svc_state
+                    == XPM_SVC_STATE_NS_REGISTERING) {
         messages_wait_and_handle_next();
     }
 
@@ -184,11 +197,13 @@ errval_t service_start(void)
         return LIB_ERR_NAMESERVICE_CLIENT_INIT;
     }
 
-    DEBUG_SVC("Service up and running.\n");
-
     svc_state = XPM_SVC_STATE_RUNNING;
+
+    PRINTF_SVC("Xeon Phi Manager service up and running.\n");
+
     messages_handler_loop();
 
-    DEBUG_SVC("Message handler terminated.\n");
-    return -1;
+    USER_PANIC("Xeon Phi Manager service terminated!\n");
+
+    return SYS_ERR_OK;
 }
index 97139dc..7968492 100644 (file)
@@ -11,9 +11,6 @@
 #define XEON_PHI_MANAGER_SERVICE_H_
 
 
-#define DEBUG_SVC(x...) debug_printf("SVC | " x);
-//#define DEBUG_SVC(x...)
-
 /**
  * \brief   starts Xeon Phi manager service
  *
@@ -23,5 +20,4 @@ errval_t service_start(void);
 
 
 
-
 #endif /* SERVICE_H_ */