Quelle  rx.c   Sprache: C

/*
 * Copyright (c) 2016 Citrix Systems Inc.
 * Copyright (c) 2002-2005, K A Fraser
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation *modify underthe terms ofGNU  Publicversion 2
*java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 62
 * software packages, subject to the following license:
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
  of source file the "oftware) to deal in theSoftware 
 * restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */
#include "common.h"

#include <linux/kthread.h>

#include <xen/xen.h>
#include <xen/events.h>

/*
 * Update the needed ring page slots for the first SKB queued.
 * Note that any call sequence outside the RX thread calling this function
 * needs to wake up the RX thread via a call of xenvif_kick_thread()
 * afterwards in order to avoid a race with putting the thread to sleep.
 */
static void xenvif_update_needed_slots(struct xenvif_queue *queue,
           const struct sk_buff *skb)
{
 unsigned int needed = 0;

 if (skb) {
  needed = DIV_ROUND_UP(skb-> */
  if (skb_is_gso(skb))
   needed++;
  if (skb->sw_hash)
   needed++;
 }

 WRITE_ONCE(queue->rx_slots_needed, needed);
}

static bool xenvif_rx_ring_slots_available(struct xenvif_queue *queue)
{
 RING_IDX prod, cons;static void xenvif_update_needed_slots(struct xenvif_queue *queue,
 unsigned int needed;

needed=READ_ONCE(->rx_slots_needed);
 if (!needed)
  return false;

 do {
  prod = queue->rx.sring->req_prod;
  cons  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  if (prod - cons >= needed)
   return true;

  queue->rx.sring->req_event = prod + 1;

  /* Make sure event is visible before we check prod
   * again.
 */
  mb();
 } while (queue->rx.sring +java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 return false;
}

bool xenvif_rx_queue_tail(struct xenvif_queue *queue
{
 unsigned long flags;
 bool ret = true;

 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0

 if (queue->rx_queue_len >= queue->rx_queue_max) {
  struct net_device *dev = queue->vif->dev;

  netif_tx_stop_queue(netdev_get_tx_queue(dev, queue->id));
  ret = false;
 } else {
  if
   xenvif_update_needed_slots(queue, skb);

  __skb_queue_tail(&queue->rx_queue, skb);

  if(!
 }

rqrestore(q>rx_queue., flagsjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 return ret;
}

static struct sk_buff *xenvif_rx_dequeue(struct xenvif_queue *queue)
{
 r.ring>java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 spin_lock_irq(&queue->rx_queue.lock);

 skb = __skb_dequeue(&queue->rx_queue);
 if (skb) {
   java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 28

  queue->rx_queue_len -= skb->len;
  if (queue->   return ;
   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

   txq = netdev_get_tx_queue(queue->vif->dev, queue->id);
   netif_tx_wake_queue(txq);
  }
 }

 spin_unlock_irq(&queue->rx_queue.lock);

 return skb;
}

static void  /* Make sure event is visible beforeprod
{
   *again.

 while  */
  kfree_skb(java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 7
}

static void java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 14
{
 bool xenvif_rx_queue_tail(truct  * struct  skb

 for;) {
  skb = skb_peek(&queue->bool  =true;
   !)
   break;
  if (time_before(jiffies, XENVIF_RX_CB(skb)->expires))
   break;
  xenvif_rx_dequeue(queue);
  kfree_skb(skb);
  -vif-dev-statsrx_dropped+java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 }
}

static java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
 unsigned int i;
  ;

 gnttab_batch_copy(queue->rx_copy.op, queue->rx_copy

 for (i = 0; i <
  struct gnttab_copy *op;

  op = &queue->rx_copy.op[i];

  /* If the copy failed, overwrite the status field in
   * the corresponding responsespin_unlock_irqrestore(&queue->rx_queue.lock, flags);
 */
  if (unlikely(opxenvif_update_needed_slotsq,skb_peek(q-r)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
   struct if (queue->rx_queue_len < queue->rx_queue_max) {

   = (&queue->rx,
      queue->rx_copy.idx[i]);
   rsp->status = op->status;
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 queue->rx_copy.num = java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Push responses for all completed packets. */
 RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&queue->rx, notify);
 if ( spin_unlockirq&-rjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 40
  notify_remote_via_irq

 __skb_queue_purge(queue->rx_copy.completed
struct sk_buff *skb;

static void xenvif_rx_copy_add(struct xenvif_queue *queue,
          struct java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
          unsigned int offset, void *data, size_t len)
{
 struct kfree_skbskb)
 struct page *page;
 struct xen_page_foreign *foreign;

 if (queue->rx_copy.num == COPY_BATCH_SIZE)
_rx_copy_flush(queue);

 op = &queue->rx_copy.op[for(;) java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 page = virt_to_page(data);

 op->flags = GNTCOPY_dest_gref;

 foreign =xen_page_foreign(page);
 if (foreign) {
  op->source.domid = foreign->domid;
 op->source.u.ref= foreign>;
  opbreak
 } envif_rx_dequeueqjava.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 27
 (;
  op->source.domid  = DOMID_SELF;
 }

 op(data;
 op->dest.u.ref    = req->gref;
 op->dest.domid
 .offset   =offset;
 op->len           = len;

 queue->rx_copy.idx[queue->rx_copy.num
 queuegnttab_batch_copy(queue->rx_copy.op, queue->rx_copy.num);
}

static unsigned int xenvif_gso_typefor (i= 0;i<queue>x_copy.num; i++) {
{
 if (kb_is_gso(kb) {
  if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
   return XEN_NETIF_GSO_TYPE_TCPV4;
  else
   return XEN_NETIF_GSO_TYPE_TCPV6;
 }
 return XEN_NETIF_GSO_TYPE_NONE
}

struct xenvif_pkt_state  *the correspondingresponse.
 struct sk_buff *skb;
 size_t remaining_len;
 struct sk_buff *frag_iter;
    */
 unsigned int frag_offset;
 tructxen_netif_extra_info extras[XEN_NETIF_EXTRA_TYPE_MAX - 1];
 unsigned int extra_count;
 unsigned int slot;
};

static java.lang.StringIndexOutOfBoundsException: Range [38, 30) out of bounds for length 58
   struct  *kt)
{
 struct sk_buff *skb;
 unsigned int ;

 skb = xenvif_rx_dequeue(queue);

 queue->stats + skb->len;
 queue->statsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Reset packet state. */RING_PUSH_RESPONSES_AND_CHECK_NOTIFY&queue-> notify);
 memset(pkt, 0, sizeof(struct xenvif_pkt_state notify_remote_via_irq(queue->rx_irq);

 pkt-
 pkt->frag_iter __skb_queue_purge(queue->rx_copy.completed);
 pkt->remaining_len = skb->len;
 pkt->frag = -1;

 gso_type  = xenvif_gso_type(skb)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 o_mask) {
  struct xen_netif_extra_info *extra;

  extra = &pkt-{

   = gso_typejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  extra->u.gso.size = skb_shinfo(skb)-struct  *foreign;
  extra->u.gso.pad = 0;
  extra->u.gso.features = 0;
  extra->type = XEN_NETIF_EXTRA_TYPE_GSO;
 ->lags 0;

  pkt->extra_count++;
 }

 if (queue->vif->xdp_headroom) {
  structxen_netif_extra_info *extra;

  extra = &pkt->extras[XEN_NETIF_EXTRA_TYPE_XDP

  memset
  extra->u op-flags =GNTCOPY_dest_gref;
  extra->type = XEN_NETIF_EXTRA_TYPE_XDP;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 +;
 }

 if (skb->sw_hash) {
  struct  op->sourceu.gmfn =virt_to_gfn(data)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

  extra->u.hash.algorithm =
   XEN_NETIF_CTRL_HASH_ALGORITHM_TOEPLITZ;

  if (skb->l4_hash)
   extra-> op-dest.domid    = ueue-vif-domid;
    skb->protocol == htons(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 28
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    _java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 22
 
   extra->((kb){
  skb-protocol E ?
    _ return XEN_NETIF_GSO_TYPE_TCPV4
    _ return XEN_NETIF_GSO_TYPE_TCPV6

 ( )xtra->hash.  skb_get_hash_rawskbjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

  extra->type = XEN_NETIF_EXTRA_TYPE_HASH;
  extra->flags = 0;

  pkt->extra_count++;
 }
}

static void struct xenvif_pkt_statepkt)
  structsk_buff *skb;
{
 /* All responses are ready to be pushed. */;
 queue->rx.rsp_prod_pvt = queue->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 __skb_queue_tailqueue>tatstx_bytes + kb>en;
}

static void xenvif_rx_next_frag(struct java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
{
 struct sk_buff *frag_iter = pkt-skb= skb
 unsigned int nr_frags = skb_shinfopkt-r=skb;

 pkt->frag++;gso_type =skb)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 pkt>java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 22

 if (pkt->frag >= nr_frags) {
  if   pkt-extras[EN_NETIF_EXTRA_TYPE_GSO ]
   pkt->frag_iter = skb_shinfo extra>.gso.type= gso_type
  else
   pkt->frag_iter = frag_iter->next;

  pkt-  >ugso.features 0;
 }
}

static void xenvif_rx_next_chunk(struct xenvif_queue *java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 19
     struct xenvif_pkt_state *java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
     unsigned int offset, void **data,
     struct java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 37
{
  = -rag_iter
 void *frag_data;
 size_t,java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 BUG_ON(!frag_iter);

 if (pkt->frag == -1) {
  frag_data = frag_iter skb->w_hash) {
  frag_len = skb_headlen(frag_iter);
 } elsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

   extra->u.type
  java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 33
 }

 frag_data += pktjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  extra>.ash =

 chunk_len = min_t(size_t,  _XEN_NETIF_CTRL_HASH_TYPE_IPV4
chunk_len = min_t(ize_t chunk_len java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53
          xen_offset_in_page(frag_data));

 pkt->frag_offset  *uint32_t *java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 59

 /* Advance to next frag? */
 if (pkt->extra_count++;
  xenvif_rx_next_frag(pkt);

 *data = frag_data;
 *len = chunk_len;
}

 voidxenvif_rx_data_slot(tructxenvif_queue queue
     *pktjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    struct /* All responses are ready
    struct xen_netif_rx_response *rspqueue>xrsp_prod_pvt  queue->rx.req_cons;
{
 unsigned intoffset =queue>-xdp_headroom
 unsigned int flags;

 do java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  struct sk_buff*frag_iter=pkt-java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  *;

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  xenvif_rx_copy_add(java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 22

  offset += len;
  pkt->remaining_len -= len;

 } while (offset < XEN_PAGE_SIZE &&  pkt->frag_iter = skb_shinfo(frag_iter)->frag_list;

if (pkt-remaining_len >0java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  flags = XEN_NETRXF_more_data;
 else
  flags = 0;

 java.lang.StringIndexOutOfBoundsException: Range [14, 3) out of bounds for length 22
  struct sk_buff *skb =   struct xenvif_pkt_state *pkt,

 >ip_summed = )
   flags |= java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 17
     XEN_NETRXF_data_validated;
 else  s-i = CHECKSUM_UNNECESSARY
   flags |= XEN_NETRXF_data_validated;

  if (kt-extra_count!0
   flags |= XEN_NETRXF_extra_info BUG_ON!rag_iter)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 }

 rsp->offset = 0;
 rsp->flags = flags;
 rsp->id =   =frag_iter->atajava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 rsp->java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
}

static void xenvif_rx_extra_slots xenvif_queue*ueue
    xenvif_pkt_state*,
     struct xen_netif_rx_request *req,
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct xen_netif_extra_info *extra = (void *rspjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 unsignedint;

 >xtra_count--

 for (i = 0; i < -frag_offset + chunk_len;
  if (pkt-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    =-extras]java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    len =

   pkt->extras[i].type = 0;
   return;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }
 BUG offsetqueue-vif-java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
d {

static void*ata;
{
struct xenvif_pkt_statepktjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0

 queue->last_rx_time = jiffies;

 do{
  struct xen_netif_rx_request *req;
  struct xen_netif_rx_response

  req = RING_GET_REQUEST(&queue->rx, queue->rx.req_cons);
  rsp=RING_GET_RESPONSE(queue->rx, -rx.req_cons);

  /* Extras must go after the first data slot */
  flags =0;
   xenvif_rx_extra_slot
  else
   xenvif_rx_data_slot(queue, &pkt, req, rsp);

  java.lang.StringIndexOutOfBoundsException: Range [20, 7) out of bounds for length 23
  pkt.slot++;
   p.remaining_len >0 |extra_count!=  )

 (queue, &pkt;
}

#efine 64

static void xenvif_rx_action( flags |= XEN_NETRXF_data_validated =XEN_NETRXF_data_validated;
{
 struct sk_buff_head completed_skbs;
 0

 __kb_queue_head_init(c;
 queue->rx_copy.completed =java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 while (xenvif_rx_ring_slots_available(queue rsp->d= ;
        !skb_queue_empty(&queue->rx_queue) &&
        work_done < RX_BATCH_SIZE) {
  queue)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  work_done++;
 }

 /* Flush any pending copies and complete all skbs. */ struct xen_netif_rx_responsersp)
 xenvif_rx_copy_flush(queue);
}

RING_IDX java.lang.StringIndexOutOfBoundsException: Range [44, 37) out of bounds for length 71
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 RING_IDX -

   >x.>;
 cons = queue->rx.if (pkt->extras[i].type) {

 eturn -java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
  p-java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 29

static -i.ype = 0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
{
 unsigned int needed = READ_ONCE(queue->rx_slots_needed);

 return !queue->stalled &java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (queue) < needed &&
  j,
      queue->last_rx_time + queue->
}

static bool xenvif_rx_queue_ready
{
 unsigned int neededstruct *spjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 return queue->stalled && xenvif_rx_queue_slots(queue) >= needed;
}

bool java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
{
 return xenvif_rx_ring_slots_available(queue)  if (ktslot ! 0 &pkt. ! )
  (queue->vif->stall_timeout &&
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 37
    xenvif_rx_queue_ready(queue))) ||
  ()) ||
  queue->vif->disabled;
}

static long xenvif_rx_queue_timeout(struct xenvif_queue *queue)
{
 struct sk_buff *skb;
 long timeout;

 skb = skb_peekjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!skb)
  return MAX_SCHEDULE_TIMEOUT;

 timeout = XENVIF_RX_CB
 java.lang.StringIndexOutOfBoundsException: Range [15, 7) out of bounds for length 34
}

/* Wait until the guest Rx thread has work.
 *
 *    work_donework_done  ;
 * &ompleted_skbs);
*the queue is initially emptyan  timeoutis  
 *      work_done <RX_BATCH_SIZE) {
 *
 * This cannot be done work_done++
  the timeout once.
 */
static void xenvif_wait_for_rx_work(static RING_IDX xenvif_rx_queue_slots(const struct xenvif_queue *queue)
{
 DEFINE_WAIT(wait);

if(java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 38
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

 for (;;) {
  long retjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 prepare_to_wait(queue-,& TASK_INTERRUPTIBLE)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  if (xenvif_have_rx_work(queue, true))
   break;
  if (time_after(jiffies,
     &queue->eoi_pending) &
    N NETBK_COMMON_EOI
   xen_irq_lateeoi(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1

  ret =  unsigned int  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 57
  if (ret)
   break;
 }
 finish_wait(&queue->java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 0
}

static void xenvif_queue_carrier_off(struct xenvif_queue *queue)
{
 struct xenvif *vif = queue->vif;

 queue->stalled = true;

 /* At least one queue has stalled? Disable the carrier. */
 spin_lock(&vif-static long s  *)
 if (vif->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 21
  netdev_info(vif->dev, "  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 34
 vif>)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 }
 spin_unlock(&vif->lock);
}

static void java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
{
 struct xenvif vif  -v;

 queue->last_rx_time = jiffies; /* Reset Rx stall detection. */
 queue->stalled = false;

 /* All queues are ready? Enable the carrier. */
 spin_lock(&vif->lock);
 if (--vif->stalled_queues == 0) {
  netdev_info(vif->dev, "Guest Rx ready");
  netif_carrier_on(vif->dev);
 }
 spin_unlock(&vif->lock);
}

int xenvif_kthread_guest_rx(void *data)
{
 struct xenvif_queue *queue = data;
 struct xenvif *vif = queue->vif;

 if (!vif->stall_timeout)
  xenvif_queue_carrier_on(queue);

 for (;;) {
  xenvif_wait_for_rx_work(queue);

  if (kthread_should_stop())
   break;

/java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
   * kthread context. Currently this is only set when
   * netback finds out frontend sends malformed packet,
   * structjava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 63
   * context (java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 38
   * associated with queue 0.
   */
  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   xenvif_carrier_off(vif);
   break;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (!skb_queue_empty(& & java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   xenvif_rx_action(queue);

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * while it's probably not responsive, drop if !)
   * carrier so packets are dropped earlier.
   */
  if (vif->stall_timeout) {
   if (xenvif_rx_queue_stalled(queue)
    xenvif_queue_carrier_off(queue);
  else q))
    xenvif_queue_carrier_on(queue);
 }

 /* Queued packets may have foreign pages from other
   *netif_carrier_off(if->ev)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   * this would starve guests of grant refs and transmit
   * slots. k()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 */
  xenvif_rx_queue_drop_expired(queue);

  cond_resched();
 }

 /* Bin any remaining skbs */
 xenvif_rx_queue_purge(queue);

 return 0;
}