1 files changed, 50 insertions, 50 deletions

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)
 /* Pass size change message down to embedded FIFO */
 static int set_fifo_limit(struct Qdisc *q, int limit)
 {
-        struct rtattr *rta;
+        struct nlattr *nla;
         int ret = -ENOMEM;
 
         /* Hack to avoid sending change message to non-FIFO */
         if (strncmp(q->ops->id + 1, "fifo", 4) != 0)
                 return 0;
 
-        rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)), GFP_KERNEL);
-        if (rta) {
-                rta->rta_type = RTM_NEWQDISC;
-                rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt));
-                ((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit;
+        nla = kmalloc(nla_attr_size(sizeof(struct tc_fifo_qopt)), GFP_KERNEL);
+        if (nla) {
+                nla->nla_type = RTM_NEWQDISC;
+                nla->nla_len = nla_attr_size(sizeof(struct tc_fifo_qopt));
+                ((struct tc_fifo_qopt *)nla_data(nla))->limit = limit;
 
-                ret = q->ops->change(q, rta);
-                kfree(rta);
+                ret = q->ops->change(q, nla);
+                kfree(nla);
         }
         return ret;
 }
@@ -336,11 +336,11 @@ static int set_fifo_limit(struct Qdisc *q, int limit)
  * Distribution data is a variable size payload containing
  * signed 16 bit values.
  */
-static int get_dist_table(struct Qdisc *sch, const struct rtattr *attr)
+static int get_dist_table(struct Qdisc *sch, const struct nlattr *attr)
 {
         struct netem_sched_data *q = qdisc_priv(sch);
-        unsigned long n = RTA_PAYLOAD(attr)/sizeof(__s16);
-        const __s16 *data = RTA_DATA(attr);
+        unsigned long n = nla_len(attr)/sizeof(__s16);
+        const __s16 *data = nla_data(attr);
         struct disttable *d;
         int i;
 
@@ -363,12 +363,12 @@ static int get_dist_table(struct Qdisc *sch, const struct rtattr *attr)
         return 0;
 }
 
-static int get_correlation(struct Qdisc *sch, const struct rtattr *attr)
+static int get_correlation(struct Qdisc *sch, const struct nlattr *attr)
 {
         struct netem_sched_data *q = qdisc_priv(sch);
-        const struct tc_netem_corr *c = RTA_DATA(attr);
+        const struct tc_netem_corr *c = nla_data(attr);
 
-        if (RTA_PAYLOAD(attr) != sizeof(*c))
+        if (nla_len(attr) != sizeof(*c))
                 return -EINVAL;
 
         init_crandom(&q->delay_cor, c->delay_corr);
@@ -377,12 +377,12 @@ static int get_correlation(struct Qdisc *sch, const struct rtattr *attr)
         return 0;
 }
 
-static int get_reorder(struct Qdisc *sch, const struct rtattr *attr)
+static int get_reorder(struct Qdisc *sch, const struct nlattr *attr)
 {
         struct netem_sched_data *q = qdisc_priv(sch);
-        const struct tc_netem_reorder *r = RTA_DATA(attr);
+        const struct tc_netem_reorder *r = nla_data(attr);
 
-        if (RTA_PAYLOAD(attr) != sizeof(*r))
+        if (nla_len(attr) != sizeof(*r))
                 return -EINVAL;
 
         q->reorder = r->probability;
@@ -390,12 +390,12 @@ static int get_reorder(struct Qdisc *sch, const struct rtattr *attr)
         return 0;
 }
 
-static int get_corrupt(struct Qdisc *sch, const struct rtattr *attr)
+static int get_corrupt(struct Qdisc *sch, const struct nlattr *attr)
 {
         struct netem_sched_data *q = qdisc_priv(sch);
-        const struct tc_netem_corrupt *r = RTA_DATA(attr);
+        const struct tc_netem_corrupt *r = nla_data(attr);
 
-        if (RTA_PAYLOAD(attr) != sizeof(*r))
+        if (nla_len(attr) != sizeof(*r))
                 return -EINVAL;
 
         q->corrupt = r->probability;
@@ -404,16 +404,16 @@ static int get_corrupt(struct Qdisc *sch, const struct rtattr *attr)
 }
 
 /* Parse netlink message to set options */
-static int netem_change(struct Qdisc *sch, struct rtattr *opt)
+static int netem_change(struct Qdisc *sch, struct nlattr *opt)
 {
         struct netem_sched_data *q = qdisc_priv(sch);
         struct tc_netem_qopt *qopt;
         int ret;
 
-        if (opt == NULL || RTA_PAYLOAD(opt) < sizeof(*qopt))
+        if (opt == NULL || nla_len(opt) < sizeof(*qopt))
                 return -EINVAL;
 
-        qopt = RTA_DATA(opt);
+        qopt = nla_data(opt);
         ret = set_fifo_limit(q->qdisc, qopt->limit);
         if (ret) {
                 pr_debug("netem: can't set fifo limit\n");
@@ -437,33 +437,33 @@ static int netem_change(struct Qdisc *sch, struct rtattr *opt)
         /* Handle nested options after initial queue options.
          * Should have put all options in nested format but too late now.
          */
-        if (RTA_PAYLOAD(opt) > sizeof(*qopt)) {
-                struct rtattr *tb[TCA_NETEM_MAX];
-                if (rtattr_parse(tb, TCA_NETEM_MAX,
-                                 RTA_DATA(opt) + sizeof(*qopt),
-                                 RTA_PAYLOAD(opt) - sizeof(*qopt)))
+        if (nla_len(opt) > sizeof(*qopt)) {
+                struct nlattr *tb[TCA_NETEM_MAX + 1];
+                if (nla_parse(tb, TCA_NETEM_MAX,
+                              nla_data(opt) + sizeof(*qopt),
+                              nla_len(opt) - sizeof(*qopt), NULL))
                         return -EINVAL;
 
-                if (tb[TCA_NETEM_CORR-1]) {
-                        ret = get_correlation(sch, tb[TCA_NETEM_CORR-1]);
+                if (tb[TCA_NETEM_CORR]) {
+                        ret = get_correlation(sch, tb[TCA_NETEM_CORR]);
                         if (ret)
                                 return ret;
                 }
 
-                if (tb[TCA_NETEM_DELAY_DIST-1]) {
-                        ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST-1]);
+                if (tb[TCA_NETEM_DELAY_DIST]) {
+                        ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST]);
                         if (ret)
                                 return ret;
                 }
 
-                if (tb[TCA_NETEM_REORDER-1]) {
-                        ret = get_reorder(sch, tb[TCA_NETEM_REORDER-1]);
+                if (tb[TCA_NETEM_REORDER]) {
+                        ret = get_reorder(sch, tb[TCA_NETEM_REORDER]);
                         if (ret)
                                 return ret;
                 }
 
-                if (tb[TCA_NETEM_CORRUPT-1]) {
-                        ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT-1]);
+                if (tb[TCA_NETEM_CORRUPT]) {
+                        ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT]);
                         if (ret)
                                 return ret;
                 }
@@ -515,13 +515,13 @@ static int tfifo_enqueue(struct sk_buff *nskb, struct Qdisc *sch)
         return qdisc_reshape_fail(nskb, sch);
 }
 
-static int tfifo_init(struct Qdisc *sch, struct rtattr *opt)
+static int tfifo_init(struct Qdisc *sch, struct nlattr *opt)
 {
         struct fifo_sched_data *q = qdisc_priv(sch);
 
         if (opt) {
-                struct tc_fifo_qopt *ctl = RTA_DATA(opt);
-                if (RTA_PAYLOAD(opt) < sizeof(*ctl))
+                struct tc_fifo_qopt *ctl = nla_data(opt);
+                if (nla_len(opt) < sizeof(*ctl))
                         return -EINVAL;
 
                 q->limit = ctl->limit;
@@ -537,10 +537,10 @@ static int tfifo_dump(struct Qdisc *sch, struct sk_buff *skb)
         struct fifo_sched_data *q = qdisc_priv(sch);
         struct tc_fifo_qopt opt = { .limit = q->limit };
 
-        RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
+        NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
         return skb->len;
 
-rtattr_failure:
+nla_put_failure:
         return -1;
 }
 
@@ -557,7 +557,7 @@ static struct Qdisc_ops tfifo_qdisc_ops __read_mostly = {
         .dump           =       tfifo_dump,
 };
 
-static int netem_init(struct Qdisc *sch, struct rtattr *opt)
+static int netem_init(struct Qdisc *sch, struct nlattr *opt)
 {
         struct netem_sched_data *q = qdisc_priv(sch);
         int ret;
@@ -595,7 +595,7 @@ static int netem_dump(struct Qdisc *sch, struct sk_buff *skb)
 {
         const struct netem_sched_data *q = qdisc_priv(sch);
         unsigned char *b = skb_tail_pointer(skb);
-        struct rtattr *rta = (struct rtattr *) b;
+        struct nlattr *nla = (struct nlattr *) b;
         struct tc_netem_qopt qopt;
         struct tc_netem_corr cor;
         struct tc_netem_reorder reorder;
@@ -607,26 +607,26 @@ static int netem_dump(struct Qdisc *sch, struct sk_buff *skb)
         qopt.loss = q->loss;
         qopt.gap = q->gap;
         qopt.duplicate = q->duplicate;
-        RTA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt);
+        NLA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt);
 
         cor.delay_corr = q->delay_cor.rho;
         cor.loss_corr = q->loss_cor.rho;
         cor.dup_corr = q->dup_cor.rho;
-        RTA_PUT(skb, TCA_NETEM_CORR, sizeof(cor), &cor);
+        NLA_PUT(skb, TCA_NETEM_CORR, sizeof(cor), &cor);
 
         reorder.probability = q->reorder;
         reorder.correlation = q->reorder_cor.rho;
-        RTA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
+        NLA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
 
         corrupt.probability = q->corrupt;
         corrupt.correlation = q->corrupt_cor.rho;
-        RTA_PUT(skb, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);
+        NLA_PUT(skb, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);
 
-        rta->rta_len = skb_tail_pointer(skb) - b;
+        nla->nla_len = skb_tail_pointer(skb) - b;
 
         return skb->len;
 
-rtattr_failure:
+nla_put_failure:
         nlmsg_trim(skb, b);
         return -1;
 }
@@ -678,7 +678,7 @@ static void netem_put(struct Qdisc *sch, unsigned long arg)
 }
 
 static int netem_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
-                            struct rtattr **tca, unsigned long *arg)
+                            struct nlattr **tca, unsigned long *arg)
 {
         return -ENOSYS;
 }