aboutsummaryrefslogtreecommitdiffstats
path: root/net/sched
diff options
context:
space:
mode:
authorPatrick McHardy <kaber@trash.net>2008-01-23 01:11:17 -0500
committerDavid S. Miller <davem@davemloft.net>2008-01-28 18:11:10 -0500
commit1e90474c377e92db7262a8968a45c1dd980ca9e5 (patch)
tree645af56dcb17cf1a76fd3b7f1a8b833a3fffc3d7 /net/sched
parent01480e1cf5e2118eba8a8968239f3242072f9563 (diff)
[NET_SCHED]: Convert packet schedulers from rtnetlink to new netlink API
Convert packet schedulers to use the netlink API. Unfortunately a gradual conversion is not possible without breaking compilation in the middle or adding lots of casts, so this patch converts them all in one step. The patch has been mostly generated automatically with some minor edits to at least allow seperate conversion of classifiers and actions. Signed-off-by: Patrick McHardy <kaber@trash.net> Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'net/sched')
-rw-r--r--net/sched/act_api.c2
-rw-r--r--net/sched/act_police.c6
-rw-r--r--net/sched/sch_api.c87
-rw-r--r--net/sched/sch_atm.c48
-rw-r--r--net/sched/sch_cbq.c156
-rw-r--r--net/sched/sch_dsmark.c85
-rw-r--r--net/sched/sch_fifo.c10
-rw-r--r--net/sched/sch_generic.c6
-rw-r--r--net/sched/sch_gred.c59
-rw-r--r--net/sched/sch_hfsc.c72
-rw-r--r--net/sched/sch_htb.c68
-rw-r--r--net/sched/sch_ingress.c14
-rw-r--r--net/sched/sch_netem.c100
-rw-r--r--net/sched/sch_prio.c30
-rw-r--r--net/sched/sch_red.c52
-rw-r--r--net/sched/sch_sfq.c12
-rw-r--r--net/sched/sch_tbf.c49
-rw-r--r--net/sched/sch_teql.c2
18 files changed, 447 insertions, 411 deletions
diff --git a/net/sched/act_api.c b/net/sched/act_api.c
index 3825508fdcd1..11f3097a6912 100644
--- a/net/sched/act_api.c
+++ b/net/sched/act_api.c
@@ -227,7 +227,7 @@ struct tcf_common *tcf_hash_create(u32 index, struct rtattr *est, struct tc_acti
227 p->tcfc_tm.lastuse = jiffies; 227 p->tcfc_tm.lastuse = jiffies;
228 if (est) 228 if (est)
229 gen_new_estimator(&p->tcfc_bstats, &p->tcfc_rate_est, 229 gen_new_estimator(&p->tcfc_bstats, &p->tcfc_rate_est,
230 &p->tcfc_lock, est); 230 &p->tcfc_lock, (struct nlattr *)est);
231 a->priv = (void *) p; 231 a->priv = (void *) p;
232 return p; 232 return p;
233} 233}
diff --git a/net/sched/act_police.c b/net/sched/act_police.c
index a73e3e6d87ea..07ffdf9c5e59 100644
--- a/net/sched/act_police.c
+++ b/net/sched/act_police.c
@@ -174,12 +174,12 @@ static int tcf_act_police_locate(struct rtattr *rta, struct rtattr *est,
174override: 174override:
175 if (parm->rate.rate) { 175 if (parm->rate.rate) {
176 err = -ENOMEM; 176 err = -ENOMEM;
177 R_tab = qdisc_get_rtab(&parm->rate, tb[TCA_POLICE_RATE-1]); 177 R_tab = qdisc_get_rtab(&parm->rate, (struct nlattr *)tb[TCA_POLICE_RATE-1]);
178 if (R_tab == NULL) 178 if (R_tab == NULL)
179 goto failure; 179 goto failure;
180 if (parm->peakrate.rate) { 180 if (parm->peakrate.rate) {
181 P_tab = qdisc_get_rtab(&parm->peakrate, 181 P_tab = qdisc_get_rtab(&parm->peakrate,
182 tb[TCA_POLICE_PEAKRATE-1]); 182 (struct nlattr *)tb[TCA_POLICE_PEAKRATE-1]);
183 if (P_tab == NULL) { 183 if (P_tab == NULL) {
184 qdisc_put_rtab(R_tab); 184 qdisc_put_rtab(R_tab);
185 goto failure; 185 goto failure;
@@ -216,7 +216,7 @@ override:
216 if (est) 216 if (est)
217 gen_replace_estimator(&police->tcf_bstats, 217 gen_replace_estimator(&police->tcf_bstats,
218 &police->tcf_rate_est, 218 &police->tcf_rate_est,
219 &police->tcf_lock, est); 219 &police->tcf_lock, (struct nlattr *)est);
220 220
221 spin_unlock_bh(&police->tcf_lock); 221 spin_unlock_bh(&police->tcf_lock);
222 if (ret != ACT_P_CREATED) 222 if (ret != ACT_P_CREATED)
diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index dc89a9343f30..7abb028dd96b 100644
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -213,14 +213,14 @@ static struct Qdisc *qdisc_leaf(struct Qdisc *p, u32 classid)
213 213
214/* Find queueing discipline by name */ 214/* Find queueing discipline by name */
215 215
216static struct Qdisc_ops *qdisc_lookup_ops(struct rtattr *kind) 216static struct Qdisc_ops *qdisc_lookup_ops(struct nlattr *kind)
217{ 217{
218 struct Qdisc_ops *q = NULL; 218 struct Qdisc_ops *q = NULL;
219 219
220 if (kind) { 220 if (kind) {
221 read_lock(&qdisc_mod_lock); 221 read_lock(&qdisc_mod_lock);
222 for (q = qdisc_base; q; q = q->next) { 222 for (q = qdisc_base; q; q = q->next) {
223 if (rtattr_strcmp(kind, q->id) == 0) { 223 if (nla_strcmp(kind, q->id) == 0) {
224 if (!try_module_get(q->owner)) 224 if (!try_module_get(q->owner))
225 q = NULL; 225 q = NULL;
226 break; 226 break;
@@ -233,7 +233,7 @@ static struct Qdisc_ops *qdisc_lookup_ops(struct rtattr *kind)
233 233
234static struct qdisc_rate_table *qdisc_rtab_list; 234static struct qdisc_rate_table *qdisc_rtab_list;
235 235
236struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, struct rtattr *tab) 236struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, struct nlattr *tab)
237{ 237{
238 struct qdisc_rate_table *rtab; 238 struct qdisc_rate_table *rtab;
239 239
@@ -244,14 +244,14 @@ struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, struct rtattr *ta
244 } 244 }
245 } 245 }
246 246
247 if (tab == NULL || r->rate == 0 || r->cell_log == 0 || RTA_PAYLOAD(tab) != 1024) 247 if (tab == NULL || r->rate == 0 || r->cell_log == 0 || nla_len(tab) != 1024)
248 return NULL; 248 return NULL;
249 249
250 rtab = kmalloc(sizeof(*rtab), GFP_KERNEL); 250 rtab = kmalloc(sizeof(*rtab), GFP_KERNEL);
251 if (rtab) { 251 if (rtab) {
252 rtab->rate = *r; 252 rtab->rate = *r;
253 rtab->refcnt = 1; 253 rtab->refcnt = 1;
254 memcpy(rtab->data, RTA_DATA(tab), 1024); 254 memcpy(rtab->data, nla_data(tab), 1024);
255 rtab->next = qdisc_rtab_list; 255 rtab->next = qdisc_rtab_list;
256 qdisc_rtab_list = rtab; 256 qdisc_rtab_list = rtab;
257 } 257 }
@@ -445,10 +445,10 @@ static int qdisc_graft(struct net_device *dev, struct Qdisc *parent,
445 445
446static struct Qdisc * 446static struct Qdisc *
447qdisc_create(struct net_device *dev, u32 parent, u32 handle, 447qdisc_create(struct net_device *dev, u32 parent, u32 handle,
448 struct rtattr **tca, int *errp) 448 struct nlattr **tca, int *errp)
449{ 449{
450 int err; 450 int err;
451 struct rtattr *kind = tca[TCA_KIND-1]; 451 struct nlattr *kind = tca[TCA_KIND];
452 struct Qdisc *sch; 452 struct Qdisc *sch;
453 struct Qdisc_ops *ops; 453 struct Qdisc_ops *ops;
454 454
@@ -456,7 +456,7 @@ qdisc_create(struct net_device *dev, u32 parent, u32 handle,
456#ifdef CONFIG_KMOD 456#ifdef CONFIG_KMOD
457 if (ops == NULL && kind != NULL) { 457 if (ops == NULL && kind != NULL) {
458 char name[IFNAMSIZ]; 458 char name[IFNAMSIZ];
459 if (rtattr_strlcpy(name, kind, IFNAMSIZ) < IFNAMSIZ) { 459 if (nla_strlcpy(name, kind, IFNAMSIZ) < IFNAMSIZ) {
460 /* We dropped the RTNL semaphore in order to 460 /* We dropped the RTNL semaphore in order to
461 * perform the module load. So, even if we 461 * perform the module load. So, even if we
462 * succeeded in loading the module we have to 462 * succeeded in loading the module we have to
@@ -509,11 +509,11 @@ qdisc_create(struct net_device *dev, u32 parent, u32 handle,
509 509
510 sch->handle = handle; 510 sch->handle = handle;
511 511
512 if (!ops->init || (err = ops->init(sch, tca[TCA_OPTIONS-1])) == 0) { 512 if (!ops->init || (err = ops->init(sch, tca[TCA_OPTIONS])) == 0) {
513 if (tca[TCA_RATE-1]) { 513 if (tca[TCA_RATE]) {
514 err = gen_new_estimator(&sch->bstats, &sch->rate_est, 514 err = gen_new_estimator(&sch->bstats, &sch->rate_est,
515 sch->stats_lock, 515 sch->stats_lock,
516 tca[TCA_RATE-1]); 516 tca[TCA_RATE]);
517 if (err) { 517 if (err) {
518 /* 518 /*
519 * Any broken qdiscs that would require 519 * Any broken qdiscs that would require
@@ -541,20 +541,20 @@ err_out:
541 return NULL; 541 return NULL;
542} 542}
543 543
544static int qdisc_change(struct Qdisc *sch, struct rtattr **tca) 544static int qdisc_change(struct Qdisc *sch, struct nlattr **tca)
545{ 545{
546 if (tca[TCA_OPTIONS-1]) { 546 if (tca[TCA_OPTIONS]) {
547 int err; 547 int err;
548 548
549 if (sch->ops->change == NULL) 549 if (sch->ops->change == NULL)
550 return -EINVAL; 550 return -EINVAL;
551 err = sch->ops->change(sch, tca[TCA_OPTIONS-1]); 551 err = sch->ops->change(sch, tca[TCA_OPTIONS]);
552 if (err) 552 if (err)
553 return err; 553 return err;
554 } 554 }
555 if (tca[TCA_RATE-1]) 555 if (tca[TCA_RATE])
556 gen_replace_estimator(&sch->bstats, &sch->rate_est, 556 gen_replace_estimator(&sch->bstats, &sch->rate_est,
557 sch->stats_lock, tca[TCA_RATE-1]); 557 sch->stats_lock, tca[TCA_RATE]);
558 return 0; 558 return 0;
559} 559}
560 560
@@ -606,7 +606,7 @@ static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
606{ 606{
607 struct net *net = skb->sk->sk_net; 607 struct net *net = skb->sk->sk_net;
608 struct tcmsg *tcm = NLMSG_DATA(n); 608 struct tcmsg *tcm = NLMSG_DATA(n);
609 struct rtattr **tca = arg; 609 struct nlattr *tca[TCA_MAX + 1];
610 struct net_device *dev; 610 struct net_device *dev;
611 u32 clid = tcm->tcm_parent; 611 u32 clid = tcm->tcm_parent;
612 struct Qdisc *q = NULL; 612 struct Qdisc *q = NULL;
@@ -619,6 +619,10 @@ static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
619 if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL) 619 if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
620 return -ENODEV; 620 return -ENODEV;
621 621
622 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
623 if (err < 0)
624 return err;
625
622 if (clid) { 626 if (clid) {
623 if (clid != TC_H_ROOT) { 627 if (clid != TC_H_ROOT) {
624 if (TC_H_MAJ(clid) != TC_H_MAJ(TC_H_INGRESS)) { 628 if (TC_H_MAJ(clid) != TC_H_MAJ(TC_H_INGRESS)) {
@@ -641,7 +645,7 @@ static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
641 return -ENOENT; 645 return -ENOENT;
642 } 646 }
643 647
644 if (tca[TCA_KIND-1] && rtattr_strcmp(tca[TCA_KIND-1], q->ops->id)) 648 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
645 return -EINVAL; 649 return -EINVAL;
646 650
647 if (n->nlmsg_type == RTM_DELQDISC) { 651 if (n->nlmsg_type == RTM_DELQDISC) {
@@ -671,7 +675,7 @@ static int tc_modify_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
671{ 675{
672 struct net *net = skb->sk->sk_net; 676 struct net *net = skb->sk->sk_net;
673 struct tcmsg *tcm; 677 struct tcmsg *tcm;
674 struct rtattr **tca; 678 struct nlattr *tca[TCA_MAX + 1];
675 struct net_device *dev; 679 struct net_device *dev;
676 u32 clid; 680 u32 clid;
677 struct Qdisc *q, *p; 681 struct Qdisc *q, *p;
@@ -683,13 +687,16 @@ static int tc_modify_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
683replay: 687replay:
684 /* Reinit, just in case something touches this. */ 688 /* Reinit, just in case something touches this. */
685 tcm = NLMSG_DATA(n); 689 tcm = NLMSG_DATA(n);
686 tca = arg;
687 clid = tcm->tcm_parent; 690 clid = tcm->tcm_parent;
688 q = p = NULL; 691 q = p = NULL;
689 692
690 if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL) 693 if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
691 return -ENODEV; 694 return -ENODEV;
692 695
696 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
697 if (err < 0)
698 return err;
699
693 if (clid) { 700 if (clid) {
694 if (clid != TC_H_ROOT) { 701 if (clid != TC_H_ROOT) {
695 if (clid != TC_H_INGRESS) { 702 if (clid != TC_H_INGRESS) {
@@ -717,7 +724,7 @@ replay:
717 goto create_n_graft; 724 goto create_n_graft;
718 if (n->nlmsg_flags&NLM_F_EXCL) 725 if (n->nlmsg_flags&NLM_F_EXCL)
719 return -EEXIST; 726 return -EEXIST;
720 if (tca[TCA_KIND-1] && rtattr_strcmp(tca[TCA_KIND-1], q->ops->id)) 727 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
721 return -EINVAL; 728 return -EINVAL;
722 if (q == p || 729 if (q == p ||
723 (p && check_loop(q, p, 0))) 730 (p && check_loop(q, p, 0)))
@@ -750,8 +757,8 @@ replay:
750 if ((n->nlmsg_flags&NLM_F_CREATE) && 757 if ((n->nlmsg_flags&NLM_F_CREATE) &&
751 (n->nlmsg_flags&NLM_F_REPLACE) && 758 (n->nlmsg_flags&NLM_F_REPLACE) &&
752 ((n->nlmsg_flags&NLM_F_EXCL) || 759 ((n->nlmsg_flags&NLM_F_EXCL) ||
753 (tca[TCA_KIND-1] && 760 (tca[TCA_KIND] &&
754 rtattr_strcmp(tca[TCA_KIND-1], q->ops->id)))) 761 nla_strcmp(tca[TCA_KIND], q->ops->id))))
755 goto create_n_graft; 762 goto create_n_graft;
756 } 763 }
757 } 764 }
@@ -766,7 +773,7 @@ replay:
766 return -ENOENT; 773 return -ENOENT;
767 if (n->nlmsg_flags&NLM_F_EXCL) 774 if (n->nlmsg_flags&NLM_F_EXCL)
768 return -EEXIST; 775 return -EEXIST;
769 if (tca[TCA_KIND-1] && rtattr_strcmp(tca[TCA_KIND-1], q->ops->id)) 776 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
770 return -EINVAL; 777 return -EINVAL;
771 err = qdisc_change(q, tca); 778 err = qdisc_change(q, tca);
772 if (err == 0) 779 if (err == 0)
@@ -827,31 +834,31 @@ static int tc_fill_qdisc(struct sk_buff *skb, struct Qdisc *q, u32 clid,
827 tcm->tcm_parent = clid; 834 tcm->tcm_parent = clid;
828 tcm->tcm_handle = q->handle; 835 tcm->tcm_handle = q->handle;
829 tcm->tcm_info = atomic_read(&q->refcnt); 836 tcm->tcm_info = atomic_read(&q->refcnt);
830 RTA_PUT(skb, TCA_KIND, IFNAMSIZ, q->ops->id); 837 NLA_PUT(skb, TCA_KIND, IFNAMSIZ, q->ops->id);
831 if (q->ops->dump && q->ops->dump(q, skb) < 0) 838 if (q->ops->dump && q->ops->dump(q, skb) < 0)
832 goto rtattr_failure; 839 goto nla_put_failure;
833 q->qstats.qlen = q->q.qlen; 840 q->qstats.qlen = q->q.qlen;
834 841
835 if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, 842 if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS,
836 TCA_XSTATS, q->stats_lock, &d) < 0) 843 TCA_XSTATS, q->stats_lock, &d) < 0)
837 goto rtattr_failure; 844 goto nla_put_failure;
838 845
839 if (q->ops->dump_stats && q->ops->dump_stats(q, &d) < 0) 846 if (q->ops->dump_stats && q->ops->dump_stats(q, &d) < 0)
840 goto rtattr_failure; 847 goto nla_put_failure;
841 848
842 if (gnet_stats_copy_basic(&d, &q->bstats) < 0 || 849 if (gnet_stats_copy_basic(&d, &q->bstats) < 0 ||
843 gnet_stats_copy_rate_est(&d, &q->rate_est) < 0 || 850 gnet_stats_copy_rate_est(&d, &q->rate_est) < 0 ||
844 gnet_stats_copy_queue(&d, &q->qstats) < 0) 851 gnet_stats_copy_queue(&d, &q->qstats) < 0)
845 goto rtattr_failure; 852 goto nla_put_failure;
846 853
847 if (gnet_stats_finish_copy(&d) < 0) 854 if (gnet_stats_finish_copy(&d) < 0)
848 goto rtattr_failure; 855 goto nla_put_failure;
849 856
850 nlh->nlmsg_len = skb_tail_pointer(skb) - b; 857 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
851 return skb->len; 858 return skb->len;
852 859
853nlmsg_failure: 860nlmsg_failure:
854rtattr_failure: 861nla_put_failure:
855 nlmsg_trim(skb, b); 862 nlmsg_trim(skb, b);
856 return -1; 863 return -1;
857} 864}
@@ -939,7 +946,7 @@ static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
939{ 946{
940 struct net *net = skb->sk->sk_net; 947 struct net *net = skb->sk->sk_net;
941 struct tcmsg *tcm = NLMSG_DATA(n); 948 struct tcmsg *tcm = NLMSG_DATA(n);
942 struct rtattr **tca = arg; 949 struct nlattr *tca[TCA_MAX + 1];
943 struct net_device *dev; 950 struct net_device *dev;
944 struct Qdisc *q = NULL; 951 struct Qdisc *q = NULL;
945 const struct Qdisc_class_ops *cops; 952 const struct Qdisc_class_ops *cops;
@@ -956,6 +963,10 @@ static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
956 if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL) 963 if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
957 return -ENODEV; 964 return -ENODEV;
958 965
966 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
967 if (err < 0)
968 return err;
969
959 /* 970 /*
960 parent == TC_H_UNSPEC - unspecified parent. 971 parent == TC_H_UNSPEC - unspecified parent.
961 parent == TC_H_ROOT - class is root, which has no parent. 972 parent == TC_H_ROOT - class is root, which has no parent.
@@ -1069,25 +1080,25 @@ static int tc_fill_tclass(struct sk_buff *skb, struct Qdisc *q,
1069 tcm->tcm_parent = q->handle; 1080 tcm->tcm_parent = q->handle;
1070 tcm->tcm_handle = q->handle; 1081 tcm->tcm_handle = q->handle;
1071 tcm->tcm_info = 0; 1082 tcm->tcm_info = 0;
1072 RTA_PUT(skb, TCA_KIND, IFNAMSIZ, q->ops->id); 1083 NLA_PUT(skb, TCA_KIND, IFNAMSIZ, q->ops->id);
1073 if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0) 1084 if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0)
1074 goto rtattr_failure; 1085 goto nla_put_failure;
1075 1086
1076 if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, 1087 if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS,
1077 TCA_XSTATS, q->stats_lock, &d) < 0) 1088 TCA_XSTATS, q->stats_lock, &d) < 0)
1078 goto rtattr_failure; 1089 goto nla_put_failure;
1079 1090
1080 if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0) 1091 if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0)
1081 goto rtattr_failure; 1092 goto nla_put_failure;
1082 1093
1083 if (gnet_stats_finish_copy(&d) < 0) 1094 if (gnet_stats_finish_copy(&d) < 0)
1084 goto rtattr_failure; 1095 goto nla_put_failure;
1085 1096
1086 nlh->nlmsg_len = skb_tail_pointer(skb) - b; 1097 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1087 return skb->len; 1098 return skb->len;
1088 1099
1089nlmsg_failure: 1100nlmsg_failure:
1090rtattr_failure: 1101nla_put_failure:
1091 nlmsg_trim(skb, b); 1102 nlmsg_trim(skb, b);
1092 return -1; 1103 return -1;
1093} 1104}
diff --git a/net/sched/sch_atm.c b/net/sched/sch_atm.c
index 734be9d37d46..eb01aae117df 100644
--- a/net/sched/sch_atm.c
+++ b/net/sched/sch_atm.c
@@ -196,13 +196,13 @@ static const u8 llc_oui_ip[] = {
196}; /* Ethertype IP (0800) */ 196}; /* Ethertype IP (0800) */
197 197
198static int atm_tc_change(struct Qdisc *sch, u32 classid, u32 parent, 198static int atm_tc_change(struct Qdisc *sch, u32 classid, u32 parent,
199 struct rtattr **tca, unsigned long *arg) 199 struct nlattr **tca, unsigned long *arg)
200{ 200{
201 struct atm_qdisc_data *p = qdisc_priv(sch); 201 struct atm_qdisc_data *p = qdisc_priv(sch);
202 struct atm_flow_data *flow = (struct atm_flow_data *)*arg; 202 struct atm_flow_data *flow = (struct atm_flow_data *)*arg;
203 struct atm_flow_data *excess = NULL; 203 struct atm_flow_data *excess = NULL;
204 struct rtattr *opt = tca[TCA_OPTIONS - 1]; 204 struct nlattr *opt = tca[TCA_OPTIONS];
205 struct rtattr *tb[TCA_ATM_MAX]; 205 struct nlattr *tb[TCA_ATM_MAX + 1];
206 struct socket *sock; 206 struct socket *sock;
207 int fd, error, hdr_len; 207 int fd, error, hdr_len;
208 void *hdr; 208 void *hdr;
@@ -223,31 +223,31 @@ static int atm_tc_change(struct Qdisc *sch, u32 classid, u32 parent,
223 */ 223 */
224 if (flow) 224 if (flow)
225 return -EBUSY; 225 return -EBUSY;
226 if (opt == NULL || rtattr_parse_nested(tb, TCA_ATM_MAX, opt)) 226 if (opt == NULL || nla_parse_nested(tb, TCA_ATM_MAX, opt, NULL))
227 return -EINVAL; 227 return -EINVAL;
228 if (!tb[TCA_ATM_FD - 1] || RTA_PAYLOAD(tb[TCA_ATM_FD - 1]) < sizeof(fd)) 228 if (!tb[TCA_ATM_FD] || nla_len(tb[TCA_ATM_FD]) < sizeof(fd))
229 return -EINVAL; 229 return -EINVAL;
230 fd = *(int *)RTA_DATA(tb[TCA_ATM_FD - 1]); 230 fd = *(int *)nla_data(tb[TCA_ATM_FD]);
231 pr_debug("atm_tc_change: fd %d\n", fd); 231 pr_debug("atm_tc_change: fd %d\n", fd);
232 if (tb[TCA_ATM_HDR - 1]) { 232 if (tb[TCA_ATM_HDR]) {
233 hdr_len = RTA_PAYLOAD(tb[TCA_ATM_HDR - 1]); 233 hdr_len = nla_len(tb[TCA_ATM_HDR]);
234 hdr = RTA_DATA(tb[TCA_ATM_HDR - 1]); 234 hdr = nla_data(tb[TCA_ATM_HDR]);
235 } else { 235 } else {
236 hdr_len = RFC1483LLC_LEN; 236 hdr_len = RFC1483LLC_LEN;
237 hdr = NULL; /* default LLC/SNAP for IP */ 237 hdr = NULL; /* default LLC/SNAP for IP */
238 } 238 }
239 if (!tb[TCA_ATM_EXCESS - 1]) 239 if (!tb[TCA_ATM_EXCESS])
240 excess = NULL; 240 excess = NULL;
241 else { 241 else {
242 if (RTA_PAYLOAD(tb[TCA_ATM_EXCESS - 1]) != sizeof(u32)) 242 if (nla_len(tb[TCA_ATM_EXCESS]) != sizeof(u32))
243 return -EINVAL; 243 return -EINVAL;
244 excess = (struct atm_flow_data *) 244 excess = (struct atm_flow_data *)
245 atm_tc_get(sch, *(u32 *)RTA_DATA(tb[TCA_ATM_EXCESS - 1])); 245 atm_tc_get(sch, *(u32 *)nla_data(tb[TCA_ATM_EXCESS]));
246 if (!excess) 246 if (!excess)
247 return -ENOENT; 247 return -ENOENT;
248 } 248 }
249 pr_debug("atm_tc_change: type %d, payload %lu, hdr_len %d\n", 249 pr_debug("atm_tc_change: type %d, payload %lu, hdr_len %d\n",
250 opt->rta_type, RTA_PAYLOAD(opt), hdr_len); 250 opt->nla_type, nla_len(opt), hdr_len);
251 sock = sockfd_lookup(fd, &error); 251 sock = sockfd_lookup(fd, &error);
252 if (!sock) 252 if (!sock)
253 return error; /* f_count++ */ 253 return error; /* f_count++ */
@@ -541,7 +541,7 @@ static unsigned int atm_tc_drop(struct Qdisc *sch)
541 return 0; 541 return 0;
542} 542}
543 543
544static int atm_tc_init(struct Qdisc *sch, struct rtattr *opt) 544static int atm_tc_init(struct Qdisc *sch, struct nlattr *opt)
545{ 545{
546 struct atm_qdisc_data *p = qdisc_priv(sch); 546 struct atm_qdisc_data *p = qdisc_priv(sch);
547 547
@@ -602,7 +602,7 @@ static int atm_tc_dump_class(struct Qdisc *sch, unsigned long cl,
602 struct atm_qdisc_data *p = qdisc_priv(sch); 602 struct atm_qdisc_data *p = qdisc_priv(sch);
603 struct atm_flow_data *flow = (struct atm_flow_data *)cl; 603 struct atm_flow_data *flow = (struct atm_flow_data *)cl;
604 unsigned char *b = skb_tail_pointer(skb); 604 unsigned char *b = skb_tail_pointer(skb);
605 struct rtattr *rta; 605 struct nlattr *nla;
606 606
607 pr_debug("atm_tc_dump_class(sch %p,[qdisc %p],flow %p,skb %p,tcm %p)\n", 607 pr_debug("atm_tc_dump_class(sch %p,[qdisc %p],flow %p,skb %p,tcm %p)\n",
608 sch, p, flow, skb, tcm); 608 sch, p, flow, skb, tcm);
@@ -610,9 +610,9 @@ static int atm_tc_dump_class(struct Qdisc *sch, unsigned long cl,
610 return -EINVAL; 610 return -EINVAL;
611 tcm->tcm_handle = flow->classid; 611 tcm->tcm_handle = flow->classid;
612 tcm->tcm_info = flow->q->handle; 612 tcm->tcm_info = flow->q->handle;
613 rta = (struct rtattr *)b; 613 nla = (struct nlattr *)b;
614 RTA_PUT(skb, TCA_OPTIONS, 0, NULL); 614 NLA_PUT(skb, TCA_OPTIONS, 0, NULL);
615 RTA_PUT(skb, TCA_ATM_HDR, flow->hdr_len, flow->hdr); 615 NLA_PUT(skb, TCA_ATM_HDR, flow->hdr_len, flow->hdr);
616 if (flow->vcc) { 616 if (flow->vcc) {
617 struct sockaddr_atmpvc pvc; 617 struct sockaddr_atmpvc pvc;
618 int state; 618 int state;
@@ -621,21 +621,21 @@ static int atm_tc_dump_class(struct Qdisc *sch, unsigned long cl,
621 pvc.sap_addr.itf = flow->vcc->dev ? flow->vcc->dev->number : -1; 621 pvc.sap_addr.itf = flow->vcc->dev ? flow->vcc->dev->number : -1;
622 pvc.sap_addr.vpi = flow->vcc->vpi; 622 pvc.sap_addr.vpi = flow->vcc->vpi;
623 pvc.sap_addr.vci = flow->vcc->vci; 623 pvc.sap_addr.vci = flow->vcc->vci;
624 RTA_PUT(skb, TCA_ATM_ADDR, sizeof(pvc), &pvc); 624 NLA_PUT(skb, TCA_ATM_ADDR, sizeof(pvc), &pvc);
625 state = ATM_VF2VS(flow->vcc->flags); 625 state = ATM_VF2VS(flow->vcc->flags);
626 RTA_PUT(skb, TCA_ATM_STATE, sizeof(state), &state); 626 NLA_PUT(skb, TCA_ATM_STATE, sizeof(state), &state);
627 } 627 }
628 if (flow->excess) 628 if (flow->excess)
629 RTA_PUT(skb, TCA_ATM_EXCESS, sizeof(u32), &flow->classid); 629 NLA_PUT(skb, TCA_ATM_EXCESS, sizeof(u32), &flow->classid);
630 else { 630 else {
631 static u32 zero; 631 static u32 zero;
632 632
633 RTA_PUT(skb, TCA_ATM_EXCESS, sizeof(zero), &zero); 633 NLA_PUT(skb, TCA_ATM_EXCESS, sizeof(zero), &zero);
634 } 634 }
635 rta->rta_len = skb_tail_pointer(skb) - b; 635 nla->nla_len = skb_tail_pointer(skb) - b;
636 return skb->len; 636 return skb->len;
637 637
638rtattr_failure: 638nla_put_failure:
639 nlmsg_trim(skb, b); 639 nlmsg_trim(skb, b);
640 return -1; 640 return -1;
641} 641}
diff --git a/net/sched/sch_cbq.c b/net/sched/sch_cbq.c
index bea123fc24a4..5c8667ef4ba7 100644
--- a/net/sched/sch_cbq.c
+++ b/net/sched/sch_cbq.c
@@ -1377,24 +1377,24 @@ static int cbq_set_fopt(struct cbq_class *cl, struct tc_cbq_fopt *fopt)
1377 return 0; 1377 return 0;
1378} 1378}
1379 1379
1380static int cbq_init(struct Qdisc *sch, struct rtattr *opt) 1380static int cbq_init(struct Qdisc *sch, struct nlattr *opt)
1381{ 1381{
1382 struct cbq_sched_data *q = qdisc_priv(sch); 1382 struct cbq_sched_data *q = qdisc_priv(sch);
1383 struct rtattr *tb[TCA_CBQ_MAX]; 1383 struct nlattr *tb[TCA_CBQ_MAX + 1];
1384 struct tc_ratespec *r; 1384 struct tc_ratespec *r;
1385 1385
1386 if (rtattr_parse_nested(tb, TCA_CBQ_MAX, opt) < 0 || 1386 if (nla_parse_nested(tb, TCA_CBQ_MAX, opt, NULL) < 0 ||
1387 tb[TCA_CBQ_RTAB-1] == NULL || tb[TCA_CBQ_RATE-1] == NULL || 1387 tb[TCA_CBQ_RTAB] == NULL || tb[TCA_CBQ_RATE] == NULL ||
1388 RTA_PAYLOAD(tb[TCA_CBQ_RATE-1]) < sizeof(struct tc_ratespec)) 1388 nla_len(tb[TCA_CBQ_RATE]) < sizeof(struct tc_ratespec))
1389 return -EINVAL; 1389 return -EINVAL;
1390 1390
1391 if (tb[TCA_CBQ_LSSOPT-1] && 1391 if (tb[TCA_CBQ_LSSOPT] &&
1392 RTA_PAYLOAD(tb[TCA_CBQ_LSSOPT-1]) < sizeof(struct tc_cbq_lssopt)) 1392 nla_len(tb[TCA_CBQ_LSSOPT]) < sizeof(struct tc_cbq_lssopt))
1393 return -EINVAL; 1393 return -EINVAL;
1394 1394
1395 r = RTA_DATA(tb[TCA_CBQ_RATE-1]); 1395 r = nla_data(tb[TCA_CBQ_RATE]);
1396 1396
1397 if ((q->link.R_tab = qdisc_get_rtab(r, tb[TCA_CBQ_RTAB-1])) == NULL) 1397 if ((q->link.R_tab = qdisc_get_rtab(r, tb[TCA_CBQ_RTAB])) == NULL)
1398 return -EINVAL; 1398 return -EINVAL;
1399 1399
1400 q->link.refcnt = 1; 1400 q->link.refcnt = 1;
@@ -1427,8 +1427,8 @@ static int cbq_init(struct Qdisc *sch, struct rtattr *opt)
1427 1427
1428 cbq_link_class(&q->link); 1428 cbq_link_class(&q->link);
1429 1429
1430 if (tb[TCA_CBQ_LSSOPT-1]) 1430 if (tb[TCA_CBQ_LSSOPT])
1431 cbq_set_lss(&q->link, RTA_DATA(tb[TCA_CBQ_LSSOPT-1])); 1431 cbq_set_lss(&q->link, nla_data(tb[TCA_CBQ_LSSOPT]));
1432 1432
1433 cbq_addprio(q, &q->link); 1433 cbq_addprio(q, &q->link);
1434 return 0; 1434 return 0;
@@ -1438,10 +1438,10 @@ static __inline__ int cbq_dump_rate(struct sk_buff *skb, struct cbq_class *cl)
1438{ 1438{
1439 unsigned char *b = skb_tail_pointer(skb); 1439 unsigned char *b = skb_tail_pointer(skb);
1440 1440
1441 RTA_PUT(skb, TCA_CBQ_RATE, sizeof(cl->R_tab->rate), &cl->R_tab->rate); 1441 NLA_PUT(skb, TCA_CBQ_RATE, sizeof(cl->R_tab->rate), &cl->R_tab->rate);
1442 return skb->len; 1442 return skb->len;
1443 1443
1444rtattr_failure: 1444nla_put_failure:
1445 nlmsg_trim(skb, b); 1445 nlmsg_trim(skb, b);
1446 return -1; 1446 return -1;
1447} 1447}
@@ -1463,10 +1463,10 @@ static __inline__ int cbq_dump_lss(struct sk_buff *skb, struct cbq_class *cl)
1463 opt.minidle = (u32)(-cl->minidle); 1463 opt.minidle = (u32)(-cl->minidle);
1464 opt.offtime = cl->offtime; 1464 opt.offtime = cl->offtime;
1465 opt.change = ~0; 1465 opt.change = ~0;
1466 RTA_PUT(skb, TCA_CBQ_LSSOPT, sizeof(opt), &opt); 1466 NLA_PUT(skb, TCA_CBQ_LSSOPT, sizeof(opt), &opt);
1467 return skb->len; 1467 return skb->len;
1468 1468
1469rtattr_failure: 1469nla_put_failure:
1470 nlmsg_trim(skb, b); 1470 nlmsg_trim(skb, b);
1471 return -1; 1471 return -1;
1472} 1472}
@@ -1481,10 +1481,10 @@ static __inline__ int cbq_dump_wrr(struct sk_buff *skb, struct cbq_class *cl)
1481 opt.priority = cl->priority+1; 1481 opt.priority = cl->priority+1;
1482 opt.cpriority = cl->cpriority+1; 1482 opt.cpriority = cl->cpriority+1;
1483 opt.weight = cl->weight; 1483 opt.weight = cl->weight;
1484 RTA_PUT(skb, TCA_CBQ_WRROPT, sizeof(opt), &opt); 1484 NLA_PUT(skb, TCA_CBQ_WRROPT, sizeof(opt), &opt);
1485 return skb->len; 1485 return skb->len;
1486 1486
1487rtattr_failure: 1487nla_put_failure:
1488 nlmsg_trim(skb, b); 1488 nlmsg_trim(skb, b);
1489 return -1; 1489 return -1;
1490} 1490}
@@ -1498,10 +1498,10 @@ static __inline__ int cbq_dump_ovl(struct sk_buff *skb, struct cbq_class *cl)
1498 opt.priority2 = cl->priority2+1; 1498 opt.priority2 = cl->priority2+1;
1499 opt.pad = 0; 1499 opt.pad = 0;
1500 opt.penalty = cl->penalty; 1500 opt.penalty = cl->penalty;
1501 RTA_PUT(skb, TCA_CBQ_OVL_STRATEGY, sizeof(opt), &opt); 1501 NLA_PUT(skb, TCA_CBQ_OVL_STRATEGY, sizeof(opt), &opt);
1502 return skb->len; 1502 return skb->len;
1503 1503
1504rtattr_failure: 1504nla_put_failure:
1505 nlmsg_trim(skb, b); 1505 nlmsg_trim(skb, b);
1506 return -1; 1506 return -1;
1507} 1507}
@@ -1515,11 +1515,11 @@ static __inline__ int cbq_dump_fopt(struct sk_buff *skb, struct cbq_class *cl)
1515 opt.split = cl->split ? cl->split->classid : 0; 1515 opt.split = cl->split ? cl->split->classid : 0;
1516 opt.defmap = cl->defmap; 1516 opt.defmap = cl->defmap;
1517 opt.defchange = ~0; 1517 opt.defchange = ~0;
1518 RTA_PUT(skb, TCA_CBQ_FOPT, sizeof(opt), &opt); 1518 NLA_PUT(skb, TCA_CBQ_FOPT, sizeof(opt), &opt);
1519 } 1519 }
1520 return skb->len; 1520 return skb->len;
1521 1521
1522rtattr_failure: 1522nla_put_failure:
1523 nlmsg_trim(skb, b); 1523 nlmsg_trim(skb, b);
1524 return -1; 1524 return -1;
1525} 1525}
@@ -1534,11 +1534,11 @@ static __inline__ int cbq_dump_police(struct sk_buff *skb, struct cbq_class *cl)
1534 opt.police = cl->police; 1534 opt.police = cl->police;
1535 opt.__res1 = 0; 1535 opt.__res1 = 0;
1536 opt.__res2 = 0; 1536 opt.__res2 = 0;
1537 RTA_PUT(skb, TCA_CBQ_POLICE, sizeof(opt), &opt); 1537 NLA_PUT(skb, TCA_CBQ_POLICE, sizeof(opt), &opt);
1538 } 1538 }
1539 return skb->len; 1539 return skb->len;
1540 1540
1541rtattr_failure: 1541nla_put_failure:
1542 nlmsg_trim(skb, b); 1542 nlmsg_trim(skb, b);
1543 return -1; 1543 return -1;
1544} 1544}
@@ -1562,16 +1562,16 @@ static int cbq_dump(struct Qdisc *sch, struct sk_buff *skb)
1562{ 1562{
1563 struct cbq_sched_data *q = qdisc_priv(sch); 1563 struct cbq_sched_data *q = qdisc_priv(sch);
1564 unsigned char *b = skb_tail_pointer(skb); 1564 unsigned char *b = skb_tail_pointer(skb);
1565 struct rtattr *rta; 1565 struct nlattr *nla;
1566 1566
1567 rta = (struct rtattr*)b; 1567 nla = (struct nlattr*)b;
1568 RTA_PUT(skb, TCA_OPTIONS, 0, NULL); 1568 NLA_PUT(skb, TCA_OPTIONS, 0, NULL);
1569 if (cbq_dump_attr(skb, &q->link) < 0) 1569 if (cbq_dump_attr(skb, &q->link) < 0)
1570 goto rtattr_failure; 1570 goto nla_put_failure;
1571 rta->rta_len = skb_tail_pointer(skb) - b; 1571 nla->nla_len = skb_tail_pointer(skb) - b;
1572 return skb->len; 1572 return skb->len;
1573 1573
1574rtattr_failure: 1574nla_put_failure:
1575 nlmsg_trim(skb, b); 1575 nlmsg_trim(skb, b);
1576 return -1; 1576 return -1;
1577} 1577}
@@ -1591,7 +1591,7 @@ cbq_dump_class(struct Qdisc *sch, unsigned long arg,
1591{ 1591{
1592 struct cbq_class *cl = (struct cbq_class*)arg; 1592 struct cbq_class *cl = (struct cbq_class*)arg;
1593 unsigned char *b = skb_tail_pointer(skb); 1593 unsigned char *b = skb_tail_pointer(skb);
1594 struct rtattr *rta; 1594 struct nlattr *nla;
1595 1595
1596 if (cl->tparent) 1596 if (cl->tparent)
1597 tcm->tcm_parent = cl->tparent->classid; 1597 tcm->tcm_parent = cl->tparent->classid;
@@ -1600,14 +1600,14 @@ cbq_dump_class(struct Qdisc *sch, unsigned long arg,
1600 tcm->tcm_handle = cl->classid; 1600 tcm->tcm_handle = cl->classid;
1601 tcm->tcm_info = cl->q->handle; 1601 tcm->tcm_info = cl->q->handle;
1602 1602
1603 rta = (struct rtattr*)b; 1603 nla = (struct nlattr*)b;
1604 RTA_PUT(skb, TCA_OPTIONS, 0, NULL); 1604 NLA_PUT(skb, TCA_OPTIONS, 0, NULL);
1605 if (cbq_dump_attr(skb, cl) < 0) 1605 if (cbq_dump_attr(skb, cl) < 0)
1606 goto rtattr_failure; 1606 goto nla_put_failure;
1607 rta->rta_len = skb_tail_pointer(skb) - b; 1607 nla->nla_len = skb_tail_pointer(skb) - b;
1608 return skb->len; 1608 return skb->len;
1609 1609
1610rtattr_failure: 1610nla_put_failure:
1611 nlmsg_trim(skb, b); 1611 nlmsg_trim(skb, b);
1612 return -1; 1612 return -1;
1613} 1613}
@@ -1753,43 +1753,43 @@ static void cbq_put(struct Qdisc *sch, unsigned long arg)
1753} 1753}
1754 1754
1755static int 1755static int
1756cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct rtattr **tca, 1756cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct nlattr **tca,
1757 unsigned long *arg) 1757 unsigned long *arg)
1758{ 1758{
1759 int err; 1759 int err;
1760 struct cbq_sched_data *q = qdisc_priv(sch); 1760 struct cbq_sched_data *q = qdisc_priv(sch);
1761 struct cbq_class *cl = (struct cbq_class*)*arg; 1761 struct cbq_class *cl = (struct cbq_class*)*arg;
1762 struct rtattr *opt = tca[TCA_OPTIONS-1]; 1762 struct nlattr *opt = tca[TCA_OPTIONS];
1763 struct rtattr *tb[TCA_CBQ_MAX]; 1763 struct nlattr *tb[TCA_CBQ_MAX + 1];
1764 struct cbq_class *parent; 1764 struct cbq_class *parent;
1765 struct qdisc_rate_table *rtab = NULL; 1765 struct qdisc_rate_table *rtab = NULL;
1766 1766
1767 if (opt==NULL || rtattr_parse_nested(tb, TCA_CBQ_MAX, opt)) 1767 if (opt==NULL || nla_parse_nested(tb, TCA_CBQ_MAX, opt, NULL))
1768 return -EINVAL; 1768 return -EINVAL;
1769 1769
1770 if (tb[TCA_CBQ_OVL_STRATEGY-1] && 1770 if (tb[TCA_CBQ_OVL_STRATEGY] &&
1771 RTA_PAYLOAD(tb[TCA_CBQ_OVL_STRATEGY-1]) < sizeof(struct tc_cbq_ovl)) 1771 nla_len(tb[TCA_CBQ_OVL_STRATEGY]) < sizeof(struct tc_cbq_ovl))
1772 return -EINVAL; 1772 return -EINVAL;
1773 1773
1774 if (tb[TCA_CBQ_FOPT-1] && 1774 if (tb[TCA_CBQ_FOPT] &&
1775 RTA_PAYLOAD(tb[TCA_CBQ_FOPT-1]) < sizeof(struct tc_cbq_fopt)) 1775 nla_len(tb[TCA_CBQ_FOPT]) < sizeof(struct tc_cbq_fopt))
1776 return -EINVAL; 1776 return -EINVAL;
1777 1777
1778 if (tb[TCA_CBQ_RATE-1] && 1778 if (tb[TCA_CBQ_RATE] &&
1779 RTA_PAYLOAD(tb[TCA_CBQ_RATE-1]) < sizeof(struct tc_ratespec)) 1779 nla_len(tb[TCA_CBQ_RATE]) < sizeof(struct tc_ratespec))
1780 return -EINVAL; 1780 return -EINVAL;
1781 1781
1782 if (tb[TCA_CBQ_LSSOPT-1] && 1782 if (tb[TCA_CBQ_LSSOPT] &&
1783 RTA_PAYLOAD(tb[TCA_CBQ_LSSOPT-1]) < sizeof(struct tc_cbq_lssopt)) 1783 nla_len(tb[TCA_CBQ_LSSOPT]) < sizeof(struct tc_cbq_lssopt))
1784 return -EINVAL; 1784 return -EINVAL;
1785 1785
1786 if (tb[TCA_CBQ_WRROPT-1] && 1786 if (tb[TCA_CBQ_WRROPT] &&
1787 RTA_PAYLOAD(tb[TCA_CBQ_WRROPT-1]) < sizeof(struct tc_cbq_wrropt)) 1787 nla_len(tb[TCA_CBQ_WRROPT]) < sizeof(struct tc_cbq_wrropt))
1788 return -EINVAL; 1788 return -EINVAL;
1789 1789
1790#ifdef CONFIG_NET_CLS_ACT 1790#ifdef CONFIG_NET_CLS_ACT
1791 if (tb[TCA_CBQ_POLICE-1] && 1791 if (tb[TCA_CBQ_POLICE] &&
1792 RTA_PAYLOAD(tb[TCA_CBQ_POLICE-1]) < sizeof(struct tc_cbq_police)) 1792 nla_len(tb[TCA_CBQ_POLICE]) < sizeof(struct tc_cbq_police))
1793 return -EINVAL; 1793 return -EINVAL;
1794#endif 1794#endif
1795 1795
@@ -1802,8 +1802,8 @@ cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct rtattr **t
1802 return -EINVAL; 1802 return -EINVAL;
1803 } 1803 }
1804 1804
1805 if (tb[TCA_CBQ_RATE-1]) { 1805 if (tb[TCA_CBQ_RATE]) {
1806 rtab = qdisc_get_rtab(RTA_DATA(tb[TCA_CBQ_RATE-1]), tb[TCA_CBQ_RTAB-1]); 1806 rtab = qdisc_get_rtab(nla_data(tb[TCA_CBQ_RATE]), tb[TCA_CBQ_RTAB]);
1807 if (rtab == NULL) 1807 if (rtab == NULL)
1808 return -EINVAL; 1808 return -EINVAL;
1809 } 1809 }
@@ -1819,45 +1819,45 @@ cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct rtattr **t
1819 qdisc_put_rtab(rtab); 1819 qdisc_put_rtab(rtab);
1820 } 1820 }
1821 1821
1822 if (tb[TCA_CBQ_LSSOPT-1]) 1822 if (tb[TCA_CBQ_LSSOPT])
1823 cbq_set_lss(cl, RTA_DATA(tb[TCA_CBQ_LSSOPT-1])); 1823 cbq_set_lss(cl, nla_data(tb[TCA_CBQ_LSSOPT]));
1824 1824
1825 if (tb[TCA_CBQ_WRROPT-1]) { 1825 if (tb[TCA_CBQ_WRROPT]) {
1826 cbq_rmprio(q, cl); 1826 cbq_rmprio(q, cl);
1827 cbq_set_wrr(cl, RTA_DATA(tb[TCA_CBQ_WRROPT-1])); 1827 cbq_set_wrr(cl, nla_data(tb[TCA_CBQ_WRROPT]));
1828 } 1828 }
1829 1829
1830 if (tb[TCA_CBQ_OVL_STRATEGY-1]) 1830 if (tb[TCA_CBQ_OVL_STRATEGY])
1831 cbq_set_overlimit(cl, RTA_DATA(tb[TCA_CBQ_OVL_STRATEGY-1])); 1831 cbq_set_overlimit(cl, nla_data(tb[TCA_CBQ_OVL_STRATEGY]));
1832 1832
1833#ifdef CONFIG_NET_CLS_ACT 1833#ifdef CONFIG_NET_CLS_ACT
1834 if (tb[TCA_CBQ_POLICE-1]) 1834 if (tb[TCA_CBQ_POLICE])
1835 cbq_set_police(cl, RTA_DATA(tb[TCA_CBQ_POLICE-1])); 1835 cbq_set_police(cl, nla_data(tb[TCA_CBQ_POLICE]));
1836#endif 1836#endif
1837 1837
1838 if (tb[TCA_CBQ_FOPT-1]) 1838 if (tb[TCA_CBQ_FOPT])
1839 cbq_set_fopt(cl, RTA_DATA(tb[TCA_CBQ_FOPT-1])); 1839 cbq_set_fopt(cl, nla_data(tb[TCA_CBQ_FOPT]));
1840 1840
1841 if (cl->q->q.qlen) 1841 if (cl->q->q.qlen)
1842 cbq_activate_class(cl); 1842 cbq_activate_class(cl);
1843 1843
1844 sch_tree_unlock(sch); 1844 sch_tree_unlock(sch);
1845 1845
1846 if (tca[TCA_RATE-1]) 1846 if (tca[TCA_RATE])
1847 gen_replace_estimator(&cl->bstats, &cl->rate_est, 1847 gen_replace_estimator(&cl->bstats, &cl->rate_est,
1848 &sch->dev->queue_lock, 1848 &sch->dev->queue_lock,
1849 tca[TCA_RATE-1]); 1849 tca[TCA_RATE]);
1850 return 0; 1850 return 0;
1851 } 1851 }
1852 1852
1853 if (parentid == TC_H_ROOT) 1853 if (parentid == TC_H_ROOT)
1854 return -EINVAL; 1854 return -EINVAL;
1855 1855
1856 if (tb[TCA_CBQ_WRROPT-1] == NULL || tb[TCA_CBQ_RATE-1] == NULL || 1856 if (tb[TCA_CBQ_WRROPT] == NULL || tb[TCA_CBQ_RATE] == NULL ||
1857 tb[TCA_CBQ_LSSOPT-1] == NULL) 1857 tb[TCA_CBQ_LSSOPT] == NULL)
1858 return -EINVAL; 1858 return -EINVAL;
1859 1859
1860 rtab = qdisc_get_rtab(RTA_DATA(tb[TCA_CBQ_RATE-1]), tb[TCA_CBQ_RTAB-1]); 1860 rtab = qdisc_get_rtab(nla_data(tb[TCA_CBQ_RATE]), tb[TCA_CBQ_RTAB]);
1861 if (rtab == NULL) 1861 if (rtab == NULL)
1862 return -EINVAL; 1862 return -EINVAL;
1863 1863
@@ -1912,8 +1912,8 @@ cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct rtattr **t
1912 cl->share = cl->tparent; 1912 cl->share = cl->tparent;
1913 cbq_adjust_levels(parent); 1913 cbq_adjust_levels(parent);
1914 cl->minidle = -0x7FFFFFFF; 1914 cl->minidle = -0x7FFFFFFF;
1915 cbq_set_lss(cl, RTA_DATA(tb[TCA_CBQ_LSSOPT-1])); 1915 cbq_set_lss(cl, nla_data(tb[TCA_CBQ_LSSOPT]));
1916 cbq_set_wrr(cl, RTA_DATA(tb[TCA_CBQ_WRROPT-1])); 1916 cbq_set_wrr(cl, nla_data(tb[TCA_CBQ_WRROPT]));
1917 if (cl->ewma_log==0) 1917 if (cl->ewma_log==0)
1918 cl->ewma_log = q->link.ewma_log; 1918 cl->ewma_log = q->link.ewma_log;
1919 if (cl->maxidle==0) 1919 if (cl->maxidle==0)
@@ -1921,19 +1921,19 @@ cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct rtattr **t
1921 if (cl->avpkt==0) 1921 if (cl->avpkt==0)
1922 cl->avpkt = q->link.avpkt; 1922 cl->avpkt = q->link.avpkt;
1923 cl->overlimit = cbq_ovl_classic; 1923 cl->overlimit = cbq_ovl_classic;
1924 if (tb[TCA_CBQ_OVL_STRATEGY-1]) 1924 if (tb[TCA_CBQ_OVL_STRATEGY])
1925 cbq_set_overlimit(cl, RTA_DATA(tb[TCA_CBQ_OVL_STRATEGY-1])); 1925 cbq_set_overlimit(cl, nla_data(tb[TCA_CBQ_OVL_STRATEGY]));
1926#ifdef CONFIG_NET_CLS_ACT 1926#ifdef CONFIG_NET_CLS_ACT
1927 if (tb[TCA_CBQ_POLICE-1]) 1927 if (tb[TCA_CBQ_POLICE])
1928 cbq_set_police(cl, RTA_DATA(tb[TCA_CBQ_POLICE-1])); 1928 cbq_set_police(cl, nla_data(tb[TCA_CBQ_POLICE]));
1929#endif 1929#endif
1930 if (tb[TCA_CBQ_FOPT-1]) 1930 if (tb[TCA_CBQ_FOPT])
1931 cbq_set_fopt(cl, RTA_DATA(tb[TCA_CBQ_FOPT-1])); 1931 cbq_set_fopt(cl, nla_data(tb[TCA_CBQ_FOPT]));
1932 sch_tree_unlock(sch); 1932 sch_tree_unlock(sch);
1933 1933
1934 if (tca[TCA_RATE-1]) 1934 if (tca[TCA_RATE])
1935 gen_new_estimator(&cl->bstats, &cl->rate_est, 1935 gen_new_estimator(&cl->bstats, &cl->rate_est,
1936 &sch->dev->queue_lock, tca[TCA_RATE-1]); 1936 &sch->dev->queue_lock, tca[TCA_RATE]);
1937 1937
1938 *arg = (unsigned long)cl; 1938 *arg = (unsigned long)cl;
1939 return 0; 1939 return 0;
diff --git a/net/sched/sch_dsmark.c b/net/sched/sch_dsmark.c
index 40e06a6890da..f183ab768873 100644
--- a/net/sched/sch_dsmark.c
+++ b/net/sched/sch_dsmark.c
@@ -100,11 +100,11 @@ static void dsmark_put(struct Qdisc *sch, unsigned long cl)
100} 100}
101 101
102static int dsmark_change(struct Qdisc *sch, u32 classid, u32 parent, 102static int dsmark_change(struct Qdisc *sch, u32 classid, u32 parent,
103 struct rtattr **tca, unsigned long *arg) 103 struct nlattr **tca, unsigned long *arg)
104{ 104{
105 struct dsmark_qdisc_data *p = qdisc_priv(sch); 105 struct dsmark_qdisc_data *p = qdisc_priv(sch);
106 struct rtattr *opt = tca[TCA_OPTIONS-1]; 106 struct nlattr *opt = tca[TCA_OPTIONS];
107 struct rtattr *tb[TCA_DSMARK_MAX]; 107 struct nlattr *tb[TCA_DSMARK_MAX + 1];
108 int err = -EINVAL; 108 int err = -EINVAL;
109 u8 mask = 0; 109 u8 mask = 0;
110 110
@@ -113,24 +113,29 @@ static int dsmark_change(struct Qdisc *sch, u32 classid, u32 parent,
113 113
114 if (!dsmark_valid_index(p, *arg)) { 114 if (!dsmark_valid_index(p, *arg)) {
115 err = -ENOENT; 115 err = -ENOENT;
116 goto rtattr_failure; 116 goto errout;
117 } 117 }
118 118
119 if (!opt || rtattr_parse_nested(tb, TCA_DSMARK_MAX, opt)) 119 if (!opt || nla_parse_nested(tb, TCA_DSMARK_MAX, opt, NULL))
120 goto rtattr_failure; 120 goto errout;
121
122 if (tb[TCA_DSMARK_MASK-1])
123 mask = RTA_GET_U8(tb[TCA_DSMARK_MASK-1]);
124 121
125 if (tb[TCA_DSMARK_VALUE-1]) 122 if (tb[TCA_DSMARK_MASK]) {
126 p->value[*arg-1] = RTA_GET_U8(tb[TCA_DSMARK_VALUE-1]); 123 if (nla_len(tb[TCA_DSMARK_MASK]) < sizeof(u8))
124 goto errout;
125 mask = nla_get_u8(tb[TCA_DSMARK_MASK]);
126 }
127 if (tb[TCA_DSMARK_VALUE]) {
128 if (nla_len(tb[TCA_DSMARK_VALUE]) < sizeof(u8))
129 goto errout;
130 p->value[*arg-1] = nla_get_u8(tb[TCA_DSMARK_VALUE]);
131 }
127 132
128 if (tb[TCA_DSMARK_MASK-1]) 133 if (tb[TCA_DSMARK_MASK])
129 p->mask[*arg-1] = mask; 134 p->mask[*arg-1] = mask;
130 135
131 err = 0; 136 err = 0;
132 137
133rtattr_failure: 138errout:
134 return err; 139 return err;
135} 140}
136 141
@@ -335,10 +340,10 @@ static unsigned int dsmark_drop(struct Qdisc *sch)
335 return len; 340 return len;
336} 341}
337 342
338static int dsmark_init(struct Qdisc *sch, struct rtattr *opt) 343static int dsmark_init(struct Qdisc *sch, struct nlattr *opt)
339{ 344{
340 struct dsmark_qdisc_data *p = qdisc_priv(sch); 345 struct dsmark_qdisc_data *p = qdisc_priv(sch);
341 struct rtattr *tb[TCA_DSMARK_MAX]; 346 struct nlattr *tb[TCA_DSMARK_MAX + 1];
342 int err = -EINVAL; 347 int err = -EINVAL;
343 u32 default_index = NO_DEFAULT_INDEX; 348 u32 default_index = NO_DEFAULT_INDEX;
344 u16 indices; 349 u16 indices;
@@ -346,16 +351,21 @@ static int dsmark_init(struct Qdisc *sch, struct rtattr *opt)
346 351
347 pr_debug("dsmark_init(sch %p,[qdisc %p],opt %p)\n", sch, p, opt); 352 pr_debug("dsmark_init(sch %p,[qdisc %p],opt %p)\n", sch, p, opt);
348 353
349 if (!opt || rtattr_parse_nested(tb, TCA_DSMARK_MAX, opt) < 0) 354 if (!opt || nla_parse_nested(tb, TCA_DSMARK_MAX, opt, NULL) < 0)
350 goto errout; 355 goto errout;
351 356
352 indices = RTA_GET_U16(tb[TCA_DSMARK_INDICES-1]); 357 if (nla_len(tb[TCA_DSMARK_INDICES]) < sizeof(u16))
358 goto errout;
359 indices = nla_get_u16(tb[TCA_DSMARK_INDICES]);
353 360
354 if (hweight32(indices) != 1) 361 if (hweight32(indices) != 1)
355 goto errout; 362 goto errout;
356 363
357 if (tb[TCA_DSMARK_DEFAULT_INDEX-1]) 364 if (tb[TCA_DSMARK_DEFAULT_INDEX]) {
358 default_index = RTA_GET_U16(tb[TCA_DSMARK_DEFAULT_INDEX-1]); 365 if (nla_len(tb[TCA_DSMARK_DEFAULT_INDEX]) < sizeof(u16))
366 goto errout;
367 default_index = nla_get_u16(tb[TCA_DSMARK_DEFAULT_INDEX]);
368 }
359 369
360 mask = kmalloc(indices * 2, GFP_KERNEL); 370 mask = kmalloc(indices * 2, GFP_KERNEL);
361 if (mask == NULL) { 371 if (mask == NULL) {
@@ -371,7 +381,7 @@ static int dsmark_init(struct Qdisc *sch, struct rtattr *opt)
371 381
372 p->indices = indices; 382 p->indices = indices;
373 p->default_index = default_index; 383 p->default_index = default_index;
374 p->set_tc_index = RTA_GET_FLAG(tb[TCA_DSMARK_SET_TC_INDEX-1]); 384 p->set_tc_index = nla_get_flag(tb[TCA_DSMARK_SET_TC_INDEX]);
375 385
376 p->q = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops, sch->handle); 386 p->q = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops, sch->handle);
377 if (p->q == NULL) 387 if (p->q == NULL)
@@ -381,7 +391,6 @@ static int dsmark_init(struct Qdisc *sch, struct rtattr *opt)
381 391
382 err = 0; 392 err = 0;
383errout: 393errout:
384rtattr_failure:
385 return err; 394 return err;
386} 395}
387 396
@@ -409,7 +418,7 @@ static int dsmark_dump_class(struct Qdisc *sch, unsigned long cl,
409 struct sk_buff *skb, struct tcmsg *tcm) 418 struct sk_buff *skb, struct tcmsg *tcm)
410{ 419{
411 struct dsmark_qdisc_data *p = qdisc_priv(sch); 420 struct dsmark_qdisc_data *p = qdisc_priv(sch);
412 struct rtattr *opts = NULL; 421 struct nlattr *opts = NULL;
413 422
414 pr_debug("dsmark_dump_class(sch %p,[qdisc %p],class %ld\n", sch, p, cl); 423 pr_debug("dsmark_dump_class(sch %p,[qdisc %p],class %ld\n", sch, p, cl);
415 424
@@ -419,34 +428,38 @@ static int dsmark_dump_class(struct Qdisc *sch, unsigned long cl,
419 tcm->tcm_handle = TC_H_MAKE(TC_H_MAJ(sch->handle), cl-1); 428 tcm->tcm_handle = TC_H_MAKE(TC_H_MAJ(sch->handle), cl-1);
420 tcm->tcm_info = p->q->handle; 429 tcm->tcm_info = p->q->handle;
421 430
422 opts = RTA_NEST(skb, TCA_OPTIONS); 431 opts = nla_nest_start(skb, TCA_OPTIONS);
423 RTA_PUT_U8(skb, TCA_DSMARK_MASK, p->mask[cl-1]); 432 if (opts == NULL)
424 RTA_PUT_U8(skb, TCA_DSMARK_VALUE, p->value[cl-1]); 433 goto nla_put_failure;
434 NLA_PUT_U8(skb, TCA_DSMARK_MASK, p->mask[cl-1]);
435 NLA_PUT_U8(skb, TCA_DSMARK_VALUE, p->value[cl-1]);
425 436
426 return RTA_NEST_END(skb, opts); 437 return nla_nest_end(skb, opts);
427 438
428rtattr_failure: 439nla_put_failure:
429 return RTA_NEST_CANCEL(skb, opts); 440 return nla_nest_cancel(skb, opts);
430} 441}
431 442
432static int dsmark_dump(struct Qdisc *sch, struct sk_buff *skb) 443static int dsmark_dump(struct Qdisc *sch, struct sk_buff *skb)
433{ 444{
434 struct dsmark_qdisc_data *p = qdisc_priv(sch); 445 struct dsmark_qdisc_data *p = qdisc_priv(sch);
435 struct rtattr *opts = NULL; 446 struct nlattr *opts = NULL;
436 447
437 opts = RTA_NEST(skb, TCA_OPTIONS); 448 opts = nla_nest_start(skb, TCA_OPTIONS);
438 RTA_PUT_U16(skb, TCA_DSMARK_INDICES, p->indices); 449 if (opts == NULL)
450 goto nla_put_failure;
451 NLA_PUT_U16(skb, TCA_DSMARK_INDICES, p->indices);
439 452
440 if (p->default_index != NO_DEFAULT_INDEX) 453 if (p->default_index != NO_DEFAULT_INDEX)
441 RTA_PUT_U16(skb, TCA_DSMARK_DEFAULT_INDEX, p->default_index); 454 NLA_PUT_U16(skb, TCA_DSMARK_DEFAULT_INDEX, p->default_index);
442 455
443 if (p->set_tc_index) 456 if (p->set_tc_index)
444 RTA_PUT_FLAG(skb, TCA_DSMARK_SET_TC_INDEX); 457 NLA_PUT_FLAG(skb, TCA_DSMARK_SET_TC_INDEX);
445 458
446 return RTA_NEST_END(skb, opts); 459 return nla_nest_end(skb, opts);
447 460
448rtattr_failure: 461nla_put_failure:
449 return RTA_NEST_CANCEL(skb, opts); 462 return nla_nest_cancel(skb, opts);
450} 463}
451 464
452static const struct Qdisc_class_ops dsmark_class_ops = { 465static const struct Qdisc_class_ops dsmark_class_ops = {
diff --git a/net/sched/sch_fifo.c b/net/sched/sch_fifo.c
index fd0591903c8a..95ed48221652 100644
--- a/net/sched/sch_fifo.c
+++ b/net/sched/sch_fifo.c
@@ -43,7 +43,7 @@ static int pfifo_enqueue(struct sk_buff *skb, struct Qdisc* sch)
43 return qdisc_reshape_fail(skb, sch); 43 return qdisc_reshape_fail(skb, sch);
44} 44}
45 45
46static int fifo_init(struct Qdisc *sch, struct rtattr *opt) 46static int fifo_init(struct Qdisc *sch, struct nlattr *opt)
47{ 47{
48 struct fifo_sched_data *q = qdisc_priv(sch); 48 struct fifo_sched_data *q = qdisc_priv(sch);
49 49
@@ -55,9 +55,9 @@ static int fifo_init(struct Qdisc *sch, struct rtattr *opt)
55 55
56 q->limit = limit; 56 q->limit = limit;
57 } else { 57 } else {
58 struct tc_fifo_qopt *ctl = RTA_DATA(opt); 58 struct tc_fifo_qopt *ctl = nla_data(opt);
59 59
60 if (RTA_PAYLOAD(opt) < sizeof(*ctl)) 60 if (nla_len(opt) < sizeof(*ctl))
61 return -EINVAL; 61 return -EINVAL;
62 62
63 q->limit = ctl->limit; 63 q->limit = ctl->limit;
@@ -71,10 +71,10 @@ static int fifo_dump(struct Qdisc *sch, struct sk_buff *skb)
71 struct fifo_sched_data *q = qdisc_priv(sch); 71 struct fifo_sched_data *q = qdisc_priv(sch);
72 struct tc_fifo_qopt opt = { .limit = q->limit }; 72 struct tc_fifo_qopt opt = { .limit = q->limit };
73 73
74 RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt); 74 NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
75 return skb->len; 75 return skb->len;
76 76
77rtattr_failure: 77nla_put_failure:
78 return -1; 78 return -1;
79} 79}
80 80
diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index 51e64acd5098..10b5c0887fff 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -397,14 +397,14 @@ static int pfifo_fast_dump(struct Qdisc *qdisc, struct sk_buff *skb)
397 struct tc_prio_qopt opt = { .bands = PFIFO_FAST_BANDS }; 397 struct tc_prio_qopt opt = { .bands = PFIFO_FAST_BANDS };
398 398
399 memcpy(&opt.priomap, prio2band, TC_PRIO_MAX+1); 399 memcpy(&opt.priomap, prio2band, TC_PRIO_MAX+1);
400 RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt); 400 NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
401 return skb->len; 401 return skb->len;
402 402
403rtattr_failure: 403nla_put_failure:
404 return -1; 404 return -1;
405} 405}
406 406
407static int pfifo_fast_init(struct Qdisc *qdisc, struct rtattr *opt) 407static int pfifo_fast_init(struct Qdisc *qdisc, struct nlattr *opt)
408{ 408{
409 int prio; 409 int prio;
410 struct sk_buff_head *list = qdisc_priv(qdisc); 410 struct sk_buff_head *list = qdisc_priv(qdisc);
diff --git a/net/sched/sch_gred.c b/net/sched/sch_gred.c
index e2bcd6682c70..6b784838a534 100644
--- a/net/sched/sch_gred.c
+++ b/net/sched/sch_gred.c
@@ -350,16 +350,16 @@ static inline void gred_destroy_vq(struct gred_sched_data *q)
350 kfree(q); 350 kfree(q);
351} 351}
352 352
353static inline int gred_change_table_def(struct Qdisc *sch, struct rtattr *dps) 353static inline int gred_change_table_def(struct Qdisc *sch, struct nlattr *dps)
354{ 354{
355 struct gred_sched *table = qdisc_priv(sch); 355 struct gred_sched *table = qdisc_priv(sch);
356 struct tc_gred_sopt *sopt; 356 struct tc_gred_sopt *sopt;
357 int i; 357 int i;
358 358
359 if (dps == NULL || RTA_PAYLOAD(dps) < sizeof(*sopt)) 359 if (dps == NULL || nla_len(dps) < sizeof(*sopt))
360 return -EINVAL; 360 return -EINVAL;
361 361
362 sopt = RTA_DATA(dps); 362 sopt = nla_data(dps);
363 363
364 if (sopt->DPs > MAX_DPs || sopt->DPs == 0 || sopt->def_DP >= sopt->DPs) 364 if (sopt->DPs > MAX_DPs || sopt->DPs == 0 || sopt->def_DP >= sopt->DPs)
365 return -EINVAL; 365 return -EINVAL;
@@ -425,28 +425,28 @@ static inline int gred_change_vq(struct Qdisc *sch, int dp,
425 return 0; 425 return 0;
426} 426}
427 427
428static int gred_change(struct Qdisc *sch, struct rtattr *opt) 428static int gred_change(struct Qdisc *sch, struct nlattr *opt)
429{ 429{
430 struct gred_sched *table = qdisc_priv(sch); 430 struct gred_sched *table = qdisc_priv(sch);
431 struct tc_gred_qopt *ctl; 431 struct tc_gred_qopt *ctl;
432 struct rtattr *tb[TCA_GRED_MAX]; 432 struct nlattr *tb[TCA_GRED_MAX + 1];
433 int err = -EINVAL, prio = GRED_DEF_PRIO; 433 int err = -EINVAL, prio = GRED_DEF_PRIO;
434 u8 *stab; 434 u8 *stab;
435 435
436 if (opt == NULL || rtattr_parse_nested(tb, TCA_GRED_MAX, opt)) 436 if (opt == NULL || nla_parse_nested(tb, TCA_GRED_MAX, opt, NULL))
437 return -EINVAL; 437 return -EINVAL;
438 438
439 if (tb[TCA_GRED_PARMS-1] == NULL && tb[TCA_GRED_STAB-1] == NULL) 439 if (tb[TCA_GRED_PARMS] == NULL && tb[TCA_GRED_STAB] == NULL)
440 return gred_change_table_def(sch, opt); 440 return gred_change_table_def(sch, opt);
441 441
442 if (tb[TCA_GRED_PARMS-1] == NULL || 442 if (tb[TCA_GRED_PARMS] == NULL ||
443 RTA_PAYLOAD(tb[TCA_GRED_PARMS-1]) < sizeof(*ctl) || 443 nla_len(tb[TCA_GRED_PARMS]) < sizeof(*ctl) ||
444 tb[TCA_GRED_STAB-1] == NULL || 444 tb[TCA_GRED_STAB] == NULL ||
445 RTA_PAYLOAD(tb[TCA_GRED_STAB-1]) < 256) 445 nla_len(tb[TCA_GRED_STAB]) < 256)
446 return -EINVAL; 446 return -EINVAL;
447 447
448 ctl = RTA_DATA(tb[TCA_GRED_PARMS-1]); 448 ctl = nla_data(tb[TCA_GRED_PARMS]);
449 stab = RTA_DATA(tb[TCA_GRED_STAB-1]); 449 stab = nla_data(tb[TCA_GRED_STAB]);
450 450
451 if (ctl->DP >= table->DPs) 451 if (ctl->DP >= table->DPs)
452 goto errout; 452 goto errout;
@@ -486,23 +486,23 @@ errout:
486 return err; 486 return err;
487} 487}
488 488
489static int gred_init(struct Qdisc *sch, struct rtattr *opt) 489static int gred_init(struct Qdisc *sch, struct nlattr *opt)
490{ 490{
491 struct rtattr *tb[TCA_GRED_MAX]; 491 struct nlattr *tb[TCA_GRED_MAX + 1];
492 492
493 if (opt == NULL || rtattr_parse_nested(tb, TCA_GRED_MAX, opt)) 493 if (opt == NULL || nla_parse_nested(tb, TCA_GRED_MAX, opt, NULL))
494 return -EINVAL; 494 return -EINVAL;
495 495
496 if (tb[TCA_GRED_PARMS-1] || tb[TCA_GRED_STAB-1]) 496 if (tb[TCA_GRED_PARMS] || tb[TCA_GRED_STAB])
497 return -EINVAL; 497 return -EINVAL;
498 498
499 return gred_change_table_def(sch, tb[TCA_GRED_DPS-1]); 499 return gred_change_table_def(sch, tb[TCA_GRED_DPS]);
500} 500}
501 501
502static int gred_dump(struct Qdisc *sch, struct sk_buff *skb) 502static int gred_dump(struct Qdisc *sch, struct sk_buff *skb)
503{ 503{
504 struct gred_sched *table = qdisc_priv(sch); 504 struct gred_sched *table = qdisc_priv(sch);
505 struct rtattr *parms, *opts = NULL; 505 struct nlattr *parms, *opts = NULL;
506 int i; 506 int i;
507 struct tc_gred_sopt sopt = { 507 struct tc_gred_sopt sopt = {
508 .DPs = table->DPs, 508 .DPs = table->DPs,
@@ -511,9 +511,13 @@ static int gred_dump(struct Qdisc *sch, struct sk_buff *skb)
511 .flags = table->red_flags, 511 .flags = table->red_flags,
512 }; 512 };
513 513
514 opts = RTA_NEST(skb, TCA_OPTIONS); 514 opts = nla_nest_start(skb, TCA_OPTIONS);
515 RTA_PUT(skb, TCA_GRED_DPS, sizeof(sopt), &sopt); 515 if (opts == NULL)
516 parms = RTA_NEST(skb, TCA_GRED_PARMS); 516 goto nla_put_failure;
517 NLA_PUT(skb, TCA_GRED_DPS, sizeof(sopt), &sopt);
518 parms = nla_nest_start(skb, TCA_GRED_PARMS);
519 if (parms == NULL)
520 goto nla_put_failure;
517 521
518 for (i = 0; i < MAX_DPs; i++) { 522 for (i = 0; i < MAX_DPs; i++) {
519 struct gred_sched_data *q = table->tab[i]; 523 struct gred_sched_data *q = table->tab[i];
@@ -555,15 +559,16 @@ static int gred_dump(struct Qdisc *sch, struct sk_buff *skb)
555 opt.qave = red_calc_qavg(&q->parms, q->parms.qavg); 559 opt.qave = red_calc_qavg(&q->parms, q->parms.qavg);
556 560
557append_opt: 561append_opt:
558 RTA_APPEND(skb, sizeof(opt), &opt); 562 if (nla_append(skb, sizeof(opt), &opt) < 0)
563 goto nla_put_failure;
559 } 564 }
560 565
561 RTA_NEST_END(skb, parms); 566 nla_nest_end(skb, parms);
562 567
563 return RTA_NEST_END(skb, opts); 568 return nla_nest_end(skb, opts);
564 569
565rtattr_failure: 570nla_put_failure:
566 return RTA_NEST_CANCEL(skb, opts); 571 return nla_nest_cancel(skb, opts);
567} 572}
568 573
569static void gred_destroy(struct Qdisc *sch) 574static void gred_destroy(struct Qdisc *sch)
diff --git a/net/sched/sch_hfsc.c b/net/sched/sch_hfsc.c
index 69dc3bccf024..4e6a164d3058 100644
--- a/net/sched/sch_hfsc.c
+++ b/net/sched/sch_hfsc.c
@@ -988,39 +988,39 @@ hfsc_change_usc(struct hfsc_class *cl, struct tc_service_curve *usc,
988 988
989static int 989static int
990hfsc_change_class(struct Qdisc *sch, u32 classid, u32 parentid, 990hfsc_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
991 struct rtattr **tca, unsigned long *arg) 991 struct nlattr **tca, unsigned long *arg)
992{ 992{
993 struct hfsc_sched *q = qdisc_priv(sch); 993 struct hfsc_sched *q = qdisc_priv(sch);
994 struct hfsc_class *cl = (struct hfsc_class *)*arg; 994 struct hfsc_class *cl = (struct hfsc_class *)*arg;
995 struct hfsc_class *parent = NULL; 995 struct hfsc_class *parent = NULL;
996 struct rtattr *opt = tca[TCA_OPTIONS-1]; 996 struct nlattr *opt = tca[TCA_OPTIONS];
997 struct rtattr *tb[TCA_HFSC_MAX]; 997 struct nlattr *tb[TCA_HFSC_MAX + 1];
998 struct tc_service_curve *rsc = NULL, *fsc = NULL, *usc = NULL; 998 struct tc_service_curve *rsc = NULL, *fsc = NULL, *usc = NULL;
999 u64 cur_time; 999 u64 cur_time;
1000 1000
1001 if (opt == NULL || rtattr_parse_nested(tb, TCA_HFSC_MAX, opt)) 1001 if (opt == NULL || nla_parse_nested(tb, TCA_HFSC_MAX, opt, NULL))
1002 return -EINVAL; 1002 return -EINVAL;
1003 1003
1004 if (tb[TCA_HFSC_RSC-1]) { 1004 if (tb[TCA_HFSC_RSC]) {
1005 if (RTA_PAYLOAD(tb[TCA_HFSC_RSC-1]) < sizeof(*rsc)) 1005 if (nla_len(tb[TCA_HFSC_RSC]) < sizeof(*rsc))
1006 return -EINVAL; 1006 return -EINVAL;
1007 rsc = RTA_DATA(tb[TCA_HFSC_RSC-1]); 1007 rsc = nla_data(tb[TCA_HFSC_RSC]);
1008 if (rsc->m1 == 0 && rsc->m2 == 0) 1008 if (rsc->m1 == 0 && rsc->m2 == 0)
1009 rsc = NULL; 1009 rsc = NULL;
1010 } 1010 }
1011 1011
1012 if (tb[TCA_HFSC_FSC-1]) { 1012 if (tb[TCA_HFSC_FSC]) {
1013 if (RTA_PAYLOAD(tb[TCA_HFSC_FSC-1]) < sizeof(*fsc)) 1013 if (nla_len(tb[TCA_HFSC_FSC]) < sizeof(*fsc))
1014 return -EINVAL; 1014 return -EINVAL;
1015 fsc = RTA_DATA(tb[TCA_HFSC_FSC-1]); 1015 fsc = nla_data(tb[TCA_HFSC_FSC]);
1016 if (fsc->m1 == 0 && fsc->m2 == 0) 1016 if (fsc->m1 == 0 && fsc->m2 == 0)
1017 fsc = NULL; 1017 fsc = NULL;
1018 } 1018 }
1019 1019
1020 if (tb[TCA_HFSC_USC-1]) { 1020 if (tb[TCA_HFSC_USC]) {
1021 if (RTA_PAYLOAD(tb[TCA_HFSC_USC-1]) < sizeof(*usc)) 1021 if (nla_len(tb[TCA_HFSC_USC]) < sizeof(*usc))
1022 return -EINVAL; 1022 return -EINVAL;
1023 usc = RTA_DATA(tb[TCA_HFSC_USC-1]); 1023 usc = nla_data(tb[TCA_HFSC_USC]);
1024 if (usc->m1 == 0 && usc->m2 == 0) 1024 if (usc->m1 == 0 && usc->m2 == 0)
1025 usc = NULL; 1025 usc = NULL;
1026 } 1026 }
@@ -1050,10 +1050,10 @@ hfsc_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
1050 } 1050 }
1051 sch_tree_unlock(sch); 1051 sch_tree_unlock(sch);
1052 1052
1053 if (tca[TCA_RATE-1]) 1053 if (tca[TCA_RATE])
1054 gen_replace_estimator(&cl->bstats, &cl->rate_est, 1054 gen_replace_estimator(&cl->bstats, &cl->rate_est,
1055 &sch->dev->queue_lock, 1055 &sch->dev->queue_lock,
1056 tca[TCA_RATE-1]); 1056 tca[TCA_RATE]);
1057 return 0; 1057 return 0;
1058 } 1058 }
1059 1059
@@ -1106,9 +1106,9 @@ hfsc_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
1106 cl->cl_pcvtoff = parent->cl_cvtoff; 1106 cl->cl_pcvtoff = parent->cl_cvtoff;
1107 sch_tree_unlock(sch); 1107 sch_tree_unlock(sch);
1108 1108
1109 if (tca[TCA_RATE-1]) 1109 if (tca[TCA_RATE])
1110 gen_new_estimator(&cl->bstats, &cl->rate_est, 1110 gen_new_estimator(&cl->bstats, &cl->rate_est,
1111 &sch->dev->queue_lock, tca[TCA_RATE-1]); 1111 &sch->dev->queue_lock, tca[TCA_RATE]);
1112 *arg = (unsigned long)cl; 1112 *arg = (unsigned long)cl;
1113 return 0; 1113 return 0;
1114} 1114}
@@ -1304,11 +1304,11 @@ hfsc_dump_sc(struct sk_buff *skb, int attr, struct internal_sc *sc)
1304 tsc.m1 = sm2m(sc->sm1); 1304 tsc.m1 = sm2m(sc->sm1);
1305 tsc.d = dx2d(sc->dx); 1305 tsc.d = dx2d(sc->dx);
1306 tsc.m2 = sm2m(sc->sm2); 1306 tsc.m2 = sm2m(sc->sm2);
1307 RTA_PUT(skb, attr, sizeof(tsc), &tsc); 1307 NLA_PUT(skb, attr, sizeof(tsc), &tsc);
1308 1308
1309 return skb->len; 1309 return skb->len;
1310 1310
1311 rtattr_failure: 1311 nla_put_failure:
1312 return -1; 1312 return -1;
1313} 1313}
1314 1314
@@ -1317,19 +1317,19 @@ hfsc_dump_curves(struct sk_buff *skb, struct hfsc_class *cl)
1317{ 1317{
1318 if ((cl->cl_flags & HFSC_RSC) && 1318 if ((cl->cl_flags & HFSC_RSC) &&
1319 (hfsc_dump_sc(skb, TCA_HFSC_RSC, &cl->cl_rsc) < 0)) 1319 (hfsc_dump_sc(skb, TCA_HFSC_RSC, &cl->cl_rsc) < 0))
1320 goto rtattr_failure; 1320 goto nla_put_failure;
1321 1321
1322 if ((cl->cl_flags & HFSC_FSC) && 1322 if ((cl->cl_flags & HFSC_FSC) &&
1323 (hfsc_dump_sc(skb, TCA_HFSC_FSC, &cl->cl_fsc) < 0)) 1323 (hfsc_dump_sc(skb, TCA_HFSC_FSC, &cl->cl_fsc) < 0))
1324 goto rtattr_failure; 1324 goto nla_put_failure;
1325 1325
1326 if ((cl->cl_flags & HFSC_USC) && 1326 if ((cl->cl_flags & HFSC_USC) &&
1327 (hfsc_dump_sc(skb, TCA_HFSC_USC, &cl->cl_usc) < 0)) 1327 (hfsc_dump_sc(skb, TCA_HFSC_USC, &cl->cl_usc) < 0))
1328 goto rtattr_failure; 1328 goto nla_put_failure;
1329 1329
1330 return skb->len; 1330 return skb->len;
1331 1331
1332 rtattr_failure: 1332 nla_put_failure:
1333 return -1; 1333 return -1;
1334} 1334}
1335 1335
@@ -1339,20 +1339,20 @@ hfsc_dump_class(struct Qdisc *sch, unsigned long arg, struct sk_buff *skb,
1339{ 1339{
1340 struct hfsc_class *cl = (struct hfsc_class *)arg; 1340 struct hfsc_class *cl = (struct hfsc_class *)arg;
1341 unsigned char *b = skb_tail_pointer(skb); 1341 unsigned char *b = skb_tail_pointer(skb);
1342 struct rtattr *rta = (struct rtattr *)b; 1342 struct nlattr *nla = (struct nlattr *)b;
1343 1343
1344 tcm->tcm_parent = cl->cl_parent ? cl->cl_parent->classid : TC_H_ROOT; 1344 tcm->tcm_parent = cl->cl_parent ? cl->cl_parent->classid : TC_H_ROOT;
1345 tcm->tcm_handle = cl->classid; 1345 tcm->tcm_handle = cl->classid;
1346 if (cl->level == 0) 1346 if (cl->level == 0)
1347 tcm->tcm_info = cl->qdisc->handle; 1347 tcm->tcm_info = cl->qdisc->handle;
1348 1348
1349 RTA_PUT(skb, TCA_OPTIONS, 0, NULL); 1349 NLA_PUT(skb, TCA_OPTIONS, 0, NULL);
1350 if (hfsc_dump_curves(skb, cl) < 0) 1350 if (hfsc_dump_curves(skb, cl) < 0)
1351 goto rtattr_failure; 1351 goto nla_put_failure;
1352 rta->rta_len = skb_tail_pointer(skb) - b; 1352 nla->nla_len = skb_tail_pointer(skb) - b;
1353 return skb->len; 1353 return skb->len;
1354 1354
1355 rtattr_failure: 1355 nla_put_failure:
1356 nlmsg_trim(skb, b); 1356 nlmsg_trim(skb, b);
1357 return -1; 1357 return -1;
1358} 1358}
@@ -1423,15 +1423,15 @@ hfsc_schedule_watchdog(struct Qdisc *sch)
1423} 1423}
1424 1424
1425static int 1425static int
1426hfsc_init_qdisc(struct Qdisc *sch, struct rtattr *opt) 1426hfsc_init_qdisc(struct Qdisc *sch, struct nlattr *opt)
1427{ 1427{
1428 struct hfsc_sched *q = qdisc_priv(sch); 1428 struct hfsc_sched *q = qdisc_priv(sch);
1429 struct tc_hfsc_qopt *qopt; 1429 struct tc_hfsc_qopt *qopt;
1430 unsigned int i; 1430 unsigned int i;
1431 1431
1432 if (opt == NULL || RTA_PAYLOAD(opt) < sizeof(*qopt)) 1432 if (opt == NULL || nla_len(opt) < sizeof(*qopt))
1433 return -EINVAL; 1433 return -EINVAL;
1434 qopt = RTA_DATA(opt); 1434 qopt = nla_data(opt);
1435 1435
1436 q->defcls = qopt->defcls; 1436 q->defcls = qopt->defcls;
1437 for (i = 0; i < HFSC_HSIZE; i++) 1437 for (i = 0; i < HFSC_HSIZE; i++)
@@ -1459,14 +1459,14 @@ hfsc_init_qdisc(struct Qdisc *sch, struct rtattr *opt)
1459} 1459}
1460 1460
1461static int 1461static int
1462hfsc_change_qdisc(struct Qdisc *sch, struct rtattr *opt) 1462hfsc_change_qdisc(struct Qdisc *sch, struct nlattr *opt)
1463{ 1463{
1464 struct hfsc_sched *q = qdisc_priv(sch); 1464 struct hfsc_sched *q = qdisc_priv(sch);
1465 struct tc_hfsc_qopt *qopt; 1465 struct tc_hfsc_qopt *qopt;
1466 1466
1467 if (opt == NULL || RTA_PAYLOAD(opt) < sizeof(*qopt)) 1467 if (opt == NULL || nla_len(opt) < sizeof(*qopt))
1468 return -EINVAL; 1468 return -EINVAL;
1469 qopt = RTA_DATA(opt); 1469 qopt = nla_data(opt);
1470 1470
1471 sch_tree_lock(sch); 1471 sch_tree_lock(sch);
1472 q->defcls = qopt->defcls; 1472 q->defcls = qopt->defcls;
@@ -1550,10 +1550,10 @@ hfsc_dump_qdisc(struct Qdisc *sch, struct sk_buff *skb)
1550 struct tc_hfsc_qopt qopt; 1550 struct tc_hfsc_qopt qopt;
1551 1551
1552 qopt.defcls = q->defcls; 1552 qopt.defcls = q->defcls;
1553 RTA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt); 1553 NLA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt);
1554 return skb->len; 1554 return skb->len;
1555 1555
1556 rtattr_failure: 1556 nla_put_failure:
1557 nlmsg_trim(skb, b); 1557 nlmsg_trim(skb, b);
1558 return -1; 1558 return -1;
1559} 1559}
diff --git a/net/sched/sch_htb.c b/net/sched/sch_htb.c
index 6a2352cd9c2e..3b3ff641b6d7 100644
--- a/net/sched/sch_htb.c
+++ b/net/sched/sch_htb.c
@@ -992,19 +992,19 @@ static void htb_reset(struct Qdisc *sch)
992 INIT_LIST_HEAD(q->drops + i); 992 INIT_LIST_HEAD(q->drops + i);
993} 993}
994 994
995static int htb_init(struct Qdisc *sch, struct rtattr *opt) 995static int htb_init(struct Qdisc *sch, struct nlattr *opt)
996{ 996{
997 struct htb_sched *q = qdisc_priv(sch); 997 struct htb_sched *q = qdisc_priv(sch);
998 struct rtattr *tb[TCA_HTB_INIT]; 998 struct nlattr *tb[TCA_HTB_INIT + 1];
999 struct tc_htb_glob *gopt; 999 struct tc_htb_glob *gopt;
1000 int i; 1000 int i;
1001 if (!opt || rtattr_parse_nested(tb, TCA_HTB_INIT, opt) || 1001 if (!opt || nla_parse_nested(tb, TCA_HTB_INIT, opt, NULL) ||
1002 tb[TCA_HTB_INIT - 1] == NULL || 1002 tb[TCA_HTB_INIT] == NULL ||
1003 RTA_PAYLOAD(tb[TCA_HTB_INIT - 1]) < sizeof(*gopt)) { 1003 nla_len(tb[TCA_HTB_INIT]) < sizeof(*gopt)) {
1004 printk(KERN_ERR "HTB: hey probably you have bad tc tool ?\n"); 1004 printk(KERN_ERR "HTB: hey probably you have bad tc tool ?\n");
1005 return -EINVAL; 1005 return -EINVAL;
1006 } 1006 }
1007 gopt = RTA_DATA(tb[TCA_HTB_INIT - 1]); 1007 gopt = nla_data(tb[TCA_HTB_INIT]);
1008 if (gopt->version != HTB_VER >> 16) { 1008 if (gopt->version != HTB_VER >> 16) {
1009 printk(KERN_ERR 1009 printk(KERN_ERR
1010 "HTB: need tc/htb version %d (minor is %d), you have %d\n", 1010 "HTB: need tc/htb version %d (minor is %d), you have %d\n",
@@ -1036,7 +1036,7 @@ static int htb_dump(struct Qdisc *sch, struct sk_buff *skb)
1036{ 1036{
1037 struct htb_sched *q = qdisc_priv(sch); 1037 struct htb_sched *q = qdisc_priv(sch);
1038 unsigned char *b = skb_tail_pointer(skb); 1038 unsigned char *b = skb_tail_pointer(skb);
1039 struct rtattr *rta; 1039 struct nlattr *nla;
1040 struct tc_htb_glob gopt; 1040 struct tc_htb_glob gopt;
1041 spin_lock_bh(&sch->dev->queue_lock); 1041 spin_lock_bh(&sch->dev->queue_lock);
1042 gopt.direct_pkts = q->direct_pkts; 1042 gopt.direct_pkts = q->direct_pkts;
@@ -1045,13 +1045,13 @@ static int htb_dump(struct Qdisc *sch, struct sk_buff *skb)
1045 gopt.rate2quantum = q->rate2quantum; 1045 gopt.rate2quantum = q->rate2quantum;
1046 gopt.defcls = q->defcls; 1046 gopt.defcls = q->defcls;
1047 gopt.debug = 0; 1047 gopt.debug = 0;
1048 rta = (struct rtattr *)b; 1048 nla = (struct nlattr *)b;
1049 RTA_PUT(skb, TCA_OPTIONS, 0, NULL); 1049 NLA_PUT(skb, TCA_OPTIONS, 0, NULL);
1050 RTA_PUT(skb, TCA_HTB_INIT, sizeof(gopt), &gopt); 1050 NLA_PUT(skb, TCA_HTB_INIT, sizeof(gopt), &gopt);
1051 rta->rta_len = skb_tail_pointer(skb) - b; 1051 nla->nla_len = skb_tail_pointer(skb) - b;
1052 spin_unlock_bh(&sch->dev->queue_lock); 1052 spin_unlock_bh(&sch->dev->queue_lock);
1053 return skb->len; 1053 return skb->len;
1054rtattr_failure: 1054nla_put_failure:
1055 spin_unlock_bh(&sch->dev->queue_lock); 1055 spin_unlock_bh(&sch->dev->queue_lock);
1056 nlmsg_trim(skb, skb_tail_pointer(skb)); 1056 nlmsg_trim(skb, skb_tail_pointer(skb));
1057 return -1; 1057 return -1;
@@ -1062,7 +1062,7 @@ static int htb_dump_class(struct Qdisc *sch, unsigned long arg,
1062{ 1062{
1063 struct htb_class *cl = (struct htb_class *)arg; 1063 struct htb_class *cl = (struct htb_class *)arg;
1064 unsigned char *b = skb_tail_pointer(skb); 1064 unsigned char *b = skb_tail_pointer(skb);
1065 struct rtattr *rta; 1065 struct nlattr *nla;
1066 struct tc_htb_opt opt; 1066 struct tc_htb_opt opt;
1067 1067
1068 spin_lock_bh(&sch->dev->queue_lock); 1068 spin_lock_bh(&sch->dev->queue_lock);
@@ -1071,8 +1071,8 @@ static int htb_dump_class(struct Qdisc *sch, unsigned long arg,
1071 if (!cl->level && cl->un.leaf.q) 1071 if (!cl->level && cl->un.leaf.q)
1072 tcm->tcm_info = cl->un.leaf.q->handle; 1072 tcm->tcm_info = cl->un.leaf.q->handle;
1073 1073
1074 rta = (struct rtattr *)b; 1074 nla = (struct nlattr *)b;
1075 RTA_PUT(skb, TCA_OPTIONS, 0, NULL); 1075 NLA_PUT(skb, TCA_OPTIONS, 0, NULL);
1076 1076
1077 memset(&opt, 0, sizeof(opt)); 1077 memset(&opt, 0, sizeof(opt));
1078 1078
@@ -1083,11 +1083,11 @@ static int htb_dump_class(struct Qdisc *sch, unsigned long arg,
1083 opt.quantum = cl->un.leaf.quantum; 1083 opt.quantum = cl->un.leaf.quantum;
1084 opt.prio = cl->un.leaf.prio; 1084 opt.prio = cl->un.leaf.prio;
1085 opt.level = cl->level; 1085 opt.level = cl->level;
1086 RTA_PUT(skb, TCA_HTB_PARMS, sizeof(opt), &opt); 1086 NLA_PUT(skb, TCA_HTB_PARMS, sizeof(opt), &opt);
1087 rta->rta_len = skb_tail_pointer(skb) - b; 1087 nla->nla_len = skb_tail_pointer(skb) - b;
1088 spin_unlock_bh(&sch->dev->queue_lock); 1088 spin_unlock_bh(&sch->dev->queue_lock);
1089 return skb->len; 1089 return skb->len;
1090rtattr_failure: 1090nla_put_failure:
1091 spin_unlock_bh(&sch->dev->queue_lock); 1091 spin_unlock_bh(&sch->dev->queue_lock);
1092 nlmsg_trim(skb, b); 1092 nlmsg_trim(skb, b);
1093 return -1; 1093 return -1;
@@ -1290,29 +1290,29 @@ static void htb_put(struct Qdisc *sch, unsigned long arg)
1290} 1290}
1291 1291
1292static int htb_change_class(struct Qdisc *sch, u32 classid, 1292static int htb_change_class(struct Qdisc *sch, u32 classid,
1293 u32 parentid, struct rtattr **tca, 1293 u32 parentid, struct nlattr **tca,
1294 unsigned long *arg) 1294 unsigned long *arg)
1295{ 1295{
1296 int err = -EINVAL; 1296 int err = -EINVAL;
1297 struct htb_sched *q = qdisc_priv(sch); 1297 struct htb_sched *q = qdisc_priv(sch);
1298 struct htb_class *cl = (struct htb_class *)*arg, *parent; 1298 struct htb_class *cl = (struct htb_class *)*arg, *parent;
1299 struct rtattr *opt = tca[TCA_OPTIONS - 1]; 1299 struct nlattr *opt = tca[TCA_OPTIONS];
1300 struct qdisc_rate_table *rtab = NULL, *ctab = NULL; 1300 struct qdisc_rate_table *rtab = NULL, *ctab = NULL;
1301 struct rtattr *tb[TCA_HTB_RTAB]; 1301 struct nlattr *tb[TCA_HTB_RTAB + 1];
1302 struct tc_htb_opt *hopt; 1302 struct tc_htb_opt *hopt;
1303 1303
1304 /* extract all subattrs from opt attr */ 1304 /* extract all subattrs from opt attr */
1305 if (!opt || rtattr_parse_nested(tb, TCA_HTB_RTAB, opt) || 1305 if (!opt || nla_parse_nested(tb, TCA_HTB_RTAB, opt, NULL) ||
1306 tb[TCA_HTB_PARMS - 1] == NULL || 1306 tb[TCA_HTB_PARMS] == NULL ||
1307 RTA_PAYLOAD(tb[TCA_HTB_PARMS - 1]) < sizeof(*hopt)) 1307 nla_len(tb[TCA_HTB_PARMS]) < sizeof(*hopt))
1308 goto failure; 1308 goto failure;
1309 1309
1310 parent = parentid == TC_H_ROOT ? NULL : htb_find(parentid, sch); 1310 parent = parentid == TC_H_ROOT ? NULL : htb_find(parentid, sch);
1311 1311
1312 hopt = RTA_DATA(tb[TCA_HTB_PARMS - 1]); 1312 hopt = nla_data(tb[TCA_HTB_PARMS]);
1313 1313
1314 rtab = qdisc_get_rtab(&hopt->rate, tb[TCA_HTB_RTAB - 1]); 1314 rtab = qdisc_get_rtab(&hopt->rate, tb[TCA_HTB_RTAB]);
1315 ctab = qdisc_get_rtab(&hopt->ceil, tb[TCA_HTB_CTAB - 1]); 1315 ctab = qdisc_get_rtab(&hopt->ceil, tb[TCA_HTB_CTAB]);
1316 if (!rtab || !ctab) 1316 if (!rtab || !ctab)
1317 goto failure; 1317 goto failure;
1318 1318
@@ -1320,12 +1320,12 @@ static int htb_change_class(struct Qdisc *sch, u32 classid,
1320 struct Qdisc *new_q; 1320 struct Qdisc *new_q;
1321 int prio; 1321 int prio;
1322 struct { 1322 struct {
1323 struct rtattr rta; 1323 struct nlattr nla;
1324 struct gnet_estimator opt; 1324 struct gnet_estimator opt;
1325 } est = { 1325 } est = {
1326 .rta = { 1326 .nla = {
1327 .rta_len = RTA_LENGTH(sizeof(est.opt)), 1327 .nla_len = nla_attr_size(sizeof(est.opt)),
1328 .rta_type = TCA_RATE, 1328 .nla_type = TCA_RATE,
1329 }, 1329 },
1330 .opt = { 1330 .opt = {
1331 /* 4s interval, 16s averaging constant */ 1331 /* 4s interval, 16s averaging constant */
@@ -1350,7 +1350,7 @@ static int htb_change_class(struct Qdisc *sch, u32 classid,
1350 1350
1351 gen_new_estimator(&cl->bstats, &cl->rate_est, 1351 gen_new_estimator(&cl->bstats, &cl->rate_est,
1352 &sch->dev->queue_lock, 1352 &sch->dev->queue_lock,
1353 tca[TCA_RATE-1] ? : &est.rta); 1353 tca[TCA_RATE] ? : &est.nla);
1354 cl->refcnt = 1; 1354 cl->refcnt = 1;
1355 INIT_LIST_HEAD(&cl->sibling); 1355 INIT_LIST_HEAD(&cl->sibling);
1356 INIT_HLIST_NODE(&cl->hlist); 1356 INIT_HLIST_NODE(&cl->hlist);
@@ -1403,10 +1403,10 @@ static int htb_change_class(struct Qdisc *sch, u32 classid,
1403 list_add_tail(&cl->sibling, 1403 list_add_tail(&cl->sibling,
1404 parent ? &parent->children : &q->root); 1404 parent ? &parent->children : &q->root);
1405 } else { 1405 } else {
1406 if (tca[TCA_RATE-1]) 1406 if (tca[TCA_RATE])
1407 gen_replace_estimator(&cl->bstats, &cl->rate_est, 1407 gen_replace_estimator(&cl->bstats, &cl->rate_est,
1408 &sch->dev->queue_lock, 1408 &sch->dev->queue_lock,
1409 tca[TCA_RATE-1]); 1409 tca[TCA_RATE]);
1410 sch_tree_lock(sch); 1410 sch_tree_lock(sch);
1411 } 1411 }
1412 1412
diff --git a/net/sched/sch_ingress.c b/net/sched/sch_ingress.c
index 72525710b66f..f6decbb56645 100644
--- a/net/sched/sch_ingress.c
+++ b/net/sched/sch_ingress.c
@@ -57,7 +57,7 @@ static void ingress_put(struct Qdisc *sch, unsigned long cl)
57} 57}
58 58
59static int ingress_change(struct Qdisc *sch, u32 classid, u32 parent, 59static int ingress_change(struct Qdisc *sch, u32 classid, u32 parent,
60 struct rtattr **tca, unsigned long *arg) 60 struct nlattr **tca, unsigned long *arg)
61{ 61{
62 return 0; 62 return 0;
63} 63}
@@ -156,7 +156,7 @@ static struct nf_hook_ops ing_ops[] __read_mostly = {
156}; 156};
157#endif 157#endif
158 158
159static int ingress_init(struct Qdisc *sch, struct rtattr *opt) 159static int ingress_init(struct Qdisc *sch, struct nlattr *opt)
160{ 160{
161#if !defined(CONFIG_NET_CLS_ACT) && defined(CONFIG_NETFILTER) 161#if !defined(CONFIG_NET_CLS_ACT) && defined(CONFIG_NETFILTER)
162 printk("Ingress scheduler: Classifier actions prefered over netfilter\n"); 162 printk("Ingress scheduler: Classifier actions prefered over netfilter\n");
@@ -184,14 +184,14 @@ static void ingress_destroy(struct Qdisc *sch)
184static int ingress_dump(struct Qdisc *sch, struct sk_buff *skb) 184static int ingress_dump(struct Qdisc *sch, struct sk_buff *skb)
185{ 185{
186 unsigned char *b = skb_tail_pointer(skb); 186 unsigned char *b = skb_tail_pointer(skb);
187 struct rtattr *rta; 187 struct nlattr *nla;
188 188
189 rta = (struct rtattr *)b; 189 nla = (struct nlattr *)b;
190 RTA_PUT(skb, TCA_OPTIONS, 0, NULL); 190 NLA_PUT(skb, TCA_OPTIONS, 0, NULL);
191 rta->rta_len = skb_tail_pointer(skb) - b; 191 nla->nla_len = skb_tail_pointer(skb) - b;
192 return skb->len; 192 return skb->len;
193 193
194rtattr_failure: 194nla_put_failure:
195 nlmsg_trim(skb, b); 195 nlmsg_trim(skb, b);
196 return -1; 196 return -1;
197} 197}
diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c
index 6c344ade33c2..a7b58df4546d 100644
--- a/net/sched/sch_netem.c
+++ b/net/sched/sch_netem.c
@@ -313,21 +313,21 @@ static void netem_reset(struct Qdisc *sch)
313/* Pass size change message down to embedded FIFO */ 313/* Pass size change message down to embedded FIFO */
314static int set_fifo_limit(struct Qdisc *q, int limit) 314static int set_fifo_limit(struct Qdisc *q, int limit)
315{ 315{
316 struct rtattr *rta; 316 struct nlattr *nla;
317 int ret = -ENOMEM; 317 int ret = -ENOMEM;
318 318
319 /* Hack to avoid sending change message to non-FIFO */ 319 /* Hack to avoid sending change message to non-FIFO */
320 if (strncmp(q->ops->id + 1, "fifo", 4) != 0) 320 if (strncmp(q->ops->id + 1, "fifo", 4) != 0)
321 return 0; 321 return 0;
322 322
323 rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)), GFP_KERNEL); 323 nla = kmalloc(nla_attr_size(sizeof(struct tc_fifo_qopt)), GFP_KERNEL);
324 if (rta) { 324 if (nla) {
325 rta->rta_type = RTM_NEWQDISC; 325 nla->nla_type = RTM_NEWQDISC;
326 rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt)); 326 nla->nla_len = nla_attr_size(sizeof(struct tc_fifo_qopt));
327 ((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit; 327 ((struct tc_fifo_qopt *)nla_data(nla))->limit = limit;
328 328
329 ret = q->ops->change(q, rta); 329 ret = q->ops->change(q, nla);
330 kfree(rta); 330 kfree(nla);
331 } 331 }
332 return ret; 332 return ret;
333} 333}
@@ -336,11 +336,11 @@ static int set_fifo_limit(struct Qdisc *q, int limit)
336 * Distribution data is a variable size payload containing 336 * Distribution data is a variable size payload containing
337 * signed 16 bit values. 337 * signed 16 bit values.
338 */ 338 */
339static int get_dist_table(struct Qdisc *sch, const struct rtattr *attr) 339static int get_dist_table(struct Qdisc *sch, const struct nlattr *attr)
340{ 340{
341 struct netem_sched_data *q = qdisc_priv(sch); 341 struct netem_sched_data *q = qdisc_priv(sch);
342 unsigned long n = RTA_PAYLOAD(attr)/sizeof(__s16); 342 unsigned long n = nla_len(attr)/sizeof(__s16);
343 const __s16 *data = RTA_DATA(attr); 343 const __s16 *data = nla_data(attr);
344 struct disttable *d; 344 struct disttable *d;
345 int i; 345 int i;
346 346
@@ -363,12 +363,12 @@ static int get_dist_table(struct Qdisc *sch, const struct rtattr *attr)
363 return 0; 363 return 0;
364} 364}
365 365
366static int get_correlation(struct Qdisc *sch, const struct rtattr *attr) 366static int get_correlation(struct Qdisc *sch, const struct nlattr *attr)
367{ 367{
368 struct netem_sched_data *q = qdisc_priv(sch); 368 struct netem_sched_data *q = qdisc_priv(sch);
369 const struct tc_netem_corr *c = RTA_DATA(attr); 369 const struct tc_netem_corr *c = nla_data(attr);
370 370
371 if (RTA_PAYLOAD(attr) != sizeof(*c)) 371 if (nla_len(attr) != sizeof(*c))
372 return -EINVAL; 372 return -EINVAL;
373 373
374 init_crandom(&q->delay_cor, c->delay_corr); 374 init_crandom(&q->delay_cor, c->delay_corr);
@@ -377,12 +377,12 @@ static int get_correlation(struct Qdisc *sch, const struct rtattr *attr)
377 return 0; 377 return 0;
378} 378}
379 379
380static int get_reorder(struct Qdisc *sch, const struct rtattr *attr) 380static int get_reorder(struct Qdisc *sch, const struct nlattr *attr)
381{ 381{
382 struct netem_sched_data *q = qdisc_priv(sch); 382 struct netem_sched_data *q = qdisc_priv(sch);
383 const struct tc_netem_reorder *r = RTA_DATA(attr); 383 const struct tc_netem_reorder *r = nla_data(attr);
384 384
385 if (RTA_PAYLOAD(attr) != sizeof(*r)) 385 if (nla_len(attr) != sizeof(*r))
386 return -EINVAL; 386 return -EINVAL;
387 387
388 q->reorder = r->probability; 388 q->reorder = r->probability;
@@ -390,12 +390,12 @@ static int get_reorder(struct Qdisc *sch, const struct rtattr *attr)
390 return 0; 390 return 0;
391} 391}
392 392
393static int get_corrupt(struct Qdisc *sch, const struct rtattr *attr) 393static int get_corrupt(struct Qdisc *sch, const struct nlattr *attr)
394{ 394{
395 struct netem_sched_data *q = qdisc_priv(sch); 395 struct netem_sched_data *q = qdisc_priv(sch);
396 const struct tc_netem_corrupt *r = RTA_DATA(attr); 396 const struct tc_netem_corrupt *r = nla_data(attr);
397 397
398 if (RTA_PAYLOAD(attr) != sizeof(*r)) 398 if (nla_len(attr) != sizeof(*r))
399 return -EINVAL; 399 return -EINVAL;
400 400
401 q->corrupt = r->probability; 401 q->corrupt = r->probability;
@@ -404,16 +404,16 @@ static int get_corrupt(struct Qdisc *sch, const struct rtattr *attr)
404} 404}
405 405
406/* Parse netlink message to set options */ 406/* Parse netlink message to set options */
407static int netem_change(struct Qdisc *sch, struct rtattr *opt) 407static int netem_change(struct Qdisc *sch, struct nlattr *opt)
408{ 408{
409 struct netem_sched_data *q = qdisc_priv(sch); 409 struct netem_sched_data *q = qdisc_priv(sch);
410 struct tc_netem_qopt *qopt; 410 struct tc_netem_qopt *qopt;
411 int ret; 411 int ret;
412 412
413 if (opt == NULL || RTA_PAYLOAD(opt) < sizeof(*qopt)) 413 if (opt == NULL || nla_len(opt) < sizeof(*qopt))
414 return -EINVAL; 414 return -EINVAL;
415 415
416 qopt = RTA_DATA(opt); 416 qopt = nla_data(opt);
417 ret = set_fifo_limit(q->qdisc, qopt->limit); 417 ret = set_fifo_limit(q->qdisc, qopt->limit);
418 if (ret) { 418 if (ret) {
419 pr_debug("netem: can't set fifo limit\n"); 419 pr_debug("netem: can't set fifo limit\n");
@@ -437,33 +437,33 @@ static int netem_change(struct Qdisc *sch, struct rtattr *opt)
437 /* Handle nested options after initial queue options. 437 /* Handle nested options after initial queue options.
438 * Should have put all options in nested format but too late now. 438 * Should have put all options in nested format but too late now.
439 */ 439 */
440 if (RTA_PAYLOAD(opt) > sizeof(*qopt)) { 440 if (nla_len(opt) > sizeof(*qopt)) {
441 struct rtattr *tb[TCA_NETEM_MAX]; 441 struct nlattr *tb[TCA_NETEM_MAX + 1];
442 if (rtattr_parse(tb, TCA_NETEM_MAX, 442 if (nla_parse(tb, TCA_NETEM_MAX,
443 RTA_DATA(opt) + sizeof(*qopt), 443 nla_data(opt) + sizeof(*qopt),
444 RTA_PAYLOAD(opt) - sizeof(*qopt))) 444 nla_len(opt) - sizeof(*qopt), NULL))
445 return -EINVAL; 445 return -EINVAL;
446 446
447 if (tb[TCA_NETEM_CORR-1]) { 447 if (tb[TCA_NETEM_CORR]) {
448 ret = get_correlation(sch, tb[TCA_NETEM_CORR-1]); 448 ret = get_correlation(sch, tb[TCA_NETEM_CORR]);
449 if (ret) 449 if (ret)
450 return ret; 450 return ret;
451 } 451 }
452 452
453 if (tb[TCA_NETEM_DELAY_DIST-1]) { 453 if (tb[TCA_NETEM_DELAY_DIST]) {
454 ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST-1]); 454 ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST]);
455 if (ret) 455 if (ret)
456 return ret; 456 return ret;
457 } 457 }
458 458
459 if (tb[TCA_NETEM_REORDER-1]) { 459 if (tb[TCA_NETEM_REORDER]) {
460 ret = get_reorder(sch, tb[TCA_NETEM_REORDER-1]); 460 ret = get_reorder(sch, tb[TCA_NETEM_REORDER]);
461 if (ret) 461 if (ret)
462 return ret; 462 return ret;
463 } 463 }
464 464
465 if (tb[TCA_NETEM_CORRUPT-1]) { 465 if (tb[TCA_NETEM_CORRUPT]) {
466 ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT-1]); 466 ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT]);
467 if (ret) 467 if (ret)
468 return ret; 468 return ret;
469 } 469 }
@@ -515,13 +515,13 @@ static int tfifo_enqueue(struct sk_buff *nskb, struct Qdisc *sch)
515 return qdisc_reshape_fail(nskb, sch); 515 return qdisc_reshape_fail(nskb, sch);
516} 516}
517 517
518static int tfifo_init(struct Qdisc *sch, struct rtattr *opt) 518static int tfifo_init(struct Qdisc *sch, struct nlattr *opt)
519{ 519{
520 struct fifo_sched_data *q = qdisc_priv(sch); 520 struct fifo_sched_data *q = qdisc_priv(sch);
521 521
522 if (opt) { 522 if (opt) {
523 struct tc_fifo_qopt *ctl = RTA_DATA(opt); 523 struct tc_fifo_qopt *ctl = nla_data(opt);
524 if (RTA_PAYLOAD(opt) < sizeof(*ctl)) 524 if (nla_len(opt) < sizeof(*ctl))
525 return -EINVAL; 525 return -EINVAL;
526 526
527 q->limit = ctl->limit; 527 q->limit = ctl->limit;
@@ -537,10 +537,10 @@ static int tfifo_dump(struct Qdisc *sch, struct sk_buff *skb)
537 struct fifo_sched_data *q = qdisc_priv(sch); 537 struct fifo_sched_data *q = qdisc_priv(sch);
538 struct tc_fifo_qopt opt = { .limit = q->limit }; 538 struct tc_fifo_qopt opt = { .limit = q->limit };
539 539
540 RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt); 540 NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
541 return skb->len; 541 return skb->len;
542 542
543rtattr_failure: 543nla_put_failure:
544 return -1; 544 return -1;
545} 545}
546 546
@@ -557,7 +557,7 @@ static struct Qdisc_ops tfifo_qdisc_ops __read_mostly = {
557 .dump = tfifo_dump, 557 .dump = tfifo_dump,
558}; 558};
559 559
560static int netem_init(struct Qdisc *sch, struct rtattr *opt) 560static int netem_init(struct Qdisc *sch, struct nlattr *opt)
561{ 561{
562 struct netem_sched_data *q = qdisc_priv(sch); 562 struct netem_sched_data *q = qdisc_priv(sch);
563 int ret; 563 int ret;
@@ -595,7 +595,7 @@ static int netem_dump(struct Qdisc *sch, struct sk_buff *skb)
595{ 595{
596 const struct netem_sched_data *q = qdisc_priv(sch); 596 const struct netem_sched_data *q = qdisc_priv(sch);
597 unsigned char *b = skb_tail_pointer(skb); 597 unsigned char *b = skb_tail_pointer(skb);
598 struct rtattr *rta = (struct rtattr *) b; 598 struct nlattr *nla = (struct nlattr *) b;
599 struct tc_netem_qopt qopt; 599 struct tc_netem_qopt qopt;
600 struct tc_netem_corr cor; 600 struct tc_netem_corr cor;
601 struct tc_netem_reorder reorder; 601 struct tc_netem_reorder reorder;
@@ -607,26 +607,26 @@ static int netem_dump(struct Qdisc *sch, struct sk_buff *skb)
607 qopt.loss = q->loss; 607 qopt.loss = q->loss;
608 qopt.gap = q->gap; 608 qopt.gap = q->gap;
609 qopt.duplicate = q->duplicate; 609 qopt.duplicate = q->duplicate;
610 RTA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt); 610 NLA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt);
611 611
612 cor.delay_corr = q->delay_cor.rho; 612 cor.delay_corr = q->delay_cor.rho;
613 cor.loss_corr = q->loss_cor.rho; 613 cor.loss_corr = q->loss_cor.rho;
614 cor.dup_corr = q->dup_cor.rho; 614 cor.dup_corr = q->dup_cor.rho;
615 RTA_PUT(skb, TCA_NETEM_CORR, sizeof(cor), &cor); 615 NLA_PUT(skb, TCA_NETEM_CORR, sizeof(cor), &cor);
616 616
617 reorder.probability = q->reorder; 617 reorder.probability = q->reorder;
618 reorder.correlation = q->reorder_cor.rho; 618 reorder.correlation = q->reorder_cor.rho;
619 RTA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder); 619 NLA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
620 620
621 corrupt.probability = q->corrupt; 621 corrupt.probability = q->corrupt;
622 corrupt.correlation = q->corrupt_cor.rho; 622 corrupt.correlation = q->corrupt_cor.rho;
623 RTA_PUT(skb, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt); 623 NLA_PUT(skb, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);
624 624
625 rta->rta_len = skb_tail_pointer(skb) - b; 625 nla->nla_len = skb_tail_pointer(skb) - b;
626 626
627 return skb->len; 627 return skb->len;
628 628
629rtattr_failure: 629nla_put_failure:
630 nlmsg_trim(skb, b); 630 nlmsg_trim(skb, b);
631 return -1; 631 return -1;
632} 632}
@@ -678,7 +678,7 @@ static void netem_put(struct Qdisc *sch, unsigned long arg)
678} 678}
679 679
680static int netem_change_class(struct Qdisc *sch, u32 classid, u32 parentid, 680static int netem_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
681 struct rtattr **tca, unsigned long *arg) 681 struct nlattr **tca, unsigned long *arg)
682{ 682{
683 return -ENOSYS; 683 return -ENOSYS;
684} 684}
diff --git a/net/sched/sch_prio.c b/net/sched/sch_prio.c
index 2243aaa8d851..a4f932df86e9 100644
--- a/net/sched/sch_prio.c
+++ b/net/sched/sch_prio.c
@@ -224,15 +224,15 @@ prio_destroy(struct Qdisc* sch)
224 qdisc_destroy(q->queues[prio]); 224 qdisc_destroy(q->queues[prio]);
225} 225}
226 226
227static int prio_tune(struct Qdisc *sch, struct rtattr *opt) 227static int prio_tune(struct Qdisc *sch, struct nlattr *opt)
228{ 228{
229 struct prio_sched_data *q = qdisc_priv(sch); 229 struct prio_sched_data *q = qdisc_priv(sch);
230 struct tc_prio_qopt *qopt; 230 struct tc_prio_qopt *qopt;
231 struct rtattr *tb[TCA_PRIO_MAX]; 231 struct nlattr *tb[TCA_PRIO_MAX + 1];
232 int i; 232 int i;
233 233
234 if (rtattr_parse_nested_compat(tb, TCA_PRIO_MAX, opt, qopt, 234 if (nla_parse_nested_compat(tb, TCA_PRIO_MAX, opt, NULL, qopt,
235 sizeof(*qopt))) 235 sizeof(*qopt)))
236 return -EINVAL; 236 return -EINVAL;
237 q->bands = qopt->bands; 237 q->bands = qopt->bands;
238 /* If we're multiqueue, make sure the number of incoming bands 238 /* If we're multiqueue, make sure the number of incoming bands
@@ -242,7 +242,7 @@ static int prio_tune(struct Qdisc *sch, struct rtattr *opt)
242 * only one that is enabled for multiqueue, since it's the only one 242 * only one that is enabled for multiqueue, since it's the only one
243 * that interacts with the underlying device. 243 * that interacts with the underlying device.
244 */ 244 */
245 q->mq = RTA_GET_FLAG(tb[TCA_PRIO_MQ - 1]); 245 q->mq = nla_get_flag(tb[TCA_PRIO_MQ]);
246 if (q->mq) { 246 if (q->mq) {
247 if (sch->parent != TC_H_ROOT) 247 if (sch->parent != TC_H_ROOT)
248 return -EINVAL; 248 return -EINVAL;
@@ -296,7 +296,7 @@ static int prio_tune(struct Qdisc *sch, struct rtattr *opt)
296 return 0; 296 return 0;
297} 297}
298 298
299static int prio_init(struct Qdisc *sch, struct rtattr *opt) 299static int prio_init(struct Qdisc *sch, struct nlattr *opt)
300{ 300{
301 struct prio_sched_data *q = qdisc_priv(sch); 301 struct prio_sched_data *q = qdisc_priv(sch);
302 int i; 302 int i;
@@ -319,20 +319,24 @@ static int prio_dump(struct Qdisc *sch, struct sk_buff *skb)
319{ 319{
320 struct prio_sched_data *q = qdisc_priv(sch); 320 struct prio_sched_data *q = qdisc_priv(sch);
321 unsigned char *b = skb_tail_pointer(skb); 321 unsigned char *b = skb_tail_pointer(skb);
322 struct rtattr *nest; 322 struct nlattr *nest;
323 struct tc_prio_qopt opt; 323 struct tc_prio_qopt opt;
324 324
325 opt.bands = q->bands; 325 opt.bands = q->bands;
326 memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX+1); 326 memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX+1);
327 327
328 nest = RTA_NEST_COMPAT(skb, TCA_OPTIONS, sizeof(opt), &opt); 328 nest = nla_nest_compat_start(skb, TCA_OPTIONS, sizeof(opt), &opt);
329 if (q->mq) 329 if (nest == NULL)
330 RTA_PUT_FLAG(skb, TCA_PRIO_MQ); 330 goto nla_put_failure;
331 RTA_NEST_COMPAT_END(skb, nest); 331 if (q->mq) {
332 if (nla_put_flag(skb, TCA_PRIO_MQ) < 0)
333 goto nla_put_failure;
334 }
335 nla_nest_compat_end(skb, nest);
332 336
333 return skb->len; 337 return skb->len;
334 338
335rtattr_failure: 339nla_put_failure:
336 nlmsg_trim(skb, b); 340 nlmsg_trim(skb, b);
337 return -1; 341 return -1;
338} 342}
@@ -392,7 +396,7 @@ static void prio_put(struct Qdisc *q, unsigned long cl)
392 return; 396 return;
393} 397}
394 398
395static int prio_change(struct Qdisc *sch, u32 handle, u32 parent, struct rtattr **tca, unsigned long *arg) 399static int prio_change(struct Qdisc *sch, u32 handle, u32 parent, struct nlattr **tca, unsigned long *arg)
396{ 400{
397 unsigned long cl = *arg; 401 unsigned long cl = *arg;
398 struct prio_sched_data *q = qdisc_priv(sch); 402 struct prio_sched_data *q = qdisc_priv(sch);
diff --git a/net/sched/sch_red.c b/net/sched/sch_red.c
index f1e9647f7db7..6ce8da5aca0b 100644
--- a/net/sched/sch_red.c
+++ b/net/sched/sch_red.c
@@ -177,21 +177,21 @@ static void red_destroy(struct Qdisc *sch)
177static struct Qdisc *red_create_dflt(struct Qdisc *sch, u32 limit) 177static struct Qdisc *red_create_dflt(struct Qdisc *sch, u32 limit)
178{ 178{
179 struct Qdisc *q; 179 struct Qdisc *q;
180 struct rtattr *rta; 180 struct nlattr *nla;
181 int ret; 181 int ret;
182 182
183 q = qdisc_create_dflt(sch->dev, &bfifo_qdisc_ops, 183 q = qdisc_create_dflt(sch->dev, &bfifo_qdisc_ops,
184 TC_H_MAKE(sch->handle, 1)); 184 TC_H_MAKE(sch->handle, 1));
185 if (q) { 185 if (q) {
186 rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)), 186 nla = kmalloc(nla_attr_size(sizeof(struct tc_fifo_qopt)),
187 GFP_KERNEL); 187 GFP_KERNEL);
188 if (rta) { 188 if (nla) {
189 rta->rta_type = RTM_NEWQDISC; 189 nla->nla_type = RTM_NEWQDISC;
190 rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt)); 190 nla->nla_len = nla_attr_size(sizeof(struct tc_fifo_qopt));
191 ((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit; 191 ((struct tc_fifo_qopt *)nla_data(nla))->limit = limit;
192 192
193 ret = q->ops->change(q, rta); 193 ret = q->ops->change(q, nla);
194 kfree(rta); 194 kfree(nla);
195 195
196 if (ret == 0) 196 if (ret == 0)
197 return q; 197 return q;
@@ -201,23 +201,23 @@ static struct Qdisc *red_create_dflt(struct Qdisc *sch, u32 limit)
201 return NULL; 201 return NULL;
202} 202}
203 203
204static int red_change(struct Qdisc *sch, struct rtattr *opt) 204static int red_change(struct Qdisc *sch, struct nlattr *opt)
205{ 205{
206 struct red_sched_data *q = qdisc_priv(sch); 206 struct red_sched_data *q = qdisc_priv(sch);
207 struct rtattr *tb[TCA_RED_MAX]; 207 struct nlattr *tb[TCA_RED_MAX + 1];
208 struct tc_red_qopt *ctl; 208 struct tc_red_qopt *ctl;
209 struct Qdisc *child = NULL; 209 struct Qdisc *child = NULL;
210 210
211 if (opt == NULL || rtattr_parse_nested(tb, TCA_RED_MAX, opt)) 211 if (opt == NULL || nla_parse_nested(tb, TCA_RED_MAX, opt, NULL))
212 return -EINVAL; 212 return -EINVAL;
213 213
214 if (tb[TCA_RED_PARMS-1] == NULL || 214 if (tb[TCA_RED_PARMS] == NULL ||
215 RTA_PAYLOAD(tb[TCA_RED_PARMS-1]) < sizeof(*ctl) || 215 nla_len(tb[TCA_RED_PARMS]) < sizeof(*ctl) ||
216 tb[TCA_RED_STAB-1] == NULL || 216 tb[TCA_RED_STAB] == NULL ||
217 RTA_PAYLOAD(tb[TCA_RED_STAB-1]) < RED_STAB_SIZE) 217 nla_len(tb[TCA_RED_STAB]) < RED_STAB_SIZE)
218 return -EINVAL; 218 return -EINVAL;
219 219
220 ctl = RTA_DATA(tb[TCA_RED_PARMS-1]); 220 ctl = nla_data(tb[TCA_RED_PARMS]);
221 221
222 if (ctl->limit > 0) { 222 if (ctl->limit > 0) {
223 child = red_create_dflt(sch, ctl->limit); 223 child = red_create_dflt(sch, ctl->limit);
@@ -235,7 +235,7 @@ static int red_change(struct Qdisc *sch, struct rtattr *opt)
235 235
236 red_set_parms(&q->parms, ctl->qth_min, ctl->qth_max, ctl->Wlog, 236 red_set_parms(&q->parms, ctl->qth_min, ctl->qth_max, ctl->Wlog,
237 ctl->Plog, ctl->Scell_log, 237 ctl->Plog, ctl->Scell_log,
238 RTA_DATA(tb[TCA_RED_STAB-1])); 238 nla_data(tb[TCA_RED_STAB]));
239 239
240 if (skb_queue_empty(&sch->q)) 240 if (skb_queue_empty(&sch->q))
241 red_end_of_idle_period(&q->parms); 241 red_end_of_idle_period(&q->parms);
@@ -244,7 +244,7 @@ static int red_change(struct Qdisc *sch, struct rtattr *opt)
244 return 0; 244 return 0;
245} 245}
246 246
247static int red_init(struct Qdisc* sch, struct rtattr *opt) 247static int red_init(struct Qdisc* sch, struct nlattr *opt)
248{ 248{
249 struct red_sched_data *q = qdisc_priv(sch); 249 struct red_sched_data *q = qdisc_priv(sch);
250 250
@@ -255,7 +255,7 @@ static int red_init(struct Qdisc* sch, struct rtattr *opt)
255static int red_dump(struct Qdisc *sch, struct sk_buff *skb) 255static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
256{ 256{
257 struct red_sched_data *q = qdisc_priv(sch); 257 struct red_sched_data *q = qdisc_priv(sch);
258 struct rtattr *opts = NULL; 258 struct nlattr *opts = NULL;
259 struct tc_red_qopt opt = { 259 struct tc_red_qopt opt = {
260 .limit = q->limit, 260 .limit = q->limit,
261 .flags = q->flags, 261 .flags = q->flags,
@@ -266,12 +266,14 @@ static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
266 .Scell_log = q->parms.Scell_log, 266 .Scell_log = q->parms.Scell_log,
267 }; 267 };
268 268
269 opts = RTA_NEST(skb, TCA_OPTIONS); 269 opts = nla_nest_start(skb, TCA_OPTIONS);
270 RTA_PUT(skb, TCA_RED_PARMS, sizeof(opt), &opt); 270 if (opts == NULL)
271 return RTA_NEST_END(skb, opts); 271 goto nla_put_failure;
272 NLA_PUT(skb, TCA_RED_PARMS, sizeof(opt), &opt);
273 return nla_nest_end(skb, opts);
272 274
273rtattr_failure: 275nla_put_failure:
274 return RTA_NEST_CANCEL(skb, opts); 276 return nla_nest_cancel(skb, opts);
275} 277}
276 278
277static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d) 279static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
@@ -332,7 +334,7 @@ static void red_put(struct Qdisc *sch, unsigned long arg)
332} 334}
333 335
334static int red_change_class(struct Qdisc *sch, u32 classid, u32 parentid, 336static int red_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
335 struct rtattr **tca, unsigned long *arg) 337 struct nlattr **tca, unsigned long *arg)
336{ 338{
337 return -ENOSYS; 339 return -ENOSYS;
338} 340}
diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c
index 25afe0f1d83a..91af539ab6e6 100644
--- a/net/sched/sch_sfq.c
+++ b/net/sched/sch_sfq.c
@@ -397,13 +397,13 @@ static void sfq_perturbation(unsigned long arg)
397 mod_timer(&q->perturb_timer, jiffies + q->perturb_period); 397 mod_timer(&q->perturb_timer, jiffies + q->perturb_period);
398} 398}
399 399
400static int sfq_change(struct Qdisc *sch, struct rtattr *opt) 400static int sfq_change(struct Qdisc *sch, struct nlattr *opt)
401{ 401{
402 struct sfq_sched_data *q = qdisc_priv(sch); 402 struct sfq_sched_data *q = qdisc_priv(sch);
403 struct tc_sfq_qopt *ctl = RTA_DATA(opt); 403 struct tc_sfq_qopt *ctl = nla_data(opt);
404 unsigned int qlen; 404 unsigned int qlen;
405 405
406 if (opt->rta_len < RTA_LENGTH(sizeof(*ctl))) 406 if (opt->nla_len < nla_attr_size(sizeof(*ctl)))
407 return -EINVAL; 407 return -EINVAL;
408 408
409 sch_tree_lock(sch); 409 sch_tree_lock(sch);
@@ -426,7 +426,7 @@ static int sfq_change(struct Qdisc *sch, struct rtattr *opt)
426 return 0; 426 return 0;
427} 427}
428 428
429static int sfq_init(struct Qdisc *sch, struct rtattr *opt) 429static int sfq_init(struct Qdisc *sch, struct nlattr *opt)
430{ 430{
431 struct sfq_sched_data *q = qdisc_priv(sch); 431 struct sfq_sched_data *q = qdisc_priv(sch);
432 int i; 432 int i;
@@ -481,11 +481,11 @@ static int sfq_dump(struct Qdisc *sch, struct sk_buff *skb)
481 opt.divisor = SFQ_HASH_DIVISOR; 481 opt.divisor = SFQ_HASH_DIVISOR;
482 opt.flows = q->limit; 482 opt.flows = q->limit;
483 483
484 RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt); 484 NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
485 485
486 return skb->len; 486 return skb->len;
487 487
488rtattr_failure: 488nla_put_failure:
489 nlmsg_trim(skb, b); 489 nlmsg_trim(skb, b);
490 return -1; 490 return -1;
491} 491}
diff --git a/net/sched/sch_tbf.c b/net/sched/sch_tbf.c
index d88fea9d6b61..6c4ad7e677b3 100644
--- a/net/sched/sch_tbf.c
+++ b/net/sched/sch_tbf.c
@@ -245,20 +245,21 @@ static void tbf_reset(struct Qdisc* sch)
245static struct Qdisc *tbf_create_dflt_qdisc(struct Qdisc *sch, u32 limit) 245static struct Qdisc *tbf_create_dflt_qdisc(struct Qdisc *sch, u32 limit)
246{ 246{
247 struct Qdisc *q; 247 struct Qdisc *q;
248 struct rtattr *rta; 248 struct nlattr *nla;
249 int ret; 249 int ret;
250 250
251 q = qdisc_create_dflt(sch->dev, &bfifo_qdisc_ops, 251 q = qdisc_create_dflt(sch->dev, &bfifo_qdisc_ops,
252 TC_H_MAKE(sch->handle, 1)); 252 TC_H_MAKE(sch->handle, 1));
253 if (q) { 253 if (q) {
254 rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)), GFP_KERNEL); 254 nla = kmalloc(nla_attr_size(sizeof(struct tc_fifo_qopt)),
255 if (rta) { 255 GFP_KERNEL);
256 rta->rta_type = RTM_NEWQDISC; 256 if (nla) {
257 rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt)); 257 nla->nla_type = RTM_NEWQDISC;
258 ((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit; 258 nla->nla_len = nla_attr_size(sizeof(struct tc_fifo_qopt));
259 ((struct tc_fifo_qopt *)nla_data(nla))->limit = limit;
259 260
260 ret = q->ops->change(q, rta); 261 ret = q->ops->change(q, nla);
261 kfree(rta); 262 kfree(nla);
262 263
263 if (ret == 0) 264 if (ret == 0)
264 return q; 265 return q;
@@ -269,30 +270,30 @@ static struct Qdisc *tbf_create_dflt_qdisc(struct Qdisc *sch, u32 limit)
269 return NULL; 270 return NULL;
270} 271}
271 272
272static int tbf_change(struct Qdisc* sch, struct rtattr *opt) 273static int tbf_change(struct Qdisc* sch, struct nlattr *opt)
273{ 274{
274 int err = -EINVAL; 275 int err = -EINVAL;
275 struct tbf_sched_data *q = qdisc_priv(sch); 276 struct tbf_sched_data *q = qdisc_priv(sch);
276 struct rtattr *tb[TCA_TBF_PTAB]; 277 struct nlattr *tb[TCA_TBF_PTAB + 1];
277 struct tc_tbf_qopt *qopt; 278 struct tc_tbf_qopt *qopt;
278 struct qdisc_rate_table *rtab = NULL; 279 struct qdisc_rate_table *rtab = NULL;
279 struct qdisc_rate_table *ptab = NULL; 280 struct qdisc_rate_table *ptab = NULL;
280 struct Qdisc *child = NULL; 281 struct Qdisc *child = NULL;
281 int max_size,n; 282 int max_size,n;
282 283
283 if (rtattr_parse_nested(tb, TCA_TBF_PTAB, opt) || 284 if (nla_parse_nested(tb, TCA_TBF_PTAB, opt, NULL) ||
284 tb[TCA_TBF_PARMS-1] == NULL || 285 tb[TCA_TBF_PARMS] == NULL ||
285 RTA_PAYLOAD(tb[TCA_TBF_PARMS-1]) < sizeof(*qopt)) 286 nla_len(tb[TCA_TBF_PARMS]) < sizeof(*qopt))
286 goto done; 287 goto done;
287 288
288 qopt = RTA_DATA(tb[TCA_TBF_PARMS-1]); 289 qopt = nla_data(tb[TCA_TBF_PARMS]);
289 rtab = qdisc_get_rtab(&qopt->rate, tb[TCA_TBF_RTAB-1]); 290 rtab = qdisc_get_rtab(&qopt->rate, tb[TCA_TBF_RTAB]);
290 if (rtab == NULL) 291 if (rtab == NULL)
291 goto done; 292 goto done;
292 293
293 if (qopt->peakrate.rate) { 294 if (qopt->peakrate.rate) {
294 if (qopt->peakrate.rate > qopt->rate.rate) 295 if (qopt->peakrate.rate > qopt->rate.rate)
295 ptab = qdisc_get_rtab(&qopt->peakrate, tb[TCA_TBF_PTAB-1]); 296 ptab = qdisc_get_rtab(&qopt->peakrate, tb[TCA_TBF_PTAB]);
296 if (ptab == NULL) 297 if (ptab == NULL)
297 goto done; 298 goto done;
298 } 299 }
@@ -339,7 +340,7 @@ done:
339 return err; 340 return err;
340} 341}
341 342
342static int tbf_init(struct Qdisc* sch, struct rtattr *opt) 343static int tbf_init(struct Qdisc* sch, struct nlattr *opt)
343{ 344{
344 struct tbf_sched_data *q = qdisc_priv(sch); 345 struct tbf_sched_data *q = qdisc_priv(sch);
345 346
@@ -371,11 +372,11 @@ static int tbf_dump(struct Qdisc *sch, struct sk_buff *skb)
371{ 372{
372 struct tbf_sched_data *q = qdisc_priv(sch); 373 struct tbf_sched_data *q = qdisc_priv(sch);
373 unsigned char *b = skb_tail_pointer(skb); 374 unsigned char *b = skb_tail_pointer(skb);
374 struct rtattr *rta; 375 struct nlattr *nla;
375 struct tc_tbf_qopt opt; 376 struct tc_tbf_qopt opt;
376 377
377 rta = (struct rtattr*)b; 378 nla = (struct nlattr*)b;
378 RTA_PUT(skb, TCA_OPTIONS, 0, NULL); 379 NLA_PUT(skb, TCA_OPTIONS, 0, NULL);
379 380
380 opt.limit = q->limit; 381 opt.limit = q->limit;
381 opt.rate = q->R_tab->rate; 382 opt.rate = q->R_tab->rate;
@@ -385,12 +386,12 @@ static int tbf_dump(struct Qdisc *sch, struct sk_buff *skb)
385 memset(&opt.peakrate, 0, sizeof(opt.peakrate)); 386 memset(&opt.peakrate, 0, sizeof(opt.peakrate));
386 opt.mtu = q->mtu; 387 opt.mtu = q->mtu;
387 opt.buffer = q->buffer; 388 opt.buffer = q->buffer;
388 RTA_PUT(skb, TCA_TBF_PARMS, sizeof(opt), &opt); 389 NLA_PUT(skb, TCA_TBF_PARMS, sizeof(opt), &opt);
389 rta->rta_len = skb_tail_pointer(skb) - b; 390 nla->nla_len = skb_tail_pointer(skb) - b;
390 391
391 return skb->len; 392 return skb->len;
392 393
393rtattr_failure: 394nla_put_failure:
394 nlmsg_trim(skb, b); 395 nlmsg_trim(skb, b);
395 return -1; 396 return -1;
396} 397}
@@ -442,7 +443,7 @@ static void tbf_put(struct Qdisc *sch, unsigned long arg)
442} 443}
443 444
444static int tbf_change_class(struct Qdisc *sch, u32 classid, u32 parentid, 445static int tbf_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
445 struct rtattr **tca, unsigned long *arg) 446 struct nlattr **tca, unsigned long *arg)
446{ 447{
447 return -ENOSYS; 448 return -ENOSYS;
448} 449}
diff --git a/net/sched/sch_teql.c b/net/sched/sch_teql.c
index c0ed06d4a504..1411c7b1fbdc 100644
--- a/net/sched/sch_teql.c
+++ b/net/sched/sch_teql.c
@@ -168,7 +168,7 @@ teql_destroy(struct Qdisc* sch)
168 } 168 }
169} 169}
170 170
171static int teql_qdisc_init(struct Qdisc *sch, struct rtattr *opt) 171static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt)
172{ 172{
173 struct net_device *dev = sch->dev; 173 struct net_device *dev = sch->dev;
174 struct teql_master *m = (struct teql_master*)sch->ops; 174 struct teql_master *m = (struct teql_master*)sch->ops;
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-20 05:34:09 -0400