Hi Xuan,

kernel test robot noticed the following build warnings:

[auto build test WARNING on net-next/main]

url:    
https://github.com/intel-lab-lkp/linux/commits/Xuan-Zhuo/virtio_net-introduce-device-stats-feature-and-structures/20240227-161123
base:   net-next/main
patch link:    
https://lore.kernel.org/r/20240227080303.63894-4-xuanzhuo%40linux.alibaba.com
patch subject: [PATCH net-next v3 3/6] virtio_net: support device stats
config: x86_64-randconfig-121-20240229 
(https://download.01.org/0day-ci/archive/20240229/202402291808.cmzzaiyx-...@intel.com/config)
compiler: gcc-12 (Debian 12.2.0-14) 12.2.0
reproduce (this is a W=1 build): 
(https://download.01.org/0day-ci/archive/20240229/202402291808.cmzzaiyx-...@intel.com/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <l...@intel.com>
| Closes: 
https://lore.kernel.org/oe-kbuild-all/202402291808.cmzzaiyx-...@intel.com/

sparse warnings: (new ones prefixed by >>)
>> drivers/net/virtio_net.c:3571:57: sparse: sparse: cast to restricted __le64

vim +3571 drivers/net/virtio_net.c

  3466  
  3467  static int virtnet_get_hw_stats(struct virtnet_info *vi,
  3468                                  struct virtnet_stats_ctx *ctx)
  3469  {
  3470          struct virtio_net_ctrl_queue_stats *req;
  3471          struct virtio_net_stats_reply_hdr *hdr;
  3472          struct scatterlist sgs_in, sgs_out;
  3473          u32 num_rx, num_tx, num_cq, offset;
  3474          int qnum, i, j,  qid, res_size;
  3475          struct virtnet_stats_map *m;
  3476          void *reply, *p;
  3477          u64 bitmap;
  3478          int ok;
  3479          u64 *v;
  3480  
  3481          if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_DEVICE_STATS))
  3482                  return 0;
  3483  
  3484          qnum = 0;
  3485          if (ctx->bitmap_cq)
  3486                  qnum += 1;
  3487  
  3488          if (ctx->bitmap_rx)
  3489                  qnum += vi->curr_queue_pairs;
  3490  
  3491          if (ctx->bitmap_tx)
  3492                  qnum += vi->curr_queue_pairs;
  3493  
  3494          req = kcalloc(qnum, sizeof(*req), GFP_KERNEL);
  3495          if (!req)
  3496                  return -ENOMEM;
  3497  
  3498          res_size = (ctx->size_rx + ctx->size_tx) * vi->curr_queue_pairs 
+ ctx->size_cq;
  3499          reply = kmalloc(res_size, GFP_KERNEL);
  3500          if (!reply) {
  3501                  kfree(req);
  3502                  return -ENOMEM;
  3503          }
  3504  
  3505          j = 0;
  3506          for (i = 0; i < vi->curr_queue_pairs; ++i) {
  3507                  if (ctx->bitmap_rx) {
  3508                          req->stats[j].vq_index = cpu_to_le16(i * 2);
  3509                          req->stats[j].types_bitmap[0] = 
cpu_to_le64(ctx->bitmap_rx);
  3510                          ++j;
  3511                  }
  3512  
  3513                  if (ctx->bitmap_tx) {
  3514                          req->stats[j].vq_index = cpu_to_le16(i * 2 + 1);
  3515                          req->stats[j].types_bitmap[0] = 
cpu_to_le64(ctx->bitmap_tx);
  3516                          ++j;
  3517                  }
  3518          }
  3519  
  3520          if (ctx->size_cq) {
  3521                  req->stats[j].vq_index = 
cpu_to_le16(vi->max_queue_pairs * 2);
  3522                  req->stats[j].types_bitmap[0] = 
cpu_to_le64(ctx->bitmap_cq);
  3523                  ++j;
  3524          }
  3525  
  3526          sg_init_one(&sgs_out, req, sizeof(*req) * j);
  3527          sg_init_one(&sgs_in, reply, res_size);
  3528  
  3529          ok = virtnet_send_command(vi, VIRTIO_NET_CTRL_STATS,
  3530                                    VIRTIO_NET_CTRL_STATS_GET,
  3531                                    &sgs_out, &sgs_in);
  3532          kfree(req);
  3533  
  3534          if (!ok) {
  3535                  kfree(reply);
  3536                  return ok;
  3537          }
  3538  
  3539          num_rx = VIRTNET_RQ_STATS_LEN + ctx->num_rx;
  3540          num_tx = VIRTNET_SQ_STATS_LEN + ctx->num_tx;
  3541          num_cq = ctx->num_tx;
  3542  
  3543          for (p = reply; p - reply < res_size; p += 
le16_to_cpu(hdr->size)) {
  3544                  hdr = p;
  3545  
  3546                  qid = le16_to_cpu(hdr->vq_index);
  3547  
  3548                  if (qid == vi->max_queue_pairs * 2) {
  3549                          offset = 0;
  3550                          bitmap = ctx->bitmap_cq;
  3551                  } else if (qid % 2) {
  3552                          offset = num_cq + num_rx * vi->curr_queue_pairs 
+ num_tx * (qid / 2);
  3553                          offset += VIRTNET_SQ_STATS_LEN;
  3554                          bitmap = ctx->bitmap_tx;
  3555                  } else {
  3556                          offset = num_cq + num_rx * (qid / 2) + 
VIRTNET_RQ_STATS_LEN;
  3557                          bitmap = ctx->bitmap_rx;
  3558                  }
  3559  
  3560                  for (i = 0; i < ARRAY_SIZE(virtio_net_stats_map); ++i) {
  3561                          m = &virtio_net_stats_map[i];
  3562  
  3563                          if (m->stat_type & bitmap)
  3564                                  offset += m->num;
  3565  
  3566                          if (hdr->type != m->reply_type)
  3567                                  continue;
  3568  
  3569                          for (j = 0; j < m->num; ++j) {
  3570                                  v = p + m->desc[j].offset;
> 3571                                  ctx->data[offset + j] = le64_to_cpu(*v);
  3572                          }
  3573  
  3574                          break;
  3575                  }
  3576          }
  3577  
  3578          kfree(reply);
  3579          return 0;
  3580  }
  3581  

-- 
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki

Reply via email to