librumpxen_xendev: Rename applicable `d' variables to `dd'

This used to be a reference to the shared device context structure.
Now there are three structures.  Change all the variables referring to
what is now struct rumpxenbus_data_dev to `dd'.  This includes all the
references in busdev.c.

No functional change.

Signed-off-by: Ian Jackson <Ian.Jackson@eu.citrix.com>

diff --git a/platform/xen/librumpxen_xendev/busdev.c b/platform/xen/librumpxen_xendev/busdev.c
index 8068042a13e234f5ddca196f3a4c10797289a968..635a41bc14f2a43fd4801820d5dcbb303619d060 100644 (file)
--- a/platform/xen/librumpxen_xendev/busdev.c
+++ b/platform/xen/librumpxen_xendev/busdev.c
@@ -77,7 +77,7 @@ struct rumpxenbus_data_dev {
 
        struct selinfo selinfo;
        /* The lock used for the purposes described in select(9)
-        * is xenbus_req_lock, not d->lock. */
+        * is xenbus_req_lock, not dd->lock. */
 };
 
 
@@ -110,56 +110,56 @@ static int
 xenbus_dev_write(struct file *fp, off_t *offset, struct uio *uio,
                 kauth_cred_t cred, int flags)
 {
-       struct rumpxenbus_data_dev *const d = fp->f_data;
-       struct rumpxenbus_data_common *const dc = &d->dc;
+       struct rumpxenbus_data_dev *const dd = fp->f_data;
+       struct rumpxenbus_data_common *const dc = &dd->dc;
        int err;
 
-       DPRINTF(("/dev/xen/xenbus[%p,dd=%p]: write...\n",dc,d));
+       DPRINTF(("/dev/xen/xenbus[%p,dd=%p]: write...\n",dc,dd));
 
        if (uio->uio_offset < 0)
                return EINVAL;
 
-       mutex_enter(&d->lock);
+       mutex_enter(&dd->lock);
 
        for (;;) { /* keep reading more until we're done */
 
                if (!uio->uio_resid)
                        break;
 
-               uio->uio_offset = d->wbuf_used;
-               err = uiomove(d->wbuf.buffer + d->wbuf_used,
-                             sizeof(d->wbuf.buffer) -  d->wbuf_used,
+               uio->uio_offset = dd->wbuf_used;
+               err = uiomove(dd->wbuf.buffer + dd->wbuf_used,
+                             sizeof(dd->wbuf.buffer) -  dd->wbuf_used,
                              uio);
-               d->wbuf_used = uio->uio_offset;
+               dd->wbuf_used = uio->uio_offset;
                if (err)
                        goto end;
 
                for (;;) { /* process message(s) in the buffer */
 
-                       if (d->wbuf_used < sizeof(d->wbuf.msg))
+                       if (dd->wbuf_used < sizeof(dd->wbuf.msg))
                                break;
 
-                       if (d->wbuf.msg.len > XENSTORE_PAYLOAD_MAX)
+                       if (dd->wbuf.msg.len > XENSTORE_PAYLOAD_MAX)
                                WTROUBLE(dc,"too much payload in packet");
 
                        uint32_t packetlen =
-                               d->wbuf.msg.len + sizeof(d->wbuf.msg);
+                               dd->wbuf.msg.len + sizeof(dd->wbuf.msg);
 
-                       KASSERT(packetlen <= sizeof(d->wbuf.buffer));
+                       KASSERT(packetlen <= sizeof(dd->wbuf.buffer));
 
-                       if (d->wbuf_used < packetlen)
+                       if (dd->wbuf_used < packetlen)
                                break;
 
-                       err = rumpxenbus_process_request(&d->dc);
+                       err = rumpxenbus_process_request(&dd->dc);
 
-                       if (d->wbuf_used) {
+                       if (dd->wbuf_used) {
                                /* Remove from the buffer before checking
                                 * for errors - but some errors may have
                                 * emptied the buffer already. */
-                               d->wbuf_used -= packetlen;
-                               memmove(d->wbuf.buffer,
-                                       d->wbuf.buffer + packetlen,
-                                       d->wbuf_used);
+                               dd->wbuf_used -= packetlen;
+                               memmove(dd->wbuf.buffer,
+                                       dd->wbuf.buffer + packetlen,
+                                       dd->wbuf_used);
                        }
 
                        if (err)
@@ -169,7 +169,7 @@ xenbus_dev_write(struct file *fp, off_t *offset, struct uio *uio,
 
        err = 0;
 end:
-       mutex_exit(&d->lock);
+       mutex_exit(&dd->lock);
 
        DPRINTF(("/dev/xen/xenbus: write done, err=%d\n", err));
        return err;
@@ -179,31 +179,31 @@ end:
 
 void rumpxenbus_block_before(struct rumpxenbus_data_common *dc)
 {
-       struct rumpxenbus_data_dev *d =
+       struct rumpxenbus_data_dev *dd =
                container_of(dc, struct rumpxenbus_data_dev, dc);
-       mutex_exit(&d->lock);
+       mutex_exit(&dd->lock);
 }
 
 void rumpxenbus_block_after(struct rumpxenbus_data_common *dc)
 {
-       struct rumpxenbus_data_dev *d =
+       struct rumpxenbus_data_dev *dd =
                container_of(dc, struct rumpxenbus_data_dev, dc);
-       mutex_enter(&d->lock);
+       mutex_enter(&dd->lock);
 }
 
 static int
 xenbus_dev_read(struct file *fp, off_t *offset, struct uio *uio,
                kauth_cred_t cred, int flags)
 {
-       struct rumpxenbus_data_dev *const d = fp->f_data;
-       struct rumpxenbus_data_common *const dc = &d->dc;
+       struct rumpxenbus_data_dev *const dd = fp->f_data;
+       struct rumpxenbus_data_common *const dc = &dd->dc;
        size_t org_resid = uio->uio_resid;
        int err;
 
        DPRINTF(("/dev/xen/xenbus[%p,dd=%p:"
                 " read (nonblock=%d)...\n",
-                dc,d, !(fp->f_flag & FNONBLOCK)));
-       mutex_enter(&d->lock);
+                dc,dd, !(fp->f_flag & FNONBLOCK)));
+       mutex_enter(&dd->lock);
 
        for (;;) {
                DPRINTF(("/dev/xen/xenbus: read... uio_resid=%lu (org=%lu)"
@@ -224,20 +224,20 @@ xenbus_dev_read(struct file *fp, off_t *offset, struct uio *uio,
                        /* done what we have been asked to do */
                        break;
 
-               if (!d->rmsg) {
+               if (!dd->rmsg) {
                        int err_if_block = 0;
-                       if (d->want_restart) {
+                       if (dd->want_restart) {
                                err_if_block = ERESTART;
                        } else if (fp->f_flag & FNONBLOCK) {
                                err_if_block = EAGAIN;
                        }
 
-                       d->rmsg = rumpxenbus_next_event_msg(&d->dc,
+                       dd->rmsg = rumpxenbus_next_event_msg(&dd->dc,
                                                 !err_if_block,
-                                                &d->rmsg_free);
+                                                &dd->rmsg_free);
                        DPRINTF(("/dev/xen/xenbus: read... rmsg=%p (eib=%d)\n",
-                                d->rmsg, err_if_block));
-                       if (!d->rmsg) {
+                                dd->rmsg, err_if_block));
+                       if (!dd->rmsg) {
                                if (uio->uio_resid != org_resid)
                                        /* Done something, claim success. */
                                        break;
@@ -246,37 +246,37 @@ xenbus_dev_read(struct file *fp, off_t *offset, struct uio *uio,
                        }
                }
 
-               uint32_t avail = sizeof(*d->rmsg) + d->rmsg->len;
+               uint32_t avail = sizeof(*dd->rmsg) + dd->rmsg->len;
                KASSERT(avail < BUFFER_SIZE*2); /* sanity check */
                KASSERT(avail > 0);
-               KASSERT(d->rmsg_done <= avail);
+               KASSERT(dd->rmsg_done <= avail);
 
                DPRINTF(("/dev/xen/xenbus: read... rmsg->len=%lu"
                         " msg_done=%lu avail=%lu\n",
-                        (unsigned long)d->rmsg->len,
-                        (unsigned long)d->rmsg_done,
+                        (unsigned long)dd->rmsg->len,
+                        (unsigned long)dd->rmsg_done,
                         (unsigned long)avail));
 
-               uio->uio_offset = d->rmsg_done;
-               err = uiomove((char*)d->rmsg + d->rmsg_done,
-                             avail - d->rmsg_done,
+               uio->uio_offset = dd->rmsg_done;
+               err = uiomove((char*)dd->rmsg + dd->rmsg_done,
+                             avail - dd->rmsg_done,
                              uio);
-               d->rmsg_done = uio->uio_offset;
+               dd->rmsg_done = uio->uio_offset;
                if (err)
                        goto end;
 
-               if (d->rmsg_done == avail) {
+               if (dd->rmsg_done == avail) {
                        DPRINTF(("/dev/xen/xenbus: read... msg complete\n"));
-                       d->rmsg_free(d->rmsg);
-                       d->rmsg = 0;
-                       d->rmsg_done = 0;
+                       dd->rmsg_free(dd->rmsg);
+                       dd->rmsg = 0;
+                       dd->rmsg_done = 0;
                }
        }
 
        err = 0;
 
 end:
-       mutex_exit(&d->lock);
+       mutex_exit(&dd->lock);
        DPRINTF(("/dev/xen/xenbus: read done, err=%d\n", err));
        return err;
 }
@@ -288,36 +288,36 @@ end:
 
 void rumpxenbus_dev_xb_wakeup(struct rumpxenbus_data_common *dc)
 {
-       struct rumpxenbus_data_dev *d =
+       struct rumpxenbus_data_dev *dd =
                container_of(dc, struct rumpxenbus_data_dev, dc);
-       DPRINTF(("/dev/xen/xenbus[%p,dd=%p]: wakeup\n",d,dc));
-       selnotify(&d->selinfo, RBITS, NOTE_SUBMIT);
+       DPRINTF(("/dev/xen/xenbus[%p,dd=%p]: wakeup\n",dd,dc));
+       selnotify(&dd->selinfo, RBITS, NOTE_SUBMIT);
 }
 
 static void
 xenbus_dev_restart(file_t *fp)
 {
-       struct rumpxenbus_data_dev *d = fp->f_data;
+       struct rumpxenbus_data_dev *dd = fp->f_data;
 
-       DPRINTF(("/dev/xen/xenbus[dd=%p]: restart!\n",d));
+       DPRINTF(("/dev/xen/xenbus[dd=%p]: restart!\n",dd));
 
-       mutex_enter(&d->lock);
-       d->want_restart |= 1;
-       rumpxenbus_dev_restart_wakeup(&d->dc);
-       mutex_exit(&d->lock);
+       mutex_enter(&dd->lock);
+       dd->want_restart |= 1;
+       rumpxenbus_dev_restart_wakeup(&dd->dc);
+       mutex_exit(&dd->lock);
 }
 
 static int
 xenbus_dev_poll(struct file *fp, int events)
 {
-       struct rumpxenbus_data_dev *const d = fp->f_data;
-       struct rumpxenbus_data_common *const dc = &d->dc;
+       struct rumpxenbus_data_dev *const dd = fp->f_data;
+       struct rumpxenbus_data_common *const dc = &dd->dc;
        int revents = 0;
 
        DPRINTF(("/dev/xen/xenbus[%p,dd=%p]: poll events=0%o...\n",
-                dc,d,events));
+                dc,dd,events));
 
-       mutex_enter(&d->lock);
+       mutex_enter(&dd->lock);
 
        /* always writeable - we don't do proper blocking for writing
         * since this can only wait at most until other requests have
@@ -325,15 +325,15 @@ xenbus_dev_poll(struct file *fp, int events)
        revents |= events & WBITS;
 
        if (events & RBITS)
-               if (d->rmsg || dc->queued_enomem || d->want_restart)
+               if (dd->rmsg || dc->queued_enomem || dd->want_restart)
                        revents |= events & RBITS;
 
        if (!revents) {
                if (events & RBITS)
-                       selrecord(curlwp, &d->selinfo);
+                       selrecord(curlwp, &dd->selinfo);
        }
 
-       mutex_exit(&d->lock);
+       mutex_exit(&dd->lock);
 
        DPRINTF(("/dev/xen/xenbus: poll events=0%o done, revents=0%o\n",
                 events, revents));
@@ -345,24 +345,24 @@ xenbus_dev_poll(struct file *fp, int events)
 static int
 xenbus_dev_close(struct file *fp)
 {
-       struct rumpxenbus_data_dev *d = fp->f_data;
+       struct rumpxenbus_data_dev *dd = fp->f_data;
 
-       DPRINTF(("/dev/xen/xenbus[dd=%p]: close...\n",d));
+       DPRINTF(("/dev/xen/xenbus[dd=%p]: close...\n",dd));
 
        /* Not neeeded against concurrent access (we assume!)
         * but next_event_msg will want to unlock and relock it */
-       mutex_enter(&d->lock);
+       mutex_enter(&dd->lock);
 
-       xbd_free(d->rmsg);
-       d->rmsg = 0;
+       xbd_free(dd->rmsg);
+       dd->rmsg = 0;
 
-       rumpxenbus_dev_user_shutdown(&d->dc);
+       rumpxenbus_dev_user_shutdown(&dd->dc);
 
-       KASSERT(!d->rmsg);
+       KASSERT(!dd->rmsg);
 
        DPRINTF(("/dev/xen/xenbus: close seldestroy...\n"));
-       seldestroy(&d->selinfo);
-       xbd_free(d);
+       seldestroy(&dd->selinfo);
+       xbd_free(dd);
 
        DPRINTF(("/dev/xen/xenbus: close done.\n"));
        return 0;
@@ -383,35 +383,35 @@ const struct fileops xenbus_dev_fileops = {
 int
 xenbus_dev_open(struct file *fp, void **fdata_r)
 {
-       struct rumpxenbus_data_dev *d;
+       struct rumpxenbus_data_dev *dd;
        int err;
 
        DPRINTF(("/dev/xen/xenbus: open: entry...\n"));
 
-       d = xbd_malloc(sizeof(*d));
-       if (!d)
+       dd = xbd_malloc(sizeof(*dd));
+       if (!dd)
                return ENOMEM;
 
-       d->dc.du = 0;
+       dd->dc.du = 0;
 
-       DPRINTF(("/dev/xen/xenbus[%p,du=%p]: open: alloc...\n",&d->dc,d));
+       DPRINTF(("/dev/xen/xenbus[%p,du=%p]: open: alloc...\n",&dd->dc,dd));
 
-       err = rumpxenbus_dev_user_open(&d->dc);
+       err = rumpxenbus_dev_user_open(&dd->dc);
        if (err) {
-               xbd_free(d);
+               xbd_free(dd);
                return err;
        }
 
-       mutex_init(&d->lock, MUTEX_DEFAULT, IPL_HIGH);
-       d->want_restart = 0;
-       d->rmsg = 0;
-       d->rmsg_done = 0;
-       selinit(&d->selinfo);
+       mutex_init(&dd->lock, MUTEX_DEFAULT, IPL_HIGH);
+       dd->want_restart = 0;
+       dd->rmsg = 0;
+       dd->rmsg_done = 0;
+       selinit(&dd->selinfo);
 
-       *fdata_r = d;
+       *fdata_r = dd;
 
        DPRINTF(("/dev/xen/xenbus[%p,dd=%p,du=%p]: opened.\n",
-                &d->dc, d, d->dc.du));
+                &dd->dc, dd, dd->dc.du));
 
        return 0;
 }

diff --git a/platform/xen/librumpxen_xendev/busdev_user.c b/platform/xen/librumpxen_xendev/busdev_user.c
index 44253e637b34e3add2ae386c0f7e981ab22c085d..c47d7ceefc507fa79b5b64368c3c0fcaa516e26f 100644 (file)
--- a/platform/xen/librumpxen_xendev/busdev_user.c
+++ b/platform/xen/librumpxen_xendev/busdev_user.c
@@ -485,7 +485,7 @@ rumpxenbus_next_event_msg(struct rumpxenbus_data_common *dc,
  * If !!err_r, will block iff user process read should block:
  * will either return successfully, or set *err_r and return 0.
  *
- * Must be called with d->lock held; may temporarily release it
+ * Must be called with dd->lock held; may temporarily release it
  * by calling rumpxenbus_block_{before,after}. */
 {
        struct rumpxenbus_data_user *d = dc->du;