static int do_block_io_op(blkif_t *blkif);
-static int dispatch_rw_block_io(blkif_t *blkif,
+static void dispatch_rw_block_io(blkif_t *blkif,
blkif_request_t *req,
pending_req_t *pending_req);
static void make_response(blkif_t *blkif, u64 id,
blkif_request_t req;
pending_req_t *pending_req;
RING_IDX rc, rp;
- int more_to_do = 0, ret;
+ int more_to_do = 0;
rc = blk_rings->common.req_cons;
rp = blk_rings->common.sring->req_prod;
rmb(); /* Ensure we see queued requests up to 'rp'. */
- while ((rc != rp) || (blkif->is_suspended_req)) {
+ while ((rc != rp)) {
if (RING_REQUEST_CONS_OVERFLOW(&blk_rings->common, rc))
break;
break;
}
- /* Handle the suspended request first, if one exists */
- if(blkif->is_suspended_req)
- {
- memcpy(&req, &blkif->suspended_req, sizeof(req));
- blkif->is_suspended_req = 0;
- goto handle_request;
- }
-
switch (blkif->blk_protocol) {
case BLKIF_PROTOCOL_NATIVE:
memcpy(&req, RING_GET_REQUEST(&blk_rings->native, rc), sizeof(req));
/* Apply all sanity checks to /private copy/ of request. */
barrier();
-handle_request:
- ret = 0;
switch (req.operation) {
case BLKIF_OP_READ:
blkif->st_rd_req++;
- ret = dispatch_rw_block_io(blkif, &req, pending_req);
+ dispatch_rw_block_io(blkif, &req, pending_req);
break;
case BLKIF_OP_WRITE_BARRIER:
blkif->st_br_req++;
/* fall through */
case BLKIF_OP_WRITE:
blkif->st_wr_req++;
- ret = dispatch_rw_block_io(blkif, &req, pending_req);
+ dispatch_rw_block_io(blkif, &req, pending_req);
break;
default:
/* A good sign something is wrong: sleep for a while to
free_req(pending_req);
break;
}
- BUG_ON(ret != 0 && ret != -EAGAIN);
- /* If we can't handle the request at the moment, save it, and break the
- * loop */
- if(ret == -EAGAIN)
- {
- memcpy(&blkif->suspended_req, &req, sizeof(req));
- blkif->is_suspended_req = 1;
- /* Return "no more work pending", restart will be handled 'out of
- * band' */
- return 0;
- }
/* Yield point for this unbounded loop. */
cond_resched();
return more_to_do;
}
-static int dispatch_rw_block_io(blkif_t *blkif,
+static void dispatch_rw_block_io(blkif_t *blkif,
blkif_request_t *req,
pending_req_t *pending_req)
{
ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, map, nseg);
BUG_ON(ret);
-#define GENERAL_ERR (1<<0)
-#define EAGAIN_ERR (1<<1)
for (i = 0; i < nseg; i++) {
- if (unlikely(map[i].status != 0)) {
+ if (unlikely(map[i].status == GNTST_eagain))
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &map[i])
+ if (unlikely(map[i].status != GNTST_okay)) {
DPRINTK("invalid buffer -- could not remap it\n");
map[i].handle = BLKBACK_INVALID_HANDLE;
- ret |= GENERAL_ERR;
- if(map[i].status == GNTST_eagain)
- ret |= EAGAIN_ERR;
+ ret = 1;
} else {
blkback_pagemap_set(vaddr_pagenr(pending_req, i),
pending_page(pending_req, i),
(req->seg[i].first_sect << 9);
}
- /* If any of grant maps failed with GNTST_eagain, suspend and retry later */
- if(ret & EAGAIN_ERR)
- {
- fast_flush_area(pending_req);
- free_req(pending_req);
- return -EAGAIN;
- }
-
if (ret)
goto fail_flush;
else if (operation == WRITE || operation == WRITE_BARRIER)
blkif->st_wr_sect += preq.nr_sects;
- return 0;
+ return;
fail_flush:
fast_flush_area(pending_req);
make_response(blkif, req->id, req->operation, BLKIF_RSP_ERROR);
free_req(pending_req);
msleep(1); /* back off a bit */
- return 0;
+ return;
fail_put_bio:
__end_block_io_op(pending_req, -EINVAL);
bio_put(bio);
unplug_queue(blkif);
msleep(1); /* back off a bit */
- return 0;
+ return;
}
struct task_struct *xenblkd;
unsigned int waiting_reqs;
request_queue_t *plug;
- int is_suspended_req;
- blkif_request_t suspended_req;
/* statistics */
unsigned long st_print;
static int map_frontend_page(blkif_t *blkif, unsigned long shared_page)
{
struct gnttab_map_grant_ref op;
+ int ret;
gnttab_set_map_op(&op, (unsigned long)blkif->blk_ring_area->addr,
GNTMAP_host_map, shared_page, blkif->domid);
- do {
- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
- BUG();
- msleep(100);
- } while(op.status == GNTST_eagain);
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
- if (op.status) {
- DPRINTK(" Grant table operation failure !\n");
- return op.status;
+ if (op.status == GNTST_okay) {
+ blkif->shmem_ref = shared_page;
+ blkif->shmem_handle = op.handle;
+ ret = 0;
+ } else {
+ DPRINTK(" Grant table operation failure %d!\n", (int)op.status);
+ ret = -EINVAL;
}
- blkif->shmem_ref = shared_page;
- blkif->shmem_handle = op.handle;
-
- return 0;
+ return ret;
}
static void unmap_frontend_page(blkif_t *blkif)
uvaddr = MMAP_VADDR(info->user_vstart, usr_idx, i/2);
- if (unlikely(map[i].status != 0)) {
- WPRINTK("invalid kernel buffer -- "
- "could not remap it\n");
- if(map[i].status == GNTST_eagain)
- WPRINTK("grant GNTST_eagain: please use blktap2\n");
- ret |= 1;
+ gnttab_check_GNTST_eagain_while(GNTTABOP_map_grant_ref, &map[i]);
+
+ if (unlikely(map[i].status != GNTST_okay)) {
+ WPRINTK("invalid kernel buffer -- could not remap it\n");
+ ret = 1;
map[i].handle = INVALID_GRANT_HANDLE;
}
- if (unlikely(map[i+1].status != 0)) {
- WPRINTK("invalid user buffer -- "
- "could not remap it\n");
- ret |= 1;
+ if (unlikely(map[i+1].status != GNTST_okay)) {
+ WPRINTK("invalid kernel buffer -- could not remap it\n");
+ ret = 1;
map[i+1].handle = INVALID_GRANT_HANDLE;
}
uvaddr = MMAP_VADDR(info->user_vstart, usr_idx, i);
- if (unlikely(map[i].status != 0)) {
- WPRINTK("invalid kernel buffer -- "
- "could not remap it\n");
- if(map[i].status == GNTST_eagain)
- WPRINTK("grant GNTST_eagain: please use blktap2\n");
- ret |= 1;
+ gnttab_check_GNTST_eagain_while(GNTTABOP_map_grant_ref, &map[i]);
+
+ if (unlikely(map[i].status != GNTST_okay)) {
+ WPRINTK("invalid kernel buffer -- could not remap it\n");
+ ret = 1;
map[i].handle = INVALID_GRANT_HANDLE;
}
static int map_frontend_page(blkif_t *blkif, unsigned long shared_page)
{
struct gnttab_map_grant_ref op;
+ int ret;
gnttab_set_map_op(&op, (unsigned long)blkif->blk_ring_area->addr,
GNTMAP_host_map, shared_page, blkif->domid);
- do {
- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
- BUG();
- msleep(10);
- } while(op.status == GNTST_eagain);
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
- if (op.status) {
- DPRINTK(" Grant table operation failure !\n");
- return op.status;
+ if (op.status == GNTST_okay) {
+ blkif->shmem_ref = shared_page;
+ blkif->shmem_handle = op.handle;
+ ret = 0;
+ } else {
+ DPRINTK("Grant table operation failure %d!\n", (int)op.status);
+ ret = -EINVAL;
}
- blkif->shmem_ref = shared_page;
- blkif->shmem_handle = op.handle;
-
- return 0;
+ return ret;
}
static void unmap_frontend_page(blkif_t *blkif)
uvaddr = MMAP_VADDR(ring->user_vstart, usr_idx, i);
- if (unlikely(table->grants[grant].status)) {
+ if (unlikely(table->grants[grant].status != GNTST_okay)) {
BTERR("invalid kernel buffer: could not remap it\n");
- /* This should never happen: blkback should handle eagain first */
- BUG_ON(table->grants[grant].status == GNTST_eagain);
+ /* This should never happen: blkback should handle eagain first */
+ BUG_ON(table->grants[grant].status == GNTST_eagain);
err |= 1;
table->grants[grant].handle = INVALID_GRANT_HANDLE;
}
foreign_mfn = table->grants[grant].dev_bus_addr >> PAGE_SHIFT;
grant++;
- if (xen_feature(XENFEAT_auto_translated_physmap))
- goto done;
-
- if (unlikely(table->grants[grant].status)) {
- BTERR("invalid user buffer: could not remap it\n");
- err |= 1;
+ if (!xen_feature(XENFEAT_auto_translated_physmap)) {
+ if (unlikely(table->grants[grant].status != GNTST_okay)) {
+ /* This should never happen: blkback should handle eagain first */
+ WARN_ON(table->grants[grant].status == GNTST_eagain);
+ BTERR("invalid user buffer: could not remap it\n");
+ err |= 1;
+ }
table->grants[grant].handle = INVALID_GRANT_HANDLE;
+ request->handles[i].user = table->grants[grant].handle;
+ grant++;
}
- request->handles[i].user = table->grants[grant].handle;
- grant++;
-
- done:
if (err)
continue;
set_page_private(tap_page, page_private(page));
SetPageBlkback(tap_page);
- err = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref,
- &map, 1);
- BUG_ON(err);
- /* We are not expecting the grant op to fail */
- BUG_ON(map.status != GNTST_okay);
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &map);
+
+ /* We are not expecting the grant op to fail */
+ BUG_ON(map.status != GNTST_okay);
err = vm_insert_page(ring->vma, uvaddr, tap_page);
if (err) {
return -ENOSYS;
}
- BUG_ON(rc || setup.status);
+ BUG_ON(rc || setup.status != GNTST_okay);
if (shared == NULL)
shared = arch_gnttab_alloc_shared(frames);
err = HYPERVISOR_grant_table_op(GNTTABOP_unmap_and_replace,
&unmap, 1);
BUG_ON(err);
- BUG_ON(unmap.status);
+ BUG_ON(unmap.status != GNTST_okay);
write_sequnlock(&gnttab_dma_lock);
vma->vm_mm->context.has_foreign_mappings = 1;
#endif
- exit_ret = -ENOMEM;
+ exit_ret = -ENOMEM;
for (i = 0; i < size; ++i) {
flags = GNTMAP_host_map;
ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref,
&op, 1);
BUG_ON(ret);
- if (op.status) {
- if(op.status != GNTST_eagain)
+ if (op.status != GNTST_okay) {
+ if (op.status != GNTST_eagain)
printk(KERN_ERR "Error mapping the grant reference "
"into the kernel (%d). domid = %d; ref = %d\n",
op.status,
.u.valid.domid,
private_data->grants[slot_index+i]
.u.valid.ref);
- else
- /* Propagate eagain instead of trying to fix it up */
- exit_ret = -EAGAIN;
+ else
+ /* Propagate eagain instead of trying to fix it up */
+ exit_ret = -EAGAIN;
goto undo_map_out;
}
ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref,
&op, 1);
BUG_ON(ret);
- if (op.status) {
+ if (op.status != GNTST_okay) {
printk(KERN_ERR "Error mapping the grant "
"reference into user space (%d). domid "
"= %d; ref = %d\n", op.status,
.valid.domid,
private_data->grants[slot_index+i].u
.valid.ref);
- /* This should never happen after we've mapped into
- * the kernel space. */
- BUG_ON(op.status == GNTST_eagain);
+ /* This should never happen after we've mapped into
+ * the kernel space. */
+ BUG_ON(op.status == GNTST_eagain);
goto undo_map_out;
}
}
}
- exit_ret = 0;
+ exit_ret = 0;
up_write(&private_data->grants_sem);
return exit_ret;
ret = HYPERVISOR_grant_table_op(
GNTTABOP_unmap_grant_ref, &op, 1);
BUG_ON(ret);
- if (op.status)
+ if (op.status != GNTST_okay)
printk("User unmap grant status = %d\n",
op.status);
} else {
ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref,
&op, 1);
BUG_ON(ret);
- if (op.status)
+ if (op.status != GNTST_okay)
printk("Kernel unmap grant status = %d\n", op.status);
gnttab_set_map_op(&op, (unsigned long)netif->tx_comms_area->addr,
GNTMAP_host_map, tx_ring_ref, netif->domid);
- do {
- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
- BUG();
- msleep(10);
- } while(op.status == GNTST_eagain);
-
- if (op.status) {
- DPRINTK(" Gnttab failure mapping tx_ring_ref!\n");
- return op.status;
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
+
+ if (op.status != GNTST_okay) {
+ DPRINTK(" Gnttab failure mapping tx_ring_ref %d!\n", (int)op.status);
+ return -EINVAL;
}
netif->tx_shmem_ref = tx_ring_ref;
gnttab_set_map_op(&op, (unsigned long)netif->rx_comms_area->addr,
GNTMAP_host_map, rx_ring_ref, netif->domid);
- do {
- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
- BUG();
- msleep(10);
- } while(op.status == GNTST_eagain);
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
- if (op.status) {
+ if (op.status != GNTST_okay) {
struct gnttab_unmap_grant_ref unop;
gnttab_set_unmap_op(&unop,
GNTMAP_host_map, netif->tx_shmem_handle);
VOID(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref,
&unop, 1));
- DPRINTK(" Gnttab failure mapping rx_ring_ref!\n");
- return op.status;
+ DPRINTK(" Gnttab failure mapping rx_ring_ref %d!\n", (int)op.status);
+ return -EINVAL;
}
netif->rx_shmem_ref = rx_ring_ref;
used to set up the operations on the top of
netrx_pending_operations, which have since been done. Check that
they didn't give any errors and advance over them. */
-static int netbk_check_gop(int nr_frags, domid_t domid,
- struct netrx_pending_operations *npo, int *eagain)
+static int netbk_check_gop(int nr_frags, domid_t domid, struct netrx_pending_operations *npo)
{
multicall_entry_t *mcl;
gnttab_transfer_t *gop;
int status = NETIF_RSP_OKAY;
int i;
- *eagain = 0;
-
for (i = 0; i <= nr_frags; i++) {
if (npo->meta[npo->meta_cons + i].copy) {
copy_op = npo->copy + npo->copy_cons++;
- if (copy_op->status != GNTST_okay) {
+ if (unlikely(copy_op->status == GNTST_eagain))
+ gnttab_check_GNTST_eagain_while(GNTTABOP_copy, copy_op);
+ if (unlikely(copy_op->status != GNTST_okay)) {
DPRINTK("Bad status %d from copy to DOM%d.\n",
copy_op->status, domid);
status = NETIF_RSP_ERROR;
- if(copy_op->status == GNTST_eagain)
- *eagain = 1;
}
} else {
if (!xen_feature(XENFEAT_auto_translated_physmap)) {
gop = npo->trans + npo->trans_cons++;
/* Check the reassignment error code. */
- if (gop->status != 0) {
+ if (unlikely(gop->status != GNTST_okay)) {
DPRINTK("Bad status %d from grant transfer to DOM%u\n",
gop->status, domid);
/*
* a fatal error anyway.
*/
BUG_ON(gop->status == GNTST_bad_page);
- if(gop->status == GNTST_eagain)
- *eagain = 1;
status = NETIF_RSP_ERROR;
}
}
int nr_frags;
int count;
unsigned long offset;
- int eagain;
/*
* Putting hundreds of bytes on the stack is considered rude.
netif = netdev_priv(skb->dev);
- status = netbk_check_gop(nr_frags, netif->domid, &npo, &eagain);
+ status = netbk_check_gop(nr_frags, netif->domid, &npo);
/* We can't rely on skb_release_data to release the
pages used by fragments for us, since it tries to
/* (Freeing the fragments is safe since we copy
non-linear skbs destined for flipping interfaces) */
if (!netif->copying_receiver) {
- /*
- * Cannot handle failed grant transfers at the moment (because
- * mmu_updates likely completed)
- */
- BUG_ON(eagain);
atomic_set(&(skb_shinfo(skb)->dataref), 1);
skb_shinfo(skb)->frag_list = NULL;
skb_shinfo(skb)->nr_frags = 0;
netbk_free_pages(nr_frags, meta + npo.meta_cons + 1);
}
- if(!eagain)
- {
- netif->stats.tx_bytes += skb->len;
- netif->stats.tx_packets++;
- }
+ netif->stats.tx_bytes += skb->len;
+ netif->stats.tx_packets++;
id = meta[npo.meta_cons].id;
flags = nr_frags ? NETRXF_more_data : 0;
!netbk_queue_full(netif))
netif_wake_queue(netif->dev);
- if(!eagain || netbk_queue_full(netif))
- {
- netif_put(netif);
- dev_kfree_skb(skb);
- netif->stats.tx_dropped += !!eagain;
- }
- else
- {
- netif->rx_req_cons_peek += skb_shinfo(skb)->nr_frags + 1 +
- !!skb_shinfo(skb)->gso_size;
- skb_queue_head(&rx_queue, skb);
- }
+ netif_put(netif);
+ dev_kfree_skb(skb);
npo.meta_cons += nr_frags + 1;
}
/* Check status of header. */
err = mop->status;
- if (unlikely(err)) {
+ if (unlikely(err != GNTST_okay)) {
txp = &pending_tx_info[pending_idx].req;
make_tx_response(netif, txp, NETIF_RSP_ERROR);
pending_ring[MASK_PEND_IDX(pending_prod++)] = pending_idx;
/* Check error status: if okay then remember grant handle. */
newerr = (++mop)->status;
- if (likely(!newerr)) {
+ if (likely(newerr == GNTST_okay)) {
set_phys_to_machine(idx_to_pfn(pending_idx),
FOREIGN_FRAME(mop->dev_bus_addr>>PAGE_SHIFT));
grant_tx_handle[pending_idx] = mop->handle;
/* Had a previous error? Invalidate this fragment. */
- if (unlikely(err))
+ if (unlikely(err != GNTST_okay))
netif_idx_release(pending_idx);
continue;
}
netif_put(netif);
/* Not the first error? Preceding frags already invalidated. */
- if (err)
+ if (err != GNTST_okay)
continue;
/* First error: invalidate header and preceding fragments. */
unsigned long ring_ref)
{
struct gnttab_map_grant_ref op;
- int err;
+ int ret;
gnttab_set_map_op(&op, (unsigned long)info->ring_area->addr,
GNTMAP_host_map, ring_ref,
info->domid);
-
- do {
- err = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);
- BUG_ON(err);
- msleep(10);
- } while(op.status == GNTST_eagain);
-
- if (op.status) {
- printk(KERN_ERR "scsiback: Grant table operation failure !\n");
- return op.status;
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
+
+ if (op.status != GNTST_okay) {
+ printk(KERN_ERR "scsiback: Grant table operation failure %d!\n", (int)op.status);
+ ret = -EINVAL;
+ } else {
+ info->shmem_ref = ring_ref;
+ info->shmem_handle = op.handle;
+ ret = 0;
}
- info->shmem_ref = ring_ref;
- info->shmem_handle = op.handle;
-
- return (GNTST_okay);
+ return ret;
}
static void unmap_frontend_page(struct vscsibk_info *info)
err = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, map, nr_segments);
BUG_ON(err);
- /* Retry maps with GNTST_eagain */
- for(i=0; i < nr_segments; i++) {
- while(unlikely(map[i].status == GNTST_eagain))
- {
- msleep(10);
- err = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref,
- &map[i],
- 1);
- BUG_ON(err);
- }
- }
for (i = 0; i < nr_segments; i++) {
struct page *pg;
- if (unlikely(map[i].status != 0)) {
+ /* Retry maps with GNTST_eagain */
+ if (unlikely(map[i].status == GNTST_eagain))
+ gnttab_check_GNTST_eagain_while(GNTTABOP_map_grant_ref, &map[i]);
+ if (unlikely(map[i].status != GNTST_okay)) {
printk(KERN_ERR "scsiback: invalid buffer -- could not remap it\n");
map[i].handle = SCSIBACK_INVALID_HANDLE;
err |= 1;
u64 *dev_bus_addr, unsigned flags)
{
struct gnttab_map_grant_ref op;
+ int ret;
gnttab_set_map_op(&op, (unsigned long)vaddr, flags,
gnt_ref, dev->otherend_id);
- BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1));
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
if (op.status != GNTST_okay) {
xenbus_dev_error
(dev, op.status,
"failed mapping in shared page %d from domain %d\n",
gnt_ref, dev->otherend_id);
+ ret = -EINVAL;
} else {
*handle = op.handle;
if (dev_bus_addr)
*dev_bus_addr = op.dev_bus_addr;
+ ret = 0;
}
- return op.status;
+ return ret;
}
"failed unmapping page at handle %d error %d\n",
handle, op.status);
- return op.status;
+ return op.status == GNTST_okay ? 0 : -EINVAL;
}
/* Map a series of grants into a contiguous virtual area */
static void *net_accel_map_grants_valloc(struct xenbus_device *dev,
unsigned *grants, int npages,
- unsigned flags, void **priv, int *errno)
+ unsigned flags, void **priv)
{
struct net_accel_valloc_grant_mapping *map;
struct vm_struct *vm;
/* Do the actual mapping */
addr = vm->addr;
- if(errno != NULL) *errno = 0;
+
for (i = 0; i < npages; i++) {
rc = net_accel_map_grant(dev, grants[i], map->grant_handles + i,
addr, NULL, flags);
- if (rc != 0)
- {
- if(errno != NULL)
- *errno = (rc == GNTST_eagain ? -EAGAIN : -EINVAL);
+ if (rc < 0)
goto undo;
- }
addr = (void*)((unsigned long)addr + PAGE_SIZE);
}
unsigned *grants, int npages,
void **priv)
{
- int errno;
- void *ret;
-
- do {
- ret = net_accel_map_grants_valloc(dev, grants, npages,
- GNTMAP_host_map, priv, &errno);
- if(errno) msleep(10);
- } while(errno == -EAGAIN);
-
- return ret;
+ return net_accel_map_grants_valloc(dev, grants, npages, GNTMAP_host_map, priv);
}
EXPORT_SYMBOL(net_accel_map_grants_contig);
void *net_accel_map_iomem_page(struct xenbus_device *dev, int gnt_ref,
void **priv)
{
- int errno;
- void *ret;
-
- do {
- ret = net_accel_map_grants_valloc(dev, &gnt_ref, 1,
- GNTMAP_host_map, priv, &errno);
- if(errno) msleep(10);
- } while(errno == -EAGAIN);
-
- return ret;
+ return net_accel_map_grants_valloc(dev, &gnt_ref, 1, GNTMAP_host_map, priv);
}
EXPORT_SYMBOL(net_accel_map_iomem_page);
static int map_frontend_page(tpmif_t *tpmif, unsigned long shared_page)
{
struct gnttab_map_grant_ref op;
+ int ret;
gnttab_set_map_op(&op, (unsigned long)tpmif->tx_area->addr,
GNTMAP_host_map, shared_page, tpmif->domid);
- do {
- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
- BUG();
- msleep(10);
- } while(op.status == GNTST_eagain);
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
- if (op.status) {
- DPRINTK(" Grant table operation failure !\n");
- return op.status;
+ if (op.status != GNTST_okay) {
+ DPRINTK(" Grant table operation failure %d!\n", (int)op.status);
+ ret = -EINVAL;
+ } else {
+ tpmif->shmem_ref = shared_page;
+ tpmif->shmem_handle = op.handle;
+ ret = 0;
}
- tpmif->shmem_ref = shared_page;
- tpmif->shmem_handle = op.handle;
-
- return 0;
+ return ret;
}
static void unmap_frontend_page(tpmif_t *tpmif)
gnttab_set_map_op(&map_op, idx_to_kaddr(tpmif, i),
GNTMAP_host_map, tx->ref, tpmif->domid);
- do {
- if (unlikely(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref,
- &map_op, 1)))
- BUG();
- if(map_op.status) msleep(10);
- } while(map_op.status == GNTST_eagain);
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &map_op);
- handle = map_op.handle;
-
- if (map_op.status) {
+ if (map_op.status != GNTST_okay) {
DPRINTK(" Grant table operation failure !\n");
return 0;
}
+ handle = map_op.handle;
+
tocopy = min_t(size_t, size - offset, PAGE_SIZE);
if (copy_from_buffer((void *)(idx_to_kaddr(tpmif, i) |
gnttab_set_map_op(&map_op, idx_to_kaddr(tpmif, i),
GNTMAP_host_map, tx->ref, tpmif->domid);
- do {
- if (unlikely(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref,
- &map_op, 1)))
- BUG();
- if(map_op.status) msleep(10);
- } while(map_op.status == GNTST_eagain);
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &map_op);
- if (map_op.status) {
+ if (map_op.status != GNTST_okay) {
DPRINTK(" Grant table operation failure !\n");
return -EFAULT;
}
gnttab_set_map_op(&op, (unsigned long)usbif->urb_ring_area->addr,
GNTMAP_host_map, urb_ring_ref, usbif->domid);
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
- do {
- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
- BUG();
- msleep(10);
- } while (op.status == GNTST_eagain);
-
- if (op.status) {
- printk(KERN_ERR "grant table failure mapping urb_ring_ref\n");
- return op.status;
+ if (op.status != GNTST_okay) {
+ printk(KERN_ERR "grant table failure mapping urb_ring_ref %d\n", (int)op.status);
+ return -EINVAL;
}
usbif->urb_shmem_ref = urb_ring_ref;
gnttab_set_map_op(&op, (unsigned long)usbif->conn_ring_area->addr,
GNTMAP_host_map, conn_ring_ref, usbif->domid);
- do {
- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
- BUG();
- msleep(10);
- } while (op.status == GNTST_eagain);
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
- if (op.status) {
+ if (op.status != GNTST_okay) {
struct gnttab_unmap_grant_ref unop;
gnttab_set_unmap_op(&unop,
(unsigned long) usbif->urb_ring_area->addr,
GNTMAP_host_map, usbif->urb_shmem_handle);
VOID(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &unop,
1));
- printk(KERN_ERR "grant table failure mapping conn_ring_ref\n");
- return op.status;
+ printk(KERN_ERR "grant table failure mapping conn_ring_ref %d\n", (int)op.status);
+ return -EINVAL;
}
usbif->conn_shmem_ref = conn_ring_ref;
ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref,
map, nr_segs);
BUG_ON(ret);
- /* Make sure than none of the map ops failed with GNTST_eagain */
- for( i = 0; i < nr_segs; i++) {
- while(map[i].status == GNTST_eagain) {
- msleep(10);
- ret = HYPERVISOR_grant_table_op(
- GNTTABOP_map_grant_ref,
- &map[i], 1);
- BUG_ON(ret);
- }
- }
for (i = 0; i < nr_segs; i++) {
- if (unlikely(map[i].status != 0)) {
+ /* Make sure than none of the map ops failed with GNTST_eagain */
+ if (unlikely(map[i].status == GNTST_eagain))
+ gnttab_check_GNTST_eagain_while(GNTTABOP_map_grant_ref, &map[i]);
+
+ if (unlikely(map[i].status != GNTST_okay)) {
printk(KERN_ERR "usbback: invalid buffer -- could not remap it\n");
map[i].handle = USBBACK_INVALID_HANDLE;
ret |= 1;
gnttab_set_map_op(&op, (unsigned long)area->addr, GNTMAP_host_map,
gnt_ref, dev->otherend_id);
- do {
- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
- BUG();
- msleep(10);
- } while(op.status == GNTST_eagain);
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
if (op.status != GNTST_okay) {
free_vm_area(area);
"mapping in shared page %d from domain %d",
gnt_ref, dev->otherend_id);
BUG_ON(!IS_ERR(ERR_PTR(op.status)));
- return ERR_PTR(op.status);
+ return ERR_PTR(-EINVAL);
}
/* Stuff the handle in an unused field */
grant_handle_t *handle, void *vaddr)
{
struct gnttab_map_grant_ref op;
+ int ret;
gnttab_set_map_op(&op, (unsigned long)vaddr, GNTMAP_host_map,
gnt_ref, dev->otherend_id);
- do {
- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
- BUG();
- msleep(10);
- } while(op.status == GNTST_eagain);
+
+ gnttab_check_GNTST_eagain_do_while(GNTTABOP_map_grant_ref, &op);
if (op.status != GNTST_okay) {
xenbus_dev_fatal(dev, op.status,
"mapping in shared page %d from domain %d",
gnt_ref, dev->otherend_id);
- } else
+ ret = -EINVAL;
+ } else {
*handle = op.handle;
+ ret = 0;
+ }
- return op.status;
+ return ret;
}
EXPORT_SYMBOL_GPL(xenbus_map_ring);
"unmapping page at handle %d error %d",
(int16_t)area->phys_addr, op.status);
- return op.status;
+ return op.status == GNTST_okay ? 0 : -EINVAL;
}
EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
"unmapping page at handle %d error %d",
handle, op.status);
- return op.status;
+ return op.status == GNTST_okay ? 0 : -EINVAL;
}
EXPORT_SYMBOL_GPL(xenbus_unmap_ring);
#include <asm/hypervisor.h>
#include <asm/maddr.h> /* maddr_t */
#include <linux/mm.h>
+#include <linux/delay.h>
#include <xen/interface/grant_table.h>
#include <xen/features.h>
unmap->handle = handle;
}
+#define gnttab_check_GNTST_eagain_while(__HCop, __HCarg_p) \
+{ \
+ u8 __hc_delay = 1; \
+ int __ret; \
+ while (unlikely((__HCarg_p)->status == GNTST_eagain && __hc_delay)) { \
+ msleep(__hc_delay++); \
+ __ret = HYPERVISOR_grant_table_op(__HCop, (__HCarg_p), 1); \
+ BUG_ON(__ret); \
+ } \
+ if (__hc_delay == 0) { \
+ printk(KERN_ERR "%s: %s gnt busy\n", __func__, current->comm); \
+ (__HCarg_p)->status = GNTST_bad_page; \
+ } \
+ if ((__HCarg_p)->status != GNTST_okay) \
+ printk(KERN_ERR "%s: %s gnt status %x\n", \
+ __func__, current->comm, (__HCarg_p)->status); \
+}
+
+#define gnttab_check_GNTST_eagain_do_while(__HCop, __HCarg_p) \
+{ \
+ u8 __hc_delay = 1; \
+ int __ret; \
+ do { \
+ __ret = HYPERVISOR_grant_table_op(__HCop, (__HCarg_p), 1); \
+ BUG_ON(__ret); \
+ if ((__HCarg_p)->status == GNTST_eagain) \
+ msleep(__hc_delay++); \
+ } while ((__HCarg_p)->status == GNTST_eagain && __hc_delay); \
+ if (__hc_delay == 0) { \
+ printk(KERN_ERR "%s: %s gnt busy\n", __func__, current->comm); \
+ (__HCarg_p)->status = GNTST_bad_page; \
+ } \
+ if ((__HCarg_p)->status != GNTST_okay) \
+ printk(KERN_ERR "%s: %s gnt status %x\n", \
+ __func__, current->comm, (__HCarg_p)->status); \
+}
+
#endif /* __ASM_GNTTAB_H__ */
projects / people / royger / linux-2.6.18-xen.git / commitdiff