}
 
        err = nlmsg_parse(nlh, crypto_msg_min[type], attrs, CRYPTOCFGA_MAX,
-                         crypto_policy, NULL);
+                         crypto_policy, extack);
        if (err < 0)
                return err;
 
 
                        goto team_put;
                }
                err = nla_parse_nested(opt_attrs, TEAM_ATTR_OPTION_MAX,
-                                      nl_option, team_nl_option_policy, NULL);
+                                      nl_option, team_nl_option_policy,
+                                      info->extack);
                if (err)
                        goto team_put;
                if (!opt_attrs[TEAM_ATTR_OPTION_NAME] ||
 
 
        if (nla_parse_nested(attrs, NL802154_KEY_ATTR_MAX,
                             info->attrs[NL802154_ATTR_SEC_KEY],
-                            nl802154_key_policy, NULL))
+                            nl802154_key_policy, info->extack))
                return -EINVAL;
 
        if (!attrs[NL802154_KEY_ATTR_USAGE_FRAMES] ||
 
        if (nla_parse_nested(attrs, NL802154_KEY_ATTR_MAX,
                             info->attrs[NL802154_ATTR_SEC_KEY],
-                            nl802154_key_policy, NULL))
+                            nl802154_key_policy, info->extack))
                return -EINVAL;
 
        if (ieee802154_llsec_parse_key_id(attrs[NL802154_KEY_ATTR_ID], &id) < 0)
 
        if (nla_parse_nested(attrs, NL802154_DEV_ATTR_MAX,
                             info->attrs[NL802154_ATTR_SEC_DEVICE],
-                            nl802154_dev_policy, NULL))
+                            nl802154_dev_policy, info->extack))
                return -EINVAL;
 
        if (!attrs[NL802154_DEV_ATTR_EXTENDED_ADDR])
        if (!info->attrs[NL802154_ATTR_SEC_DEVKEY] ||
            nla_parse_nested(attrs, NL802154_DEVKEY_ATTR_MAX,
                             info->attrs[NL802154_ATTR_SEC_DEVKEY],
-                            nl802154_devkey_policy, NULL) < 0)
+                            nl802154_devkey_policy, info->extack) < 0)
                return -EINVAL;
 
        if (!attrs[NL802154_DEVKEY_ATTR_FRAME_COUNTER] ||
 
        if (nla_parse_nested(attrs, NL802154_DEVKEY_ATTR_MAX,
                             info->attrs[NL802154_ATTR_SEC_DEVKEY],
-                            nl802154_devkey_policy, NULL))
+                            nl802154_devkey_policy, info->extack))
                return -EINVAL;
 
        if (!attrs[NL802154_DEVKEY_ATTR_EXTENDED_ADDR])
 
                if (!info->attrs[IPVS_CMD_ATTR_DAEMON] ||
                    nla_parse_nested(daemon_attrs, IPVS_DAEMON_ATTR_MAX,
                                     info->attrs[IPVS_CMD_ATTR_DAEMON],
-                                    ip_vs_daemon_policy, NULL))
+                                    ip_vs_daemon_policy, info->extack))
                        goto out;
 
                if (cmd == IPVS_CMD_NEW_DAEMON)
 
                __u8 subsys_id = NFNL_SUBSYS_ID(type);
 
                err = nla_parse(cda, ss->cb[cb_id].attr_count, attr, attrlen,
-                               ss->cb[cb_id].policy, NULL);
+                               ss->cb[cb_id].policy, extack);
                if (err < 0) {
                        rcu_read_unlock();
                        return err;
 
 
        if (attrbuf) {
                err = nlmsg_parse(nlh, hdrlen, attrbuf, family->maxattr,
-                                 ops->policy, NULL);
+                                 ops->policy, extack);
                if (err < 0)
                        goto out;
        }
 
 
        nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) {
                rc = nla_parse_nested(sdp_attrs, NFC_SDP_ATTR_MAX, attr,
-                                     nfc_sdp_genl_policy, NULL);
+                                     nfc_sdp_genl_policy, info->extack);
 
                if (rc != 0) {
                        rc = -EINVAL;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX,
                               info->attrs[TIPC_NLA_BEARER],
-                              tipc_nl_bearer_policy, NULL);
+                              tipc_nl_bearer_policy, info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX,
                               info->attrs[TIPC_NLA_BEARER],
-                              tipc_nl_bearer_policy, NULL);
+                              tipc_nl_bearer_policy, info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX,
                               info->attrs[TIPC_NLA_BEARER],
-                              tipc_nl_bearer_policy, NULL);
+                              tipc_nl_bearer_policy, info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX,
                               info->attrs[TIPC_NLA_BEARER],
-                              tipc_nl_bearer_policy, NULL);
+                              tipc_nl_bearer_policy, info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX,
                               info->attrs[TIPC_NLA_BEARER],
-                              tipc_nl_bearer_policy, NULL);
+                              tipc_nl_bearer_policy, info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_MEDIA_MAX,
                               info->attrs[TIPC_NLA_MEDIA],
-                              tipc_nl_media_policy, NULL);
+                              tipc_nl_media_policy, info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_MEDIA_MAX,
                               info->attrs[TIPC_NLA_MEDIA],
-                              tipc_nl_media_policy, NULL);
+                              tipc_nl_media_policy, info->extack);
 
        if (!attrs[TIPC_NLA_MEDIA_NAME])
                return -EINVAL;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_NET_MAX,
                               info->attrs[TIPC_NLA_NET], tipc_nl_net_policy,
-                              NULL);
+                              info->extack);
        if (err)
                return err;
 
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_NET_MAX,
                               info->attrs[TIPC_NLA_NET], tipc_nl_net_policy,
-                              NULL);
+                              info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
                               info->attrs[TIPC_NLA_LINK],
-                              tipc_nl_link_policy, NULL);
+                              tipc_nl_link_policy, info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
                               info->attrs[TIPC_NLA_LINK],
-                              tipc_nl_link_policy, NULL);
+                              tipc_nl_link_policy, info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(attrs, TIPC_NLA_MON_MAX,
                               info->attrs[TIPC_NLA_MON],
-                              tipc_nl_monitor_policy, NULL);
+                              tipc_nl_monitor_policy, info->extack);
        if (err)
                return err;
 
 
                int err = nla_parse_nested(kdt,
                                           NUM_NL80211_KEY_DEFAULT_TYPES - 1,
                                           info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
-                                          nl80211_key_default_policy, NULL);
+                                          nl80211_key_default_policy,
+                                          info->extack);
                if (err)
                        return err;
 
                                    rem_txq_params) {
                        result = nla_parse_nested(tb, NL80211_TXQ_ATTR_MAX,
                                                  nl_txq_params,
-                                                 txq_params_policy, NULL);
+                                                 txq_params_policy,
+                                                 info->extack);
                        if (result)
                                return result;
                        result = parse_txq_params(tb, &txq_params);
                if (sband == NULL)
                        return -EINVAL;
                err = nla_parse_nested(tb, NL80211_TXRATE_MAX, tx_rates,
-                                      nl80211_txattr_policy, NULL);
+                                      nl80211_txattr_policy, info->extack);
                if (err)
                        return err;
                if (tb[NL80211_TXRATE_LEGACY]) {
                return 0;
 
        if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX, nla,
-                            sta_flags_policy, NULL))
+                            sta_flags_policy, info->extack))
                return -EINVAL;
 
        /*
 
        nla = info->attrs[NL80211_ATTR_STA_WME];
        err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
-                              nl80211_sta_wme_policy, NULL);
+                              nl80211_sta_wme_policy, info->extack);
        if (err)
                return err;
 
                return -EINVAL;
        if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
                             info->attrs[NL80211_ATTR_MESH_CONFIG],
-                            nl80211_meshconf_params_policy, NULL))
+                            nl80211_meshconf_params_policy, info->extack))
                return -EINVAL;
 
        /* This makes sure that there aren't more than 32 mesh config
                return -EINVAL;
        if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
                             info->attrs[NL80211_ATTR_MESH_SETUP],
-                            nl80211_mesh_setup_params_policy, NULL))
+                            nl80211_mesh_setup_params_policy, info->extack))
                return -EINVAL;
 
        if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
        nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
                            rem_reg_rules) {
                r = nla_parse_nested(tb, NL80211_REG_RULE_ATTR_MAX,
-                                    nl_reg_rule, reg_rule_policy, NULL);
+                                    nl_reg_rule, reg_rule_policy,
+                                    info->extack);
                if (r)
                        goto bad_reg;
                r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
 
        err = nla_parse_nested(csa_attrs, NL80211_ATTR_MAX,
                               info->attrs[NL80211_ATTR_CSA_IES],
-                              nl80211_policy, NULL);
+                              nl80211_policy, info->extack);
        if (err)
                return err;
 
                return -EINVAL;
 
        err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
-                              nl80211_attr_cqm_policy, NULL);
+                              nl80211_attr_cqm_policy, info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TRIG,
                               info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
-                              nl80211_wowlan_policy, NULL);
+                              nl80211_wowlan_policy, info->extack);
        if (err)
                return err;
 
                        u8 *mask_pat;
 
                        nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
-                                        NULL, NULL);
+                                        NULL, info->extack);
                        err = -EINVAL;
                        if (!pat_tb[NL80211_PKTPAT_MASK] ||
                            !pat_tb[NL80211_PKTPAT_PATTERN])
 
        err = nla_parse_nested(tb, MAX_NL80211_REKEY_DATA,
                               info->attrs[NL80211_ATTR_REKEY_DATA],
-                              nl80211_rekey_policy, NULL);
+                              nl80211_rekey_policy, info->extack);
        if (err)
                return err;
 
 
        err = nla_parse_nested(tb, NL80211_NAN_FUNC_ATTR_MAX,
                               info->attrs[NL80211_ATTR_NAN_FUNC],
-                              nl80211_nan_func_policy, NULL);
+                              nl80211_nan_func_policy, info->extack);
        if (err)
                return err;
 
 
                err = nla_parse_nested(srf_tb, NL80211_NAN_SRF_ATTR_MAX,
                                       tb[NL80211_NAN_FUNC_SRF],
-                                      nl80211_nan_srf_policy, NULL);
+                                      nl80211_nan_srf_policy, info->extack);
                if (err)
                        goto out;
 
 
 
        err = nlmsg_parse(nlh, xfrm_msg_min[type], attrs,
                          link->nla_max ? : XFRMA_MAX,
-                         link->nla_pol ? : xfrma_policy, NULL);
+                         link->nla_pol ? : xfrma_policy, extack);
        if (err < 0)
                return err;