nfsiod.tproj/nfsiod.c

   1 /*
   2  * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /*
  24  * Copyright (c) 1989, 1993
  25  *      The Regents of the University of California.  All rights reserved.
  26  *
  27  * This code is derived from software contributed to Berkeley by
  28  * Rick Macklem at The University of Guelph.
  29  *
  30  * Redistribution and use in source and binary forms, with or without
  31  * modification, are permitted provided that the following conditions
  32  * are met:
  33  * 1. Redistributions of source code must retain the above copyright
  34  *    notice, this list of conditions and the following disclaimer.
  35  * 2. Redistributions in binary form must reproduce the above copyright
  36  *    notice, this list of conditions and the following disclaimer in the
  37  *    documentation and/or other materials provided with the distribution.
  38  * 3. All advertising materials mentioning features or use of this software
  39  *    must display the following acknowledgement:
  40  *      This product includes software developed by the University of
  41  *      California, Berkeley and its contributors.
  42  * 4. Neither the name of the University nor the names of its contributors
  43  *    may be used to endorse or promote products derived from this software
  44  *    without specific prior written permission.
  45  *
  46  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  47  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  48  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  49  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  50  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  51  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  52  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  53  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  54  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  55  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  56  * SUCH DAMAGE.
  57  */
  58
  59
  60 #include <sys/param.h>
  61 #include <sys/ioctl.h>
  62 #include <sys/syslog.h>
  63 #include <sys/ucred.h>
  64 #include <sys/wait.h>
  65
  66 #include <sys/mount.h>
  67 #include <sys/time.h>
  68 #include <nfs/rpcv2.h>
  69 #include <nfs/nfsproto.h>
  70 #include <nfs/nfs.h>
  71
  72 #include <err.h>
  73 #include <errno.h>
  74 #include <fcntl.h>
  75 #include <signal.h>
  76 #include <stdio.h>
  77 #include <stdlib.h>
  78 #include <unistd.h>
  79 #include <string.h>
  80 #include <pthread.h>
  81
  82 /* Global defs */
  83 #ifdef DEBUG
  84 int debug = 1;
  85 #else
  86 int debug = 0;
  87 #endif
  88 int *thread_status = NULL;
  89 pthread_cond_t cond;
  90 pthread_mutex_t mutex;
  91
  92 void nonfs __P((int));
  93 void usage __P((void));
  94 void *nfsiod_thread __P((void *));
  95
  96 /*
  97  * Nfsiod does asynchronous buffered I/O on behalf of the NFS client.
  98  * It does not have to be running for correct operation, but will
  99  * improve throughput.
 100  */
 101 int
 102 main(argc, argv)
 103         int argc;
 104         char *argv[];
 105 {
 106         int ch, num_servers;
 107         int i, rv, threadcnt;
 108
 109 #define MAXNFSIODCNT      32
 110 #define DEFNFSIODCNT       1
 111         num_servers = DEFNFSIODCNT;
 112         while ((ch = getopt(argc, argv, "n:")) != EOF)
 113                 switch (ch) {
 114                 case 'n':
 115                         num_servers = atoi(optarg);
 116                         if (num_servers < 1 || num_servers > MAXNFSIODCNT) {
 117                                 warnx("nfsiod count %d; reset to %d",
 118                                     num_servers, DEFNFSIODCNT);
 119                                 num_servers = DEFNFSIODCNT;
 120                         }
 121                         break;
 122                 case '?':
 123                 default:
 124                         usage();
 125                 }
 126         argc -= optind;
 127         argv += optind;
 128
 129         /*
 130          * XXX
 131          * Backward compatibility, trailing number is the count of daemons.
 132          */
 133         if (argc > 1)
 134                 usage();
 135         if (argc == 1) {
 136                 num_servers = atoi(argv[0]);
 137                 if (num_servers < 1 || num_servers > MAXNFSIODCNT) {
 138                         warnx("nfsiod count %d; reset to %d",
 139                                 num_servers, DEFNFSIODCNT);
 140                         num_servers = DEFNFSIODCNT;
 141                 }
 142         }
 143
 144         thread_status = malloc(sizeof(int) * num_servers);
 145         if (thread_status == NULL)
 146                 errx(1, "unable to allocate memory");
 147         rv = pthread_cond_init(&cond, NULL);
 148         if (rv)
 149                 errc(1, rv, "condition variable init failed");
 150         rv = pthread_mutex_init(&mutex, NULL);
 151         if (rv)
 152                 errc(1, rv, "mutex init failed");
 153
 154         if (debug == 0) {
 155                 daemon(0, 0);
 156                 (void)signal(SIGHUP, SIG_IGN);
 157                 (void)signal(SIGINT, SIG_IGN);
 158                 (void)signal(SIGQUIT, SIG_IGN);
 159                 (void)signal(SIGSYS, nonfs);
 160         }
 161
 162         openlog("nfsiod:", LOG_PID, LOG_DAEMON);
 163
 164         threadcnt = 0;
 165         for (i=0; i < num_servers; i++) {
 166                 pthread_t thd;
 167                 thread_status[i] = 1;
 168                 rv = pthread_create(&thd, NULL, nfsiod_thread, (void*)i);
 169                 if (rv) {
 170                         syslog(LOG_ERR, "thread_create: %s", strerror(rv));
 171                         thread_status[i] = 0;
 172                         continue;
 173                 }
 174                 threadcnt++;
 175         }
 176         /* if no threads started exit */
 177         if (!threadcnt)
 178                 errx(1, "unable to start any threads");
 179         if (threadcnt != num_servers)
 180                 syslog(LOG_ERR, "only able to create %d of %d threads",
 181                         threadcnt, num_servers);
 182
 183         /* wait for threads to complete */
 184         rv = pthread_mutex_lock(&mutex);
 185         if (rv)
 186                 errc(1, rv, "mutex lock failed");
 187         while (threadcnt > 0) {
 188                 rv = pthread_cond_wait(&cond, &mutex);
 189                 if (rv)
 190                         errc(1, rv, "nfsiod: cond wait failed");
 191                 for (i=0; i < num_servers; i++) {
 192                         if (!thread_status[i])
 193                                 continue;
 194                         if (thread_status[i] == 1)
 195                                 continue;
 196                         threadcnt--;
 197                         thread_status[i] = 0;
 198                         syslog(LOG_ERR, "lost nfsiod thread %d - "
 199                                 "%d of %d threads remain",
 200                                 i, threadcnt, num_servers);
 201                 }
 202                 rv = pthread_mutex_lock(&mutex);
 203                 if (rv)
 204                         errc(1, rv, "mutex lock failed");
 205         }
 206
 207         exit (0);
 208 }
 209
 210 void *
 211 nfsiod_thread(void *arg)
 212 {
 213         int rv, thread = (int)arg;
 214         if ((rv = nfssvc(NFSSVC_BIOD, NULL)) < 0) {
 215                 thread_status[thread] = rv;
 216                 syslog(LOG_ERR, "nfssvc: %s", strerror(rv));
 217                 pthread_cond_signal(&cond);
 218                 return NULL;
 219         }
 220         thread_status[thread] = 0;
 221         pthread_cond_signal(&cond);
 222         return NULL;
 223 }
 224
 225 void
 226 nonfs(signo)
 227         int signo;
 228 {
 229         syslog(LOG_ERR, "missing system call: NFS not available.");
 230 }
 231
 232 void
 233 usage()
 234 {
 235         (void)fprintf(stderr, "usage: nfsiod [-n num_servers]\n");
 236         exit(1);
 237 }