Annotation of sys/xfs/xfs_dev-common.c, Revision 1.1.1.1
1.1 nbrk 1: /*
2: * Copyright (c) 1995 - 2003 Kungliga Tekniska Högskolan
3: * (Royal Institute of Technology, Stockholm, Sweden).
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: *
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: *
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: *
17: * 3. Neither the name of the Institute nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: */
33:
34:
35: #include <xfs/xfs_locl.h>
36: #include <xfs/xfs_message.h>
37: #include <xfs/xfs_msg_locl.h>
38: #include <xfs/xfs_fs.h>
39: #include <xfs/xfs_dev.h>
40: #include <xfs/xfs_deb.h>
41:
42: RCSID("$arla: xfs_dev-common.c,v 1.61 2003/07/15 16:25:42 lha Exp $");
43:
44: struct xfs_channel xfs_channel[NNNPFS];
45:
46: void
47: xfs_initq(struct xfs_link *q)
48: {
49: q->next = q;
50: q->prev = q;
51: }
52:
53: /* Is this queue empty? */
54: int
55: xfs_emptyq(const struct xfs_link *q)
56: {
57: return q->next == q;
58: }
59:
60: /* Is this link on any queue? Link *must* be inited! */
61: int
62: xfs_onq(const struct xfs_link *link)
63: {
64: return link->next != NULL || link->prev != NULL;
65: }
66:
67: /* Append q with p */
68: void
69: xfs_appendq(struct xfs_link *q, struct xfs_link *p)
70: {
71: p->next = q;
72: p->prev = q->prev;
73: p->prev->next = p;
74: q->prev = p;
75: }
76:
77: /* remove `p' from its queue */
78: void
79: xfs_outq(struct xfs_link *p)
80: {
81: p->next->prev = p->prev;
82: p->prev->next = p->next;
83: p->next = p->prev = NULL;
84: }
85:
86: /*
87: * Only allow one open.
88: */
89: int
90: xfs_devopen_common(dev_t dev)
91: {
92: struct xfs_channel *chan;
93:
94: if (minor(dev) < 0 || minor(dev) >= NNNPFS)
95: return ENXIO;
96:
97: chan = &xfs_channel[minor(dev)];
98:
99: /* Only allow one reader/writer */
100: if (chan->status & CHANNEL_OPENED) {
101: NNPFSDEB(XDEBDEV, ("xfs_devopen: already open\n"));
102: return EBUSY;
103: } else {
104: chan->status |= CHANNEL_OPENED;
105: }
106:
107: chan->message_buffer = xfs_alloc(MAX_XMSG_SIZE, M_NNPFS_MSG);
108:
109: /* initialize the queues if they have not been initialized before */
110: xfs_initq(&chan->sleepq);
111: xfs_initq(&chan->messageq);
112:
113: return 0;
114: }
115:
116: #if defined(HAVE_TWO_ARGUMENT_VFS_BUSY)
117: #define xfs_vfs_busy(mp, flags, lock, proc) vfs_busy((mp), (flags))
118: #define xfs_vfs_unbusy(mp, proc) vfs_unbusy((mp))
119: #elif defined(HAVE_THREE_ARGUMENT_VFS_BUSY)
120: #define xfs_vfs_busy(mp, flags, lock, proc) vfs_busy((mp), (flags), (lock))
121: #define xfs_vfs_unbusy(mp, proc) vfs_unbusy((mp))
122: #elif defined(HAVE_FOUR_ARGUMENT_VFS_BUSY)
123: #define xfs_vfs_busy(mp, flags, lock, proc) vfs_busy((mp), (flags), (lock), (proc))
124: #define xfs_vfs_unbusy(mp, proc) vfs_unbusy((mp), (proc))
125: #elif defined(__osf__)
126: #define xfs_vfs_busy(mp, flags, lock, proc) (0)
127: #define xfs_vfs_unbusy(mp, proc) (0)
128: #else
129: #define xfs_vfs_busy(mp, flags, lock, proc) vfs_busy((mp))
130: #define xfs_vfs_unbusy(mp, proc) vfs_unbusy((mp))
131: #endif
132:
133: /*
134: * Wakeup all sleepers and cleanup.
135: */
136: int
137: xfs_devclose_common(dev_t dev, d_thread_t *proc)
138: {
139: struct xfs_channel *chan = &xfs_channel[minor(dev)];
140: struct xfs_link *first;
141:
142: /* Sanity check, paranoia? */
143: if (!(chan->status & CHANNEL_OPENED))
144: panic("xfs_devclose never opened?");
145:
146: chan->status &= ~CHANNEL_OPENED;
147:
148: /* No one is going to read those messages so empty queue! */
149: while (!xfs_emptyq(&chan->messageq)) {
150: NNPFSDEB(XDEBDEV, ("before outq(messageq)\n"));
151:
152: first = chan->messageq.next;
153: xfs_outq(first);
154: if (first->error_or_size != 0)
155: xfs_free(first, first->error_or_size, M_NNPFS_LINK);
156:
157: NNPFSDEB(XDEBDEV, ("after outq(messageq)\n"));
158: }
159:
160: /* Wakeup those waiting for replies that will never arrive. */
161: while (!xfs_emptyq(&chan->sleepq)) {
162: NNPFSDEB(XDEBDEV, ("before outq(sleepq)\n"));
163: first = chan->sleepq.next;
164: xfs_outq(first);
165: first->error_or_size = ENODEV;
166: wakeup((caddr_t) first);
167: NNPFSDEB(XDEBDEV, ("after outq(sleepq)\n"));
168: }
169:
170: if (chan->status & CHANNEL_WAITING)
171: wakeup((caddr_t) chan);
172:
173: if (chan->message_buffer) {
174: xfs_free(chan->message_buffer, MAX_XMSG_SIZE, M_NNPFS_MSG);
175: chan->message_buffer = NULL;
176: }
177:
178: /*
179: * Free all xfs nodes.
180: */
181:
182: if (xfs[minor(dev)].mp != NULL) {
183: if (xfs_vfs_busy(xfs[minor(dev)].mp, VB_READ|VB_WAIT, NULL, proc)) {
184: NNPFSDEB(XDEBNODE, ("xfs_dev_close: vfs_busy() --> BUSY\n"));
185: return EBUSY;
186: }
187: free_all_xfs_nodes(&xfs[minor(dev)], FORCECLOSE, 0);
188:
189: xfs_vfs_unbusy(xfs[minor(dev)].mp, proc);
190: }
191:
192: return 0;
193: }
194:
195: #ifdef NNPFS_DEBUG
196: /*
197: * debugging glue for CURSIG
198: */
199:
200: static long
201: xfs_cursig (d_thread_t *p)
202: {
203: #if defined(__osf__)
204: thread_t th = current_thread();
205: struct np_uthread *npu = thread_to_np_uthread(th);
206: return CURSIG(p,npu);
207: #elif defined(HAVE_FREEBSD_THREAD)
208: #ifndef CURSIG
209: return 0; /* XXX we would like to use sig_ffs, but that isn't
210: * exported */
211: #else
212: return CURSIG(p->td_proc);
213: #endif
214: #else
215: #if defined(__NetBSD__) && __NetBSD_Version__ >= 106130000
216: return 0; /* XXX CURSIG operates on a struct lwp */
217: #else
218: return CURSIG(p);
219: #endif
220: #endif
221: }
222: #endif
223:
224: /*
225: * Move messages from kernel to user space.
226: */
227:
228: int
229: xfs_devread(dev_t dev, struct uio * uiop, int ioflag)
230: {
231: struct xfs_channel *chan = &xfs_channel[minor(dev)];
232: struct xfs_link *first;
233: int error = 0;
234: #ifdef NNPFS_DEBUG
235: char devname[64];
236: #endif
237:
238: NNPFSDEB(XDEBDEV, ("xfs_devread dev = %s\n",
239: xfs_devtoname_r(dev, devname, sizeof(devname))));
240:
241: NNPFSDEB(XDEBDEV, ("xfs_devread: m = %lx, m->prev = %lx, m->next = %lx\n",
242: (unsigned long)&chan->messageq,
243: (unsigned long)chan->messageq.prev,
244: (unsigned long)chan->messageq.next));
245:
246: #ifdef HAVE_FREEBSD_THREAD
247: chan->proc = xfs_uio_to_thread(uiop);
248: #else
249: chan->proc = xfs_uio_to_proc(uiop);
250: #endif
251:
252: again:
253:
254: if (!xfs_emptyq (&chan->messageq)) {
255: while (!xfs_emptyq (&chan->messageq)) {
256: /* Remove message */
257: first = chan->messageq.next;
258: NNPFSDEB(XDEBDEV, ("xfs_devread: first = %lx, "
259: "first->prev = %lx, first->next = %lx\n",
260: (unsigned long)first,
261: (unsigned long)first->prev,
262: (unsigned long)first->next));
263:
264: NNPFSDEB(XDEBDEV, ("xfs_devread: message->size = %u\n",
265: first->message->size));
266:
267: if (first->message->size > uiop->uio_resid)
268: break;
269:
270: error = uiomove((caddr_t) first->message, first->message->size,
271: uiop);
272: if (error)
273: break;
274:
275: xfs_outq(first);
276:
277: if (first->error_or_size != 0)
278: xfs_free(first, first->error_or_size, M_NNPFS_LINK);
279: }
280: } else {
281: chan->status |= CHANNEL_WAITING;
282: if (tsleep((caddr_t) chan, (PZERO + 1) | PCATCH, "xfsread", 0)) {
283: #ifdef HAVE_FREEBSD_THREAD
284: NNPFSDEB(XDEBMSG,
285: ("caught signal xfs_devread: %ld\n",
286: xfs_cursig(xfs_uio_to_thread(uiop))));
287: #else
288: NNPFSDEB(XDEBMSG,
289: ("caught signal xfs_devread: %ld\n",
290: xfs_cursig(xfs_uio_to_proc(uiop))));
291: #endif
292: error = EINTR;
293: } else if ((chan->status & CHANNEL_WAITING) == 0) {
294: goto again;
295: } else
296: error = EIO;
297: }
298:
299: NNPFSDEB(XDEBDEV, ("xfs_devread done error = %d\n", error));
300:
301: return error;
302: }
303:
304: /*
305: * Move messages from user space to kernel space,
306: * wakeup sleepers, insert new data in VFS.
307: */
308: int
309: xfs_devwrite(dev_t dev, struct uio *uiop, int ioflag)
310: {
311: struct xfs_channel *chan = &xfs_channel[minor(dev)];
312: char *p;
313: int error;
314: u_int cnt;
315: struct xfs_message_header *msg_buf;
316: #ifdef NNPFS_DEBUG
317: char devname[64];
318: #endif
319:
320: NNPFSDEB(XDEBDEV, ("xfs_devwrite dev = %s\n",
321: xfs_devtoname_r (dev, devname, sizeof(devname))));
322:
323: #ifdef HAVE_FREEBSD_THREAD
324: chan->proc = xfs_uio_to_thread(uiop);
325: #else
326: chan->proc = xfs_uio_to_proc(uiop);
327: #endif
328: cnt = uiop->uio_resid;
329: error = uiomove((caddr_t) chan->message_buffer, MAX_XMSG_SIZE, uiop);
330: if (error != 0)
331: return error;
332:
333: cnt -= uiop->uio_resid;
334:
335: /*
336: * This thread handles the received message.
337: */
338: for (p = (char *)chan->message_buffer;
339: cnt > 0;
340: p += msg_buf->size, cnt -= msg_buf->size) {
341: #ifdef HAVE_FREEBSD_THREAD
342: d_thread_t *pp = xfs_uio_to_thread(uiop);
343: #else
344: d_thread_t *pp = xfs_uio_to_proc(uiop);
345: #endif
346:
347: msg_buf = (struct xfs_message_header *)p;
348: error = xfs_message_receive (minor(dev),
349: msg_buf,
350: msg_buf->size,
351: pp);
352: }
353: NNPFSDEB(XDEBDEV, ("xfs_devwrite error = %d\n", error));
354: return error;
355: }
356:
357: /*
358: * Send a message to user space.
359: */
360: int
361: xfs_message_send(int fd, struct xfs_message_header * message, u_int size)
362: {
363: struct xfs_channel *chan = &xfs_channel[fd];
364: struct {
365: struct xfs_link this_message;
366: struct xfs_message_header msg;
367: } *t;
368:
369: NNPFSDEB(XDEBMSG, ("xfs_message_send opcode = %d\n", message->opcode));
370:
371: if (!(chan->status & CHANNEL_OPENED)) /* No receiver? */
372: return ENODEV;
373:
374: /* Prepare message and copy it later */
375: message->size = size;
376: message->sequence_num = chan->nsequence++;
377:
378: t = xfs_alloc(sizeof(t->this_message) + size, M_NNPFS);
379: t->this_message.error_or_size = sizeof(t->this_message) + size;
380: bcopy(message, &t->msg, size);
381:
382: t->this_message.message = &t->msg;
383: xfs_appendq(&chan->messageq, &t->this_message);
384: if (chan->status & CHANNEL_WAITING) {
385: chan->status &= ~CHANNEL_WAITING;
386: wakeup((caddr_t) chan);
387: }
388: xfs_select_wakeup(chan);
389:
390: return 0;
391: }
392:
393: #if defined(SWEXIT)
394: #define NNPFS_P_EXIT SWEXIT
395: #elif defined(P_WEXIT)
396: #define NNPFS_P_EXIT P_WEXIT
397: #else
398: #error what is your exit named ?
399: #endif
400:
401: #if defined(HAVE_STRUCT_PROC_P_SIGMASK) || defined(HAVE_STRUCT_PROC_P_SIGCTX) || defined(HAVE_STRUCT_PROC_P_SIGWAITMASK) || defined(__osf__) || defined(HAVE_FREEBSD_THREAD)
402: static void
403: xfs_block_sigset (sigset_t *sigset)
404: {
405:
406: #if defined(__sigaddset)
407: #define xfs_sig_block(ss,signo) __sigaddset((ss), (signo))
408: #elif defined(SIGADDSET)
409: #define xfs_sig_block(ss,signo) SIGADDSET(*(ss), (signo))
410: #else
411: #define xfs_sig_block(ss,signo) *(ss) |= sigmask(signo)
412: #endif
413:
414: xfs_sig_block(sigset, SIGIO);
415: xfs_sig_block(sigset, SIGALRM);
416: xfs_sig_block(sigset, SIGVTALRM);
417: xfs_sig_block(sigset, SIGCHLD);
418: #ifdef SIGINFO
419: xfs_sig_block(sigset, SIGINFO);
420: #endif
421: #undef xfs_sig_block
422: }
423: #endif
424:
425: /*
426: * Send a message to user space and wait for reply.
427: */
428:
429: int
430: xfs_message_rpc(int fd, struct xfs_message_header * message, u_int size,
431: d_thread_t *proc)
432: {
433: int ret;
434: struct xfs_channel *chan = &xfs_channel[fd];
435: struct xfs_link *this_message;
436: struct xfs_link *this_process;
437: struct xfs_message_header *msg;
438: #if defined(HAVE_STRUCT_PROC_P_SIGMASK) || defined(HAVE_STRUCT_PROC_P_SIGCTX) || defined(__osf__) || defined(HAVE_FREEBSD_THREAD)
439: sigset_t oldsigmask;
440: #endif
441: int catch;
442:
443: NNPFSDEB(XDEBMSG, ("xfs_message_rpc opcode = %d\n", message->opcode));
444:
445: if (proc == NULL) {
446: #ifdef HAVE_FREEBSD_THREAD
447: proc = xfs_curthread();
448: #else
449: proc = xfs_curproc();
450: #endif
451: }
452: if (!(chan->status & CHANNEL_OPENED)) /* No receiver? */
453: return ENODEV;
454:
455: #ifdef HAVE_FREEBSD_THREAD
456: if (chan->proc != NULL && chan->proc->td_proc != NULL &&
457: proc->td_proc->p_pid == chan->proc->td_proc->p_pid) {
458: printf("xfs_message_rpc: deadlock avoided "
459: "pid = %u == %u\n", proc->td_proc->p_pid, chan->proc->td_proc->p_pid);
460: #else
461: if (chan->proc != NULL && proc->p_pid == chan->proc->p_pid) {
462: printf("xfs_message_rpc: deadlock avoided "
463: "pid = %u == %u\n", proc->p_pid, chan->proc->p_pid);
464: #endif
465: #if 0
466: psignal (proc, SIGABRT);
467: #endif
468: return EDEADLK;
469: }
470:
471: if (size < sizeof(struct xfs_message_wakeup)) {
472: printf("NNPFS PANIC Error: Message to small to receive wakeup, opcode = %d\n", message->opcode);
473: return ENOMEM;
474: }
475: this_message = xfs_alloc(sizeof(struct xfs_link), M_NNPFS_LINK);
476: this_process = xfs_alloc(sizeof(struct xfs_link), M_NNPFS_LINK);
477: msg = xfs_alloc(size, M_NNPFS_MSG);
478: bcopy(message, msg, size);
479:
480: msg->size = size;
481: msg->sequence_num = chan->nsequence++;
482: this_message->error_or_size = 0;
483: this_message->message = msg;
484: this_process->message = msg;
485: xfs_appendq(&chan->messageq, this_message);
486: xfs_appendq(&chan->sleepq, this_process);
487: xfs_select_wakeup(chan);
488: this_process->error_or_size = 0;
489:
490: if (chan->status & CHANNEL_WAITING) {
491: chan->status &= ~CHANNEL_WAITING;
492: wakeup((caddr_t) chan);
493: }
494:
495: /*
496: * Remove signals from the sigmask so no IO will wake us up from
497: * tsleep(). We don't want to wake up from since program (emacs,
498: * bash & co can't handle them.
499: */
500:
501: #ifdef HAVE_FREEBSD_THREAD
502: /* FreeBSD 5.1 */
503: oldsigmask = proc->td_sigmask;
504: xfs_block_sigset (&proc->td_sigmask);
505: #elif HAVE_STRUCT_PROC_P_SIGMASK
506: /* NetBSD 1.5, Darwin 1.3, FreeBSD 4.3, 5.0, OpenBSD 2.8 */
507: oldsigmask = proc->p_sigmask;
508: xfs_block_sigset (&proc->p_sigmask);
509: #elif defined(HAVE_STRUCT_PROC_P_SIGCTX)
510: /* NetBSD 1.6 */
511: oldsigmask = proc->p_sigctx.ps_sigmask;
512: xfs_block_sigset (&proc->p_sigctx.ps_sigmask);
513: #elif defined(HAVE_STRUCT_PROC_P_SIGWAITMASK)
514: /* OSF 4.0 */
515: oldsigmask = proc->p_sigwaitmask;
516: xfs_block_sigset (&proc->p_sigwaitmask);
517: #elif defined(__osf__)
518: /* OSF 5.0 */
519: oldsigmask = u.u_sigmask;
520: xfs_block_sigset (&u.u_sigmask);
521: #endif
522:
523: /*
524: * if we are exiting we should not try to catch signals, since
525: * there might not be enough context left in the process to handle
526: * signal delivery, and besides, most BSD-variants ignore all
527: * signals while closing anyway.
528: */
529:
530: catch = 0;
531: #ifdef HAVE_FREEBSD_THREAD
532: if (!(proc->td_proc->p_flag & NNPFS_P_EXIT))
533: #else
534: if (!(proc->p_flag & NNPFS_P_EXIT))
535: #endif
536: catch |= PCATCH;
537:
538: /*
539: * We have to check if we have a receiver here too because the
540: * daemon could have terminated before we sleep. This seems to
541: * happen sometimes when rebooting. */
542:
543: if (!(chan->status & CHANNEL_OPENED)) {
544: NNPFSDEB(XDEBMSG, ("xfs_message_rpc: channel went away\n"));
545: this_process->error_or_size = EINTR;
546: } else if ((ret = tsleep((caddr_t) this_process,
547: (PZERO + 1) | catch, "xfs", 0)) != 0) {
548: NNPFSDEB(XDEBMSG, ("caught signal (%d): %ld\n",
549: ret, xfs_cursig(proc)));
550: this_process->error_or_size = EINTR;
551: }
552:
553: #ifdef HAVE_FREEBSD_THREAD
554: proc->td_sigmask = oldsigmask;
555: #elif HAVE_STRUCT_PROC_P_SIGMASK
556: proc->p_sigmask = oldsigmask;
557: #elif defined(HAVE_STRUCT_PROC_P_SIGCTX)
558: proc->p_sigctx.ps_sigmask = oldsigmask;
559: #elif defined(HAVE_STRUCT_PROC_P_SIGWAITMASK)
560: proc->p_sigwaitmask = oldsigmask;
561: #elif defined(__osf__)
562: u.u_sigmask = oldsigmask;
563: #endif
564:
565: /*
566: * Caught signal, got reply message or device was closed.
567: * Need to clean up both messageq and sleepq.
568: */
569: if (xfs_onq(this_message)) {
570: xfs_outq(this_message);
571: }
572: if (xfs_onq(this_process)) {
573: xfs_outq(this_process);
574: }
575: ret = this_process->error_or_size;
576:
577: NNPFSDEB(XDEBMSG, ("xfs_message_rpc this_process->error_or_size = %d\n",
578: this_process->error_or_size));
579: NNPFSDEB(XDEBMSG, ("xfs_message_rpc opcode ((xfs_message_wakeup*)(this_process->message))->error = %d\n", ((struct xfs_message_wakeup *) (this_process->message))->error));
580:
581: bcopy(msg, message, size);
582:
583: xfs_free(this_message, sizeof(*this_message), M_NNPFS_LINK);
584: xfs_free(this_process, sizeof(*this_process), M_NNPFS_LINK);
585: xfs_free(msg, size, M_NNPFS_MSG);
586:
587: return ret;
588: }
589:
590: /*
591: * For each message type there is a message handler
592: * that implements its action, xfs_message_receive
593: * invokes the correct function.
594: */
595: int
596: xfs_message_receive(int fd,
597: struct xfs_message_header *message,
598: u_int size,
599: d_thread_t *p)
600: {
601: NNPFSDEB(XDEBMSG, ("xfs_message_receive opcode = %d\n", message->opcode));
602:
603: /* Dispatch and coerce message type */
604: switch (message->opcode) {
605: case NNPFS_MSG_WAKEUP:
606: return xfs_message_wakeup(fd,
607: (struct xfs_message_wakeup *) message,
608: message->size,
609: p);
610: case NNPFS_MSG_WAKEUP_DATA:
611: return xfs_message_wakeup_data(fd,
612: (struct xfs_message_wakeup_data *) message,
613: message->size,
614: p);
615: case NNPFS_MSG_INSTALLROOT:
616: return xfs_message_installroot(fd,
617: (struct xfs_message_installroot *) message,
618: message->size,
619: p);
620: case NNPFS_MSG_INSTALLNODE:
621: return xfs_message_installnode(fd,
622: (struct xfs_message_installnode *) message,
623: message->size,
624: p);
625: case NNPFS_MSG_INSTALLATTR:
626: return xfs_message_installattr(fd,
627: (struct xfs_message_installattr *) message,
628: message->size,
629: p);
630: case NNPFS_MSG_INSTALLDATA:
631: return xfs_message_installdata(fd,
632: (struct xfs_message_installdata *) message,
633: message->size,
634: p);
635: case NNPFS_MSG_INVALIDNODE:
636: return xfs_message_invalidnode(fd,
637: (struct xfs_message_invalidnode *) message,
638: message->size,
639: p);
640: case NNPFS_MSG_UPDATEFID:
641: return xfs_message_updatefid(fd,
642: (struct xfs_message_updatefid *)message,
643: message->size,
644: p);
645: case NNPFS_MSG_GC_NODES:
646: return xfs_message_gc_nodes(fd,
647: (struct xfs_message_gc_nodes *)message,
648: message->size,
649: p);
650: case NNPFS_MSG_VERSION:
651: return xfs_message_version(fd,
652: (struct xfs_message_version *)message,
653: message->size,
654: p);
655: default:
656: printf("NNPFS PANIC Warning xfs_dev: Unknown message opcode == %d\n",
657: message->opcode);
658: return EINVAL;
659: }
660: }
661:
662: int
663: xfs_message_wakeup(int fd,
664: struct xfs_message_wakeup *message,
665: u_int size,
666: d_thread_t *p)
667: {
668: struct xfs_channel *chan = &xfs_channel[fd];
669: struct xfs_link *sleepq = &chan->sleepq;
670: struct xfs_link *t = chan->sleepq.next; /* Really first in q */
671:
672: NNPFSDEB(XDEBMSG, ("xfs_message_wakeup error: %d\n", message->error));
673:
674: for (; t != sleepq; t = t->next)
675: if (t->message->sequence_num == message->sleepers_sequence_num) {
676: if (t->message->size < size) {
677: printf("NNPFS PANIC Error: Could not wakeup requestor with opcode = %d properly, to small receive buffer.\n", t->message->opcode);
678: t->error_or_size = ENOMEM;
679: } else
680: bcopy(message, t->message, size);
681:
682: wakeup((caddr_t) t);
683: break;
684: }
685:
686: return 0;
687: }
688:
689: int
690: xfs_message_wakeup_data(int fd,
691: struct xfs_message_wakeup_data * message,
692: u_int size,
693: d_thread_t *p)
694: {
695: struct xfs_channel *chan = &xfs_channel[fd];
696: struct xfs_link *sleepq = &chan->sleepq;
697: struct xfs_link *t = chan->sleepq.next; /* Really first in q */
698:
699: NNPFSDEB(XDEBMSG, ("xfs_message_wakeup_data error: %d\n", message->error));
700:
701: for (; t != sleepq; t = t->next)
702: if (t->message->sequence_num == message->sleepers_sequence_num) {
703: if (t->message->size < size) {
704: printf("NNPFS PANIC Error: Could not wakeup requestor with opcode = %d properly, to small receive buffer.\n", t->message->opcode);
705: t->error_or_size = ENOMEM;
706: } else
707: bcopy(message, t->message, size);
708: wakeup((caddr_t) t);
709: break;
710: }
711: return 0;
712: }
713:
714: /*
715: *
716: */
717: int
718: xfs_uprintf_device(void)
719: {
720: #if 0
721: int i;
722:
723: for (i = 0; i < NNNPFS; i++) {
724: uprintf("xfs_channel[%d] = {\n", i);
725: uprintf("messageq.next = %lx ", xfs_channel[i].messageq.next);
726: uprintf("messageq.prev = %lx ", xfs_channel[i].messageq.prev);
727: uprintf("sleepq.next = %lx ", xfs_channel[i].sleepq.next);
728: uprintf("sleepq.prev = %lx ", xfs_channel[i].sleepq.prev);
729: uprintf("nsequence = %d status = %d\n",
730: xfs_channel[i].nsequence,
731: xfs_channel[i].status);
732: uprintf("}\n");
733: }
734: #endif
735: return 0;
736: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to xfs_dev-common.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / xfs