Page MenuHomeFreeBSD
Files F177344188

D7313.1794160776.diff
No OneTemporary
Actions

Authored By
Unknown
Size
21 KB
Referenced Files
None
Subscribers
None

D7313.1794160776.diff
View Options

Index: head/sys/dev/hyperv/vmbus/hv_ring_buffer.c
===================================================================
--- head/sys/dev/hyperv/vmbus/hv_ring_buffer.c
+++ head/sys/dev/hyperv/vmbus/hv_ring_buffer.c
@@ -34,32 +34,32 @@
#include <dev/hyperv/vmbus/vmbus_reg.h>
#include <dev/hyperv/vmbus/vmbus_brvar.h>
-/* Amount of space to write to */
-#define HV_BYTES_AVAIL_TO_WRITE(r, w, z) \
- ((w) >= (r)) ? ((z) - ((w) - (r))) : ((r) - (w))
+/* Amount of space available for write */
+#define VMBUS_BR_WAVAIL(r, w, z) \
+ (((w) >= (r)) ? ((z) - ((w) - (r))) : ((r) - (w)))
-static uint32_t copy_to_ring_buffer(hv_vmbus_ring_buffer_info *ring_info,
+static uint32_t copy_to_ring_buffer(const struct vmbus_txbr *tbr,
uint32_t start_write_offset, const uint8_t *src,
uint32_t src_len);
-static uint32_t copy_from_ring_buffer(hv_vmbus_ring_buffer_info *ring_info,
+static uint32_t copy_from_ring_buffer(const struct vmbus_rxbr *rbr,
char *dest, uint32_t dest_len, uint32_t start_read_offset);
static int
vmbus_br_sysctl_state(SYSCTL_HANDLER_ARGS)
{
- const hv_vmbus_ring_buffer_info *br = arg1;
- uint32_t rindex, windex, intr_mask, ravail, wavail;
+ const struct vmbus_br *br = arg1;
+ uint32_t rindex, windex, imask, ravail, wavail;
char state[256];
- rindex = br->ring_buffer->br_rindex;
- windex = br->ring_buffer->br_windex;
- intr_mask = br->ring_buffer->br_imask;
- wavail = HV_BYTES_AVAIL_TO_WRITE(rindex, windex, br->ring_data_size);
- ravail = br->ring_data_size - wavail;
+ rindex = br->vbr_rindex;
+ windex = br->vbr_windex;
+ imask = br->vbr_imask;
+ wavail = VMBUS_BR_WAVAIL(rindex, windex, br->vbr_dsize);
+ ravail = br->vbr_dsize - wavail;
snprintf(state, sizeof(state),
- "rindex:%u windex:%u intr_mask:%u ravail:%u wavail:%u",
- rindex, windex, intr_mask, ravail, wavail);
+ "rindex:%u windex:%u imask:%u ravail:%u wavail:%u",
+ rindex, windex, imask, ravail, wavail);
return sysctl_handle_string(oidp, state, sizeof(state), req);
}
@@ -76,25 +76,25 @@
#define BR_STATE_WSPC 4
#define BR_STATE_MAX 5
- const hv_vmbus_ring_buffer_info *br = arg1;
+ const struct vmbus_br *br = arg1;
uint32_t rindex, windex, wavail, state[BR_STATE_MAX];
- rindex = br->ring_buffer->br_rindex;
- windex = br->ring_buffer->br_windex;
- wavail = HV_BYTES_AVAIL_TO_WRITE(rindex, windex, br->ring_data_size);
+ rindex = br->vbr_rindex;
+ windex = br->vbr_windex;
+ wavail = VMBUS_BR_WAVAIL(rindex, windex, br->vbr_dsize);
state[BR_STATE_RIDX] = rindex;
state[BR_STATE_WIDX] = windex;
- state[BR_STATE_IMSK] = br->ring_buffer->br_imask;
+ state[BR_STATE_IMSK] = br->vbr_imask;
state[BR_STATE_WSPC] = wavail;
- state[BR_STATE_RSPC] = br->ring_data_size - wavail;
+ state[BR_STATE_RSPC] = br->vbr_dsize - wavail;
return sysctl_handle_opaque(oidp, state, sizeof(state), req);
}
void
vmbus_br_sysctl_create(struct sysctl_ctx_list *ctx, struct sysctl_oid *br_tree,
- hv_vmbus_ring_buffer_info *br, const char *name)
+ struct vmbus_br *br, const char *name)
{
struct sysctl_oid *tree;
char desc[64];
@@ -115,40 +115,30 @@
br, 0, vmbus_br_sysctl_state_bin, "IU", desc);
}
-/**
- * @brief Get number of bytes available to read and to write to
- * for the specified ring buffer
- */
-static __inline void
-get_ring_buffer_avail_bytes(hv_vmbus_ring_buffer_info *rbi, uint32_t *read,
- uint32_t *write)
+void
+vmbus_rxbr_intr_mask(struct vmbus_rxbr *rbr)
{
- uint32_t read_loc, write_loc;
-
- /*
- * Capture the read/write indices before they changed
- */
- read_loc = rbi->ring_buffer->br_rindex;
- write_loc = rbi->ring_buffer->br_windex;
-
- *write = HV_BYTES_AVAIL_TO_WRITE(read_loc, write_loc,
- rbi->ring_data_size);
- *read = rbi->ring_data_size - *write;
+ rbr->rxbr_imask = 1;
+ mb();
}
-void
-hv_ring_buffer_read_begin(hv_vmbus_ring_buffer_info *ring_info)
+static __inline uint32_t
+vmbus_rxbr_avail(const struct vmbus_rxbr *rbr)
{
- ring_info->ring_buffer->br_imask = 1;
- mb();
+ uint32_t rindex, windex;
+
+ /* Get snapshot */
+ rindex = rbr->rxbr_rindex;
+ windex = rbr->rxbr_windex;
+
+ return (rbr->rxbr_dsize -
+ VMBUS_BR_WAVAIL(rindex, windex, rbr->rxbr_dsize));
}
uint32_t
-hv_ring_buffer_read_end(hv_vmbus_ring_buffer_info *ring_info)
+vmbus_rxbr_intr_unmask(struct vmbus_rxbr *rbr)
{
- uint32_t read, write;
-
- ring_info->ring_buffer->br_imask = 0;
+ rbr->rxbr_imask = 0;
mb();
/*
@@ -156,8 +146,7 @@
* If it is not, we raced and we need to process new
* incoming messages.
*/
- get_ring_buffer_avail_bytes(ring_info, &read, &write);
- return (read);
+ return vmbus_rxbr_avail(rbr);
}
/*
@@ -177,10 +166,10 @@
*/
static boolean_t
hv_ring_buffer_needsig_on_write(uint32_t old_write_location,
- hv_vmbus_ring_buffer_info *rbi)
+ const struct vmbus_txbr *tbr)
{
mb();
- if (rbi->ring_buffer->br_imask)
+ if (tbr->txbr_imask)
return (FALSE);
/* Read memory barrier */
@@ -189,54 +178,73 @@
* This is the only case we need to signal when the
* ring transitions from being empty to non-empty.
*/
- if (old_write_location == rbi->ring_buffer->br_rindex)
+ if (old_write_location == tbr->txbr_rindex)
return (TRUE);
return (FALSE);
}
-/**
- * @brief Initialize the ring buffer.
- */
+static void
+vmbus_br_setup(struct vmbus_br *br, void *buf, int blen)
+{
+ br->vbr = buf;
+ br->vbr_dsize = blen - sizeof(struct vmbus_bufring);
+}
+
void
-hv_vmbus_ring_buffer_init(hv_vmbus_ring_buffer_info *ring_info, void *buffer,
- uint32_t buffer_len)
+vmbus_rxbr_init(struct vmbus_rxbr *rbr)
{
- ring_info->ring_buffer = buffer;
- ring_info->ring_data_size = buffer_len - sizeof(struct vmbus_bufring);
+ mtx_init(&rbr->rxbr_lock, "vmbus_rxbr", NULL, MTX_SPIN);
}
void
-vmbus_br_init(hv_vmbus_ring_buffer_info *ring_info)
+vmbus_rxbr_deinit(struct vmbus_rxbr *rbr)
{
- mtx_init(&ring_info->ring_lock, "vmbus_br", NULL, MTX_SPIN);
+ mtx_destroy(&rbr->rxbr_lock);
}
void
-vmbus_br_deinit(hv_vmbus_ring_buffer_info *ring_info)
+vmbus_rxbr_setup(struct vmbus_rxbr *rbr, void *buf, int blen)
{
- mtx_destroy(&ring_info->ring_lock);
+ vmbus_br_setup(&rbr->rxbr, buf, blen);
}
-/**
- * @brief Cleanup the ring buffer.
- */
void
-hv_ring_buffer_cleanup(hv_vmbus_ring_buffer_info *ring_info)
+vmbus_txbr_init(struct vmbus_txbr *tbr)
{
- /* Do nothing */
+ mtx_init(&tbr->txbr_lock, "vmbus_txbr", NULL, MTX_SPIN);
+}
+
+void
+vmbus_txbr_deinit(struct vmbus_txbr *tbr)
+{
+ mtx_destroy(&tbr->txbr_lock);
+}
+
+void
+vmbus_txbr_setup(struct vmbus_txbr *tbr, void *buf, int blen)
+{
+ vmbus_br_setup(&tbr->txbr, buf, blen);
+}
+
+static __inline uint32_t
+vmbus_txbr_avail(const struct vmbus_txbr *tbr)
+{
+ uint32_t rindex, windex;
+
+ /* Get snapshot */
+ rindex = tbr->txbr_rindex;
+ windex = tbr->txbr_windex;
+
+ return VMBUS_BR_WAVAIL(rindex, windex, tbr->txbr_dsize);
}
-/**
- * @brief Write to the ring buffer.
- */
int
-hv_ring_buffer_write(hv_vmbus_ring_buffer_info *out_ring_info,
- const struct iovec iov[], uint32_t iovlen, boolean_t *need_sig)
+vmbus_txbr_write(struct vmbus_txbr *tbr, const struct iovec iov[], int iovlen,
+ boolean_t *need_sig)
{
int i = 0;
uint32_t byte_avail_to_write;
- uint32_t byte_avail_to_read;
uint32_t old_write_location;
uint32_t total_bytes_to_write = 0;
volatile uint32_t next_write_location;
@@ -247,10 +255,9 @@
total_bytes_to_write += sizeof(uint64_t);
- mtx_lock_spin(&out_ring_info->ring_lock);
+ mtx_lock_spin(&tbr->txbr_lock);
- get_ring_buffer_avail_bytes(out_ring_info, &byte_avail_to_read,
- &byte_avail_to_write);
+ byte_avail_to_write = vmbus_txbr_avail(tbr);
/*
* If there is only room for the packet, assume it is full.
@@ -258,28 +265,28 @@
* is empty since the read index == write index
*/
if (byte_avail_to_write <= total_bytes_to_write) {
- mtx_unlock_spin(&out_ring_info->ring_lock);
+ mtx_unlock_spin(&tbr->txbr_lock);
return (EAGAIN);
}
/*
* Write to the ring buffer
*/
- next_write_location = out_ring_info->ring_buffer->br_windex;
+ next_write_location = tbr->txbr_windex;
old_write_location = next_write_location;
for (i = 0; i < iovlen; i++) {
- next_write_location = copy_to_ring_buffer(out_ring_info,
+ next_write_location = copy_to_ring_buffer(tbr,
next_write_location, iov[i].iov_base, iov[i].iov_len);
}
/*
* Set previous packet start
*/
- prev_indices = ((uint64_t)out_ring_info->ring_buffer->br_windex) << 32;
+ prev_indices = ((uint64_t)tbr->txbr_windex) << 32;
- next_write_location = copy_to_ring_buffer(out_ring_info,
+ next_write_location = copy_to_ring_buffer(tbr,
next_write_location, (char *)&prev_indices, sizeof(uint64_t));
/*
@@ -290,88 +297,73 @@
/*
* Now, update the write location
*/
- out_ring_info->ring_buffer->br_windex = next_write_location;
+ tbr->txbr_windex = next_write_location;
- mtx_unlock_spin(&out_ring_info->ring_lock);
+ mtx_unlock_spin(&tbr->txbr_lock);
- *need_sig = hv_ring_buffer_needsig_on_write(old_write_location,
- out_ring_info);
+ *need_sig = hv_ring_buffer_needsig_on_write(old_write_location, tbr);
return (0);
}
-/**
- * @brief Read without advancing the read index.
- */
int
-hv_ring_buffer_peek(hv_vmbus_ring_buffer_info *in_ring_info, void *buffer,
- uint32_t buffer_len)
+vmbus_rxbr_peek(struct vmbus_rxbr *rbr, void *data, int dlen)
{
- uint32_t bytesAvailToWrite;
uint32_t bytesAvailToRead;
uint32_t nextReadLocation = 0;
- mtx_lock_spin(&in_ring_info->ring_lock);
+ mtx_lock_spin(&rbr->rxbr_lock);
- get_ring_buffer_avail_bytes(in_ring_info, &bytesAvailToRead,
- &bytesAvailToWrite);
+ bytesAvailToRead = vmbus_rxbr_avail(rbr);
/*
* Make sure there is something to read
*/
- if (bytesAvailToRead < buffer_len) {
- mtx_unlock_spin(&in_ring_info->ring_lock);
+ if (bytesAvailToRead < dlen) {
+ mtx_unlock_spin(&rbr->rxbr_lock);
return (EAGAIN);
}
/*
* Convert to byte offset
*/
- nextReadLocation = in_ring_info->ring_buffer->br_rindex;
+ nextReadLocation = rbr->rxbr_rindex;
- nextReadLocation = copy_from_ring_buffer(in_ring_info,
- (char *)buffer, buffer_len, nextReadLocation);
+ nextReadLocation = copy_from_ring_buffer(rbr, data, dlen,
+ nextReadLocation);
- mtx_unlock_spin(&in_ring_info->ring_lock);
+ mtx_unlock_spin(&rbr->rxbr_lock);
return (0);
}
-/**
- * @brief Read and advance the read index.
- */
int
-hv_ring_buffer_read(hv_vmbus_ring_buffer_info *in_ring_info, void *buffer,
- uint32_t buffer_len, uint32_t offset)
+vmbus_rxbr_read(struct vmbus_rxbr *rbr, void *data, int dlen, uint32_t offset)
{
- uint32_t bytes_avail_to_write;
uint32_t bytes_avail_to_read;
uint32_t next_read_location = 0;
uint64_t prev_indices = 0;
- if (buffer_len <= 0)
- return (EINVAL);
+ KASSERT(dlen > 0, ("invalid dlen %d", dlen));
- mtx_lock_spin(&in_ring_info->ring_lock);
+ mtx_lock_spin(&rbr->rxbr_lock);
- get_ring_buffer_avail_bytes(in_ring_info, &bytes_avail_to_read,
- &bytes_avail_to_write);
+ bytes_avail_to_read = vmbus_rxbr_avail(rbr);
/*
* Make sure there is something to read
*/
- if (bytes_avail_to_read < buffer_len) {
- mtx_unlock_spin(&in_ring_info->ring_lock);
+ if (bytes_avail_to_read < dlen) {
+ mtx_unlock_spin(&rbr->rxbr_lock);
return (EAGAIN);
}
- next_read_location = (in_ring_info->ring_buffer->br_rindex + offset) %
- in_ring_info->ring_data_size;
+ next_read_location = (rbr->rxbr_rindex + offset) % rbr->rxbr_dsize;
- next_read_location = copy_from_ring_buffer(in_ring_info, (char *)buffer,
- buffer_len, next_read_location);
+ next_read_location = copy_from_ring_buffer(rbr, data, dlen,
+ next_read_location);
- next_read_location = copy_from_ring_buffer(in_ring_info,
+ next_read_location = copy_from_ring_buffer(rbr,
(char *)&prev_indices, sizeof(uint64_t), next_read_location);
/*
@@ -384,9 +376,9 @@
/*
* Update the read index
*/
- in_ring_info->ring_buffer->br_rindex = next_read_location;
+ rbr->rxbr_rindex = next_read_location;
- mtx_unlock_spin(&in_ring_info->ring_lock);
+ mtx_unlock_spin(&rbr->rxbr_lock);
return (0);
}
@@ -397,11 +389,11 @@
* Assume there is enough room. Handles wrap-around in dest case only!
*/
static uint32_t
-copy_to_ring_buffer(hv_vmbus_ring_buffer_info *ring_info,
+copy_to_ring_buffer(const struct vmbus_txbr *tbr,
uint32_t start_write_offset, const uint8_t *src, uint32_t src_len)
{
- char *ring_buffer = ring_info->ring_buffer->br_data;
- uint32_t ring_buffer_size = ring_info->ring_data_size;
+ char *ring_buffer = tbr->txbr_data;
+ uint32_t ring_buffer_size = tbr->txbr_dsize;
uint32_t fragLen;
if (src_len > ring_buffer_size - start_write_offset) {
@@ -425,12 +417,12 @@
* Assume there is enough room. Handles wrap-around in src case only!
*/
static uint32_t
-copy_from_ring_buffer(hv_vmbus_ring_buffer_info *ring_info, char *dest,
+copy_from_ring_buffer(const struct vmbus_rxbr *rbr, char *dest,
uint32_t dest_len, uint32_t start_read_offset)
{
uint32_t fragLen;
- char *ring_buffer = ring_info->ring_buffer->br_data;
- uint32_t ring_buffer_size = ring_info->ring_data_size;
+ char *ring_buffer = rbr->rxbr_data;
+ uint32_t ring_buffer_size = rbr->rxbr_dsize;
if (dest_len > ring_buffer_size - start_read_offset) {
/* wrap-around detected at the src */
Index: head/sys/dev/hyperv/vmbus/vmbus_brvar.h
===================================================================
--- head/sys/dev/hyperv/vmbus/vmbus_brvar.h
+++ head/sys/dev/hyperv/vmbus/vmbus_brvar.h
@@ -36,50 +36,58 @@
#include <sys/mutex.h>
#include <sys/_iovec.h>
-typedef struct {
- struct vmbus_bufring *ring_buffer;
- struct mtx ring_lock;
- uint32_t ring_data_size; /* ring_size */
-} hv_vmbus_ring_buffer_info;
+struct vmbus_br {
+ struct vmbus_bufring *vbr;
+ uint32_t vbr_dsize; /* total data size */
+};
+
+#define vbr_windex vbr->br_windex
+#define vbr_rindex vbr->br_rindex
+#define vbr_imask vbr->br_imask
+#define vbr_data vbr->br_data
+
+struct vmbus_rxbr {
+ struct mtx rxbr_lock;
+ struct vmbus_br rxbr;
+};
+
+#define rxbr_windex rxbr.vbr_windex
+#define rxbr_rindex rxbr.vbr_rindex
+#define rxbr_imask rxbr.vbr_imask
+#define rxbr_data rxbr.vbr_data
+#define rxbr_dsize rxbr.vbr_dsize
+
+struct vmbus_txbr {
+ struct mtx txbr_lock;
+ struct vmbus_br txbr;
+};
+
+#define txbr_windex txbr.vbr_windex
+#define txbr_rindex txbr.vbr_rindex
+#define txbr_imask txbr.vbr_imask
+#define txbr_data txbr.vbr_data
+#define txbr_dsize txbr.vbr_dsize
struct sysctl_ctx_list;
struct sysctl_oid;
-void vmbus_br_sysctl_create(struct sysctl_ctx_list *ctx,
- struct sysctl_oid *br_tree, hv_vmbus_ring_buffer_info *br,
- const char *name);
-
-void vmbus_br_init(hv_vmbus_ring_buffer_info *ring_info);
-void vmbus_br_deinit(hv_vmbus_ring_buffer_info *ring_info);
-
-void hv_vmbus_ring_buffer_init(
- hv_vmbus_ring_buffer_info *ring_info,
- void *buffer,
- uint32_t buffer_len);
-void hv_ring_buffer_cleanup(
- hv_vmbus_ring_buffer_info *ring_info);
-
-int hv_ring_buffer_write(
- hv_vmbus_ring_buffer_info *ring_info,
- const struct iovec iov[],
- uint32_t iovlen,
- boolean_t *need_sig);
-
-int hv_ring_buffer_peek(
- hv_vmbus_ring_buffer_info *ring_info,
- void *buffer,
- uint32_t buffer_len);
-
-int hv_ring_buffer_read(
- hv_vmbus_ring_buffer_info *ring_info,
- void *buffer,
- uint32_t buffer_len,
- uint32_t offset);
-
-void hv_ring_buffer_read_begin(
- hv_vmbus_ring_buffer_info *ring_info);
-
-uint32_t hv_ring_buffer_read_end(
- hv_vmbus_ring_buffer_info *ring_info);
+void vmbus_br_sysctl_create(struct sysctl_ctx_list *ctx,
+ struct sysctl_oid *br_tree, struct vmbus_br *br,
+ const char *name);
+
+void vmbus_rxbr_init(struct vmbus_rxbr *rbr);
+void vmbus_rxbr_deinit(struct vmbus_rxbr *rbr);
+void vmbus_rxbr_setup(struct vmbus_rxbr *rbr, void *buf, int blen);
+int vmbus_rxbr_peek(struct vmbus_rxbr *rbr, void *data, int dlen);
+int vmbus_rxbr_read(struct vmbus_rxbr *rbr, void *data, int dlen,
+ uint32_t offset);
+void vmbus_rxbr_intr_mask(struct vmbus_rxbr *rbr);
+uint32_t vmbus_rxbr_intr_unmask(struct vmbus_rxbr *rbr);
+
+void vmbus_txbr_init(struct vmbus_txbr *tbr);
+void vmbus_txbr_deinit(struct vmbus_txbr *tbr);
+void vmbus_txbr_setup(struct vmbus_txbr *tbr, void *buf, int blen);
+int vmbus_txbr_write(struct vmbus_txbr *tbr,
+ const struct iovec iov[], int iovlen, boolean_t *need_sig);
#endif /* _VMBUS_BRVAR_H_ */
Index: head/sys/dev/hyperv/vmbus/vmbus_chan.c
===================================================================
--- head/sys/dev/hyperv/vmbus/vmbus_chan.c
+++ head/sys/dev/hyperv/vmbus/vmbus_chan.c
@@ -178,11 +178,11 @@
/*
* Create sysctl tree for RX bufring.
*/
- vmbus_br_sysctl_create(ctx, br_tree, &chan->ch_rxbr, "rx");
+ vmbus_br_sysctl_create(ctx, br_tree, &chan->ch_rxbr.rxbr, "rx");
/*
* Create sysctl tree for TX bufring.
*/
- vmbus_br_sysctl_create(ctx, br_tree, &chan->ch_txbr, "tx");
+ vmbus_br_sysctl_create(ctx, br_tree, &chan->ch_txbr.txbr, "tx");
}
}
@@ -239,9 +239,9 @@
chan->ch_bufring = br;
/* TX bufring comes first */
- hv_vmbus_ring_buffer_init(&chan->ch_txbr, br, txbr_size);
+ vmbus_txbr_setup(&chan->ch_txbr, br, txbr_size);
/* RX bufring immediately follows TX bufring */
- hv_vmbus_ring_buffer_init(&chan->ch_rxbr, br + txbr_size, rxbr_size);
+ vmbus_rxbr_setup(&chan->ch_rxbr, br + txbr_size, rxbr_size);
/* Create sysctl tree for this channel */
vmbus_chan_sysctl_create(chan);
@@ -549,8 +549,6 @@
/*
* Destroy the TX+RX bufrings.
*/
- hv_ring_buffer_cleanup(&chan->ch_txbr);
- hv_ring_buffer_cleanup(&chan->ch_rxbr);
if (chan->ch_bufring != NULL) {
hyperv_dmamem_free(&chan->ch_bufring_dma, chan->ch_bufring);
chan->ch_bufring = NULL;
@@ -620,7 +618,7 @@
iov[2].iov_base = &pad;
iov[2].iov_len = pad_pktlen - pktlen;
- error = hv_ring_buffer_write(&chan->ch_txbr, iov, 3, &send_evt);
+ error = vmbus_txbr_write(&chan->ch_txbr, iov, 3, &send_evt);
if (!error && send_evt)
vmbus_chan_signal_tx(chan);
return error;
@@ -660,7 +658,7 @@
iov[3].iov_base = &pad;
iov[3].iov_len = pad_pktlen - pktlen;
- error = hv_ring_buffer_write(&chan->ch_txbr, iov, 4, &send_evt);
+ error = vmbus_txbr_write(&chan->ch_txbr, iov, 4, &send_evt);
if (!error && send_evt)
vmbus_chan_signal_tx(chan);
return error;
@@ -702,7 +700,7 @@
iov[3].iov_base = &pad;
iov[3].iov_len = pad_pktlen - pktlen;
- error = hv_ring_buffer_write(&chan->ch_txbr, iov, 4, &send_evt);
+ error = vmbus_txbr_write(&chan->ch_txbr, iov, 4, &send_evt);
if (!error && send_evt)
vmbus_chan_signal_tx(chan);
return error;
@@ -715,7 +713,7 @@
struct vmbus_chanpkt_hdr pkt;
int error, dlen, hlen;
- error = hv_ring_buffer_peek(&chan->ch_rxbr, &pkt, sizeof(pkt));
+ error = vmbus_rxbr_peek(&chan->ch_rxbr, &pkt, sizeof(pkt));
if (error)
return error;
@@ -732,8 +730,8 @@
*dlen0 = dlen;
/* Skip packet header */
- error = hv_ring_buffer_read(&chan->ch_rxbr, data, dlen, hlen);
- KASSERT(!error, ("hv_ring_buffer_read failed"));
+ error = vmbus_rxbr_read(&chan->ch_rxbr, data, dlen, hlen);
+ KASSERT(!error, ("vmbus_rxbr_read failed"));
return 0;
}
@@ -745,7 +743,7 @@
struct vmbus_chanpkt_hdr pkt;
int error, pktlen;
- error = hv_ring_buffer_peek(&chan->ch_rxbr, &pkt, sizeof(pkt));
+ error = vmbus_rxbr_peek(&chan->ch_rxbr, &pkt, sizeof(pkt));
if (error)
return error;
@@ -758,8 +756,8 @@
*pktlen0 = pktlen;
/* Include packet header */
- error = hv_ring_buffer_read(&chan->ch_rxbr, pkt0, pktlen, 0);
- KASSERT(!error, ("hv_ring_buffer_read failed"));
+ error = vmbus_rxbr_read(&chan->ch_rxbr, pkt0, pktlen, 0);
+ KASSERT(!error, ("vmbus_rxbr_read failed"));
return 0;
}
@@ -788,12 +786,12 @@
cb(chan, cbarg);
- left = hv_ring_buffer_read_end(&chan->ch_rxbr);
+ left = vmbus_rxbr_intr_unmask(&chan->ch_rxbr);
if (left == 0) {
/* No more data in RX bufring; done */
break;
}
- hv_ring_buffer_read_begin(&chan->ch_rxbr);
+ vmbus_rxbr_intr_mask(&chan->ch_rxbr);
}
}
@@ -835,7 +833,7 @@
continue;
if (chan->ch_flags & VMBUS_CHAN_FLAG_BATCHREAD)
- hv_ring_buffer_read_begin(&chan->ch_rxbr);
+ vmbus_rxbr_intr_mask(&chan->ch_rxbr);
taskqueue_enqueue(chan->ch_tq, &chan->ch_task);
}
}
@@ -914,8 +912,8 @@
mtx_init(&chan->ch_subchan_lock, "vmbus subchan", NULL, MTX_DEF);
TAILQ_INIT(&chan->ch_subchans);
TASK_INIT(&chan->ch_detach_task, 0, vmbus_chan_detach_task, chan);
- vmbus_br_init(&chan->ch_rxbr);
- vmbus_br_init(&chan->ch_txbr);
+ vmbus_rxbr_init(&chan->ch_rxbr);
+ vmbus_txbr_init(&chan->ch_txbr);
return chan;
}
@@ -928,8 +926,8 @@
/* TODO: asset no longer on the vmbus channel list */
hyperv_dmamem_free(&chan->ch_monprm_dma, chan->ch_monprm);
mtx_destroy(&chan->ch_subchan_lock);
- vmbus_br_deinit(&chan->ch_rxbr);
- vmbus_br_deinit(&chan->ch_txbr);
+ vmbus_rxbr_deinit(&chan->ch_rxbr);
+ vmbus_txbr_deinit(&chan->ch_txbr);
free(chan, M_DEVBUF);
}
Index: head/sys/dev/hyperv/vmbus/vmbus_chanvar.h
===================================================================
--- head/sys/dev/hyperv/vmbus/vmbus_chanvar.h
+++ head/sys/dev/hyperv/vmbus/vmbus_chanvar.h
@@ -52,7 +52,7 @@
/*
* RX bufring; immediately following ch_txbr.
*/
- hv_vmbus_ring_buffer_info ch_rxbr;
+ struct vmbus_rxbr ch_rxbr;
struct taskqueue *ch_tq;
struct task ch_task;
@@ -71,7 +71,7 @@
* TX bufring and following MNF/evtflags do _not_ fit in
* one 64B cacheline.
*/
- hv_vmbus_ring_buffer_info ch_txbr __aligned(CACHE_LINE_SIZE);
+ struct vmbus_txbr ch_txbr __aligned(CACHE_LINE_SIZE);
uint32_t ch_txflags; /* VMBUS_CHAN_TXF_ */
/*

File Metadata

Mime Type
text/plain
Expires
Sun, Nov 8, 5:59 PM (8 h, 44 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
41594494
Default Alt Text
D7313.1794160776.diff (21 KB)

Event Timeline