root/xfs/xfs_dev-common.c

DEFINITIONS

1. xfs_initq
2. xfs_emptyq
3. xfs_onq
4. xfs_appendq
5. xfs_outq
6. xfs_devopen_common
7. xfs_devclose_common
8. xfs_cursig
9. xfs_devread
10. xfs_devwrite
11. xfs_message_send
12. xfs_block_sigset
13. xfs_message_rpc
14. xfs_message_receive
15. xfs_message_wakeup
16. xfs_message_wakeup_data
17. xfs_uprintf_device

    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  */
   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>
RCSID("$arla: xfs_dev-common.c,v 1.61 2003/07/15 16:25:42 lha Exp $");
   44 struct xfs_channel xfs_channel[NNNPFS];
   46 void
xfs_initq(struct xfs_link *q)
   48 {
q->next = q;
q->prev = q;
   51 }
   53 /* Is this queue empty? */
   54 int
xfs_emptyq(const struct xfs_link *q)
   56 {
   57     return q->next == q;
   58 }
   60 /* Is this link on any queue? Link *must* be inited! */
   61 int
xfs_onq(const struct xfs_link *link)
   63 {
   64     return link->next != NULL || link->prev != NULL;
   65 }
   67 /* Append q with p */
   68 void
xfs_appendq(struct xfs_link *q, struct xfs_link *p)
   70 {
p->next = q;
p->prev = q->prev;
p->prev->next = p;
q->prev = p;
   75 }
   77 /* remove `p' from its queue */
   78 void
xfs_outq(struct xfs_link *p)
   80 {
p->next->prev = p->prev;
p->prev->next = p->next;
p->next = p->prev = NULL;
   84 }
   86 /*
   87  * Only allow one open.
   88  */
   89 int
xfs_devopen_common(dev_t dev)
   91 {
   92     struct xfs_channel *chan;
   94     if (minor(dev) < 0 || minor(dev) >= NNNPFS)
   95         return ENXIO;
chan = &xfs_channel[minor(dev)];
   99     /* Only allow one reader/writer */
  100     if (chan->status & CHANNEL_OPENED) {
NNPFSDEB(XDEBDEV, ("xfs_devopen: already open\n"));
  102         return EBUSY;
  103     } else {
chan->status |= CHANNEL_OPENED;
  105     }
chan->message_buffer = xfs_alloc(MAX_XMSG_SIZE, M_NNPFS_MSG);
  109     /* initialize the queues if they have not been initialized before */
xfs_initq(&chan->sleepq);
xfs_initq(&chan->messageq);
  113     return 0;
  114 }
  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
  133 /*
  134  * Wakeup all sleepers and cleanup.
  135  */
  136 int
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;
  142     /* Sanity check, paranoia? */
  143     if (!(chan->status & CHANNEL_OPENED))
panic("xfs_devclose never opened?");
chan->status &= ~CHANNEL_OPENED;
  148     /* No one is going to read those messages so empty queue! */
  149     while (!xfs_emptyq(&chan->messageq)) {
NNPFSDEB(XDEBDEV, ("before outq(messageq)\n"));
first = chan->messageq.next;
xfs_outq(first);
  154         if (first->error_or_size != 0)
xfs_free(first, first->error_or_size, M_NNPFS_LINK);
NNPFSDEB(XDEBDEV, ("after outq(messageq)\n"));
  158     }
  160     /* Wakeup those waiting for replies that will never arrive. */
  161     while (!xfs_emptyq(&chan->sleepq)) {
NNPFSDEB(XDEBDEV, ("before outq(sleepq)\n"));
first = chan->sleepq.next;
xfs_outq(first);
first->error_or_size = ENODEV;
wakeup((caddr_t) first);
NNPFSDEB(XDEBDEV, ("after outq(sleepq)\n"));
  168     }
  170     if (chan->status & CHANNEL_WAITING)
wakeup((caddr_t) chan);
  173     if (chan->message_buffer) {
xfs_free(chan->message_buffer, MAX_XMSG_SIZE, M_NNPFS_MSG);
chan->message_buffer = NULL;
  176     }
  178     /*
  179      * Free all xfs nodes.
  180      */
  182     if (xfs[minor(dev)].mp != NULL) {
  183         if (xfs_vfs_busy(xfs[minor(dev)].mp, VB_READ|VB_WAIT, NULL, proc)) {
NNPFSDEB(XDEBNODE, ("xfs_dev_close: vfs_busy() --> BUSY\n"));
  185             return EBUSY;
  186         }
free_all_xfs_nodes(&xfs[minor(dev)], FORCECLOSE, 0);
xfs_vfs_unbusy(xfs[minor(dev)].mp, proc);
  190     }
  192     return 0;
  193 }
  195 #ifdef NNPFS_DEBUG
  196 /*
  197  * debugging glue for CURSIG
  198  */
  200 static long
xfs_cursig (d_thread_t *p)
  202 {
  203 #if defined(__osf__)
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
  224 /*
  225  * Move messages from kernel to user space.
  226  */
  228 int
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
NNPFSDEB(XDEBDEV, ("xfs_devread dev = %s\n",
xfs_devtoname_r(dev, devname, sizeof(devname))));
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));
  246 #ifdef HAVE_FREEBSD_THREAD
chan->proc = xfs_uio_to_thread(uiop);
  248 #else
chan->proc = xfs_uio_to_proc(uiop);
  250 #endif
again:
  254     if (!xfs_emptyq (&chan->messageq)) {
  255         while (!xfs_emptyq (&chan->messageq)) {
  256             /* Remove message */
first = chan->messageq.next;
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));
NNPFSDEB(XDEBDEV, ("xfs_devread: message->size = %u\n",
first->message->size));
  267             if (first->message->size > uiop->uio_resid)
  268                 break;
error = uiomove((caddr_t) first->message, first->message->size, 
uiop);
  272             if (error)
  273                 break;
xfs_outq(first);
  277             if (first->error_or_size != 0)
xfs_free(first, first->error_or_size, M_NNPFS_LINK);
  279         }
  280     } else {
chan->status |= CHANNEL_WAITING;
  282         if (tsleep((caddr_t) chan, (PZERO + 1) | PCATCH, "xfsread", 0)) {
  283 #ifdef HAVE_FREEBSD_THREAD
NNPFSDEB(XDEBMSG,
  285                    ("caught signal xfs_devread: %ld\n",
xfs_cursig(xfs_uio_to_thread(uiop))));
  287 #else
NNPFSDEB(XDEBMSG,
  289                    ("caught signal xfs_devread: %ld\n",
xfs_cursig(xfs_uio_to_proc(uiop))));
  291 #endif
error = EINTR;
  293         } else if ((chan->status & CHANNEL_WAITING) == 0) {
  294             goto again;
  295         } else
error = EIO;
  297     }
NNPFSDEB(XDEBDEV, ("xfs_devread done error = %d\n", error));
  301     return error;
  302 }
  304 /*
  305  * Move messages from user space to kernel space,
  306  * wakeup sleepers, insert new data in VFS.
  307  */
  308 int
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;
u_int cnt;
  315     struct xfs_message_header *msg_buf;
  316 #ifdef NNPFS_DEBUG
  317     char devname[64];
  318 #endif
NNPFSDEB(XDEBDEV, ("xfs_devwrite dev = %s\n",
xfs_devtoname_r (dev, devname, sizeof(devname))));
  323 #ifdef HAVE_FREEBSD_THREAD
chan->proc = xfs_uio_to_thread(uiop);
  325 #else
chan->proc = xfs_uio_to_proc(uiop);
  327 #endif
cnt = uiop->uio_resid;
error = uiomove((caddr_t) chan->message_buffer, MAX_XMSG_SIZE, uiop);
  330     if (error != 0)
  331         return error;
cnt -= uiop->uio_resid;
  335     /*
  336      * This thread handles the received message.
  337      */
  338     for (p = (char *)chan->message_buffer;
cnt > 0;
p += msg_buf->size, cnt -= msg_buf->size) {
  341 #ifdef HAVE_FREEBSD_THREAD
d_thread_t *pp = xfs_uio_to_thread(uiop);
  343 #else
d_thread_t *pp = xfs_uio_to_proc(uiop);
  345 #endif
msg_buf = (struct xfs_message_header *)p;
error = xfs_message_receive (minor(dev),
msg_buf,
msg_buf->size,
pp);
  352     }
NNPFSDEB(XDEBDEV, ("xfs_devwrite error = %d\n", error));
  354     return error;
  355 }
  357 /*
  358  * Send a message to user space.
  359  */
  360 int
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;
NNPFSDEB(XDEBMSG, ("xfs_message_send opcode = %d\n", message->opcode));
  371     if (!(chan->status & CHANNEL_OPENED))       /* No receiver? */
  372         return ENODEV;
  374     /* Prepare message and copy it later */
message->size = size;
message->sequence_num = chan->nsequence++;
t = xfs_alloc(sizeof(t->this_message) + size, M_NNPFS);
t->this_message.error_or_size = sizeof(t->this_message) + size;
bcopy(message, &t->msg, size);
t->this_message.message = &t->msg;
xfs_appendq(&chan->messageq, &t->this_message);
  384     if (chan->status & CHANNEL_WAITING) {
chan->status &= ~CHANNEL_WAITING;
wakeup((caddr_t) chan);
  387     }
xfs_select_wakeup(chan);
  390     return 0;
  391 }
  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
  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
xfs_block_sigset (sigset_t *sigset)
  404 {
  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
xfs_sig_block(sigset, SIGIO);
xfs_sig_block(sigset, SIGALRM);
xfs_sig_block(sigset, SIGVTALRM);
xfs_sig_block(sigset, SIGCHLD);
  418 #ifdef SIGINFO
xfs_sig_block(sigset, SIGINFO);
  420 #endif
  421 #undef xfs_sig_block
  422 }
  423 #endif
  425 /*
  426  * Send a message to user space and wait for reply.
  427  */
  429 int
xfs_message_rpc(int fd, struct xfs_message_header * message, u_int size,
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)
sigset_t oldsigmask;
  440 #endif
  441     int catch;
NNPFSDEB(XDEBMSG, ("xfs_message_rpc opcode = %d\n", message->opcode));
  445     if (proc == NULL) {
  446 #ifdef HAVE_FREEBSD_THREAD
proc = xfs_curthread();
  448 #else
proc = xfs_curproc();
  450 #endif
  451     }
  452     if (!(chan->status & CHANNEL_OPENED))       /* No receiver? */
  453         return ENODEV;
  455 #ifdef HAVE_FREEBSD_THREAD
  456     if (chan->proc != NULL && chan->proc->td_proc != NULL &&
proc->td_proc->p_pid == chan->proc->td_proc->p_pid) {
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) {
printf("xfs_message_rpc: deadlock avoided "
  463                "pid = %u == %u\n", proc->p_pid, chan->proc->p_pid);
  464 #endif
  465 #if 0
psignal (proc, SIGABRT);
  467 #endif
  468         return EDEADLK;
  469     }
  471     if (size < sizeof(struct xfs_message_wakeup)) {
printf("NNPFS PANIC Error: Message to small to receive wakeup, opcode = %d\n", message->opcode);
  473         return ENOMEM;
  474     }
this_message = xfs_alloc(sizeof(struct xfs_link), M_NNPFS_LINK);
this_process = xfs_alloc(sizeof(struct xfs_link), M_NNPFS_LINK);
msg = xfs_alloc(size, M_NNPFS_MSG);
bcopy(message, msg, size);
msg->size = size;
msg->sequence_num = chan->nsequence++;
this_message->error_or_size = 0;
this_message->message = msg;
this_process->message = msg;
xfs_appendq(&chan->messageq, this_message);
xfs_appendq(&chan->sleepq, this_process);
xfs_select_wakeup(chan);
this_process->error_or_size = 0;
  490     if (chan->status & CHANNEL_WAITING) {
chan->status &= ~CHANNEL_WAITING;
wakeup((caddr_t) chan);
  493     }
  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      */
  501 #ifdef HAVE_FREEBSD_THREAD
  502     /* FreeBSD 5.1 */
oldsigmask = proc->td_sigmask;
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 */
oldsigmask = proc->p_sigmask;
xfs_block_sigset (&proc->p_sigmask);
  509 #elif defined(HAVE_STRUCT_PROC_P_SIGCTX)
  510     /* NetBSD 1.6 */
oldsigmask = proc->p_sigctx.ps_sigmask;
xfs_block_sigset (&proc->p_sigctx.ps_sigmask);
  513 #elif defined(HAVE_STRUCT_PROC_P_SIGWAITMASK)
  514     /* OSF 4.0 */
oldsigmask = proc->p_sigwaitmask;
xfs_block_sigset (&proc->p_sigwaitmask);
  517 #elif defined(__osf__)
  518     /* OSF 5.0 */
oldsigmask = u.u_sigmask;
xfs_block_sigset (&u.u_sigmask);
  521 #endif
  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      */
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
catch |= PCATCH;
  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.  */
  543     if (!(chan->status & CHANNEL_OPENED)) {
NNPFSDEB(XDEBMSG, ("xfs_message_rpc: channel went away\n"));
this_process->error_or_size = EINTR;
  546     } else if ((ret = tsleep((caddr_t) this_process,
  547                              (PZERO + 1) | catch, "xfs", 0)) != 0) {
NNPFSDEB(XDEBMSG, ("caught signal (%d): %ld\n",
ret, xfs_cursig(proc)));
this_process->error_or_size = EINTR;
  551     }
  553 #ifdef HAVE_FREEBSD_THREAD
proc->td_sigmask = oldsigmask;
  555 #elif HAVE_STRUCT_PROC_P_SIGMASK
proc->p_sigmask = oldsigmask;
  557 #elif defined(HAVE_STRUCT_PROC_P_SIGCTX)
proc->p_sigctx.ps_sigmask = oldsigmask;
  559 #elif defined(HAVE_STRUCT_PROC_P_SIGWAITMASK)
proc->p_sigwaitmask = oldsigmask;
  561 #elif defined(__osf__)
u.u_sigmask = oldsigmask;
  563 #endif
  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)) {
xfs_outq(this_message);
  571     }
  572     if (xfs_onq(this_process)) {
xfs_outq(this_process);
  574     }
ret = this_process->error_or_size;
NNPFSDEB(XDEBMSG, ("xfs_message_rpc this_process->error_or_size = %d\n",
this_process->error_or_size));
NNPFSDEB(XDEBMSG, ("xfs_message_rpc opcode ((xfs_message_wakeup*)(this_process->message))->error = %d\n", ((struct xfs_message_wakeup *) (this_process->message))->error));
bcopy(msg, message, size);
xfs_free(this_message, sizeof(*this_message), M_NNPFS_LINK);
xfs_free(this_process, sizeof(*this_process), M_NNPFS_LINK);
xfs_free(msg, size, M_NNPFS_MSG);
  587     return ret;
  588 }
  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
xfs_message_receive(int fd,
  597                     struct xfs_message_header *message,
u_int size,
d_thread_t *p)
  600 {
NNPFSDEB(XDEBMSG, ("xfs_message_receive opcode = %d\n", message->opcode));
  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,
message->size,
p);
  610     case NNPFS_MSG_WAKEUP_DATA:
  611         return xfs_message_wakeup_data(fd,
  612                                  (struct xfs_message_wakeup_data *) message,
message->size,
p);
  615     case NNPFS_MSG_INSTALLROOT:
  616         return xfs_message_installroot(fd,
  617                                  (struct xfs_message_installroot *) message,
message->size,
p);
  620     case NNPFS_MSG_INSTALLNODE:
  621         return xfs_message_installnode(fd,
  622                                  (struct xfs_message_installnode *) message,
message->size,
p);
  625     case NNPFS_MSG_INSTALLATTR:
  626         return xfs_message_installattr(fd,
  627                                  (struct xfs_message_installattr *) message,
message->size,
p);
  630     case NNPFS_MSG_INSTALLDATA:
  631         return xfs_message_installdata(fd,
  632                                  (struct xfs_message_installdata *) message,
message->size,
p);
  635     case NNPFS_MSG_INVALIDNODE:
  636         return xfs_message_invalidnode(fd,
  637                                  (struct xfs_message_invalidnode *) message,
message->size,
p);
  640     case NNPFS_MSG_UPDATEFID:
  641         return xfs_message_updatefid(fd,
  642                                      (struct xfs_message_updatefid *)message,
message->size,
p);
  645     case NNPFS_MSG_GC_NODES:
  646         return xfs_message_gc_nodes(fd,
  647                                     (struct xfs_message_gc_nodes *)message,
message->size,
p);
  650     case NNPFS_MSG_VERSION:
  651         return xfs_message_version(fd,
  652                                    (struct xfs_message_version *)message,
message->size,
p);
  655     default:
printf("NNPFS PANIC Warning xfs_dev: Unknown message opcode == %d\n",
message->opcode);
  658         return EINVAL;
  659     }
  660 }
  662 int
xfs_message_wakeup(int fd,
  664                    struct xfs_message_wakeup *message,
u_int size,
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 */
NNPFSDEB(XDEBMSG, ("xfs_message_wakeup error: %d\n", message->error));
  674     for (; t != sleepq; t = t->next)
  675         if (t->message->sequence_num == message->sleepers_sequence_num) {
  676             if (t->message->size < size) {
printf("NNPFS PANIC Error: Could not wakeup requestor with opcode = %d properly, to small receive buffer.\n", t->message->opcode);
t->error_or_size = ENOMEM;
  679             } else
bcopy(message, t->message, size);
wakeup((caddr_t) t);
  683             break;
  684         }
  686     return 0;
  687 }
  689 int
xfs_message_wakeup_data(int fd,
  691                         struct xfs_message_wakeup_data * message,
u_int size,
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 */
NNPFSDEB(XDEBMSG, ("xfs_message_wakeup_data error: %d\n", message->error));
  701     for (; t != sleepq; t = t->next)
  702         if (t->message->sequence_num == message->sleepers_sequence_num) {
  703             if (t->message->size < size) {
printf("NNPFS PANIC Error: Could not wakeup requestor with opcode = %d properly, to small receive buffer.\n", t->message->opcode);
t->error_or_size = ENOMEM;
  706             } else
bcopy(message, t->message, size);
wakeup((caddr_t) t);
  709             break;
  710         }
  711     return 0;
  712 }
  714 /*
  715  *
  716  */
  717 int
xfs_uprintf_device(void)
  719 {
  720 #if 0
  721     int i;
  723     for (i = 0; i < NNNPFS; i++) {
uprintf("xfs_channel[%d] = {\n", i);
uprintf("messageq.next = %lx ", xfs_channel[i].messageq.next);
uprintf("messageq.prev = %lx ", xfs_channel[i].messageq.prev);
uprintf("sleepq.next = %lx ", xfs_channel[i].sleepq.next);
uprintf("sleepq.prev = %lx ", xfs_channel[i].sleepq.prev);
uprintf("nsequence = %d status = %d\n",
xfs_channel[i].nsequence,
xfs_channel[i].status);
uprintf("}\n");
  733     }
  734 #endif
  735     return 0;
  736 }