int mem_event_get_response(struct domain *d, struct mem_event_domain *med, mem_event_response_t *rsp)
{
mem_event_front_ring_t *front_ring;
RING_IDX rsp_cons;
mem_event_ring_lock(med);
front_ring = &med->front_ring;
rsp_cons = front_ring->rsp_cons;
if ( !RING_HAS_UNCONSUMED_RESPONSES(front_ring) )
{
mem_event_ring_unlock(med);
return 0;
}
/* Copy response */
memcpy(rsp, RING_GET_RESPONSE(front_ring, rsp_cons), sizeof(*rsp));
rsp_cons++;
/* Update ring */
front_ring->rsp_cons = rsp_cons;
front_ring->sring->rsp_event = rsp_cons + 1;
/* Kick any waiters -- since we've just consumed an event,
* there may be additional space available in the ring. */
mem_event_wake(d, med);
mem_event_ring_unlock(med);
return 1;
}
/**
* Poll for completed packets
*
* @v netdev Network device
*/
static void netfront_poll_tx ( struct net_device *netdev ) {
struct netfront_nic *netfront = netdev->priv;
struct xen_device *xendev = netfront->xendev;
struct netif_tx_response *response;
struct io_buffer *iobuf;
unsigned int status;
int rc;
/* Consume any unconsumed responses */
while ( RING_HAS_UNCONSUMED_RESPONSES ( &netfront->tx_fring ) ) {
/* Get next response */
response = RING_GET_RESPONSE ( &netfront->tx_fring,
netfront->tx_fring.rsp_cons++ );
/* Retrieve from descriptor ring */
iobuf = netfront_pull ( netfront, &netfront->tx, response->id );
status = response->status;
if ( status == NETIF_RSP_OKAY ) {
DBGC2 ( netfront, "NETFRONT %s TX id %d complete\n",
xendev->key, response->id );
netdev_tx_complete ( netdev, iobuf );
} else {
rc = -EIO_NETIF_RSP ( status );
DBGC2 ( netfront, "NETFRONT %s TX id %d error %d: %s\n",
xendev->key, response->id, status,
strerror ( rc ) );
netdev_tx_complete_err ( netdev, iobuf, rc );
}
}
}
static int
xpvtap_user_response_get(xpvtap_state_t *state, blkif_response_t *resp,
uint_t *uid)
{
blkif_front_ring_t *uring;
blkif_response_t *target;
uring = &state->bt_user_ring.ur_ring;
if (!RING_HAS_UNCONSUMED_RESPONSES(uring)) {
return (B_FALSE);
}
target = NULL;
target = RING_GET_RESPONSE(uring, uring->rsp_cons);
if (target == NULL) {
return (B_FALSE);
}
/* copy out the user app response */
bcopy(target, resp, sizeof (*resp));
uring->rsp_cons++;
/* restore the quests id from the original request */
*uid = (uint_t)resp->id;
resp->id = state->bt_map.um_outstanding_reqs[*uid].id;
return (B_TRUE);
}
static int write_block(FILE *p, blkif_sector_t sector, size_t amt)
{
static uint64_t next_reqid = 1;
blkif_response_t *rsp;
blkif_request_t *req;
int notify, work_to_do;
uint64_t reqid;
RING_IDX i;
/* wait until we can write something */
while(RING_FULL(&p->ring)) runtime_block(1);
/* write out the request */
i = p->ring.req_prod_pvt++;
req = RING_GET_REQUEST(&p->ring, i);
memset(req, 0, sizeof(blkif_request_t));
req->operation = BLKIF_OP_WRITE;
req->nr_segments = 1;
req->handle = p->disk_handle;
req->id = reqid = next_reqid++;
req->sector_number = sector;
req->seg[0].gref = p->block_grant;
req->seg[0].first_sect = 0;
req->seg[0].last_sect = (amt - 1) / 512;
wmb();
RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&p->ring, notify);
if(notify) channel_send(p->chan);
/* wait for it to be satisfied */
do {
while(!RING_HAS_UNCONSUMED_RESPONSES(&p->ring))
runtime_block(1);
i = p->ring.rsp_cons++;
rsp = RING_GET_RESPONSE(&p->ring, i);
} while(rsp->id != reqid);
/* was it successful? */
if(rsp->status != BLKIF_RSP_OKAY) {
printf("PROFILING: Block write failed!\n");
return 0;
}
/* we do writes one at a time, synchronously, so work_to_do should always
be false */
RING_FINAL_CHECK_FOR_RESPONSES(&p->ring, work_to_do);
assert(!work_to_do);
return 1;
}
static int xennet_open(struct net_device *dev)
{
struct netfront_info *np = netdev_priv(dev);
napi_enable(&np->napi);
spin_lock_bh(&np->rx_lock);
if (netif_carrier_ok(dev)) {
xennet_alloc_rx_buffers(dev);
np->rx.sring->rsp_event = np->rx.rsp_cons + 1;
if (RING_HAS_UNCONSUMED_RESPONSES(&np->rx))
netif_rx_schedule(dev, &np->napi);
}
spin_unlock_bh(&np->rx_lock);
netif_start_queue(dev);
return 0;
}
/**
* Poll for received packets
*
* @v netdev Network device
*/
static void netfront_poll_rx ( struct net_device *netdev ) {
struct netfront_nic *netfront = netdev->priv;
struct xen_device *xendev = netfront->xendev;
struct netif_rx_response *response;
struct io_buffer *iobuf;
int status;
size_t len;
int rc;
/* Consume any unconsumed responses */
while ( RING_HAS_UNCONSUMED_RESPONSES ( &netfront->rx_fring ) ) {
/* Get next response */
response = RING_GET_RESPONSE ( &netfront->rx_fring,
netfront->rx_fring.rsp_cons++ );
/* Retrieve from descriptor ring */
iobuf = netfront_pull ( netfront, &netfront->rx, response->id );
status = response->status;
if ( status >= 0 ) {
len = status;
iob_reserve ( iobuf, response->offset );
iob_put ( iobuf, len );
DBGC2 ( netfront, "NETFRONT %s RX id %d complete "
"%#08lx+%zx\n", xendev->key, response->id,
virt_to_phys ( iobuf->data ), len );
netdev_rx ( netdev, iobuf );
} else {
rc = -EIO_NETIF_RSP ( status );
DBGC2 ( netfront, "NETFRONT %s RX id %d error %d: %s\n",
xendev->key, response->id, status,
strerror ( rc ) );
netdev_rx_err ( netdev, iobuf, rc );
}
}
}
VOID
ReceiverHandleNotification(
IN PRECEIVER Receiver
)
/*++
Routine Description:
Interrupt handler for receive processing
Put the received packets into an array and call NdisMIndicateReceivePacket
If we run low on RFDs, allocate another one
Arguments:
Adapter Pointer to our adapter
Return Value:
None
--*/
{
PADAPTER Adapter = Receiver->Common.Adapter;
RING_IDX prod;
int more_work;
PNDIS_PACKET PacketArray[XENNET_DEF_RFDS];
NDIS_STATUS PacketStatus[XENNET_DEF_RFDS];
UINT PacketCount;
if (!RING_HAS_UNCONSUMED_RESPONSES(&Receiver->Common.Ring))
return;
NdisDprAcquireSpinLock(&Receiver->Common.Lock);
if (Receiver->Common.Adapter->media_disconnect) {
NdisDprReleaseSpinLock(&Receiver->Common.Lock);
return;
}
if (__RING_IDX_DIFFERENCE(Receiver->Common.Ring.req_prod_pvt,
Receiver->Common.Ring.sring->rsp_prod) >
NET_RX_RING_SIZE)
TraceWarning(("Strange: rsp_prod ahead of req_prod (%d vs %d (s %d))\n",
Receiver->Common.Ring.sring->rsp_prod,
Receiver->Common.Ring.req_prod_pvt,
Receiver->Common.Ring.sring->req_prod));
PacketCount = 0;
top:
prod = Receiver->Common.Ring.sring->rsp_prod;
XsMemoryBarrier();
while (!RING_IDXS_EQ(Receiver->Common.Ring.rsp_cons, prod)) {
PNDIS_PACKET packet;
ULONG totFrags;
NDIS_STATUS status;
status = ReceiverReceivePacket(Receiver, &packet, &totFrags);
if (status != NDIS_STATUS_SUCCESS)
continue;
TraceProfile(("%s(%s, %p)\n", __FUNCTION__, Adapter->XenbusPrefix, packet));
// See http://msdn.microsoft.com/en-us/library/ms797610.aspx
if (Receiver->LowResources == 2 ||
(Receiver->LowResources == 1 && totFrags > 1)) {
status = NDIS_STATUS_RESOURCES;
NDIS_SET_PACKET_STATUS(packet, status);
}
PacketArray[PacketCount] = packet;
PacketStatus[PacketCount] = status;
PacketCount++;
if (PacketCount == XENNET_DEF_RFDS) {
ULONG Index;
Receiver->Common.Frames += PacketCount;
Receiver->nRxInNdis += PacketCount;
if (Receiver->nRxInNdis >= Receiver->nRxInNdisMax)
Receiver->nRxInNdisMax = Receiver->nRxInNdis;
NdisDprReleaseSpinLock(&Receiver->Common.Lock);
NdisMIndicateReceivePacket(
Receiver->Common.Adapter->AdapterHandle,
PacketArray,
PacketCount);
NdisDprAcquireSpinLock(&Receiver->Common.Lock);
for (Index = 0; Index < PacketCount; Index++) {
if (PacketStatus[Index] == NDIS_STATUS_RESOURCES) {
ReceiverReleasePacket(Receiver, PacketArray[Index]);
Receiver->nRxInNdis--;
} else {
XM_ASSERT(PacketStatus[Index] == NDIS_STATUS_SUCCESS);
}
}
PacketCount = 0;
ReceiverSwizzle(Receiver);
}
}
RING_FINAL_CHECK_FOR_RESPONSES(&Receiver->Common.Ring, more_work);
if (more_work)
goto top;
if (PacketCount != 0) {
ULONG Index;
Receiver->Common.Frames += PacketCount;
Receiver->nRxInNdis += PacketCount;
if (Receiver->nRxInNdis >= Receiver->nRxInNdisMax)
Receiver->nRxInNdisMax = Receiver->nRxInNdis;
NdisDprReleaseSpinLock(&Receiver->Common.Lock);
NdisMIndicateReceivePacket(
Receiver->Common.Adapter->AdapterHandle,
PacketArray,
PacketCount);
NdisDprAcquireSpinLock(&Receiver->Common.Lock);
for (Index = 0; Index < PacketCount; Index++) {
if (PacketStatus[Index] == NDIS_STATUS_RESOURCES) {
ReceiverReleasePacket(Receiver, PacketArray[Index]);
Receiver->nRxInNdis--;
} else {
XM_ASSERT(PacketStatus[Index] == NDIS_STATUS_SUCCESS);
}
}
PacketCount = 0;
}
// Swizzle unconditionally to make sure we replenish the ring even if
// nothing was passed to NDIS.
ReceiverSwizzle(Receiver);
NdisDprReleaseSpinLock(&Receiver->Common.Lock);
/* XXX Should maybe adjust size of packet pool from here. */
}
