imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,28 +1,28 @@
 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(skb->sk);
   struct nlattr *tb[IFA_MAX + 1];
   struct in_device *in_dev;
   struct ifaddrmsg *ifm;
   struct in_ifaddr *ifa, **ifap;
   int err = -EINVAL;
   ASSERT_RTNL();
-  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
+  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy, NULL);
   if (err < 0) goto errout;
   ifm = nlmsg_data(nlh);
   in_dev = inetdev_by_index(net, ifm->ifa_index);
   if (!in_dev) {
     err = -ENODEV;
     goto errout;
   }
   for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; ifap = &ifa->ifa_next) {
     if (tb[IFA_LOCAL] && ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL])) continue;
     if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label)) continue;
     if (tb[IFA_ADDRESS] && (ifm->ifa_prefixlen != ifa->ifa_prefixlen || !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa))) continue;
     if (ipv4_is_multicast(ifa->ifa_address)) ip_mc_config(net->ipv4.mc_autojoin_sk, false, ifa);
     __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
     return 0;
   }
   err = -EADDRNOTAVAIL;
 errout:
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,13 +1,13 @@
 static struct nfc_dev *__get_device_from_cb(struct netlink_callback *cb) {
   struct nlattr **attrbuf = genl_family_attrbuf(&nfc_genl_family);
   struct nfc_dev *dev;
   int rc;
   u32 idx;
-  rc = nlmsg_parse(cb->nlh, GENL_HDRLEN + nfc_genl_family.hdrsize, attrbuf, nfc_genl_family.maxattr, nfc_genl_policy);
+  rc = nlmsg_parse(cb->nlh, GENL_HDRLEN + nfc_genl_family.hdrsize, attrbuf, nfc_genl_family.maxattr, nfc_genl_policy, NULL);
   if (rc < 0) return ERR_PTR(rc);
   if (!attrbuf[NFC_ATTR_DEVICE_INDEX]) return ERR_PTR(-EINVAL);
   idx = nla_get_u32(attrbuf[NFC_ATTR_DEVICE_INDEX]);
   dev = nfc_get_device(idx);
   if (!dev) return ERR_PTR(-ENODEV);
   return dev;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,32 +1,32 @@
 static int mpls_netconf_get_devconf(struct sk_buff *in_skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(in_skb->sk);
   struct nlattr *tb[NETCONFA_MAX + 1];
   struct netconfmsg *ncm;
   struct net_device *dev;
   struct mpls_dev *mdev;
   struct sk_buff *skb;
   int ifindex;
   int err;
-  err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX, devconf_mpls_policy);
+  err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX, devconf_mpls_policy, NULL);
   if (err < 0) goto errout;
   err = -EINVAL;
   if (!tb[NETCONFA_IFINDEX]) goto errout;
   ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
   dev = __dev_get_by_index(net, ifindex);
   if (!dev) goto errout;
   mdev = mpls_dev_get(dev);
   if (!mdev) goto errout;
   err = -ENOBUFS;
   skb = nlmsg_new(mpls_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
   if (!skb) goto errout;
   err = mpls_netconf_fill_devconf(skb, mdev, NETLINK_CB(in_skb).portid, nlh->nlmsg_seq, RTM_NEWNETCONF, 0, NETCONFA_ALL);
   if (err < 0) {
     /* -EMSGSIZE implies BUG in mpls_netconf_msgsize_devconf() */
     WARN_ON(err == -EMSGSIZE);
     kfree_skb(skb);
     goto errout;
   }
   err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
 errout:
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,41 +1,41 @@
 static int ip6addrlbl_get(struct sk_buff *in_skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(in_skb->sk);
   struct ifaddrlblmsg *ifal;
   struct nlattr *tb[IFAL_MAX + 1];
   struct in6_addr *addr;
   u32 lseq;
   int err = 0;
   struct ip6addrlbl_entry *p;
   struct sk_buff *skb;
-  err = nlmsg_parse(nlh, sizeof(*ifal), tb, IFAL_MAX, ifal_policy);
+  err = nlmsg_parse(nlh, sizeof(*ifal), tb, IFAL_MAX, ifal_policy, NULL);
   if (err < 0) return err;
   ifal = nlmsg_data(nlh);
   if (ifal->ifal_family != AF_INET6 || ifal->ifal_prefixlen != 128) return -EINVAL;
   if (ifal->ifal_index && !__dev_get_by_index(net, ifal->ifal_index)) return -EINVAL;
   if (!tb[IFAL_ADDRESS]) return -EINVAL;
   addr = nla_data(tb[IFAL_ADDRESS]);
   rcu_read_lock();
   p = __ipv6_addr_label(net, addr, ipv6_addr_type(addr), ifal->ifal_index);
   if (p && !ip6addrlbl_hold(p)) p = NULL;
   lseq = ip6addrlbl_table.seq;
   rcu_read_unlock();
   if (!p) {
     err = -ESRCH;
     goto out;
   }
   skb = nlmsg_new(ip6addrlbl_msgsize(), GFP_KERNEL);
   if (!skb) {
     ip6addrlbl_put(p);
     return -ENOBUFS;
   }
   err = ip6addrlbl_fill(skb, p, lseq, NETLINK_CB(in_skb).portid, nlh->nlmsg_seq, RTM_NEWADDRLABEL, 0);
   ip6addrlbl_put(p);
   if (err < 0) {
     WARN_ON(err == -EMSGSIZE);
     kfree_skb(skb);
     goto out;
   }
   err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
 out:
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,41 +1,41 @@
 static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(in_skb->sk);
   struct ifaddrmsg *ifm;
   struct nlattr *tb[IFA_MAX + 1];
   struct in6_addr *addr = NULL, *peer;
   struct net_device *dev = NULL;
   struct inet6_ifaddr *ifa;
   struct sk_buff *skb;
   int err;
-  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
+  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy, NULL);
   if (err < 0) goto errout;
   addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
   if (!addr) {
     err = -EINVAL;
     goto errout;
   }
   ifm = nlmsg_data(nlh);
   if (ifm->ifa_index) dev = __dev_get_by_index(net, ifm->ifa_index);
   ifa = ipv6_get_ifaddr(net, addr, dev, 1);
   if (!ifa) {
     err = -EADDRNOTAVAIL;
     goto errout;
   }
   skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
   if (!skb) {
     err = -ENOBUFS;
     goto errout_ifa;
   }
   err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).portid, nlh->nlmsg_seq, RTM_NEWADDR, 0);
   if (err < 0) {
     /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
     WARN_ON(err == -EMSGSIZE);
     kfree_skb(skb);
     goto errout_ifa;
   }
   err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
 errout_ifa:
   in6_ifa_put(ifa);
 errout:
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,27 +1,27 @@
 static int route_doit(struct sk_buff *skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(skb->sk);
   struct nlattr *tb[RTA_MAX + 1];
   struct net_device *dev;
   struct rtmsg *rtm;
   int err;
   u8 dst;
   if (!netlink_capable(skb, CAP_NET_ADMIN)) return -EPERM;
   if (!netlink_capable(skb, CAP_SYS_ADMIN)) return -EPERM;
   ASSERT_RTNL();
-  err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_phonet_policy);
+  err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_phonet_policy, NULL);
   if (err < 0) return err;
   rtm = nlmsg_data(nlh);
   if (rtm->rtm_table != RT_TABLE_MAIN || rtm->rtm_type != RTN_UNICAST) return -EINVAL;
   if (tb[RTA_DST] == NULL || tb[RTA_OIF] == NULL) return -EINVAL;
   dst = nla_get_u8(tb[RTA_DST]);
   if (dst & 3) /* Phonet addresses only have 6 high-order bits */
     return -EINVAL;
   dev = __dev_get_by_index(net, nla_get_u32(tb[RTA_OIF]));
   if (dev == NULL) return -ENODEV;
   if (nlh->nlmsg_type == RTM_NEWROUTE)
     err = phonet_route_add(dev, dst);
   else
     err = phonet_route_del(dev, dst);
   if (!err) rtm_phonet_notify(nlh->nlmsg_type, dev, dst);
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,31 +1,31 @@
 static int rtnl_net_getid(struct sk_buff *skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(skb->sk);
   struct nlattr *tb[NETNSA_MAX + 1];
   struct sk_buff *msg;
   struct net *peer;
   int err, id;
-  err = nlmsg_parse(nlh, sizeof(struct rtgenmsg), tb, NETNSA_MAX, rtnl_net_policy);
+  err = nlmsg_parse(nlh, sizeof(struct rtgenmsg), tb, NETNSA_MAX, rtnl_net_policy, NULL);
   if (err < 0) return err;
   if (tb[NETNSA_PID])
     peer = get_net_ns_by_pid(nla_get_u32(tb[NETNSA_PID]));
   else if (tb[NETNSA_FD])
     peer = get_net_ns_by_fd(nla_get_u32(tb[NETNSA_FD]));
   else
     return -EINVAL;
   if (IS_ERR(peer)) return PTR_ERR(peer);
   msg = nlmsg_new(rtnl_net_get_size(), GFP_KERNEL);
   if (!msg) {
     err = -ENOMEM;
     goto out;
   }
   id = peernet2id(net, peer);
   err = rtnl_net_fill(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0, RTM_NEWNSID, net, id);
   if (err < 0) goto err_out;
   err = rtnl_unicast(msg, net, NETLINK_CB(skb).portid);
   goto out;
 err_out:
   nlmsg_free(msg);
 out:
   put_net(peer);
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,25 +1,25 @@
 static int dn_nl_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(skb->sk);
   struct nlattr *tb[IFA_MAX + 1];
   struct dn_dev *dn_db;
   struct ifaddrmsg *ifm;
   struct dn_ifaddr *ifa;
   struct dn_ifaddr __rcu **ifap;
   int err = -EINVAL;
   if (!netlink_capable(skb, CAP_NET_ADMIN)) return -EPERM;
   if (!net_eq(net, &init_net)) goto errout;
-  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, dn_ifa_policy);
+  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, dn_ifa_policy, NULL);
   if (err < 0) goto errout;
   err = -ENODEV;
   ifm = nlmsg_data(nlh);
   if ((dn_db = dn_dev_by_index(ifm->ifa_index)) == NULL) goto errout;
   err = -EADDRNOTAVAIL;
   for (ifap = &dn_db->ifa_list; (ifa = rtnl_dereference(*ifap)) != NULL; ifap = &ifa->ifa_next) {
     if (tb[IFA_LOCAL] && nla_memcmp(tb[IFA_LOCAL], &ifa->ifa_local, 2)) continue;
     if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label)) continue;
     dn_dev_del_ifa(dn_db, ifap, 1);
     return 0;
   }
 errout:
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,53 +1,53 @@
 static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(skb->sk);
   struct ndmsg *ndm;
   struct nlattr *tb[NDA_MAX + 1];
   struct net_device *dev;
   int err = -EINVAL;
   __u8 *addr;
   u16 vid;
   if (!netlink_capable(skb, CAP_NET_ADMIN)) return -EPERM;
-  err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
+  err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL, NULL);
   if (err < 0) return err;
   ndm = nlmsg_data(nlh);
   if (ndm->ndm_ifindex == 0) {
     pr_info("PF_BRIDGE: RTM_DELNEIGH with invalid ifindex\n");
     return -EINVAL;
   }
   dev = __dev_get_by_index(net, ndm->ndm_ifindex);
   if (dev == NULL) {
     pr_info("PF_BRIDGE: RTM_DELNEIGH with unknown ifindex\n");
     return -ENODEV;
   }
   if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
     pr_info("PF_BRIDGE: RTM_DELNEIGH with invalid address\n");
     return -EINVAL;
   }
   addr = nla_data(tb[NDA_LLADDR]);
   err = fdb_vid_parse(tb[NDA_VLAN], &vid);
   if (err) return err;
   err = -EOPNOTSUPP;
   /* Support fdb on master device the net/bridge default case */
   if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) && (dev->priv_flags & IFF_BRIDGE_PORT)) {
     struct net_device *br_dev = netdev_master_upper_dev_get(dev);
     const struct net_device_ops *ops = br_dev->netdev_ops;
     if (ops->ndo_fdb_del) err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
     if (err)
       goto out;
     else
       ndm->ndm_flags &= ~NTF_MASTER;
   }
   /* Embedded bridge, macvlan, and any other device support */
   if (ndm->ndm_flags & NTF_SELF) {
     if (dev->netdev_ops->ndo_fdb_del)
       err = dev->netdev_ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
     else
       err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
     if (!err) {
       rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH, ndm->ndm_state);
       ndm->ndm_flags &= ~NTF_SELF;
     }
   }
 out:
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,31 +1,31 @@
 static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(skb->sk);
   struct ifinfomsg *ifm;
   struct net_device *dev;
   int err;
   struct nlattr *tb[IFLA_MAX + 1];
   char ifname[IFNAMSIZ];
-  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
+  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, NULL);
   if (err < 0) goto errout;
   if (tb[IFLA_IFNAME])
     nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
   else
     ifname[0] = '\0';
   err = -EINVAL;
   ifm = nlmsg_data(nlh);
   if (ifm->ifi_index > 0)
     dev = __dev_get_by_index(net, ifm->ifi_index);
   else if (tb[IFLA_IFNAME])
     dev = __dev_get_by_name(net, ifname);
   else
     goto errout;
   if (dev == NULL) {
     err = -ENODEV;
     goto errout;
   }
   err = validate_linkmsg(dev, tb);
   if (err < 0) goto errout;
   err = do_setlink(skb, dev, ifm, tb, ifname, 0);
 errout:
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,32 +1,32 @@
 static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(skb->sk);
   struct ifinfomsg *ifm;
   char ifname[IFNAMSIZ];
   struct nlattr *tb[IFLA_MAX + 1];
   struct net_device *dev = NULL;
   struct sk_buff *nskb;
   int err;
   u32 ext_filter_mask = 0;
-  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
+  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, NULL);
   if (err < 0) return err;
   if (tb[IFLA_IFNAME]) nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
   if (tb[IFLA_EXT_MASK]) ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
   ifm = nlmsg_data(nlh);
   if (ifm->ifi_index > 0)
     dev = __dev_get_by_index(net, ifm->ifi_index);
   else if (tb[IFLA_IFNAME])
     dev = __dev_get_by_name(net, ifname);
   else
     return -EINVAL;
   if (dev == NULL) return -ENODEV;
   nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL);
   if (nskb == NULL) return -ENOBUFS;
   err = rtnl_fill_ifinfo(nskb, dev, RTM_NEWLINK, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0, 0, ext_filter_mask);
   if (err < 0) {
     /* -EMSGSIZE implies BUG in if_nlmsg_size */
     WARN_ON(err == -EMSGSIZE);
     kfree_skb(nskb);
   } else
     err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,65 +1,65 @@
 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(in_skb->sk);
   struct nlattr *tb[RTA_MAX + 1];
   struct rt6_info *rt;
   struct sk_buff *skb;
   struct rtmsg *rtm;
   struct flowi6 fl6;
   int err, iif = 0, oif = 0;
-  err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
+  err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy, NULL);
   if (err < 0) goto errout;
   err = -EINVAL;
   memset(&fl6, 0, sizeof(fl6));
   rtm = nlmsg_data(nlh);
   fl6.flowlabel = ip6_make_flowinfo(rtm->rtm_tos, 0);
   if (tb[RTA_SRC]) {
     if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr)) goto errout;
     fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
   }
   if (tb[RTA_DST]) {
     if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr)) goto errout;
     fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
   }
   if (tb[RTA_IIF]) iif = nla_get_u32(tb[RTA_IIF]);
   if (tb[RTA_OIF]) oif = nla_get_u32(tb[RTA_OIF]);
   if (tb[RTA_MARK]) fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
   if (tb[RTA_UID])
     fl6.flowi6_uid = make_kuid(current_user_ns(), nla_get_u32(tb[RTA_UID]));
   else
     fl6.flowi6_uid = iif ? INVALID_UID : current_uid();
   if (iif) {
     struct net_device *dev;
     int flags = 0;
     dev = __dev_get_by_index(net, iif);
     if (!dev) {
       err = -ENODEV;
       goto errout;
     }
     fl6.flowi6_iif = iif;
     if (!ipv6_addr_any(&fl6.saddr)) flags |= RT6_LOOKUP_F_HAS_SADDR;
     rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6, flags);
   } else {
     fl6.flowi6_oif = oif;
     rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
   }
   if (rt == net->ipv6.ip6_null_entry) {
     err = rt->dst.error;
     ip6_rt_put(rt);
     goto errout;
   }
   skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
   if (!skb) {
     ip6_rt_put(rt);
     err = -ENOBUFS;
     goto errout;
   }
   skb_dst_set(skb, &rt->dst);
   err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif, RTM_NEWROUTE, NETLINK_CB(in_skb).portid, nlh->nlmsg_seq, 0);
   if (err < 0) {
     kfree_skb(skb);
     goto errout;
   }
   err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
 errout:
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,12 +1,12 @@
 bool intel_gmbus_is_valid_pin(struct drm_i915_private *dev_priv, unsigned int pin) {
   unsigned int size;
-  if (IS_BROXTON(dev_priv))
+  if (IS_GEN9_LP(dev_priv))
     size = ARRAY_SIZE(gmbus_pins_bxt);
   else if (IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev_priv))
     size = ARRAY_SIZE(gmbus_pins_skl);
   else if (IS_BROADWELL(dev_priv))
     size = ARRAY_SIZE(gmbus_pins_bdw);
   else
     size = ARRAY_SIZE(gmbus_pins);
   return pin < size && i915_mmio_reg_valid(get_gmbus_pin(dev_priv, pin)->reg);
 }<sep>@@
expression e;
@@

-       IS_BROXTON
+       IS_GEN9_LP
		(e)
--- initial
+++ final
@@ -1,5 +1,5 @@
 static bool skl_needs_memory_bw_wa(struct intel_atomic_state *state) {
   struct drm_i915_private *dev_priv = to_i915(state->base.dev);
-  if (IS_SKYLAKE(dev_priv) || IS_BROXTON(dev_priv) || IS_KABYLAKE(dev_priv)) return true;
+  if (IS_SKYLAKE(dev_priv) || IS_GEN9_LP(dev_priv) || IS_KABYLAKE(dev_priv)) return true;
   return false;
 }<sep>@@
expression e;
@@

-       IS_BROXTON
+       IS_GEN9_LP
		(e)
--- initial
+++ final
@@ -1,34 +1,34 @@
 static void gen9_sseu_device_status(struct drm_i915_private *dev_priv, struct sseu_dev_info *sseu) {
   int s_max = 3, ss_max = 4;
   int s, ss;
   u32 s_reg[s_max], eu_reg[2 * s_max], eu_mask[2];
   /* BXT has a single slice and at most 3 subslices. */
-  if (IS_BROXTON(dev_priv)) {
+  if (IS_GEN9_LP(dev_priv)) {
     s_max = 1;
     ss_max = 3;
   }
   for (s = 0; s < s_max; s++) {
     s_reg[s] = I915_READ(GEN9_SLICE_PGCTL_ACK(s));
     eu_reg[2 * s] = I915_READ(GEN9_SS01_EU_PGCTL_ACK(s));
     eu_reg[2 * s + 1] = I915_READ(GEN9_SS23_EU_PGCTL_ACK(s));
   }
   eu_mask[0] = GEN9_PGCTL_SSA_EU08_ACK | GEN9_PGCTL_SSA_EU19_ACK | GEN9_PGCTL_SSA_EU210_ACK | GEN9_PGCTL_SSA_EU311_ACK;
   eu_mask[1] = GEN9_PGCTL_SSB_EU08_ACK | GEN9_PGCTL_SSB_EU19_ACK | GEN9_PGCTL_SSB_EU210_ACK | GEN9_PGCTL_SSB_EU311_ACK;
   for (s = 0; s < s_max; s++) {
     if ((s_reg[s] & GEN9_PGCTL_SLICE_ACK) == 0) /* skip disabled slice */
       continue;
     sseu->slice_mask |= BIT(s);
     if (IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev_priv)) sseu->subslice_mask = INTEL_INFO(dev_priv)->sseu.subslice_mask;
     for (ss = 0; ss < ss_max; ss++) {
       unsigned int eu_cnt;
-      if (IS_BROXTON(dev_priv)) {
+      if (IS_GEN9_LP(dev_priv)) {
         if (!(s_reg[s] & (GEN9_PGCTL_SS_ACK(ss)))) /* skip disabled subslice */
           continue;
         sseu->subslice_mask |= BIT(ss);
       }
       eu_cnt = 2 * hweight32(eu_reg[2 * s + ss / 2] & eu_mask[ss % 2]);
       sseu->eu_total += eu_cnt;
       sseu->eu_per_subslice = max_t(unsigned int, sseu->eu_per_subslice, eu_cnt);
     }
   }
 }<sep>@@
expression e;
@@

-       IS_BROXTON
+       IS_GEN9_LP
		(e)
--- initial
+++ final
@@ -1,6 +1,6 @@
 u32 intel_dsi_get_pclk(struct intel_encoder *encoder, int pipe_bpp, struct intel_crtc_state *config) {
-  if (IS_BROXTON(to_i915(encoder->base.dev)))
+  if (IS_GEN9_LP(to_i915(encoder->base.dev)))
     return bxt_dsi_get_pclk(encoder, pipe_bpp, config);
   else
     return vlv_dsi_get_pclk(encoder, pipe_bpp, config);
 }<sep>@@
expression e;
@@

-       IS_BROXTON
+       IS_GEN9_LP
		(e)
--- initial
+++ final
@@ -1,15 +1,15 @@
 static void gtt_write_workarounds(struct drm_i915_private *dev_priv) {
   /* This function is for gtt related workarounds. This function is
    * called on driver load and after a GPU reset, so you can place
    * workarounds here even if they get overwritten by GPU reset.
    */
   /* WaIncreaseDefaultTLBEntries:chv,bdw,skl,bxt */
   if (IS_BROADWELL(dev_priv))
     I915_WRITE(GEN8_L3_LRA_1_GPGPU, GEN8_L3_LRA_1_GPGPU_DEFAULT_VALUE_BDW);
   else if (IS_CHERRYVIEW(dev_priv))
     I915_WRITE(GEN8_L3_LRA_1_GPGPU, GEN8_L3_LRA_1_GPGPU_DEFAULT_VALUE_CHV);
   else if (IS_SKYLAKE(dev_priv))
     I915_WRITE(GEN8_L3_LRA_1_GPGPU, GEN9_L3_LRA_1_GPGPU_DEFAULT_VALUE_SKL);
-  else if (IS_BROXTON(dev_priv))
+  else if (IS_GEN9_LP(dev_priv))
     I915_WRITE(GEN8_L3_LRA_1_GPGPU, GEN9_L3_LRA_1_GPGPU_DEFAULT_VALUE_BXT);
 }<sep>@@
expression e;
@@

-       IS_BROXTON
+       IS_GEN9_LP
		(e)
--- initial
+++ final
@@ -1,10 +1,10 @@
 static void intel_dsi_get_config(struct intel_encoder *encoder, struct intel_crtc_state *pipe_config) {
   struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
   u32 pclk;
   DRM_DEBUG_KMS("\n");
-  if (IS_BROXTON(dev_priv)) bxt_dsi_get_pipe_config(encoder, pipe_config);
+  if (IS_GEN9_LP(dev_priv)) bxt_dsi_get_pipe_config(encoder, pipe_config);
   pclk = intel_dsi_get_pclk(encoder, pipe_config->pipe_bpp, pipe_config);
   if (!pclk) return;
   pipe_config->base.adjusted_mode.crtc_clock = pclk;
   pipe_config->port_clock = pclk;
 }<sep>@@
expression e;
@@

-       IS_BROXTON
+       IS_GEN9_LP
		(e)
--- initial
+++ final
@@ -1,45 +1,45 @@
 bool intel_ddi_get_hw_state(struct intel_encoder *encoder, enum pipe *pipe) {
   struct drm_device *dev = encoder->base.dev;
   struct drm_i915_private *dev_priv = to_i915(dev);
   enum port port = intel_ddi_get_encoder_port(encoder);
   enum intel_display_power_domain power_domain;
   u32 tmp;
   int i;
   bool ret;
   power_domain = intel_display_port_power_domain(encoder);
   if (!intel_display_power_get_if_enabled(dev_priv, power_domain)) return false;
   ret = false;
   tmp = I915_READ(DDI_BUF_CTL(port));
   if (!(tmp & DDI_BUF_CTL_ENABLE)) goto out;
   if (port == PORT_A) {
     tmp = I915_READ(TRANS_DDI_FUNC_CTL(TRANSCODER_EDP));
     switch (tmp & TRANS_DDI_EDP_INPUT_MASK) {
     case TRANS_DDI_EDP_INPUT_A_ON:
     case TRANS_DDI_EDP_INPUT_A_ONOFF: *pipe = PIPE_A; break;
     case TRANS_DDI_EDP_INPUT_B_ONOFF: *pipe = PIPE_B; break;
     case TRANS_DDI_EDP_INPUT_C_ONOFF: *pipe = PIPE_C; break;
     }
     ret = true;
     goto out;
   }
   for (i = TRANSCODER_A; i <= TRANSCODER_C; i++) {
     tmp = I915_READ(TRANS_DDI_FUNC_CTL(i));
     if ((tmp & TRANS_DDI_PORT_MASK) == TRANS_DDI_SELECT_PORT(port)) {
       if ((tmp & TRANS_DDI_MODE_SELECT_MASK) == TRANS_DDI_MODE_SELECT_DP_MST) goto out;
       *pipe = i;
       ret = true;
       goto out;
     }
   }
   DRM_DEBUG_KMS("No pipe for ddi port %c found\n", port_name(port));
 out:
-  if (ret && IS_BROXTON(dev_priv)) {
+  if (ret && IS_GEN9_LP(dev_priv)) {
     tmp = I915_READ(BXT_PHY_CTL(port));
     if ((tmp & (BXT_PHY_LANE_POWERDOWN_ACK | BXT_PHY_LANE_ENABLED)) != BXT_PHY_LANE_ENABLED)
       DRM_ERROR("Port %c enabled but PHY powered down? "
                 "(PHY_CTL %08x)\n",
                 port_name(port), tmp);
   }
   intel_display_power_put(dev_priv, power_domain);
   return ret;
 }<sep>@@
expression e;
@@

-       IS_BROXTON
+       IS_GEN9_LP
		(e)