imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,19 +1,19 @@
 static int lo_read_simple(struct loop_device *lo, struct request *rq, loff_t pos) {
   struct bio_vec bvec;
   struct req_iterator iter;
   struct iov_iter i;
   ssize_t len;
   rq_for_each_segment(bvec, rq, iter) {
-    iov_iter_bvec(&i, ITER_BVEC, &bvec, 1, bvec.bv_len);
+    iov_iter_bvec(&i, READ, &bvec, 1, bvec.bv_len);
     len = vfs_iter_read(lo->lo_backing_file, &i, &pos, 0);
     if (len < 0) return len;
     flush_dcache_page(bvec.bv_page);
     if (len != bvec.bv_len) {
       struct bio *bio;
       __rq_for_each_bio(bio, rq) zero_fill_bio(bio);
       break;
     }
     cond_resched();
   }
   return 0;
 }<sep>@@
expression e1,e2,e3,e4;
@@
               iov_iter_bvec(e1,
-                              ITER_BVEC
+                              READ
                            , e2,e3,e4)
--- initial
+++ final
@@ -1,52 +1,52 @@
 static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) {
   struct net *net = sock_net(skb->sk);
   int h, s_h;
   int idx = 0, s_idx;
   struct net_device *dev;
   struct hlist_head *head;
   struct nlattr *tb[IFLA_MAX + 1];
   u32 ext_filter_mask = 0;
   const struct rtnl_link_ops *kind_ops = NULL;
   unsigned int flags = NLM_F_MULTI;
   int master_idx = 0;
   int err;
   int hdrlen;
   s_h = cb->args[0];
   s_idx = cb->args[1];
   cb->seq = net->dev_base_seq;
   /* A hack to preserve kernel<->userspace interface.
    * The correct header is ifinfomsg. It is consistent with rtnl_getlink.
    * However, before Linux v3.9 the code here assumed rtgenmsg and that's
    * what iproute2 < v3.9.0 used.
    * We can detect the old iproute2. Even including the IFLA_EXT_MASK
    * attribute, its netlink message is shorter than struct ifinfomsg.
    */
   hdrlen = nlmsg_len(cb->nlh) < sizeof(struct ifinfomsg) ? sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
-  if (nlmsg_parse(cb->nlh, hdrlen, tb, IFLA_MAX, ifla_policy) >= 0) {
+  if (nlmsg_parse(cb->nlh, hdrlen, tb, IFLA_MAX, ifla_policy, NULL) >= 0) {
     if (tb[IFLA_EXT_MASK]) ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
     if (tb[IFLA_MASTER]) master_idx = nla_get_u32(tb[IFLA_MASTER]);
     if (tb[IFLA_LINKINFO]) kind_ops = linkinfo_to_kind_ops(tb[IFLA_LINKINFO]);
     if (master_idx || kind_ops) flags |= NLM_F_DUMP_FILTERED;
   }
   for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
     idx = 0;
     head = &net->dev_index_head[h];
     hlist_for_each_entry(dev, head, index_hlist) {
       if (link_dump_filtered(dev, master_idx, kind_ops)) goto cont;
       if (idx < s_idx) goto cont;
       err = rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, 0, flags, ext_filter_mask);
       /* If we ran out of room on the first message,
        * we're in trouble
        */
       WARN_ON((err == -EMSGSIZE) && (skb->len == 0));
       if (err < 0) goto out;
       nl_dump_check_consistent(cb, nlmsg_hdr(skb));
     cont:
       idx++;
     }
   }
 out:
   cb->args[1] = idx;
   cb->args[0] = h;
   return skb->len;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,44 +1,44 @@
 static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n) {
   struct net *net = sock_net(skb->sk);
   struct tcmsg *tcm = nlmsg_data(n);
   struct nlattr *tca[TCA_MAX + 1];
   struct net_device *dev;
   u32 clid;
   struct Qdisc *q = NULL;
   struct Qdisc *p = NULL;
   int err;
   if ((n->nlmsg_type != RTM_GETQDISC) && !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) return -EPERM;
-  err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
+  err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL, NULL);
   if (err < 0) return err;
   dev = __dev_get_by_index(net, tcm->tcm_ifindex);
   if (!dev) return -ENODEV;
   clid = tcm->tcm_parent;
   if (clid) {
     if (clid != TC_H_ROOT) {
       if (TC_H_MAJ(clid) != TC_H_MAJ(TC_H_INGRESS)) {
         p = qdisc_lookup(dev, TC_H_MAJ(clid));
         if (!p) return -ENOENT;
         q = qdisc_leaf(p, clid);
       } else if (dev_ingress_queue(dev)) {
         q = dev_ingress_queue(dev)->qdisc_sleeping;
       }
     } else {
       q = dev->qdisc;
     }
     if (!q) return -ENOENT;
     if (tcm->tcm_handle && q->handle != tcm->tcm_handle) return -EINVAL;
   } else {
     q = qdisc_lookup(dev, tcm->tcm_handle);
     if (!q) return -ENOENT;
   }
   if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id)) return -EINVAL;
   if (n->nlmsg_type == RTM_DELQDISC) {
     if (!clid) return -EINVAL;
     if (q->handle == 0) return -ENOENT;
     err = qdisc_graft(dev, p, skb, n, clid, NULL, q);
     if (err != 0) return err;
   } else {
     qdisc_notify(net, skb, n, clid, NULL, q);
   }
   return 0;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,14 +1,14 @@
 static struct nlattr *find_dump_kind(const struct nlmsghdr *n) {
   struct nlattr *tb1, *tb2[TCA_ACT_MAX + 1];
   struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
   struct nlattr *nla[TCAA_MAX + 1];
   struct nlattr *kind;
-  if (nlmsg_parse(n, sizeof(struct tcamsg), nla, TCAA_MAX, NULL) < 0) return NULL;
+  if (nlmsg_parse(n, sizeof(struct tcamsg), nla, TCAA_MAX, NULL, NULL) < 0) return NULL;
   tb1 = nla[TCA_ACT_TAB];
   if (tb1 == NULL) return NULL;
   if (nla_parse(tb, TCA_ACT_MAX_PRIO, nla_data(tb1), NLMSG_ALIGN(nla_len(tb1)), NULL) < 0) return NULL;
   if (tb[1] == NULL) return NULL;
   if (nla_parse_nested(tb2, TCA_ACT_MAX, tb[1], NULL) < 0) return NULL;
   kind = tb2[TCA_ACT_KIND];
   return kind;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,22 +1,22 @@
 static int nl802154_dump_wpan_phy_parse(struct sk_buff *skb, struct netlink_callback *cb, struct nl802154_dump_wpan_phy_state *state) {
   struct nlattr **tb = genl_family_attrbuf(&nl802154_fam);
-  int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl802154_fam.hdrsize, tb, nl802154_fam.maxattr, nl802154_policy);
+  int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl802154_fam.hdrsize, tb, nl802154_fam.maxattr, nl802154_policy, NULL);
   /* TODO check if we can handle error here,
    * we have no backward compatibility
    */
   if (ret) return 0;
   if (tb[NL802154_ATTR_WPAN_PHY]) state->filter_wpan_phy = nla_get_u32(tb[NL802154_ATTR_WPAN_PHY]);
   if (tb[NL802154_ATTR_WPAN_DEV]) state->filter_wpan_phy = nla_get_u64(tb[NL802154_ATTR_WPAN_DEV]) >> 32;
   if (tb[NL802154_ATTR_IFINDEX]) {
     struct net_device *netdev;
     struct cfg802154_registered_device *rdev;
     int ifidx = nla_get_u32(tb[NL802154_ATTR_IFINDEX]);
     netdev = __dev_get_by_index(&init_net, ifidx);
     if (!netdev) return -ENODEV;
     if (netdev->ieee802154_ptr) {
       rdev = wpan_phy_to_rdev(netdev->ieee802154_ptr->wpan_phy);
       state->filter_wpan_phy = rdev->wpan_phy_idx;
     }
   }
   return 0;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,44 +1,44 @@
 static int inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(skb->sk);
   struct ifaddrmsg *ifm;
   struct nlattr *tb[IFA_MAX + 1];
   struct in6_addr *pfx, *peer_pfx;
   struct inet6_ifaddr *ifa;
   struct net_device *dev;
   u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME;
   u32 ifa_flags;
   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) return err;
   ifm = nlmsg_data(nlh);
   pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
   if (!pfx) return -EINVAL;
   if (tb[IFA_CACHEINFO]) {
     struct ifa_cacheinfo *ci;
     ci = nla_data(tb[IFA_CACHEINFO]);
     valid_lft = ci->ifa_valid;
     preferred_lft = ci->ifa_prefered;
   } else {
     preferred_lft = INFINITY_LIFE_TIME;
     valid_lft = INFINITY_LIFE_TIME;
   }
   dev = __dev_get_by_index(net, ifm->ifa_index);
   if (!dev) return -ENODEV;
   ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
   /* We ignore other flags so far. */
   ifa_flags &= IFA_F_NODAD | IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR | IFA_F_NOPREFIXROUTE | IFA_F_MCAUTOJOIN;
   ifa = ipv6_get_ifaddr(net, pfx, dev, 1);
   if (!ifa) {
     /*
      * It would be best to check for !NLM_F_CREATE here but
      * userspace already relies on not having to provide this.
      */
     return inet6_addr_add(net, ifm->ifa_index, pfx, peer_pfx, ifm->ifa_prefixlen, ifa_flags, preferred_lft, valid_lft);
   }
   if (nlh->nlmsg_flags & NLM_F_EXCL || !(nlh->nlmsg_flags & NLM_F_REPLACE))
     err = -EEXIST;
   else
     err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft);
   in6_ifa_put(ifa);
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,40 +1,40 @@
 static int inet_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 sk_buff *skb;
   struct ipv4_devconf *devconf;
   struct in_device *in_dev;
   struct net_device *dev;
   int ifindex;
   int err;
-  err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX, devconf_ipv4_policy);
+  err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX, devconf_ipv4_policy, NULL);
   if (err < 0) goto errout;
   err = -EINVAL;
   if (!tb[NETCONFA_IFINDEX]) goto errout;
   ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
   switch (ifindex) {
   case NETCONFA_IFINDEX_ALL: devconf = net->ipv4.devconf_all; break;
   case NETCONFA_IFINDEX_DEFAULT: devconf = net->ipv4.devconf_dflt; break;
   default:
     dev = __dev_get_by_index(net, ifindex);
     if (!dev) goto errout;
     in_dev = __in_dev_get_rtnl(dev);
     if (!in_dev) goto errout;
     devconf = &in_dev->cnf;
     break;
   }
   err = -ENOBUFS;
   skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
   if (!skb) goto errout;
   err = inet_netconf_fill_devconf(skb, ifindex, devconf, NETLINK_CB(in_skb).portid, nlh->nlmsg_seq, RTM_NEWNETCONF, 0, NETCONFA_ALL);
   if (err < 0) {
     /* -EMSGSIZE implies BUG in inet_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,29 +1,29 @@
 static int xfrm_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) {
   struct net *net = sock_net(skb->sk);
   struct nlattr *attrs[XFRMA_MAX + 1];
   const struct xfrm_link *link;
   int type, err;
 #ifdef CONFIG_COMPAT
   if (in_compat_syscall()) return -EOPNOTSUPP;
 #endif
   type = nlh->nlmsg_type;
   if (type > XFRM_MSG_MAX) return -EINVAL;
   type -= XFRM_MSG_BASE;
   link = &xfrm_dispatch[type];
   /* All operations require privileges, even GET */
   if (!netlink_net_capable(skb, CAP_NET_ADMIN)) return -EPERM;
   if ((type == (XFRM_MSG_GETSA - XFRM_MSG_BASE) || type == (XFRM_MSG_GETPOLICY - XFRM_MSG_BASE)) && (nlh->nlmsg_flags & NLM_F_DUMP)) {
     if (link->dump == NULL) return -EINVAL;
     {
       struct netlink_dump_control c = {
           .dump = link->dump,
           .done = link->done,
       };
       return netlink_dump_start(net->xfrm.nlsk, skb, nlh, &c);
     }
   }
-  err = nlmsg_parse(nlh, xfrm_msg_min[type], attrs, link->nla_max ?: XFRMA_MAX, link->nla_pol ?: xfrma_policy);
+  err = nlmsg_parse(nlh, xfrm_msg_min[type], attrs, link->nla_max ?: XFRMA_MAX, link->nla_pol ?: xfrma_policy, NULL);
   if (err < 0) return err;
   if (link->doit == NULL) return -EINVAL;
   return link->doit(skb, nlh, attrs);
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,47 +1,47 @@
 static int rtm_to_ipmr_mfcc(struct net *net, struct nlmsghdr *nlh, struct mfcctl *mfcc, int *mrtsock, struct mr_table **mrtret) {
   struct net_device *dev = NULL;
   u32 tblid = RT_TABLE_DEFAULT;
   struct mr_table *mrt;
   struct nlattr *attr;
   struct rtmsg *rtm;
   int ret, rem;
-  ret = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipmr_policy);
+  ret = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipmr_policy, NULL);
   if (ret < 0) goto out;
   rtm = nlmsg_data(nlh);
   ret = -EINVAL;
   if (rtm->rtm_family != RTNL_FAMILY_IPMR || rtm->rtm_dst_len != 32 || rtm->rtm_type != RTN_MULTICAST || rtm->rtm_scope != RT_SCOPE_UNIVERSE || !ipmr_rtm_validate_proto(rtm->rtm_protocol)) goto out;
   memset(mfcc, 0, sizeof(*mfcc));
   mfcc->mfcc_parent = -1;
   ret = 0;
   nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), rem) {
     switch (nla_type(attr)) {
     case RTA_SRC: mfcc->mfcc_origin.s_addr = nla_get_be32(attr); break;
     case RTA_DST: mfcc->mfcc_mcastgrp.s_addr = nla_get_be32(attr); break;
     case RTA_IIF:
       dev = __dev_get_by_index(net, nla_get_u32(attr));
       if (!dev) {
         ret = -ENODEV;
         goto out;
       }
       break;
     case RTA_MULTIPATH:
       if (ipmr_nla_get_ttls(attr, mfcc) < 0) {
         ret = -EINVAL;
         goto out;
       }
       break;
     case RTA_PREFSRC: ret = 1; break;
     case RTA_TABLE: tblid = nla_get_u32(attr); break;
     }
   }
   mrt = ipmr_get_table(net, tblid);
   if (!mrt) {
     ret = -ENOENT;
     goto out;
   }
   *mrtret = mrt;
   *mrtsock = rtm->rtm_protocol == RTPROT_MROUTED ? 1 : 0;
   if (dev) mfcc->mfcc_parent = ipmr_find_vif(mrt, dev);
 out:
   return ret;
 }<sep>@@
expression e1,e2,e3,e4;
@@

       nlmsg_validate(e1,e2,e3,e4
+            , NULL
       )
--- initial
+++ final
@@ -1,68 +1,68 @@
 static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh) {
   int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
   struct net *net = sock_net(skb->sk);
   struct ndmsg *ndm;
   struct nlattr *tb[NDA_MAX + 1];
   struct neigh_table *tbl;
   struct net_device *dev = NULL;
   struct neighbour *neigh;
   void *dst, *lladdr;
   int err;
   ASSERT_RTNL();
-  err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
+  err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL, NULL);
   if (err < 0) goto out;
   err = -EINVAL;
   if (tb[NDA_DST] == NULL) goto out;
   ndm = nlmsg_data(nlh);
   if (ndm->ndm_ifindex) {
     dev = __dev_get_by_index(net, ndm->ndm_ifindex);
     if (dev == NULL) {
       err = -ENODEV;
       goto out;
     }
     if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len) goto out;
   }
   tbl = neigh_find_table(ndm->ndm_family);
   if (tbl == NULL) return -EAFNOSUPPORT;
   if (nla_len(tb[NDA_DST]) < tbl->key_len) goto out;
   dst = nla_data(tb[NDA_DST]);
   lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
   if (ndm->ndm_flags & NTF_PROXY) {
     struct pneigh_entry *pn;
     err = -ENOBUFS;
     pn = pneigh_lookup(tbl, net, dst, dev, 1);
     if (pn) {
       pn->flags = ndm->ndm_flags;
       err = 0;
     }
     goto out;
   }
   if (dev == NULL) goto out;
   neigh = neigh_lookup(tbl, dst, dev);
   if (neigh == NULL) {
     if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
       err = -ENOENT;
       goto out;
     }
     neigh = __neigh_lookup_errno(tbl, dst, dev);
     if (IS_ERR(neigh)) {
       err = PTR_ERR(neigh);
       goto out;
     }
   } else {
     if (nlh->nlmsg_flags & NLM_F_EXCL) {
       err = -EEXIST;
       neigh_release(neigh);
       goto out;
     }
     if (!(nlh->nlmsg_flags & NLM_F_REPLACE)) flags &= ~NEIGH_UPDATE_F_OVERRIDE;
   }
   if (ndm->ndm_flags & NTF_USE) {
     neigh_event_send(neigh, NULL);
     err = 0;
   } else
     err = neigh_update(neigh, lladdr, ndm->ndm_state, flags, NETLINK_CB(skb).portid);
   neigh_release(neigh);
 out:
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,21 +1,21 @@
 static int nl80211_dump_wiphy_parse(struct sk_buff *skb, struct netlink_callback *cb, struct nl80211_dump_wiphy_state *state) {
   struct nlattr **tb = genl_family_attrbuf(&nl80211_fam);
-  int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, tb, nl80211_fam.maxattr, nl80211_policy);
+  int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, tb, nl80211_fam.maxattr, nl80211_policy, NULL);
   /* ignore parse errors for backward compatibility */
   if (ret) return 0;
   state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
   if (tb[NL80211_ATTR_WIPHY]) state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
   if (tb[NL80211_ATTR_WDEV]) state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
   if (tb[NL80211_ATTR_IFINDEX]) {
     struct net_device *netdev;
     struct cfg80211_registered_device *rdev;
     int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
     netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
     if (!netdev) return -ENODEV;
     if (netdev->ieee80211_ptr) {
       rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
       state->filter_wiphy = rdev->wiphy_idx;
     }
   }
   return 0;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,39 +1,39 @@
 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, struct netlink_callback *cb) {
   struct net *net = sock_net(skb->sk);
   const struct nlmsghdr *nlh = cb->nlh;
   struct nlattr *tb[NDA_MAX + 1];
   struct neighbour *n;
   int rc, h, s_h = cb->args[1];
   int idx, s_idx = idx = cb->args[2];
   struct neigh_hash_table *nht;
   int filter_master_idx = 0, filter_idx = 0;
   unsigned int flags = NLM_F_MULTI;
   int err;
-  err = nlmsg_parse(nlh, sizeof(struct ndmsg), tb, NDA_MAX, NULL);
+  err = nlmsg_parse(nlh, sizeof(struct ndmsg), tb, NDA_MAX, NULL, NULL);
   if (!err) {
     if (tb[NDA_IFINDEX]) filter_idx = nla_get_u32(tb[NDA_IFINDEX]);
     if (tb[NDA_MASTER]) filter_master_idx = nla_get_u32(tb[NDA_MASTER]);
     if (filter_idx || filter_master_idx) flags |= NLM_F_DUMP_FILTERED;
   }
   rcu_read_lock_bh();
   nht = rcu_dereference_bh(tbl->nht);
   for (h = s_h; h < (1 << nht->hash_shift); h++) {
     if (h > s_h) s_idx = 0;
     for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0; n != NULL; n = rcu_dereference_bh(n->next)) {
       if (idx < s_idx || !net_eq(dev_net(n->dev), net)) goto next;
       if (neigh_ifindex_filtered(n->dev, filter_idx) || neigh_master_filtered(n->dev, filter_master_idx)) goto next;
       if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, RTM_NEWNEIGH, flags) < 0) {
         rc = -1;
         goto out;
       }
     next:
       idx++;
     }
   }
   rc = skb->len;
 out:
   rcu_read_unlock_bh();
   cb->args[1] = h;
   cb->args[2] = idx;
   return rc;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,75 +1,75 @@
 int fib_nl_delrule(struct sk_buff *skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(skb->sk);
   struct fib_rule_hdr *frh = nlmsg_data(nlh);
   struct fib_rules_ops *ops = NULL;
   struct fib_rule *rule, *tmp;
   struct nlattr *tb[FRA_MAX + 1];
   struct fib_kuid_range range;
   int err = -EINVAL;
   if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*frh))) goto errout;
   ops = lookup_rules_ops(net, frh->family);
   if (ops == NULL) {
     err = -EAFNOSUPPORT;
     goto errout;
   }
-  err = nlmsg_parse(nlh, sizeof(*frh), tb, FRA_MAX, ops->policy);
+  err = nlmsg_parse(nlh, sizeof(*frh), tb, FRA_MAX, ops->policy, NULL);
   if (err < 0) goto errout;
   err = validate_rulemsg(frh, tb, ops);
   if (err < 0) goto errout;
   if (tb[FRA_UID_RANGE]) {
     range = nla_get_kuid_range(tb);
     if (!uid_range_set(&range)) goto errout;
   } else {
     range = fib_kuid_range_unset;
   }
   list_for_each_entry(rule, &ops->rules_list, list) {
     if (frh->action && (frh->action != rule->action)) continue;
     if (frh_get_table(frh, tb) && (frh_get_table(frh, tb) != rule->table)) continue;
     if (tb[FRA_PRIORITY] && (rule->pref != nla_get_u32(tb[FRA_PRIORITY]))) continue;
     if (tb[FRA_IIFNAME] && nla_strcmp(tb[FRA_IIFNAME], rule->iifname)) continue;
     if (tb[FRA_OIFNAME] && nla_strcmp(tb[FRA_OIFNAME], rule->oifname)) continue;
     if (tb[FRA_FWMARK] && (rule->mark != nla_get_u32(tb[FRA_FWMARK]))) continue;
     if (tb[FRA_FWMASK] && (rule->mark_mask != nla_get_u32(tb[FRA_FWMASK]))) continue;
     if (tb[FRA_TUN_ID] && (rule->tun_id != nla_get_be64(tb[FRA_TUN_ID]))) continue;
     if (tb[FRA_L3MDEV] && (rule->l3mdev != nla_get_u8(tb[FRA_L3MDEV]))) continue;
     if (uid_range_set(&range) && (!uid_eq(rule->uid_range.start, range.start) || !uid_eq(rule->uid_range.end, range.end))) continue;
     if (!ops->compare(rule, frh, tb)) continue;
     if (rule->flags & FIB_RULE_PERMANENT) {
       err = -EPERM;
       goto errout;
     }
     if (ops->delete) {
       err = ops->delete (rule);
       if (err) goto errout;
     }
     if (rule->tun_id) ip_tunnel_unneed_metadata();
     list_del_rcu(&rule->list);
     if (rule->action == FR_ACT_GOTO) {
       ops->nr_goto_rules--;
       if (rtnl_dereference(rule->ctarget) == NULL) ops->unresolved_rules--;
     }
     /*
      * Check if this rule is a target to any of them. If so,
      * disable them. As this operation is eventually very
      * expensive, it is only performed if goto rules have
      * actually been added.
      */
     if (ops->nr_goto_rules > 0) {
       list_for_each_entry(tmp, &ops->rules_list, list) {
         if (rtnl_dereference(tmp->ctarget) == rule) {
           RCU_INIT_POINTER(tmp->ctarget, NULL);
           ops->unresolved_rules++;
         }
       }
     }
     notify_rule_change(RTM_DELRULE, rule, ops, nlh, NETLINK_CB(skb).portid);
     fib_rule_put(rule);
     flush_route_cache(ops);
     rules_ops_put(ops);
     return 0;
   }
   err = -ENOENT;
 errout:
   rules_ops_put(ops);
   return err;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )
--- initial
+++ final
@@ -1,17 +1,17 @@
 static int inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh) {
   struct net *net = sock_net(skb->sk);
   struct ifaddrmsg *ifm;
   struct nlattr *tb[IFA_MAX + 1];
   struct in6_addr *pfx, *peer_pfx;
   u32 ifa_flags;
   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) return err;
   ifm = nlmsg_data(nlh);
   pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
   if (!pfx) return -EINVAL;
   ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
   /* We ignore other flags so far. */
   ifa_flags &= IFA_F_MANAGETEMPADDR;
   return inet6_addr_del(net, ifm->ifa_index, ifa_flags, pfx, ifm->ifa_prefixlen);
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@
       nlmsg_parse(e1,e2,e3,e4,e5
+            , NULL
       )