tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[NETLINK]: Convert netlink users to use group numbers instead of bitmasks

Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Patrick McHardy and committed by
David S. Miller ac6d439d d629b836

+183 -91
+1 -1
drivers/w1/w1_netlink.c
··· 51 51 52 52 memcpy(data, msg, sizeof(struct w1_netlink_msg)); 53 53 54 - NETLINK_CB(skb).dst_groups = dev->groups; 54 + NETLINK_CB(skb).dst_group = dev->groups; 55 55 netlink_broadcast(dev->nls, skb, 0, dev->groups, GFP_ATOMIC); 56 56 57 57 nlmsg_failure:
+22 -1
include/linux/netfilter/nfnetlink.h
··· 2 2 #define _NFNETLINK_H 3 3 #include <linux/types.h> 4 4 5 - /* nfnetlink groups: Up to 32 maximum */ 5 + #ifndef __KERNEL__ 6 + /* nfnetlink groups: Up to 32 maximum - backwards compatibility for userspace */ 6 7 #define NF_NETLINK_CONNTRACK_NEW 0x00000001 7 8 #define NF_NETLINK_CONNTRACK_UPDATE 0x00000002 8 9 #define NF_NETLINK_CONNTRACK_DESTROY 0x00000004 9 10 #define NF_NETLINK_CONNTRACK_EXP_NEW 0x00000008 10 11 #define NF_NETLINK_CONNTRACK_EXP_UPDATE 0x00000010 11 12 #define NF_NETLINK_CONNTRACK_EXP_DESTROY 0x00000020 13 + #endif 14 + 15 + enum nfnetlink_groups { 16 + NFNLGRP_NONE, 17 + #define NFNLGRP_NONE NFNLGRP_NONE 18 + NFNLGRP_CONNTRACK_NEW, 19 + #define NFNLGRP_CONNTRACK_NEW NFNLGRP_CONNTRACK_NEW 20 + NFNLGRP_CONNTRACK_UPDATE, 21 + #define NFNLGRP_CONNTRACK_UPDATE NFNLGRP_CONNTRACK_UPDATE 22 + NFNLGRP_CONNTRACK_DESTROY, 23 + #define NFNLGRP_CONNTRACK_DESTROY NFNLGRP_CONNTRACK_DESTROY 24 + NFNLGRP_CONNTRACK_EXP_NEW, 25 + #define NFNLGRP_CONNTRACK_EXP_NEW NFNLGRP_CONNTRACK_EXP_NEW 26 + NFNLGRP_CONNTRACK_EXP_UPDATE, 27 + #define NFNLGRP_CONNTRACK_EXP_UPDATE NFNLGRP_CONNTRACK_EXP_UPDATE 28 + NFNLGRP_CONNTRACK_EXP_DESTROY, 29 + #define NFNLGRP_CONNTRACK_EXP_DESTROY NFNLGRP_CONNTRACK_EXP_DESTROY 30 + __NFNLGRP_MAX, 31 + }; 32 + #define NFNLGRP_MAX (__NFNLGRP_MAX - 1) 12 33 13 34 /* Generic structure for encapsulation optional netfilter information. 14 35 * It is reminiscent of sockaddr, but with sa_family replaced
+14
include/linux/netfilter_decnet.h
··· 56 56 57 57 #define NFDN_RTMSG(r) ((unsigned char *)(r) + NLMSG_ALIGN(sizeof(struct nf_dn_rtmsg))) 58 58 59 + #ifndef __KERNEL__ 60 + /* backwards compatibility for userspace */ 59 61 #define DNRMG_L1_GROUP 0x01 60 62 #define DNRMG_L2_GROUP 0x02 63 + #endif 64 + 65 + enum { 66 + DNRNG_NLGRP_NONE, 67 + #define DNRNG_NLGRP_NONE DNRNG_NLGRP_NONE 68 + DNRNG_NLGRP_L1, 69 + #define DNRNG_NLGRP_L1 DNRNG_NLGRP_L1 70 + DNRNG_NLGRP_L2, 71 + #define DNRNG_NLGRP_L2 DNRNG_NLGRP_L2 72 + __DNRNG_NLGRP_MAX 73 + }; 74 + #define DNRNG_NLGRP_MAX (__DNRNG_NLGRP_MAX - 1) 61 75 62 76 #endif /*__LINUX_DECNET_NETFILTER_H*/
+39 -3
include/linux/rtnetlink.h
··· 826 826 #define TCA_RTA(r) ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcmsg)))) 827 827 #define TCA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcmsg)) 828 828 829 - 830 - /* RTnetlink multicast groups */ 831 - 829 + #ifndef __KERNEL__ 830 + /* RTnetlink multicast groups - backwards compatibility for userspace */ 832 831 #define RTMGRP_LINK 1 833 832 #define RTMGRP_NOTIFY 2 834 833 #define RTMGRP_NEIGH 4 ··· 846 847 #define RTMGRP_DECnet_ROUTE 0x4000 847 848 848 849 #define RTMGRP_IPV6_PREFIX 0x20000 850 + #endif 851 + 852 + /* RTnetlink multicast groups */ 853 + enum rtnetlink_groups { 854 + RTNLGRP_NONE, 855 + #define RTNLGRP_NONE RTNLGRP_NONE 856 + RTNLGRP_LINK, 857 + #define RTNLGRP_LINK RTNLGRP_LINK 858 + RTNLGRP_NOTIFY, 859 + #define RTNLGRP_NOTIFY RTNLGRP_NOTIFY 860 + RTNLGRP_NEIGH, 861 + #define RTNLGRP_NEIGH RTNLGRP_NEIGH 862 + RTNLGRP_TC, 863 + #define RTNLGRP_TC RTNLGRP_TC 864 + RTNLGRP_IPV4_IFADDR, 865 + #define RTNLGRP_IPV4_IFADDR RTNLGRP_IPV4_IFADDR 866 + RTNLGRP_IPV4_MROUTE, 867 + #define RTNLGRP_IPV4_MROUTE RTNLGRP_IPV4_MROUTE 868 + RTNLGRP_IPV4_ROUTE, 869 + #define RTNLGRP_IPV4_ROUTE RTNLGRP_IPV4_ROUTE 870 + RTNLGRP_IPV6_IFADDR, 871 + #define RTNLGRP_IPV6_IFADDR RTNLGRP_IPV6_IFADDR 872 + RTNLGRP_IPV6_MROUTE, 873 + #define RTNLGRP_IPV6_MROUTE RTNLGRP_IPV6_MROUTE 874 + RTNLGRP_IPV6_ROUTE, 875 + #define RTNLGRP_IPV6_ROUTE RTNLGRP_IPV6_ROUTE 876 + RTNLGRP_IPV6_IFINFO, 877 + #define RTNLGRP_IPV6_IFINFO RTNLGRP_IPV6_IFINFO 878 + RTNLGRP_DECnet_IFADDR, 879 + #define RTNLGRP_DECnet_IFADDR RTNLGRP_DECnet_IFADDR 880 + RTNLGRP_DECnet_ROUTE, 881 + #define RTNLGRP_DECnet_ROUTE RTNLGRP_DECnet_ROUTE 882 + RTNLGRP_IPV6_PREFIX, 883 + #define RTNLGRP_IPV6_PREFIX RTNLGRP_IPV6_PREFIX 884 + __RTNLGRP_MAX 885 + }; 886 + #define RTNLGRP_MAX (__RTNLGRP_MAX - 1) 849 887 850 888 /* TC action piece */ 851 889 struct tcamsg
+12 -1
include/linux/selinux_netlink.h
··· 20 20 SELNL_MSG_MAX 21 21 }; 22 22 23 - /* Multicast groups */ 23 + #ifndef __KERNEL__ 24 + /* Multicast groups - backwards compatiblility for userspace */ 24 25 #define SELNL_GRP_NONE 0x00000000 25 26 #define SELNL_GRP_AVC 0x00000001 /* AVC notifications */ 26 27 #define SELNL_GRP_ALL 0xffffffff 28 + #endif 29 + 30 + enum selinux_nlgroups { 31 + SELNLGRP_NONE, 32 + #define SELNLGRP_NONE SELNLGRP_NONE 33 + SELNLGRP_AVC, 34 + #define SELNLGRP_AVC SELNLGRP_AVC 35 + __SELNLGRP_MAX 36 + }; 37 + #define SELNLGRP_MAX (__SELNLGRP_MAX - 1) 27 38 28 39 /* Message structures */ 29 40 struct selnl_msg_setenforce {
+18
include/linux/xfrm.h
··· 258 258 __u8 proto; 259 259 }; 260 260 261 + #ifndef __KERNEL__ 262 + /* backwards compatibility for userspace */ 261 263 #define XFRMGRP_ACQUIRE 1 262 264 #define XFRMGRP_EXPIRE 2 263 265 #define XFRMGRP_SA 4 264 266 #define XFRMGRP_POLICY 8 267 + #endif 268 + 269 + enum xfrm_nlgroups { 270 + XFRMNLGRP_NONE, 271 + #define XFRMNLGRP_NONE XFRMNLGRP_NONE 272 + XFRMNLGRP_ACQUIRE, 273 + #define XFRMNLGRP_ACQUIRE XFRMNLGRP_ACQUIRE 274 + XFRMNLGRP_EXPIRE, 275 + #define XFRMNLGRP_EXPIRE XFRMNLGRP_EXPIRE 276 + XFRMNLGRP_SA, 277 + #define XFRMNLGRP_SA XFRMNLGRP_SA 278 + XFRMNLGRP_POLICY, 279 + #define XFRMNLGRP_POLICY XFRMNLGRP_POLICY 280 + __XFRMNLGRP_MAX 281 + }; 282 + #define XFRMNLGRP_MAX (__XFRMNLGRP_MAX - 1) 265 283 266 284 #endif /* _LINUX_XFRM_H */
+1 -1
lib/kobject_uevent.c
··· 93 93 } 94 94 } 95 95 96 - NETLINK_CB(skb).dst_groups = 1; 96 + NETLINK_CB(skb).dst_group = 1; 97 97 return netlink_broadcast(uevent_sock, skb, 0, 1, gfp_mask); 98 98 } 99 99
+2 -2
net/bridge/netfilter/ebt_ulog.c
··· 78 78 if (ub->qlen > 1) 79 79 ub->lastnlh->nlmsg_type = NLMSG_DONE; 80 80 81 - NETLINK_CB(ub->skb).dst_groups = 1 << nlgroup; 82 - netlink_broadcast(ebtulognl, ub->skb, 0, 1 << nlgroup, GFP_ATOMIC); 81 + NETLINK_CB(ub->skb).dst_group = nlgroup + 1; 82 + netlink_broadcast(ebtulognl, ub->skb, 0, nlgroup + 1, GFP_ATOMIC); 83 83 84 84 ub->qlen = 0; 85 85 ub->skb = NULL;
+4 -4
net/core/neighbour.c
··· 2343 2343 } 2344 2344 nlh = (struct nlmsghdr *)skb->data; 2345 2345 nlh->nlmsg_flags = NLM_F_REQUEST; 2346 - NETLINK_CB(skb).dst_groups = RTMGRP_NEIGH; 2347 - netlink_broadcast(rtnl, skb, 0, RTMGRP_NEIGH, GFP_ATOMIC); 2346 + NETLINK_CB(skb).dst_group = RTNLGRP_NEIGH; 2347 + netlink_broadcast(rtnl, skb, 0, RTNLGRP_NEIGH, GFP_ATOMIC); 2348 2348 } 2349 2349 2350 2350 static void neigh_app_notify(struct neighbour *n) ··· 2361 2361 return; 2362 2362 } 2363 2363 nlh = (struct nlmsghdr *)skb->data; 2364 - NETLINK_CB(skb).dst_groups = RTMGRP_NEIGH; 2365 - netlink_broadcast(rtnl, skb, 0, RTMGRP_NEIGH, GFP_ATOMIC); 2364 + NETLINK_CB(skb).dst_group = RTNLGRP_NEIGH; 2365 + netlink_broadcast(rtnl, skb, 0, RTNLGRP_NEIGH, GFP_ATOMIC); 2366 2366 } 2367 2367 2368 2368 #endif /* CONFIG_ARPD */
+3 -3
net/core/rtnetlink.c
··· 148 148 { 149 149 int err = 0; 150 150 151 - NETLINK_CB(skb).dst_groups = group; 151 + NETLINK_CB(skb).dst_group = group; 152 152 if (echo) 153 153 atomic_inc(&skb->users); 154 154 netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL); ··· 458 458 kfree_skb(skb); 459 459 return; 460 460 } 461 - NETLINK_CB(skb).dst_groups = RTMGRP_LINK; 462 - netlink_broadcast(rtnl, skb, 0, RTMGRP_LINK, GFP_KERNEL); 461 + NETLINK_CB(skb).dst_group = RTNLGRP_LINK; 462 + netlink_broadcast(rtnl, skb, 0, RTNLGRP_LINK, GFP_KERNEL); 463 463 } 464 464 465 465 static int rtnetlink_done(struct netlink_callback *cb)
+2 -2
net/core/wireless.c
··· 1144 1144 kfree_skb(skb); 1145 1145 return; 1146 1146 } 1147 - NETLINK_CB(skb).dst_groups = RTMGRP_LINK; 1148 - netlink_broadcast(rtnl, skb, 0, RTMGRP_LINK, GFP_ATOMIC); 1147 + NETLINK_CB(skb).dst_group = RTNLGRP_LINK; 1148 + netlink_broadcast(rtnl, skb, 0, RTNLGRP_LINK, GFP_ATOMIC); 1149 1149 } 1150 1150 #endif /* WE_EVENT_NETLINK */ 1151 1151
+4 -4
net/decnet/dn_dev.c
··· 752 752 753 753 skb = alloc_skb(size, GFP_KERNEL); 754 754 if (!skb) { 755 - netlink_set_err(rtnl, 0, RTMGRP_DECnet_IFADDR, ENOBUFS); 755 + netlink_set_err(rtnl, 0, RTNLGRP_DECnet_IFADDR, ENOBUFS); 756 756 return; 757 757 } 758 758 if (dn_dev_fill_ifaddr(skb, ifa, 0, 0, event, 0) < 0) { 759 759 kfree_skb(skb); 760 - netlink_set_err(rtnl, 0, RTMGRP_DECnet_IFADDR, EINVAL); 760 + netlink_set_err(rtnl, 0, RTNLGRP_DECnet_IFADDR, EINVAL); 761 761 return; 762 762 } 763 - NETLINK_CB(skb).dst_groups = RTMGRP_DECnet_IFADDR; 764 - netlink_broadcast(rtnl, skb, 0, RTMGRP_DECnet_IFADDR, GFP_KERNEL); 763 + NETLINK_CB(skb).dst_group = RTNLGRP_DECnet_IFADDR; 764 + netlink_broadcast(rtnl, skb, 0, RTNLGRP_DECnet_IFADDR, GFP_KERNEL); 765 765 } 766 766 767 767 static int dn_dev_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
+2 -2
net/decnet/dn_table.c
··· 349 349 kfree_skb(skb); 350 350 return; 351 351 } 352 - NETLINK_CB(skb).dst_groups = RTMGRP_DECnet_ROUTE; 352 + NETLINK_CB(skb).dst_group = RTNLGRP_DECnet_ROUTE; 353 353 if (nlh->nlmsg_flags & NLM_F_ECHO) 354 354 atomic_inc(&skb->users); 355 - netlink_broadcast(rtnl, skb, pid, RTMGRP_DECnet_ROUTE, GFP_KERNEL); 355 + netlink_broadcast(rtnl, skb, pid, RTNLGRP_DECnet_ROUTE, GFP_KERNEL); 356 356 if (nlh->nlmsg_flags & NLM_F_ECHO) 357 357 netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT); 358 358 }
+3 -3
net/decnet/netfilter/dn_rtmsg.c
··· 71 71 72 72 switch(flags & DN_RT_CNTL_MSK) { 73 73 case DN_RT_PKT_L1RT: 74 - group = DNRMG_L1_GROUP; 74 + group = DNRMG_L1_NLGRP; 75 75 break; 76 76 case DN_RT_PKT_L2RT: 77 - group = DNRMG_L2_GROUP; 77 + group = DNRMG_L2_NLGRP; 78 78 break; 79 79 default: 80 80 return; ··· 83 83 skb2 = dnrmg_build_message(skb, &status); 84 84 if (skb2 == NULL) 85 85 return; 86 - NETLINK_CB(skb2).dst_groups = group; 86 + NETLINK_CB(skb2).dst_group = group; 87 87 netlink_broadcast(dnrmg, skb2, 0, group, GFP_ATOMIC); 88 88 } 89 89
+3 -4
net/ipv4/devinet.c
··· 1111 1111 struct sk_buff *skb = alloc_skb(size, GFP_KERNEL); 1112 1112 1113 1113 if (!skb) 1114 - netlink_set_err(rtnl, 0, RTMGRP_IPV4_IFADDR, ENOBUFS); 1114 + netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, ENOBUFS); 1115 1115 else if (inet_fill_ifaddr(skb, ifa, current->pid, 0, event, 0) < 0) { 1116 1116 kfree_skb(skb); 1117 - netlink_set_err(rtnl, 0, RTMGRP_IPV4_IFADDR, EINVAL); 1117 + netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, EINVAL); 1118 1118 } else { 1119 - NETLINK_CB(skb).dst_groups = RTMGRP_IPV4_IFADDR; 1120 - netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV4_IFADDR, GFP_KERNEL); 1119 + netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV4_IFADDR, GFP_KERNEL); 1121 1120 } 1122 1121 } 1123 1122
+1 -1
net/ipv4/fib_frontend.c
··· 560 560 pid = nlh->nlmsg_pid; /*pid of sending process */ 561 561 NETLINK_CB(skb).pid = 0; /* from kernel */ 562 562 NETLINK_CB(skb).dst_pid = pid; 563 - NETLINK_CB(skb).dst_groups = 0; /* unicast */ 563 + NETLINK_CB(skb).dst_group = 0; /* unicast */ 564 564 netlink_unicast(sk, skb, pid, MSG_DONTWAIT); 565 565 } 566 566
+2 -2
net/ipv4/fib_semantics.c
··· 290 290 kfree_skb(skb); 291 291 return; 292 292 } 293 - NETLINK_CB(skb).dst_groups = RTMGRP_IPV4_ROUTE; 293 + NETLINK_CB(skb).dst_group = RTNLGRP_IPV4_ROUTE; 294 294 if (n->nlmsg_flags&NLM_F_ECHO) 295 295 atomic_inc(&skb->users); 296 - netlink_broadcast(rtnl, skb, pid, RTMGRP_IPV4_ROUTE, GFP_KERNEL); 296 + netlink_broadcast(rtnl, skb, pid, RTNLGRP_IPV4_ROUTE, GFP_KERNEL); 297 297 if (n->nlmsg_flags&NLM_F_ECHO) 298 298 netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT); 299 299 }
+6 -6
net/ipv4/netfilter/ip_conntrack_netlink.c
··· 297 297 struct sk_buff *skb; 298 298 unsigned int type; 299 299 unsigned char *b; 300 - unsigned int flags = 0, groups; 300 + unsigned int flags = 0, group; 301 301 302 302 /* ignore our fake conntrack entry */ 303 303 if (ct == &ip_conntrack_untracked) ··· 305 305 306 306 if (events & IPCT_DESTROY) { 307 307 type = IPCTNL_MSG_CT_DELETE; 308 - groups = NF_NETLINK_CONNTRACK_DESTROY; 308 + group = NFNLGRP_CONNTRACK_DESTROY; 309 309 goto alloc_skb; 310 310 } 311 311 if (events & (IPCT_NEW | IPCT_RELATED)) { ··· 313 313 flags = NLM_F_CREATE|NLM_F_EXCL; 314 314 /* dump everything */ 315 315 events = ~0UL; 316 - groups = NF_NETLINK_CONNTRACK_NEW; 316 + group = NFNLGRP_CONNTRACK_NEW; 317 317 goto alloc_skb; 318 318 } 319 319 if (events & (IPCT_STATUS | ··· 322 322 IPCT_HELPINFO | 323 323 IPCT_NATINFO)) { 324 324 type = IPCTNL_MSG_CT_NEW; 325 - groups = NF_NETLINK_CONNTRACK_UPDATE; 325 + group = NFNLGRP_CONNTRACK_UPDATE; 326 326 goto alloc_skb; 327 327 } 328 328 ··· 375 375 goto nfattr_failure; 376 376 377 377 nlh->nlmsg_len = skb->tail - b; 378 - nfnetlink_send(skb, 0, groups, 0); 378 + nfnetlink_send(skb, 0, group, 0); 379 379 return NOTIFY_DONE; 380 380 381 381 nlmsg_failure: ··· 1194 1194 1195 1195 nlh->nlmsg_len = skb->tail - b; 1196 1196 proto = exp->tuple.dst.protonum; 1197 - nfnetlink_send(skb, 0, NF_NETLINK_CONNTRACK_EXP_NEW, 0); 1197 + nfnetlink_send(skb, 0, NFNLGRP_CONNTRACK_EXP_NEW, 0); 1198 1198 return NOTIFY_DONE; 1199 1199 1200 1200 nlmsg_failure:
+4 -4
net/ipv4/netfilter/ipt_ULOG.c
··· 116 116 if (ub->qlen > 1) 117 117 ub->lastnlh->nlmsg_type = NLMSG_DONE; 118 118 119 - NETLINK_CB(ub->skb).dst_groups = (1 << nlgroupnum); 120 - DEBUGP("ipt_ULOG: throwing %d packets to netlink mask %u\n", 121 - ub->qlen, nlgroupnum); 122 - netlink_broadcast(nflognl, ub->skb, 0, (1 << nlgroupnum), GFP_ATOMIC); 119 + NETLINK_CB(ub->skb).dst_group = nlgroupnum + 1; 120 + DEBUGP("ipt_ULOG: throwing %d packets to netlink group %u\n", 121 + ub->qlen, nlgroupnum + 1); 122 + netlink_broadcast(nflognl, ub->skb, 0, nlgroupnum + 1, GFP_ATOMIC); 123 123 124 124 ub->qlen = 0; 125 125 ub->skb = NULL;
+12 -12
net/ipv6/addrconf.c
··· 2858 2858 2859 2859 skb = alloc_skb(size, GFP_ATOMIC); 2860 2860 if (!skb) { 2861 - netlink_set_err(rtnl, 0, RTMGRP_IPV6_IFADDR, ENOBUFS); 2861 + netlink_set_err(rtnl, 0, RTNLGRP_IPV6_IFADDR, ENOBUFS); 2862 2862 return; 2863 2863 } 2864 2864 if (inet6_fill_ifaddr(skb, ifa, current->pid, 0, event, 0) < 0) { 2865 2865 kfree_skb(skb); 2866 - netlink_set_err(rtnl, 0, RTMGRP_IPV6_IFADDR, EINVAL); 2866 + netlink_set_err(rtnl, 0, RTNLGRP_IPV6_IFADDR, EINVAL); 2867 2867 return; 2868 2868 } 2869 - NETLINK_CB(skb).dst_groups = RTMGRP_IPV6_IFADDR; 2870 - netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV6_IFADDR, GFP_ATOMIC); 2869 + NETLINK_CB(skb).dst_group = RTNLGRP_IPV6_IFADDR; 2870 + netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV6_IFADDR, GFP_ATOMIC); 2871 2871 } 2872 2872 2873 2873 static void inline ipv6_store_devconf(struct ipv6_devconf *cnf, ··· 2994 2994 2995 2995 skb = alloc_skb(size, GFP_ATOMIC); 2996 2996 if (!skb) { 2997 - netlink_set_err(rtnl, 0, RTMGRP_IPV6_IFINFO, ENOBUFS); 2997 + netlink_set_err(rtnl, 0, RTNLGRP_IPV6_IFINFO, ENOBUFS); 2998 2998 return; 2999 2999 } 3000 3000 if (inet6_fill_ifinfo(skb, idev, current->pid, 0, event, 0) < 0) { 3001 3001 kfree_skb(skb); 3002 - netlink_set_err(rtnl, 0, RTMGRP_IPV6_IFINFO, EINVAL); 3002 + netlink_set_err(rtnl, 0, RTNLGRP_IPV6_IFINFO, EINVAL); 3003 3003 return; 3004 3004 } 3005 - NETLINK_CB(skb).dst_groups = RTMGRP_IPV6_IFINFO; 3006 - netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV6_IFINFO, GFP_ATOMIC); 3005 + NETLINK_CB(skb).dst_group = RTNLGRP_IPV6_IFINFO; 3006 + netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV6_IFINFO, GFP_ATOMIC); 3007 3007 } 3008 3008 3009 3009 static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev, ··· 3054 3054 3055 3055 skb = alloc_skb(size, GFP_ATOMIC); 3056 3056 if (!skb) { 3057 - netlink_set_err(rtnl, 0, RTMGRP_IPV6_PREFIX, ENOBUFS); 3057 + netlink_set_err(rtnl, 0, RTNLGRP_IPV6_PREFIX, ENOBUFS); 3058 3058 return; 3059 3059 } 3060 3060 if (inet6_fill_prefix(skb, idev, pinfo, current->pid, 0, event, 0) < 0) { 3061 3061 kfree_skb(skb); 3062 - netlink_set_err(rtnl, 0, RTMGRP_IPV6_PREFIX, EINVAL); 3062 + netlink_set_err(rtnl, 0, RTNLGRP_IPV6_PREFIX, EINVAL); 3063 3063 return; 3064 3064 } 3065 - NETLINK_CB(skb).dst_groups = RTMGRP_IPV6_PREFIX; 3066 - netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV6_PREFIX, GFP_ATOMIC); 3065 + NETLINK_CB(skb).dst_group = RTNLGRP_IPV6_PREFIX; 3066 + netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV6_PREFIX, GFP_ATOMIC); 3067 3067 } 3068 3068 3069 3069 static struct rtnetlink_link inet6_rtnetlink_table[RTM_NR_MSGTYPES] = {
+4 -4
net/ipv6/route.c
··· 1850 1850 1851 1851 skb = alloc_skb(size, gfp_any()); 1852 1852 if (!skb) { 1853 - netlink_set_err(rtnl, 0, RTMGRP_IPV6_ROUTE, ENOBUFS); 1853 + netlink_set_err(rtnl, 0, RTNLGRP_IPV6_ROUTE, ENOBUFS); 1854 1854 return; 1855 1855 } 1856 1856 if (rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0) < 0) { 1857 1857 kfree_skb(skb); 1858 - netlink_set_err(rtnl, 0, RTMGRP_IPV6_ROUTE, EINVAL); 1858 + netlink_set_err(rtnl, 0, RTNLGRP_IPV6_ROUTE, EINVAL); 1859 1859 return; 1860 1860 } 1861 - NETLINK_CB(skb).dst_groups = RTMGRP_IPV6_ROUTE; 1862 - netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV6_ROUTE, gfp_any()); 1861 + NETLINK_CB(skb).dst_group = RTNLGRP_IPV6_ROUTE; 1862 + netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV6_ROUTE, gfp_any()); 1863 1863 } 1864 1864 1865 1865 /*
+1 -1
net/netfilter/nfnetlink.c
··· 198 198 int allocation = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL; 199 199 int err = 0; 200 200 201 - NETLINK_CB(skb).dst_groups = group; 201 + NETLINK_CB(skb).dst_group = group; 202 202 if (echo) 203 203 atomic_inc(&skb->users); 204 204 netlink_broadcast(nfnl, skb, pid, group, allocation);
+4 -4
net/sched/act_api.c
··· 593 593 nlh->nlmsg_flags |= NLM_F_ROOT; 594 594 module_put(a->ops->owner); 595 595 kfree(a); 596 - err = rtnetlink_send(skb, pid, RTMGRP_TC, n->nlmsg_flags&NLM_F_ECHO); 596 + err = rtnetlink_send(skb, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO); 597 597 if (err > 0) 598 598 return 0; 599 599 ··· 656 656 657 657 /* now do the delete */ 658 658 tcf_action_destroy(head, 0); 659 - ret = rtnetlink_send(skb, pid, RTMGRP_TC, 659 + ret = rtnetlink_send(skb, pid, RTNLGRP_TC, 660 660 n->nlmsg_flags&NLM_F_ECHO); 661 661 if (ret > 0) 662 662 return 0; ··· 698 698 x->rta_len = skb->tail - (u8*)x; 699 699 700 700 nlh->nlmsg_len = skb->tail - b; 701 - NETLINK_CB(skb).dst_groups = RTMGRP_TC; 701 + NETLINK_CB(skb).dst_group = RTNLGRP_TC; 702 702 703 - err = rtnetlink_send(skb, pid, RTMGRP_TC, flags&NLM_F_ECHO); 703 + err = rtnetlink_send(skb, pid, RTNLGRP_TC, flags&NLM_F_ECHO); 704 704 if (err > 0) 705 705 err = 0; 706 706 return err;
+1 -1
net/sched/cls_api.c
··· 367 367 return -EINVAL; 368 368 } 369 369 370 - return rtnetlink_send(skb, pid, RTMGRP_TC, n->nlmsg_flags&NLM_F_ECHO); 370 + return rtnetlink_send(skb, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO); 371 371 } 372 372 373 373 struct tcf_dump_args
+2 -2
net/sched/sch_api.c
··· 816 816 } 817 817 818 818 if (skb->len) 819 - return rtnetlink_send(skb, pid, RTMGRP_TC, n->nlmsg_flags&NLM_F_ECHO); 819 + return rtnetlink_send(skb, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO); 820 820 821 821 err_out: 822 822 kfree_skb(skb); ··· 1040 1040 return -EINVAL; 1041 1041 } 1042 1042 1043 - return rtnetlink_send(skb, pid, RTMGRP_TC, n->nlmsg_flags&NLM_F_ECHO); 1043 + return rtnetlink_send(skb, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO); 1044 1044 } 1045 1045 1046 1046 struct qdisc_dump_args
+14 -21
net/xfrm/xfrm_user.c
··· 1125 1125 if (build_expire(skb, x, c->data.hard) < 0) 1126 1126 BUG(); 1127 1127 1128 - NETLINK_CB(skb).dst_groups = XFRMGRP_EXPIRE; 1129 - 1130 - return netlink_broadcast(xfrm_nl, skb, 0, XFRMGRP_EXPIRE, GFP_ATOMIC); 1128 + NETLINK_CB(skb).dst_group = XFRMNLGRP_EXPIRE; 1129 + return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_EXPIRE, GFP_ATOMIC); 1131 1130 } 1132 1131 1133 1132 static int xfrm_notify_sa_flush(struct km_event *c) ··· 1151 1152 1152 1153 nlh->nlmsg_len = skb->tail - b; 1153 1154 1154 - NETLINK_CB(skb).dst_groups = XFRMGRP_SA; 1155 - 1156 - return netlink_broadcast(xfrm_nl, skb, 0, XFRMGRP_SA, GFP_ATOMIC); 1155 + NETLINK_CB(skb).dst_group = XFRMNLGRP_SA; 1156 + return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_SA, GFP_ATOMIC); 1157 1157 1158 1158 nlmsg_failure: 1159 1159 kfree_skb(skb); ··· 1226 1228 1227 1229 nlh->nlmsg_len = skb->tail - b; 1228 1230 1229 - NETLINK_CB(skb).dst_groups = XFRMGRP_SA; 1230 - 1231 - return netlink_broadcast(xfrm_nl, skb, 0, XFRMGRP_SA, GFP_ATOMIC); 1231 + NETLINK_CB(skb).dst_group = XFRMNLGRP_SA; 1232 + return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_SA, GFP_ATOMIC); 1232 1233 1233 1234 nlmsg_failure: 1234 1235 rtattr_failure: ··· 1305 1308 if (build_acquire(skb, x, xt, xp, dir) < 0) 1306 1309 BUG(); 1307 1310 1308 - NETLINK_CB(skb).dst_groups = XFRMGRP_ACQUIRE; 1309 - 1310 - return netlink_broadcast(xfrm_nl, skb, 0, XFRMGRP_ACQUIRE, GFP_ATOMIC); 1311 + NETLINK_CB(skb).dst_group = XFRMNLGRP_ACQUIRE; 1312 + return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_ACQUIRE, GFP_ATOMIC); 1311 1313 } 1312 1314 1313 1315 /* User gives us xfrm_user_policy_info followed by an array of 0 ··· 1405 1409 if (build_polexpire(skb, xp, dir, c->data.hard) < 0) 1406 1410 BUG(); 1407 1411 1408 - NETLINK_CB(skb).dst_groups = XFRMGRP_EXPIRE; 1409 - 1410 - return netlink_broadcast(xfrm_nl, skb, 0, XFRMGRP_EXPIRE, GFP_ATOMIC); 1412 + NETLINK_CB(skb).dst_group = XFRMNLGRP_EXPIRE; 1413 + return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_EXPIRE, GFP_ATOMIC); 1411 1414 } 1412 1415 1413 1416 static int xfrm_notify_policy(struct xfrm_policy *xp, int dir, struct km_event *c) ··· 1454 1459 1455 1460 nlh->nlmsg_len = skb->tail - b; 1456 1461 1457 - NETLINK_CB(skb).dst_groups = XFRMGRP_POLICY; 1458 - 1459 - return netlink_broadcast(xfrm_nl, skb, 0, XFRMGRP_POLICY, GFP_ATOMIC); 1462 + NETLINK_CB(skb).dst_group = XFRMNLGRP_POLICY; 1463 + return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_POLICY, GFP_ATOMIC); 1460 1464 1461 1465 nlmsg_failure: 1462 1466 rtattr_failure: ··· 1480 1486 1481 1487 nlh->nlmsg_len = skb->tail - b; 1482 1488 1483 - NETLINK_CB(skb).dst_groups = XFRMGRP_POLICY; 1484 - 1485 - return netlink_broadcast(xfrm_nl, skb, 0, XFRMGRP_POLICY, GFP_ATOMIC); 1489 + NETLINK_CB(skb).dst_group = XFRMNLGRP_POLICY; 1490 + return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_POLICY, GFP_ATOMIC); 1486 1491 1487 1492 nlmsg_failure: 1488 1493 kfree_skb(skb);
+2 -2
security/selinux/netlink.c
··· 80 80 nlh = NLMSG_PUT(skb, 0, 0, msgtype, len); 81 81 selnl_add_payload(nlh, len, msgtype, data); 82 82 nlh->nlmsg_len = skb->tail - tmp; 83 - NETLINK_CB(skb).dst_groups = SELNL_GRP_AVC; 84 - netlink_broadcast(selnl, skb, 0, SELNL_GRP_AVC, GFP_USER); 83 + NETLINK_CB(skb).dst_group = SELNLGRP_AVC; 84 + netlink_broadcast(selnl, skb, 0, SELNLGRP_AVC, GFP_USER); 85 85 out: 86 86 return; 87 87