Hi Mateusz,

kernel test robot noticed the following build errors:

[auto build test ERROR on a77c49f53be0af1efad5b4541a9a145505c81800]

url:    
https://github.com/intel-lab-lkp/linux/commits/Mateusz-Polchlopek/virtchnl-add-support-for-enabling-PTP-on-iAVF/20241014-174710
base:   a77c49f53be0af1efad5b4541a9a145505c81800
patch link:    
https://lore.kernel.org/r/20241013154415.20262-10-mateusz.polchlopek%40intel.com
patch subject: [Intel-wired-lan] [PATCH iwl-next v11 09/14] libeth: move 
idpf_rx_csum_decoded and idpf_rx_extracted
config: alpha-allyesconfig 
(https://download.01.org/0day-ci/archive/20241016/202410160029.bdxyuzwz-...@intel.com/config)
compiler: alpha-linux-gcc (GCC) 13.3.0
reproduce (this is a W=1 build): 
(https://download.01.org/0day-ci/archive/20241016/202410160029.bdxyuzwz-...@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/202410160029.bdxyuzwz-...@intel.com/

All errors (new ones prefixed by >>):

   drivers/net/ethernet/intel/idpf/idpf_singleq_txrx.c: In function 
'idpf_rx_singleq_clean':
>> drivers/net/ethernet/intel/idpf/idpf_singleq_txrx.c:1040:78: error: expected 
>> ';' before 'napi_gro_receive'
    1040 |                 idpf_rx_singleq_process_skb_fields(rx_q, skb, 
rx_desc, ptype)
         |                                                                      
        ^
         |                                                                      
        ;
   ......
    1043 |                 napi_gro_receive(rx_q->pp->p.napi, skb);
         |                 ~~~~~~~~~~~~~~~~                                     
         


vim +1040 drivers/net/ethernet/intel/idpf/idpf_singleq_txrx.c

   954  
   955  /**
   956   * idpf_rx_singleq_clean - Reclaim resources after receive completes
   957   * @rx_q: rx queue to clean
   958   * @budget: Total limit on number of packets to process
   959   *
   960   * Returns true if there's any budget left (e.g. the clean is finished)
   961   */
   962  static int idpf_rx_singleq_clean(struct idpf_rx_queue *rx_q, int budget)
   963  {
   964          unsigned int total_rx_bytes = 0, total_rx_pkts = 0;
   965          struct sk_buff *skb = rx_q->skb;
   966          u16 ntc = rx_q->next_to_clean;
   967          u16 cleaned_count = 0;
   968          bool failure = false;
   969  
   970          /* Process Rx packets bounded by budget */
   971          while (likely(total_rx_pkts < (unsigned int)budget)) {
   972                  struct libeth_rqe_info fields = { };
   973                  union virtchnl2_rx_desc *rx_desc;
   974                  struct idpf_rx_buf *rx_buf;
   975                  u32 ptype;
   976  
   977                  /* get the Rx desc from Rx queue based on 
'next_to_clean' */
   978                  rx_desc = &rx_q->rx[ntc];
   979  
   980                  /* status_error_ptype_len will always be zero for unused
   981                   * descriptors because it's cleared in cleanup, and 
overlaps
   982                   * with hdr_addr which is always zero because packet 
split
   983                   * isn't used, if the hardware wrote DD then the length 
will be
   984                   * non-zero
   985                   */
   986  #define IDPF_RXD_DD VIRTCHNL2_RX_BASE_DESC_STATUS_DD_M
   987                  if (!idpf_rx_singleq_test_staterr(rx_desc,
   988                                                    IDPF_RXD_DD))
   989                          break;
   990  
   991                  /* This memory barrier is needed to keep us from reading
   992                   * any other fields out of the rx_desc
   993                   */
   994                  dma_rmb();
   995  
   996                  idpf_rx_singleq_extract_fields(rx_q, rx_desc, &fields, 
&ptype);
   997  
   998                  rx_buf = &rx_q->rx_buf[ntc];
   999                  if (!libeth_rx_sync_for_cpu(rx_buf, fields.len))
  1000                          goto skip_data;
  1001  
  1002                  if (skb)
  1003                          idpf_rx_add_frag(rx_buf, skb, fields.len);
  1004                  else
  1005                          skb = idpf_rx_build_skb(rx_buf, fields.len);
  1006  
  1007                  /* exit if we failed to retrieve a buffer */
  1008                  if (!skb)
  1009                          break;
  1010  
  1011  skip_data:
  1012                  rx_buf->page = NULL;
  1013  
  1014                  IDPF_SINGLEQ_BUMP_RING_IDX(rx_q, ntc);
  1015                  cleaned_count++;
  1016  
  1017                  /* skip if it is non EOP desc */
  1018                  if (idpf_rx_singleq_is_non_eop(rx_desc) || 
unlikely(!skb))
  1019                          continue;
  1020  
  1021  #define IDPF_RXD_ERR_S FIELD_PREP(VIRTCHNL2_RX_BASE_DESC_QW1_ERROR_M, \
  1022                                    VIRTCHNL2_RX_BASE_DESC_ERROR_RXE_M)
  1023                  if (unlikely(idpf_rx_singleq_test_staterr(rx_desc,
  1024                                                            
IDPF_RXD_ERR_S))) {
  1025                          dev_kfree_skb_any(skb);
  1026                          skb = NULL;
  1027                          continue;
  1028                  }
  1029  
  1030                  /* pad skb if needed (to make valid ethernet frame) */
  1031                  if (eth_skb_pad(skb)) {
  1032                          skb = NULL;
  1033                          continue;
  1034                  }
  1035  
  1036                  /* probably a little skewed due to removing CRC */
  1037                  total_rx_bytes += skb->len;
  1038  
  1039                  /* protocol */
> 1040                  idpf_rx_singleq_process_skb_fields(rx_q, skb, rx_desc, 
> ptype)
  1041  
  1042                  /* send completed skb up the stack */
  1043                  napi_gro_receive(rx_q->pp->p.napi, skb);
  1044                  skb = NULL;
  1045  
  1046                  /* update budget accounting */
  1047                  total_rx_pkts++;
  1048          }
  1049  
  1050          rx_q->skb = skb;
  1051  
  1052          rx_q->next_to_clean = ntc;
  1053  
  1054          page_pool_nid_changed(rx_q->pp, numa_mem_id());
  1055          if (cleaned_count)
  1056                  failure = idpf_rx_singleq_buf_hw_alloc_all(rx_q, 
cleaned_count);
  1057  
  1058          u64_stats_update_begin(&rx_q->stats_sync);
  1059          u64_stats_add(&rx_q->q_stats.packets, total_rx_pkts);
  1060          u64_stats_add(&rx_q->q_stats.bytes, total_rx_bytes);
  1061          u64_stats_update_end(&rx_q->stats_sync);
  1062  
  1063          /* guarantee a trip back through this routine if there was a 
failure */
  1064          return failure ? budget : (int)total_rx_pkts;
  1065  }
  1066  

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

Reply via email to