usr/src/cmd/mdb/common/kmdb/kmdb_wr.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 /*
  30  * The communication mechanism for requesting that the driver perform work on
  31  * behalf of the debugger.  Messages are passed and processed in FIFO order,
  32  * with no provision for high priority messages.  High priority messages, such
  33  * as debugger termination requests, should be passed using a different
  34  * mechanism.
  35  *
  36  * Two FIFO queues are used for communication - one from the debugger to the
  37  * driver, known as the driver_notify queue, and one from the driver to the
  38  * debugger, known as the debugger_notify queue.  Messages are added to one
  39  * queue, processed by the party on the other end, and are sent back as
  40  * acknowledgements on the other queue.  All messages must be acknowledged, in
  41  * part because the party who sent the message is the only one who can free it.
  42  *
  43  * Debugger-initiated work requests are usually triggered by dcmds such as
  44  * ::load.  In the case of a ::load, the debugger adds a load request to the
  45  * driver_notify queue.  The driver removes the request from the queue and
  46  * processes it.  When processing is complete, the message is turned into an
  47  * acknowledgement, and completion status is added.  The message is then added
  48  * to the debugger_notify queue.  Upon receipt, the debugger removes the
  49  * message from the queue, notes the completion status, and frees it.
  50  *
  51  * The driver can itself initiate unsolicited work, such as the automatic
  52  * loading of a dmod in response to a krtld module load notification.  In this
  53  * case, the driver loads the module and creates a work-completion message.
  54  * This completion is identical to the one sent in the solicited load case
  55  * above, with the exception of the acknowledgement bit, which isn't be set.
  56  * When the debugger receives the completion message, it notes the completion
  57  * status, and sends the message back to the driver via the driver_notify queue,
  58  * this time with the acknowledgement bit set.
  59  */
  60
  61 #include <sys/types.h>
  62
  63 #include <kmdb/kmdb_asmutil.h>
  64 #include <kmdb/kmdb_wr_impl.h>
  65 #include <mdb/mdb_debug.h>
  66 #include <mdb/mdb.h>
  67
  68 /*
  69  * Called by the driver to pass a message to the debugger.  The debugger could
  70  * start running at any time.  Nodes are added to the queue in FIFO order, but
  71  * with links pointing in reverse order.
  72  */
  73 void
  74 kmdb_wr_debugger_notify(void *arg)
  75 {
  76         kmdb_wr_t *new = arg;
  77         kmdb_wr_t *curtail;
  78
  79         new->wn_next = new->wn_prev = NULL;
  80         membar_producer();
  81
  82         do {
  83                 if ((curtail = mdb.m_dbgwrtail) == NULL) {
  84                         /*
  85                          * The queue is empty, because tail will only be NULL if
  86                          * head is NULL too.  We're the only one who can add
  87                          * to the queue, so we can blindly add our node.  The
  88                          * debugger can't look at tail until head is non-NULL,
  89                          * so we set tail first.
  90                          */
  91                         mdb.m_dbgwrtail = new;
  92                         membar_producer();
  93                         mdb.m_dbgwrhead = new;
  94                         membar_producer();
  95                         break;
  96                 }
  97
  98                 /*
  99                  * Point the new node at the current tail.  Attempt to set tail
 100                  * to point to our new node, but only as long as tail is what
 101                  * we think it is.
 102                  */
 103                 new->wn_prev = curtail;
 104                 membar_producer();
 105         } while (cas((uintptr_t *)&mdb.m_dbgwrtail, (uintptr_t)curtail,
 106             (uintptr_t)new) != (uintptr_t)curtail);
 107 }
 108
 109 /*
 110  * Called by the debugger to receive messages from the driver.  The driver
 111  * has added the nodes in FIFO order, but has only set the prev pointers.  We
 112  * have to correct that before processing the nodes.  This routine will not
 113  * be preempted.
 114  */
 115 int
 116 kmdb_wr_debugger_process(int (*cb)(kmdb_wr_t *, void *), void *arg)
 117 {
 118         kmdb_wr_t *wn, *wnn;
 119         int i;
 120
 121         if (mdb.m_dbgwrhead == NULL)
 122                 return (0); /* The queue is empty, so there's nothing to do */
 123
 124         /* Re-establish the next links so we can traverse in FIFO order */
 125         mdb.m_dbgwrtail->wn_next = NULL;
 126         for (wn = mdb.m_dbgwrtail; wn->wn_prev != NULL;
 127             wn = wn->wn_prev)
 128                 wn->wn_prev->wn_next = wn;
 129
 130         /* We don't own wn after we've invoked the callback */
 131         wn = mdb.m_dbgwrhead;
 132         i = 0;
 133         do {
 134                 wnn = wn->wn_next;
 135                 i += cb(wn, arg);
 136         } while ((wn = wnn) != NULL);
 137
 138         mdb.m_dbgwrhead = mdb.m_dbgwrtail = NULL;
 139
 140         return (i);
 141 }
 142
 143 /*
 144  * Called by the debugger to check queue status.
 145  */
 146 int
 147 kmdb_wr_debugger_notify_isempty(void)
 148 {
 149         return (mdb.m_dbgwrhead == NULL);
 150 }
 151
 152 /*
 153  * Called by the debugger to pass a message to the driver.  This routine will
 154  * not be preempted.
 155  */
 156 void
 157 kmdb_wr_driver_notify(void *arg)
 158 {
 159         kmdb_wr_t *new = arg;
 160
 161         /*
 162          * We restrict ourselves to manipulating the rear of the queue.  We
 163          * don't look at the head unless the tail is NULL.
 164          */
 165         if (mdb.m_drvwrtail == NULL) {
 166                 new->wn_next = new->wn_prev = NULL;
 167                 mdb.m_drvwrhead = mdb.m_drvwrtail = new;
 168         } else {
 169                 mdb.m_drvwrtail->wn_next = new;
 170                 new->wn_prev = mdb.m_drvwrtail;
 171                 new->wn_next = NULL;
 172                 mdb.m_drvwrtail = new;
 173         }
 174 }
 175
 176 /*
 177  * Called by the driver to receive messages from the debugger.  The debugger
 178  * could start running at any time.
 179  *
 180  * NOTE: This routine may run *after* mdb_destroy(), and may *NOT* use any MDB
 181  * services.
 182  */
 183 int
 184 kmdb_wr_driver_process(int (*cb)(kmdb_wr_t *, void *), void *arg)
 185 {
 186         kmdb_wr_t *worklist, *wn, *wnn;
 187         int rc, rv, i;
 188
 189         if ((worklist = mdb.m_drvwrhead) == NULL) {
 190                 return (0); /* The queue is empty, so there's nothing to do */
 191         }
 192
 193         mdb.m_drvwrhead = NULL;
 194         /* The debugger uses tail, so enqueues still work */
 195         membar_producer();
 196         mdb.m_drvwrtail = NULL;
 197         membar_producer();
 198
 199         /*
 200          * The current set of messages has been removed from the queue, so
 201          * we can process them at our leisure.
 202          */
 203
 204         wn = worklist;
 205         rc = i = 0;
 206         do {
 207                 wnn = wn->wn_next;
 208                 if ((rv = cb(wn, arg)) < 0)
 209                         rc = -1;
 210                 else
 211                         i += rv;
 212         } while ((wn = wnn) != NULL);
 213
 214         return (rc == 0 ? i : -1);
 215 }
 216
 217 /*
 218  * Called by the debugger to check queue status
 219  */
 220 int
 221 kmdb_wr_driver_notify_isempty(void)
 222 {
 223         return (mdb.m_drvwrhead == NULL);
 224 }