Whamcloud - gitweb
i=liang,b=13065:
[fs/lustre-release.git] / lnet / lnet / acceptor.c
index 18e825c..5b143a9 100644 (file)
 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
  * vim:expandtab:shiftwidth=8:tabstop=8:
  *
- * Copyright (C) 2005 Cluster File Systems, Inc.
+ * GPL HEADER START
  *
- *   This file is part of Lustre, http://www.lustre.org.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
- *   Lustre is free software; you can redistribute it and/or
- *   modify it under the terms of version 2 of the GNU General Public
- *   License as published by the Free Software Foundation.
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 only,
+ * as published by the Free Software Foundation.
  *
- *   Lustre is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License version 2 for more details (a copy is included
+ * in the LICENSE file that accompanied this code).
  *
- *   You should have received a copy of the GNU General Public License
- *   along with Lustre; if not, write to the Free Software
- *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * You should have received a copy of the GNU General Public License
+ * version 2 along with this program; If not, see
+ * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ * GPL HEADER END
+ */
+/*
+ * Copyright  2008 Sun Microsystems, Inc. All rights reserved
+ * Use is subject to license terms.
+ */
+/*
+ * This file is part of Lustre, http://www.lustre.org/
+ * Lustre is a trademark of Sun Microsystems, Inc.
  */
 
 #define DEBUG_SUBSYSTEM S_LNET
 #include <lnet/lib-lnet.h>
 
+#if defined(__KERNEL__) || defined(HAVE_LIBPTHREAD)
+
+static int   accept_port    = 988;
+static int   accept_backlog = 127;
+static int   accept_timeout = 5;
+
+struct {
+        int                   pta_shutdown;
+        cfs_socket_t         *pta_sock;
+#ifdef __KERNEL__
+        struct semaphore      pta_signal;
+#else
+        struct cfs_completion pta_signal;
+#endif
+} lnet_acceptor_state;
+
+int
+lnet_acceptor_port(void)
+{
+        return accept_port;
+}
+
+static inline int
+lnet_accept_magic(__u32 magic, __u32 constant)
+{
+        return (magic == constant ||
+                magic == __swab32(constant));
+}
+
 #ifdef __KERNEL__
+
+#define cfs_init_completion(c)     init_mutex_locked(c)
+#define cfs_wait_for_completion(c) mutex_down(c)
+#define cfs_complete(c)            mutex_up(c)
+#define cfs_fini_completion(c)     do { } while (0)
+#define cfs_create_thread(func, a) cfs_kernel_thread(func, a, 0)
+
+EXPORT_SYMBOL(lnet_acceptor_port);
+
 static char *accept = "secure";
+
 CFS_MODULE_PARM(accept, "s", charp, 0444,
                 "Accept connections (secure|all|none)");
-
-static int accept_port = 988;
 CFS_MODULE_PARM(accept_port, "i", int, 0444,
                 "Acceptor's port (same on all nodes)");
-
-static int accept_backlog = 127;
 CFS_MODULE_PARM(accept_backlog, "i", int, 0444,
                 "Acceptor's listen backlog");
-
-static int accept_timeout = 5;
 CFS_MODULE_PARM(accept_timeout, "i", int, 0644,
-               "Acceptor's timeout (seconds)");
+                "Acceptor's timeout (seconds)");
 
-struct {
-       int               pta_shutdown;
-       cfs_socket_t     *pta_sock;
-       struct semaphore  pta_signal;
-} lnet_acceptor_state;
+static char *accept_type = NULL;
 
 int
-lnet_acceptor_timeout(void)
+lnet_acceptor_get_tunables(void)
 {
-        return accept_timeout;
+        /* Userland acceptor uses 'accept_type' instead of 'accept', due to
+         * conflict with 'accept(2)', but kernel acceptor still uses 'accept'
+         * for compatibility. Hence the trick. */
+        accept_type = accept;
+        return 0;
 }
-EXPORT_SYMBOL(lnet_acceptor_timeout);
 
 int
-lnet_acceptor_port(void)
+lnet_acceptor_timeout(void)
 {
-        return accept_port;
+        return accept_timeout;
 }
-EXPORT_SYMBOL(lnet_acceptor_port);
+EXPORT_SYMBOL(lnet_acceptor_timeout);
 
 void
-lnet_connect_console_error (int rc, lnet_nid_t peer_nid, 
+lnet_connect_console_error (int rc, lnet_nid_t peer_nid,
                            __u32 peer_ip, int peer_port)
 {
         switch (rc) {
@@ -131,13 +177,13 @@ lnet_connect(cfs_socket_t **sockp, lnet_nid_t peer_nid,
 
         CLASSERT (sizeof(cr) <= 16);            /* not too big to be on the stack */
 
-        for (port = LNET_ACCEPTOR_MAX_RESERVED_PORT; 
-             port >= LNET_ACCEPTOR_MIN_RESERVED_PORT; 
+        for (port = LNET_ACCEPTOR_MAX_RESERVED_PORT;
+             port >= LNET_ACCEPTOR_MIN_RESERVED_PORT;
              --port) {
                 /* Iterate through reserved ports. */
 
-                rc = libcfs_sock_connect(&sock, &fatal, 
-                                         local_ip, port, 
+                rc = libcfs_sock_connect(&sock, &fatal,
+                                         local_ip, port,
                                          peer_ip, peer_port);
                 if (rc != 0) {
                         if (fatal)
@@ -147,43 +193,36 @@ lnet_connect(cfs_socket_t **sockp, lnet_nid_t peer_nid,
 
                 CLASSERT (LNET_PROTO_ACCEPTOR_VERSION == 1);
 
-                if (the_lnet.ln_ptlcompat != 2) {
-                        /* When portals compatibility is "strong", simply
-                         * connect (i.e. send no acceptor connection request).
-                         * Othewise send an acceptor connection request. I can
-                         * have no portals peers so everyone else should
-                         * understand my protocol. */
-                        cr.acr_magic   = LNET_PROTO_ACCEPTOR_MAGIC;
-                        cr.acr_version = LNET_PROTO_ACCEPTOR_VERSION;
-                        cr.acr_nid     = peer_nid;
-
-                        if (the_lnet.ln_testprotocompat != 0) {
-                                /* single-shot proto check */
-                                LNET_LOCK();
-                                if ((the_lnet.ln_testprotocompat & 4) != 0) {
-                                        cr.acr_version++;
-                                        the_lnet.ln_testprotocompat &= ~4;
-                                }
-                                if ((the_lnet.ln_testprotocompat & 8) != 0) {
-                                        cr.acr_magic = LNET_PROTO_MAGIC;
-                                        the_lnet.ln_testprotocompat &= ~8;
-                                }
-                                LNET_UNLOCK();
+                cr.acr_magic   = LNET_PROTO_ACCEPTOR_MAGIC;
+                cr.acr_version = LNET_PROTO_ACCEPTOR_VERSION;
+                cr.acr_nid     = peer_nid;
+
+                if (the_lnet.ln_testprotocompat != 0) {
+                        /* single-shot proto check */
+                        LNET_LOCK();
+                        if ((the_lnet.ln_testprotocompat & 4) != 0) {
+                                cr.acr_version++;
+                                the_lnet.ln_testprotocompat &= ~4;
                         }
-
-                        rc = libcfs_sock_write(sock, &cr, sizeof(cr),
-                                               accept_timeout);
-                        if (rc != 0)
-                                goto failed_sock;
+                        if ((the_lnet.ln_testprotocompat & 8) != 0) {
+                                cr.acr_magic = LNET_PROTO_MAGIC;
+                                the_lnet.ln_testprotocompat &= ~8;
+                        }
+                        LNET_UNLOCK();
                 }
-                
+
+                rc = libcfs_sock_write(sock, &cr, sizeof(cr),
+                                       accept_timeout);
+                if (rc != 0)
+                        goto failed_sock;
+
                 *sockp = sock;
                 return 0;
         }
 
         rc = -EADDRINUSE;
         goto failed;
-        
+
  failed_sock:
         libcfs_sock_release(sock);
  failed:
@@ -192,15 +231,47 @@ lnet_connect(cfs_socket_t **sockp, lnet_nid_t peer_nid,
 }
 EXPORT_SYMBOL(lnet_connect);
 
-static inline int
-lnet_accept_magic(__u32 magic, __u32 constant)
+#else /* below is multi-threaded user-space code */
+
+static char *accept_type = "secure";
+
+int
+lnet_acceptor_get_tunables()
 {
-        return (magic == constant ||
-                magic == __swab32(constant));
+        int   rc;
+        char *env = getenv("LNET_ACCEPT");
+
+        if (env != NULL)
+                accept_type = env;
+
+        rc = lnet_parse_int_tunable(&accept_port, "LNET_ACCEPT_PORT");
+
+        if (rc != 0)
+                return rc;
+
+        rc = lnet_parse_int_tunable(&accept_backlog, "LNET_ACCEPT_BACKLOG");
+
+        if (rc != 0)
+                return rc;
+
+        rc = lnet_parse_int_tunable(&accept_timeout, "LNET_ACCEPT_TIMEOUT");
+
+        if (rc != 0)
+                return rc;
+
+        CDEBUG(D_NET, "accept_type     = %s\n", accept_type);
+        CDEBUG(D_NET, "accept_port     = %d\n", accept_port);
+        CDEBUG(D_NET, "accept_backlog  = %d\n", accept_backlog);
+        CDEBUG(D_NET, "accept_timeout  = %d\n", accept_timeout);
+        return 0;
 }
 
+#endif /* __KERNEL__ */
+
+/* Below is the code common for both kernel and MT user-space */
+
 int
-lnet_accept(lnet_ni_t *blind_ni, cfs_socket_t *sock, __u32 magic)
+lnet_accept(cfs_socket_t *sock, __u32 magic)
 {
         lnet_acceptor_connreq_t cr;
         __u32                   peer_ip;
@@ -210,12 +281,8 @@ lnet_accept(lnet_ni_t *blind_ni, cfs_socket_t *sock, __u32 magic)
         lnet_ni_t              *ni;
         char                   *str;
 
-        /* CAVEAT EMPTOR: I may be called by an LND in any thread's context if
-         * I passed the new socket "blindly" to the single NI that needed an
-         * acceptor.  If so, blind_ni != NULL... */
-
         LASSERT (sizeof(cr) <= 16);             /* not too big for the stack */
-        
+
         rc = libcfs_sock_getaddr(sock, 1, &peer_ip, &peer_port);
         LASSERT (rc == 0);                      /* we succeeded before */
 
@@ -248,7 +315,7 @@ lnet_accept(lnet_ni_t *blind_ni, cfs_socket_t *sock, __u32 magic)
                         str = "'old' openibnal";
                 else
                         str = "unrecognised";
-            
+
                 LCONSOLE_ERROR_MSG(0x11f, "Refusing connection from %u.%u.%u.%u"
                                    " magic %08x: %s acceptor protocol\n",
                                    HIPQUAD(peer_ip), magic, str);
@@ -257,7 +324,7 @@ lnet_accept(lnet_ni_t *blind_ni, cfs_socket_t *sock, __u32 magic)
 
         flip = (magic != LNET_PROTO_ACCEPTOR_MAGIC);
 
-        rc = libcfs_sock_read(sock, &cr.acr_version, 
+        rc = libcfs_sock_read(sock, &cr.acr_version,
                               sizeof(cr.acr_version),
                               accept_timeout);
         if (rc != 0) {
@@ -268,7 +335,7 @@ lnet_accept(lnet_ni_t *blind_ni, cfs_socket_t *sock, __u32 magic)
 
         if (flip)
                 __swab32s(&cr.acr_version);
-        
+
         if (cr.acr_version != LNET_PROTO_ACCEPTOR_VERSION) {
                 /* future version compatibility!
                  * An acceptor-specific protocol rev will first send a version
@@ -323,59 +390,35 @@ lnet_accept(lnet_ni_t *blind_ni, cfs_socket_t *sock, __u32 magic)
                 return -EPERM;
         }
 
-        CDEBUG(D_NET, "Accept %s from %u.%u.%u.%u%s\n",
-               libcfs_nid2str(cr.acr_nid), HIPQUAD(peer_ip),
-               blind_ni == NULL ? "" : " (blind)");
+        CDEBUG(D_NET, "Accept %s from %u.%u.%u.%u\n",
+               libcfs_nid2str(cr.acr_nid), HIPQUAD(peer_ip));
 
-        if (blind_ni == NULL) {
-                /* called by the acceptor: call into the requested NI... */
-                rc = ni->ni_lnd->lnd_accept(ni, sock);
-        } else {
-                /* portals_compatible set and the (only) NI called me to verify
-                 * and skip the connection request... */
-                LASSERT (the_lnet.ln_ptlcompat != 0);
-                LASSERT (ni == blind_ni);
-                rc = 0;
-        }
+        rc = ni->ni_lnd->lnd_accept(ni, sock);
 
         lnet_ni_decref(ni);
         return rc;
 }
-EXPORT_SYMBOL(lnet_accept);
-        
+
 int
 lnet_acceptor(void *arg)
 {
-       char           name[16];
-       cfs_socket_t  *newsock;
-       int            rc;
-        int            n_acceptor_nis;
-       __u32          magic;
-       __u32          peer_ip;
-       int            peer_port;
-        lnet_ni_t     *blind_ni = NULL;
-        int            secure = (int)((unsigned long)arg);
-
-       LASSERT (lnet_acceptor_state.pta_sock == NULL);
-
-        if (the_lnet.ln_ptlcompat != 0) {
-                /* When portals_compatibility is enabled, peers may connect
-                 * without sending an acceptor connection request.  There is no
-                 * ambiguity about which network the peer wants to connect to
-                 * since there can only be 1 network, so I pass connections
-                 * "blindly" to it. */
-                n_acceptor_nis = lnet_count_acceptor_nis(&blind_ni);
-                LASSERT (n_acceptor_nis == 1);
-                LASSERT (blind_ni != NULL);
-        }
+        char           name[16];
+        cfs_socket_t  *newsock;
+        int            rc;
+        __u32          magic;
+        __u32          peer_ip;
+        int            peer_port;
+        int            secure = (int)((long_ptr_t)arg);
+
+        LASSERT (lnet_acceptor_state.pta_sock == NULL);
 
-       snprintf(name, sizeof(name), "acceptor_%03d", accept_port);
-       cfs_daemonize(name);
-       cfs_block_allsigs();
+        snprintf(name, sizeof(name), "acceptor_%03d", accept_port);
+        cfs_daemonize(name);
+        cfs_block_allsigs();
 
-       rc = libcfs_sock_listen(&lnet_acceptor_state.pta_sock,
-                               0, accept_port, accept_backlog);
-       if (rc != 0) {
+        rc = libcfs_sock_listen(&lnet_acceptor_state.pta_sock,
+                                0, accept_port, accept_backlog);
+        if (rc != 0) {
                 if (rc == -EADDRINUSE)
                         LCONSOLE_ERROR_MSG(0x122, "Can't start acceptor on port"
                                            " %d: port already in use\n",
@@ -385,36 +428,40 @@ lnet_acceptor(void *arg)
                                            "%d: unexpected error %d\n",
                                            accept_port, rc);
 
-               lnet_acceptor_state.pta_sock = NULL;
+                lnet_acceptor_state.pta_sock = NULL;
         } else {
-                LCONSOLE(0, "Accept %s, port %d%s\n", 
-                         accept, accept_port,
-                         blind_ni == NULL ? "" : " (proto compatible)");
+                LCONSOLE(0, "Accept %s, port %d\n", accept_type, accept_port);
         }
-        
-       /* set init status and unblock parent */
-       lnet_acceptor_state.pta_shutdown = rc;
-       mutex_up(&lnet_acceptor_state.pta_signal);
-       
-       if (rc != 0)
-               return rc;
-
-       while (lnet_acceptor_state.pta_shutdown == 0) {
-               
-               rc = libcfs_sock_accept(&newsock, lnet_acceptor_state.pta_sock);
-               if (rc != 0) {
-                       if (rc != -EAGAIN) {
-                               CWARN("Accept error %d: pausing...\n", rc);
-                               cfs_pause(cfs_time_seconds(1));
-                       }
-                       continue;
-               }
-
-               rc = libcfs_sock_getaddr(newsock, 1, &peer_ip, &peer_port);
-               if (rc != 0) {
-                       CERROR("Can't determine new connection's address\n");
-                       goto failed;
-               }
+
+        /* set init status and unblock parent */
+        lnet_acceptor_state.pta_shutdown = rc;
+        cfs_complete(&lnet_acceptor_state.pta_signal);
+
+        if (rc != 0)
+                return rc;
+
+        while (!lnet_acceptor_state.pta_shutdown) {
+
+                rc = libcfs_sock_accept(&newsock, lnet_acceptor_state.pta_sock);
+                if (rc != 0) {
+                        if (rc != -EAGAIN) {
+                                CWARN("Accept error %d: pausing...\n", rc);
+                                cfs_pause(cfs_time_seconds(1));
+                        }
+                        continue;
+                }
+
+                /* maybe we're waken up with libcfs_sock_abort_accept() */
+                if (lnet_acceptor_state.pta_shutdown) {
+                        libcfs_sock_release(newsock);
+                        break;
+                }
+
+                rc = libcfs_sock_getaddr(newsock, 1, &peer_ip, &peer_port);
+                if (rc != 0) {
+                        CERROR("Can't determine new connection's address\n");
+                        goto failed;
+                }
 
                 if (secure && peer_port > LNET_ACCEPTOR_MAX_RESERVED_PORT) {
                         CERROR("Refusing connection from %u.%u.%u.%u: "
@@ -423,115 +470,126 @@ lnet_acceptor(void *arg)
                         goto failed;
                 }
 
-                if (blind_ni != NULL) {
-                        rc = blind_ni->ni_lnd->lnd_accept(blind_ni, newsock);
-                        if (rc != 0) {
-                                CERROR("NI %s refused 'blind' connection from "
-                                       "%u.%u.%u.%u\n", 
-                                       libcfs_nid2str(blind_ni->ni_nid), 
-                                       HIPQUAD(peer_ip));
-                                goto failed;
-                        }
-                        continue;
-                }
-                
-               rc = libcfs_sock_read(newsock, &magic, sizeof(magic),
-                                     accept_timeout);
-               if (rc != 0) {
+                rc = libcfs_sock_read(newsock, &magic, sizeof(magic),
+                                      accept_timeout);
+                if (rc != 0) {
                         CERROR("Error %d reading connection request from "
                                "%u.%u.%u.%u\n", rc, HIPQUAD(peer_ip));
-                       goto failed;
-               }
+                        goto failed;
+                }
 
-                rc = lnet_accept(NULL, newsock, magic);
+                rc = lnet_accept(newsock, magic);
                 if (rc != 0)
                         goto failed;
-                
+
                 continue;
-                
-       failed:
-               libcfs_sock_release(newsock);
-       }
-       
-       libcfs_sock_release(lnet_acceptor_state.pta_sock);
+
+        failed:
+                libcfs_sock_release(newsock);
+        }
+
+        libcfs_sock_release(lnet_acceptor_state.pta_sock);
         lnet_acceptor_state.pta_sock = NULL;
 
-        if (blind_ni != NULL)
-                lnet_ni_decref(blind_ni);
+        LCONSOLE(0, "Acceptor stopping\n");
 
-        LCONSOLE(0,"Acceptor stopping\n");
-       
-       /* unblock lnet_acceptor_stop() */
-       mutex_up(&lnet_acceptor_state.pta_signal);
-       return 0;
+        /* unblock lnet_acceptor_stop() */
+        cfs_complete(&lnet_acceptor_state.pta_signal);
+        return 0;
+}
+
+static inline int
+accept2secure(const char *acc, long *sec)
+{
+        if (!strcmp(acc, "secure")) {
+                *sec = 1;
+                return 1;
+        } else if (!strcmp(acc, "all")) {
+                *sec = 0;
+                return 1;
+        } else if (!strcmp(acc, "none")) {
+                return 0;
+        } else {
+                LCONSOLE_ERROR_MSG(0x124, "Can't parse 'accept=\"%s\"'\n",
+                                   acc);
+                return -EINVAL;
+        }
 }
 
 int
 lnet_acceptor_start(void)
 {
-       long   pid;
-        long   secure;
+        int  rc;
+        long rc2;
+        long secure;
+
+        LASSERT (lnet_acceptor_state.pta_sock == NULL);
 
-       LASSERT (lnet_acceptor_state.pta_sock == NULL);
-       init_mutex_locked(&lnet_acceptor_state.pta_signal);
+        rc = lnet_acceptor_get_tunables();
+        if (rc != 0)
+                return rc;
 
-        if (!strcmp(accept, "secure")) {
-                secure = 1;
-        } else if (!strcmp(accept, "all")) {
-                secure = 0;
-        } else if (!strcmp(accept, "none")) {
+#ifndef __KERNEL__
+        /* Do nothing if we're liblustre clients */
+        if ((the_lnet.ln_pid & LNET_PID_USERFLAG) != 0)
                 return 0;
-        } else {
-                LCONSOLE_ERROR_MSG(0x124, "Can't parse 'accept=\"%s\"'\n",
-                                   accept);
-                return -EINVAL;
+#endif
+        cfs_init_completion(&lnet_acceptor_state.pta_signal);
+
+        rc = accept2secure(accept_type, &secure);
+        if (rc <= 0) {
+                cfs_fini_completion(&lnet_acceptor_state.pta_signal);
+                return rc;
+        }
+
+        if (lnet_count_acceptor_nis() == 0)  /* not required */
+                return 0;
+
+        rc2 = cfs_create_thread(lnet_acceptor, (void *)(ulong_ptr_t)secure);
+        if (rc2 < 0) {
+                CERROR("Can't start acceptor thread: %d\n", rc);
+                cfs_fini_completion(&lnet_acceptor_state.pta_signal);
+                return -ESRCH;
         }
-       
-       if (lnet_count_acceptor_nis(NULL) == 0)  /* not required */
-               return 0;
-       
-       pid = cfs_kernel_thread(lnet_acceptor, (void *)secure, 0);
-       if (pid < 0) {
-               CERROR("Can't start acceptor thread: %ld\n", pid);
-               return -ESRCH;
-       }
-
-       mutex_down(&lnet_acceptor_state.pta_signal); /* wait for acceptor to startup */
-
-       if (lnet_acceptor_state.pta_shutdown == 0) {
+
+        /* wait for acceptor to startup */
+        cfs_wait_for_completion(&lnet_acceptor_state.pta_signal);
+
+        if (!lnet_acceptor_state.pta_shutdown) {
                 /* started OK */
                 LASSERT (lnet_acceptor_state.pta_sock != NULL);
-               return 0;
+                return 0;
         }
 
         LASSERT (lnet_acceptor_state.pta_sock == NULL);
-       return -ENETDOWN;
+        cfs_fini_completion(&lnet_acceptor_state.pta_signal);
+        return -ENETDOWN;
 }
 
 void
 lnet_acceptor_stop(void)
 {
-       if (lnet_acceptor_state.pta_sock == NULL) /* not running */
-               return;
-       
-       lnet_acceptor_state.pta_shutdown = 1;
-       libcfs_sock_abort_accept(lnet_acceptor_state.pta_sock);
-
-       /* block until acceptor signals exit */
-       mutex_down(&lnet_acceptor_state.pta_signal);
-}
+        if (lnet_acceptor_state.pta_sock == NULL) /* not running */
+                return;
 
-#else /* __KERNEL__ */
+        lnet_acceptor_state.pta_shutdown = 1;
+        libcfs_sock_abort_accept(lnet_acceptor_state.pta_sock);
 
+        /* block until acceptor signals exit */
+        cfs_wait_for_completion(&lnet_acceptor_state.pta_signal);
+
+        cfs_fini_completion(&lnet_acceptor_state.pta_signal);
+}
+
+#else /* single-threaded user-space */
 int
 lnet_acceptor_start(void)
 {
-       return 0;
+        return 0;
 }
 
 void
 lnet_acceptor_stop(void)
 {
 }
-
-#endif /* !__KERNEL__ */
+#endif /* defined(__KERNEL__) || defined(HAVE_LIBPTHREAD) */