From: Ian Jackson <ian.jackson@eu.citrix.com>
Date: Wed, 5 Oct 2016 16:10:49 +0000 (+0100)
Subject: librumpxen_xendev: Rename applicable `d' variables to `dd'
X-Git-Url: http://xenbits.xensource.com/gitweb?a=commitdiff_plain;h=928e296b3968c657122b3a8c49b1cb2059324e81;p=osstest%2Frumprun.git

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 8068042..635a41b 100644
--- 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 44253e6..c47d7ce 100644
--- 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;