kernel - Major signal path adjustments to fix races, tsleep race fixes, +more
[dragonfly.git] / sys / dev / raid / vinum / vinumdaemon.c
1 /* daemon.c: kernel part of Vinum daemon */
2 /*-
3  * Copyright (c) 1997, 1998
4  *      Nan Yang Computer Services Limited.  All rights reserved.
5  *
6  *  This software is distributed under the so-called ``Berkeley
7  *  License'':
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *      This product includes software developed by Nan Yang Computer
20  *      Services Limited.
21  * 4. Neither the name of the Company nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * This software is provided ``as is'', and any express or implied
26  * warranties, including, but not limited to, the implied warranties of
27  * merchantability and fitness for a particular purpose are disclaimed.
28  * In no event shall the company or contributors be liable for any
29  * direct, indirect, incidental, special, exemplary, or consequential
30  * damages (including, but not limited to, procurement of substitute
31  * goods or services; loss of use, data, or profits; or business
32  * interruption) however caused and on any theory of liability, whether
33  * in contract, strict liability, or tort (including negligence or
34  * otherwise) arising in any way out of the use of this software, even if
35  * advised of the possibility of such damage.
36  *
37  * $Id: vinumdaemon.c,v 1.8 2000/01/03 05:22:03 grog Exp grog $
38  * $FreeBSD: src/sys/dev/vinum/vinumdaemon.c,v 1.16 2000/01/05 06:03:56 grog Exp $
39  * $DragonFly: src/sys/dev/raid/vinum/vinumdaemon.c,v 1.12 2008/06/05 18:06:31 swildner Exp $
40  */
41
42 #include "vinumhdr.h"
43 #include "request.h"
44
45 #ifdef VINUMDEBUG
46 #include <sys/reboot.h>
47 #endif
48
49 /* declarations */
50 void recover_io(struct request *rq);
51
52 int daemon_options = 0;                                     /* options */
53 int daemonpid;                                              /* PID of daemon */
54 struct daemonq *daemonq;                                    /* daemon's work queue */
55 struct daemonq *dqend;                                      /* and the end of the queue */
56
57 /*
58  * We normally call Malloc to get a queue element.  In interrupt
59  * context, we can't guarantee that we'll get one, since we're not
60  * allowed to wait.  If malloc fails, use one of these elements.
61  */
62
63 #define INTQSIZE 4
64 struct daemonq intq[INTQSIZE];                              /* queue elements for interrupt context */
65 struct daemonq *intqp;                                      /* and pointer in it */
66
67 void
68 vinum_daemon(void)
69 {
70     struct daemonq *request;
71
72     curproc->p_flags |= P_SYSTEM;                   /* we're a system process */
73     daemon_save_config();                                   /* start by saving the configuration */
74     daemonpid = curproc->p_pid;                             /* mark our territory */
75     while (1) {
76         tsleep(&vinum_daemon, 0, "vinum", 0);       /* wait for something to happen */
77
78         /*
79          * It's conceivable that, as the result of an
80          * I/O error, we'll be out of action long
81          * enough that another daemon gets started.
82          * That's OK, just give up gracefully.
83          */
84         if (curproc->p_pid != daemonpid) {                  /* we've been ousted in our sleep */
85             if (daemon_options & daemon_verbose)
86                 log(LOG_INFO, "vinum: abdicating\n");
87             return;
88         }
89         while (daemonq != NULL) {                           /* we have work to do, */
90             crit_enter();
91             request = daemonq;                              /* get the request */
92             daemonq = daemonq->next;                        /* and detach it */
93             if (daemonq == NULL)                            /* got to the end, */
94                 dqend = NULL;                               /* no end any more */
95             crit_exit();
96
97             switch (request->type) {
98                 /*
99                  * We had an I/O error on a request.  Go through the
100                  * request and try to salvage it
101                  */
102             case daemonrq_ioerror:
103                 if (daemon_options & daemon_verbose) {
104                     struct request *rq = request->info.rq;
105
106                     log(LOG_WARNING,
107                         "vinum: recovering I/O request: %p\n%s dev %d.%d, offset 0x%012llx, length %d\n",
108                         rq,
109                         (rq->bio->bio_buf->b_cmd == BUF_CMD_READ) ? "Read" : "Write",
110                         major((cdev_t)rq->bio->bio_driver_info),
111                         minor((cdev_t)rq->bio->bio_driver_info),
112                         (long long)rq->bio->bio_offset,
113                         rq->bio->bio_buf->b_bcount);
114                 }
115                 recover_io(request->info.rq);               /* the failed request */
116                 break;
117
118                 /*
119                  * Write the config to disk.  We could end up with
120                  * quite a few of these in a row.  Only honour the
121                  * last one
122                  */
123             case daemonrq_saveconfig:
124                 if ((daemonq == NULL)                       /* no more requests */
125                 ||(daemonq->type != daemonrq_saveconfig)) { /* or the next isn't the same */
126                     if (((daemon_options & daemon_noupdate) == 0) /* we're allowed to do it */
127                     &&((vinum_conf.flags & VF_READING_CONFIG) == 0)) { /* and we're not building the config now */
128                         /*
129                            * We obviously don't want to save a
130                            * partial configuration.  Less obviously,
131                            * we don't need to do anything if we're
132                            * asked to write the config when we're
133                            * building it up, because we save it at
134                            * the end.
135                          */
136                         if (daemon_options & daemon_verbose)
137                             log(LOG_INFO, "vinum: saving config\n");
138                         daemon_save_config();               /* save it */
139                     }
140                 }
141                 break;
142
143             case daemonrq_return:                           /* been told to stop */
144                 if (daemon_options & daemon_verbose)
145                     log(LOG_INFO, "vinum: stopping\n");
146                 daemon_options |= daemon_stopped;           /* note that we've stopped */
147                 Free(request);
148                 while (daemonq != NULL) {                   /* backed up requests, */
149                     request = daemonq;                      /* get the request */
150                     daemonq = daemonq->next;                /* and detach it */
151                     Free(request);                          /* then free it */
152                 }
153                 wakeup(&vinumclose);                        /* and wake any waiting vinum(8)s */
154                 return;
155
156             case daemonrq_ping:                             /* tell the caller we're here */
157                 if (daemon_options & daemon_verbose)
158                     log(LOG_INFO, "vinum: ping reply\n");
159                 wakeup(&vinum_finddaemon);                  /* wake up the caller */
160                 break;
161
162             case daemonrq_closedrive:                       /* close a drive */
163                 close_drive(request->info.drive);           /* do it */
164                 break;
165
166             case daemonrq_init:                             /* initialize a plex */
167                 /* XXX */
168             case daemonrq_revive:                           /* revive a subdisk */
169                 /* XXX */
170                 /* FALLTHROUGH */
171             default:
172                 log(LOG_WARNING, "Invalid request\n");
173                 break;
174             }
175             if (request->privateinuse)                      /* one of ours, */
176                 request->privateinuse = 0;                  /* no longer in use */
177             else
178                 Free(request);                              /* return it */
179         }
180     }
181 }
182
183 /*
184  * Recover a failed I/O operation.
185  *
186  * The correct way to do this is to examine the request and determine
187  * how to recover each individual failure.  In the case of a write,
188  * this could be as simple as doing nothing: the defective drives may
189  * already be down, and there may be nothing else to do.  In case of
190  * a read, it will be necessary to retry if there are alternative
191  * copies of the data.
192  *
193  * The easy way (here) is just to reissue the request.  This will take
194  * a little longer, but nothing like as long as the failure will have
195  * taken.
196  *
197  */
198 void
199 recover_io(struct request *rq)
200 {
201     /*
202      * This should read:
203      *
204      *     vinumstrategy(rq->bio);
205      *
206      * Negotiate with phk to get it fixed.
207      * Reissue the command.
208      */
209     dev_dstrategy((cdev_t)rq->bio->bio_driver_info, rq->bio);
210 }
211
212 /* Functions called to interface with the daemon */
213
214 /* queue a request for the daemon */
215 void
216 queue_daemon_request(enum daemonrq type, union daemoninfo info)
217 {
218     struct daemonq *qelt = (struct daemonq *) Malloc(sizeof(struct daemonq));
219
220     if (qelt == NULL) {                                     /* malloc failed, we're prepared for that */
221         /*
222          * Take one of our spares.  Give up if it's still in use; the only
223          * message we're likely to get here is a 'drive failed' message,
224          * and that'll come by again if we miss it.
225          */
226         if (intqp->privateinuse)                            /* still in use? */
227             return;                                         /* yes, give up */
228         qelt = intqp++;
229         if (intqp == &intq[INTQSIZE])                       /* got to the end, */
230             intqp = intq;                                   /* wrap around */
231         qelt->privateinuse = 1;                             /* it's ours, and it's in use */
232     } else
233         qelt->privateinuse = 0;
234
235     qelt->next = NULL;                                      /* end of the chain */
236     qelt->type = type;
237     qelt->info = info;
238     crit_enter();
239     if (daemonq) {                                          /* something queued already */
240         dqend->next = qelt;
241         dqend = qelt;
242     } else {                                                /* queue is empty, */
243         daemonq = qelt;                                     /* this is the whole queue */
244         dqend = qelt;
245     }
246     crit_exit();
247     wakeup(&vinum_daemon);                                  /* and give the dæmon a kick */
248 }
249
250 /*
251  * see if the daemon is running.  Return 0 (no error)
252  * if it is, ESRCH otherwise
253  */
254 int
255 vinum_finddaemon(void)
256 {
257     int result;
258
259     if (daemonpid != 0) {                                   /* we think we have a daemon, */
260         queue_daemon_request(daemonrq_ping, (union daemoninfo) 0); /* queue a ping */
261         result = tsleep(&vinum_finddaemon, 0, "reap", 2 * hz);
262         if (result == 0)                                    /* yup, the daemon's up and running */
263             return 0;
264     }
265     /* no daemon, or we couldn't talk to it: start it */
266     vinum_daemon();                                         /* start the daemon */
267     return 0;
268 }
269
270 int
271 vinum_setdaemonopts(int options)
272 {
273     daemon_options = options;
274     return 0;
275 }