tree:   https://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git 
master
head:   7e1ecbcf79b2fdc7349da1bb90d6dadad1f9ac89
commit: 43e665287f931a167cd2eea3387efda901bff0ce [905/906] net-next: dsa: fix 
flow dissection
config: x86_64-acpi-redef (attached as .config)
compiler: gcc-6 (Debian 6.2.0-3) 6.2.0 20160901
reproduce:
        git checkout 43e665287f931a167cd2eea3387efda901bff0ce
        # save the attached .config to linux build tree
        make ARCH=x86_64 

All errors (new ones prefixed by >>):

   net/core/flow_dissector.c: In function '__skb_flow_dissect':
>> net/core/flow_dissector.c:448:18: error: 'struct net_device' has no member 
>> named 'dsa_ptr'; did you mean 'dn_ptr'?
       ops = skb->dev->dsa_ptr->tag_ops;
                     ^~

vim +448 net/core/flow_dissector.c

   404  
   405  /**
   406   * __skb_flow_dissect - extract the flow_keys struct and return it
   407   * @skb: sk_buff to extract the flow from, can be NULL if the rest are 
specified
   408   * @flow_dissector: list of keys to dissect
   409   * @target_container: target structure to put dissected values into
   410   * @data: raw buffer pointer to the packet, if NULL use skb->data
   411   * @proto: protocol for which to get the flow, if @data is NULL use 
skb->protocol
   412   * @nhoff: network header offset, if @data is NULL use 
skb_network_offset(skb)
   413   * @hlen: packet header length, if @data is NULL use skb_headlen(skb)
   414   *
   415   * The function will try to retrieve individual keys into target 
specified
   416   * by flow_dissector from either the skbuff or a raw buffer specified 
by the
   417   * rest parameters.
   418   *
   419   * Caller must take care of zeroing target container memory.
   420   */
   421  bool __skb_flow_dissect(const struct sk_buff *skb,
   422                          struct flow_dissector *flow_dissector,
   423                          void *target_container,
   424                          void *data, __be16 proto, int nhoff, int hlen,
   425                          unsigned int flags)
   426  {
   427          struct flow_dissector_key_control *key_control;
   428          struct flow_dissector_key_basic *key_basic;
   429          struct flow_dissector_key_addrs *key_addrs;
   430          struct flow_dissector_key_ports *key_ports;
   431          struct flow_dissector_key_icmp *key_icmp;
   432          struct flow_dissector_key_tags *key_tags;
   433          struct flow_dissector_key_vlan *key_vlan;
   434          bool skip_vlan = false;
   435          u8 ip_proto = 0;
   436          bool ret;
   437  
   438          if (!data) {
   439                  data = skb->data;
   440                  proto = skb_vlan_tag_present(skb) ?
   441                           skb->vlan_proto : skb->protocol;
   442                  nhoff = skb_network_offset(skb);
   443                  hlen = skb_headlen(skb);
   444                  if (unlikely(netdev_uses_dsa(skb->dev))) {
   445                          const struct dsa_device_ops *ops;
   446                          int offset;
   447  
 > 448                          ops = skb->dev->dsa_ptr->tag_ops;
   449                          if (ops->flow_dissect &&
   450                              !ops->flow_dissect(skb, &proto, &offset)) {
   451                                  hlen -= offset;
   452                                  nhoff += offset;
   453                          }
   454                  }
   455          }
   456  
   457          /* It is ensured by skb_flow_dissector_init() that control key 
will
   458           * be always present.
   459           */
   460          key_control = skb_flow_dissector_target(flow_dissector,
   461                                                  
FLOW_DISSECTOR_KEY_CONTROL,
   462                                                  target_container);
   463  
   464          /* It is ensured by skb_flow_dissector_init() that basic key 
will
   465           * be always present.
   466           */
   467          key_basic = skb_flow_dissector_target(flow_dissector,
   468                                                FLOW_DISSECTOR_KEY_BASIC,
   469                                                target_container);
   470  
   471          if (dissector_uses_key(flow_dissector,
   472                                 FLOW_DISSECTOR_KEY_ETH_ADDRS)) {
   473                  struct ethhdr *eth = eth_hdr(skb);
   474                  struct flow_dissector_key_eth_addrs *key_eth_addrs;
   475  
   476                  key_eth_addrs = 
skb_flow_dissector_target(flow_dissector,
   477                                                            
FLOW_DISSECTOR_KEY_ETH_ADDRS,
   478                                                            
target_container);
   479                  memcpy(key_eth_addrs, &eth->h_dest, 
sizeof(*key_eth_addrs));
   480          }
   481  
   482  proto_again:
   483          switch (proto) {
   484          case htons(ETH_P_IP): {
   485                  const struct iphdr *iph;
   486                  struct iphdr _iph;
   487  ip:
   488                  iph = __skb_header_pointer(skb, nhoff, sizeof(_iph), 
data, hlen, &_iph);
   489                  if (!iph || iph->ihl < 5)
   490                          goto out_bad;
   491                  nhoff += iph->ihl * 4;
   492  
   493                  ip_proto = iph->protocol;
   494  
   495                  if (dissector_uses_key(flow_dissector,
   496                                         FLOW_DISSECTOR_KEY_IPV4_ADDRS)) {
   497                          key_addrs = 
skb_flow_dissector_target(flow_dissector,
   498                                                                
FLOW_DISSECTOR_KEY_IPV4_ADDRS,
   499                                                                
target_container);
   500  
   501                          memcpy(&key_addrs->v4addrs, &iph->saddr,
   502                                 sizeof(key_addrs->v4addrs));
   503                          key_control->addr_type = 
FLOW_DISSECTOR_KEY_IPV4_ADDRS;
   504                  }
   505  
   506                  if (ip_is_fragment(iph)) {
   507                          key_control->flags |= FLOW_DIS_IS_FRAGMENT;
   508  
   509                          if (iph->frag_off & htons(IP_OFFSET)) {
   510                                  goto out_good;
   511                          } else {
   512                                  key_control->flags |= 
FLOW_DIS_FIRST_FRAG;
   513                                  if (!(flags & 
FLOW_DISSECTOR_F_PARSE_1ST_FRAG))
   514                                          goto out_good;
   515                          }
   516                  }
   517  
   518                  __skb_flow_dissect_ipv4(skb, flow_dissector,
   519                                          target_container, data, iph);
   520  
   521                  if (flags & FLOW_DISSECTOR_F_STOP_AT_L3)
   522                          goto out_good;
   523  
   524                  break;
   525          }
   526          case htons(ETH_P_IPV6): {
   527                  const struct ipv6hdr *iph;
   528                  struct ipv6hdr _iph;
   529  
   530  ipv6:
   531                  iph = __skb_header_pointer(skb, nhoff, sizeof(_iph), 
data, hlen, &_iph);
   532                  if (!iph)
   533                          goto out_bad;
   534  
   535                  ip_proto = iph->nexthdr;
   536                  nhoff += sizeof(struct ipv6hdr);
   537  
   538                  if (dissector_uses_key(flow_dissector,
   539                                         FLOW_DISSECTOR_KEY_IPV6_ADDRS)) {
   540                          key_addrs = 
skb_flow_dissector_target(flow_dissector,
   541                                                                
FLOW_DISSECTOR_KEY_IPV6_ADDRS,
   542                                                                
target_container);
   543  
   544                          memcpy(&key_addrs->v6addrs, &iph->saddr,
   545                                 sizeof(key_addrs->v6addrs));
   546                          key_control->addr_type = 
FLOW_DISSECTOR_KEY_IPV6_ADDRS;
   547                  }
   548  
   549                  if ((dissector_uses_key(flow_dissector,
   550                                          FLOW_DISSECTOR_KEY_FLOW_LABEL) 
||
   551                       (flags & FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL)) &&
   552                      ip6_flowlabel(iph)) {
   553                          __be32 flow_label = ip6_flowlabel(iph);
   554  
   555                          if (dissector_uses_key(flow_dissector,
   556                                                 
FLOW_DISSECTOR_KEY_FLOW_LABEL)) {
   557                                  key_tags = 
skb_flow_dissector_target(flow_dissector,
   558                                                                       
FLOW_DISSECTOR_KEY_FLOW_LABEL,
   559                                                                       
target_container);
   560                                  key_tags->flow_label = 
ntohl(flow_label);
   561                          }
   562                          if (flags & FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL)
   563                                  goto out_good;
   564                  }
   565  
   566                  __skb_flow_dissect_ipv6(skb, flow_dissector,
   567                                          target_container, data, iph);
   568  
   569                  if (flags & FLOW_DISSECTOR_F_STOP_AT_L3)
   570                          goto out_good;
   571  
   572                  break;
   573          }
   574          case htons(ETH_P_8021AD):
   575          case htons(ETH_P_8021Q): {
   576                  const struct vlan_hdr *vlan;
   577                  struct vlan_hdr _vlan;
   578                  bool vlan_tag_present = skb && 
skb_vlan_tag_present(skb);
   579  
   580                  if (vlan_tag_present)
   581                          proto = skb->protocol;
   582  
   583                  if (!vlan_tag_present || eth_type_vlan(skb->protocol)) {
   584                          vlan = __skb_header_pointer(skb, nhoff, 
sizeof(_vlan),
   585                                                      data, hlen, &_vlan);
   586                          if (!vlan)
   587                                  goto out_bad;
   588                          proto = vlan->h_vlan_encapsulated_proto;
   589                          nhoff += sizeof(*vlan);
   590                          if (skip_vlan)
   591                                  goto proto_again;
   592                  }
   593  
   594                  skip_vlan = true;
   595                  if (dissector_uses_key(flow_dissector,
   596                                         FLOW_DISSECTOR_KEY_VLAN)) {
   597                          key_vlan = 
skb_flow_dissector_target(flow_dissector,
   598                                                               
FLOW_DISSECTOR_KEY_VLAN,
   599                                                               
target_container);
   600  
   601                          if (vlan_tag_present) {
   602                                  key_vlan->vlan_id = 
skb_vlan_tag_get_id(skb);
   603                                  key_vlan->vlan_priority =
   604                                          (skb_vlan_tag_get_prio(skb) >> 
VLAN_PRIO_SHIFT);
   605                          } else {
   606                                  key_vlan->vlan_id = 
ntohs(vlan->h_vlan_TCI) &
   607                                          VLAN_VID_MASK;
   608                                  key_vlan->vlan_priority =
   609                                          (ntohs(vlan->h_vlan_TCI) &
   610                                           VLAN_PRIO_MASK) >> 
VLAN_PRIO_SHIFT;
   611                          }
   612                  }
   613  
   614                  goto proto_again;
   615          }
   616          case htons(ETH_P_PPP_SES): {
   617                  struct {
   618                          struct pppoe_hdr hdr;
   619                          __be16 proto;
   620                  } *hdr, _hdr;
   621                  hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), 
data, hlen, &_hdr);
   622                  if (!hdr)
   623                          goto out_bad;
   624                  proto = hdr->proto;
   625                  nhoff += PPPOE_SES_HLEN;
   626                  switch (proto) {
   627                  case htons(PPP_IP):
   628                          goto ip;
   629                  case htons(PPP_IPV6):
   630                          goto ipv6;
   631                  default:
   632                          goto out_bad;
   633                  }
   634          }
   635          case htons(ETH_P_TIPC): {
   636                  struct {
   637                          __be32 pre[3];
   638                          __be32 srcnode;
   639                  } *hdr, _hdr;
   640                  hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), 
data, hlen, &_hdr);
   641                  if (!hdr)
   642                          goto out_bad;
   643  
   644                  if (dissector_uses_key(flow_dissector,
   645                                         FLOW_DISSECTOR_KEY_TIPC_ADDRS)) {
   646                          key_addrs = 
skb_flow_dissector_target(flow_dissector,
   647                                                                
FLOW_DISSECTOR_KEY_TIPC_ADDRS,
   648                                                                
target_container);
   649                          key_addrs->tipcaddrs.srcnode = hdr->srcnode;
   650                          key_control->addr_type = 
FLOW_DISSECTOR_KEY_TIPC_ADDRS;
   651                  }
   652                  goto out_good;
   653          }
   654  
   655          case htons(ETH_P_MPLS_UC):
   656          case htons(ETH_P_MPLS_MC):
   657  mpls:
   658                  switch (__skb_flow_dissect_mpls(skb, flow_dissector,
   659                                                  target_container, data,
   660                                                  nhoff, hlen)) {
   661                  case FLOW_DISSECT_RET_OUT_GOOD:
   662                          goto out_good;
   663                  case FLOW_DISSECT_RET_OUT_BAD:
   664                  default:
   665                          goto out_bad;
   666                  }
   667          case htons(ETH_P_FCOE):
   668                  if ((hlen - nhoff) < FCOE_HEADER_LEN)
   669                          goto out_bad;
   670  
   671                  nhoff += FCOE_HEADER_LEN;
   672                  goto out_good;
   673  
   674          case htons(ETH_P_ARP):
   675          case htons(ETH_P_RARP):
   676                  switch (__skb_flow_dissect_arp(skb, flow_dissector,
   677                                                 target_container, data,
   678                                                 nhoff, hlen)) {
   679                  case FLOW_DISSECT_RET_OUT_GOOD:
   680                          goto out_good;
   681                  case FLOW_DISSECT_RET_OUT_BAD:
   682                  default:
   683                          goto out_bad;
   684                  }
   685          default:
   686                  goto out_bad;
   687          }
   688  
   689  ip_proto_again:
   690          switch (ip_proto) {
   691          case IPPROTO_GRE:
   692                  switch (__skb_flow_dissect_gre(skb, key_control, 
flow_dissector,
   693                                                 target_container, data,
   694                                                 &proto, &nhoff, &hlen, 
flags)) {
   695                  case FLOW_DISSECT_RET_OUT_GOOD:
   696                          goto out_good;
   697                  case FLOW_DISSECT_RET_OUT_BAD:
   698                          goto out_bad;
   699                  case FLOW_DISSECT_RET_OUT_PROTO_AGAIN:
   700                          goto proto_again;
   701                  }
   702          case NEXTHDR_HOP:
   703          case NEXTHDR_ROUTING:
   704          case NEXTHDR_DEST: {
   705                  u8 _opthdr[2], *opthdr;
   706  
   707                  if (proto != htons(ETH_P_IPV6))
   708                          break;
   709  
   710                  opthdr = __skb_header_pointer(skb, nhoff, 
sizeof(_opthdr),
   711                                                data, hlen, &_opthdr);
   712                  if (!opthdr)
   713                          goto out_bad;
   714  
   715                  ip_proto = opthdr[0];
   716                  nhoff += (opthdr[1] + 1) << 3;
   717  
   718                  goto ip_proto_again;
   719          }
   720          case NEXTHDR_FRAGMENT: {
   721                  struct frag_hdr _fh, *fh;
   722  
   723                  if (proto != htons(ETH_P_IPV6))
   724                          break;
   725  
   726                  fh = __skb_header_pointer(skb, nhoff, sizeof(_fh),
   727                                            data, hlen, &_fh);
   728  
   729                  if (!fh)
   730                          goto out_bad;
   731  
   732                  key_control->flags |= FLOW_DIS_IS_FRAGMENT;
   733  
   734                  nhoff += sizeof(_fh);
   735                  ip_proto = fh->nexthdr;
   736  
   737                  if (!(fh->frag_off & htons(IP6_OFFSET))) {
   738                          key_control->flags |= FLOW_DIS_FIRST_FRAG;
   739                          if (flags & FLOW_DISSECTOR_F_PARSE_1ST_FRAG)
   740                                  goto ip_proto_again;
   741                  }
   742                  goto out_good;
   743          }
   744          case IPPROTO_IPIP:
   745                  proto = htons(ETH_P_IP);
   746  
   747                  key_control->flags |= FLOW_DIS_ENCAPSULATION;
   748                  if (flags & FLOW_DISSECTOR_F_STOP_AT_ENCAP)
   749                          goto out_good;
   750  
   751                  goto ip;
   752          case IPPROTO_IPV6:
   753                  proto = htons(ETH_P_IPV6);
   754  
   755                  key_control->flags |= FLOW_DIS_ENCAPSULATION;
   756                  if (flags & FLOW_DISSECTOR_F_STOP_AT_ENCAP)
   757                          goto out_good;
   758  
   759                  goto ipv6;
   760          case IPPROTO_MPLS:
   761                  proto = htons(ETH_P_MPLS_UC);
   762                  goto mpls;
   763          case IPPROTO_TCP:
   764                  __skb_flow_dissect_tcp(skb, flow_dissector, 
target_container,
   765                                         data, nhoff, hlen);
   766                  break;
   767          default:
   768                  break;
   769          }
   770  
   771          if (dissector_uses_key(flow_dissector,
   772                                 FLOW_DISSECTOR_KEY_PORTS)) {
   773                  key_ports = skb_flow_dissector_target(flow_dissector,
   774                                                        
FLOW_DISSECTOR_KEY_PORTS,
   775                                                        target_container);
   776                  key_ports->ports = __skb_flow_get_ports(skb, nhoff, 
ip_proto,
   777                                                          data, hlen);
   778          }
   779  
   780          if (dissector_uses_key(flow_dissector,
   781                                 FLOW_DISSECTOR_KEY_ICMP)) {
   782                  key_icmp = skb_flow_dissector_target(flow_dissector,
   783                                                       
FLOW_DISSECTOR_KEY_ICMP,
   784                                                       target_container);
   785                  key_icmp->icmp = skb_flow_get_be16(skb, nhoff, data, 
hlen);
   786          }
   787  
   788  out_good:
   789          ret = true;
   790  
   791          key_control->thoff = (u16)nhoff;
   792  out:
   793          key_basic->n_proto = proto;
   794          key_basic->ip_proto = ip_proto;
   795  
   796          return ret;
   797  
   798  out_bad:
   799          ret = false;
   800          key_control->thoff = min_t(u16, nhoff, skb ? skb->len : hlen);
   801          goto out;
   802  }
   803  EXPORT_SYMBOL(__skb_flow_dissect);
   804  

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

Attachment: .config.gz
Description: application/gzip

Reply via email to