Merge branch 'work.memdup_user' of git://git.kernel.org/pub/scm/linux/kernel/git...

[karo-tx-linux.git] / net / key / af_key.c

diff --git a/net/key/af_key.c b/net/key/af_key.c
index b1432b6680338cf60942f3dd5567a6c7a11a603f..ca9d3ae665e76ea847a4ce03b4d275f80d7705bc 100644 (file)
--- a/net/key/af_key.c
+++ b/net/key/af_key.c
@@ -109,7 +109,7 @@ static void pfkey_sock_destruct(struct sock *sk)
        }
 
        WARN_ON(atomic_read(&sk->sk_rmem_alloc));
-       WARN_ON(atomic_read(&sk->sk_wmem_alloc));
+       WARN_ON(refcount_read(&sk->sk_wmem_alloc));
 
        atomic_dec(&net_pfkey->socks_nr);
 }
@@ -203,11 +203,11 @@ static int pfkey_broadcast_one(struct sk_buff *skb, struct sk_buff **skb2,
 
        sock_hold(sk);
        if (*skb2 == NULL) {
-               if (atomic_read(&skb->users) != 1) {
+               if (refcount_read(&skb->users) != 1) {
                        *skb2 = skb_clone(skb, allocation);
                } else {
                        *skb2 = skb;
-                       atomic_inc(&skb->users);
+                       refcount_inc(&skb->users);
                }
        }
        if (*skb2 != NULL) {
@@ -349,7 +349,7 @@ static int pfkey_error(const struct sadb_msg *orig, int err, struct sock *sk)
                err = EINVAL;
        BUG_ON(err <= 0 || err >= 256);
 
-       hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+       hdr = skb_put(skb, sizeof(struct sadb_msg));
        pfkey_hdr_dup(hdr, orig);
        hdr->sadb_msg_errno = (uint8_t) err;
        hdr->sadb_msg_len = (sizeof(struct sadb_msg) /
@@ -810,12 +810,12 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
                return ERR_PTR(-ENOBUFS);
 
        /* call should fill header later */
-       hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+       hdr = skb_put(skb, sizeof(struct sadb_msg));
        memset(hdr, 0, size);   /* XXX do we need this ? */
        hdr->sadb_msg_len = size / sizeof(uint64_t);
 
        /* sa */
-       sa = (struct sadb_sa *)  skb_put(skb, sizeof(struct sadb_sa));
+       sa = skb_put(skb, sizeof(struct sadb_sa));
        sa->sadb_sa_len = sizeof(struct sadb_sa)/sizeof(uint64_t);
        sa->sadb_sa_exttype = SADB_EXT_SA;
        sa->sadb_sa_spi = x->id.spi;
@@ -862,8 +862,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
 
        /* hard time */
        if (hsc & 2) {
-               lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                            sizeof(struct sadb_lifetime));
+               lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
                lifetime->sadb_lifetime_len =
                        sizeof(struct sadb_lifetime)/sizeof(uint64_t);
                lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD;
@@ -874,8 +873,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
        }
        /* soft time */
        if (hsc & 1) {
-               lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                            sizeof(struct sadb_lifetime));
+               lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
                lifetime->sadb_lifetime_len =
                        sizeof(struct sadb_lifetime)/sizeof(uint64_t);
                lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_SOFT;
@@ -885,8 +883,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
                lifetime->sadb_lifetime_usetime = x->lft.soft_use_expires_seconds;
        }
        /* current time */
-       lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                    sizeof(struct sadb_lifetime));
+       lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
        lifetime->sadb_lifetime_len =
                sizeof(struct sadb_lifetime)/sizeof(uint64_t);
        lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
@@ -895,8 +892,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
        lifetime->sadb_lifetime_addtime = x->curlft.add_time;
        lifetime->sadb_lifetime_usetime = x->curlft.use_time;
        /* src address */
-       addr = (struct sadb_address*) skb_put(skb,
-                                             sizeof(struct sadb_address)+sockaddr_size);
+       addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
        addr->sadb_address_len =
                (sizeof(struct sadb_address)+sockaddr_size)/
                        sizeof(uint64_t);
@@ -915,8 +911,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
                BUG();
 
        /* dst address */
-       addr = (struct sadb_address*) skb_put(skb,
-                                             sizeof(struct sadb_address)+sockaddr_size);
+       addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
        addr->sadb_address_len =
                (sizeof(struct sadb_address)+sockaddr_size)/
                        sizeof(uint64_t);
@@ -933,8 +928,8 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
 
        if (!xfrm_addr_equal(&x->sel.saddr, &x->props.saddr,
                             x->props.family)) {
-               addr = (struct sadb_address*) skb_put(skb,
-                       sizeof(struct sadb_address)+sockaddr_size);
+               addr = skb_put(skb,
+                              sizeof(struct sadb_address) + sockaddr_size);
                addr->sadb_address_len =
                        (sizeof(struct sadb_address)+sockaddr_size)/
                        sizeof(uint64_t);
@@ -951,8 +946,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
 
        /* auth key */
        if (add_keys && auth_key_size) {
-               key = (struct sadb_key *) skb_put(skb,
-                                                 sizeof(struct sadb_key)+auth_key_size);
+               key = skb_put(skb, sizeof(struct sadb_key) + auth_key_size);
                key->sadb_key_len = (sizeof(struct sadb_key) + auth_key_size) /
                        sizeof(uint64_t);
                key->sadb_key_exttype = SADB_EXT_KEY_AUTH;
@@ -962,8 +956,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
        }
        /* encrypt key */
        if (add_keys && encrypt_key_size) {
-               key = (struct sadb_key *) skb_put(skb,
-                                                 sizeof(struct sadb_key)+encrypt_key_size);
+               key = skb_put(skb, sizeof(struct sadb_key) + encrypt_key_size);
                key->sadb_key_len = (sizeof(struct sadb_key) +
                                     encrypt_key_size) / sizeof(uint64_t);
                key->sadb_key_exttype = SADB_EXT_KEY_ENCRYPT;
@@ -974,7 +967,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
        }
 
        /* sa */
-       sa2 = (struct sadb_x_sa2 *)  skb_put(skb, sizeof(struct sadb_x_sa2));
+       sa2 = skb_put(skb, sizeof(struct sadb_x_sa2));
        sa2->sadb_x_sa2_len = sizeof(struct sadb_x_sa2)/sizeof(uint64_t);
        sa2->sadb_x_sa2_exttype = SADB_X_EXT_SA2;
        if ((mode = pfkey_mode_from_xfrm(x->props.mode)) < 0) {
@@ -992,7 +985,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
                struct sadb_x_nat_t_port *n_port;
 
                /* type */
-               n_type = (struct sadb_x_nat_t_type*) skb_put(skb, sizeof(*n_type));
+               n_type = skb_put(skb, sizeof(*n_type));
                n_type->sadb_x_nat_t_type_len = sizeof(*n_type)/sizeof(uint64_t);
                n_type->sadb_x_nat_t_type_exttype = SADB_X_EXT_NAT_T_TYPE;
                n_type->sadb_x_nat_t_type_type = natt->encap_type;
@@ -1001,14 +994,14 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
                n_type->sadb_x_nat_t_type_reserved[2] = 0;
 
                /* source port */
-               n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
+               n_port = skb_put(skb, sizeof(*n_port));
                n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
                n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_SPORT;
                n_port->sadb_x_nat_t_port_port = natt->encap_sport;
                n_port->sadb_x_nat_t_port_reserved = 0;
 
                /* dest port */
-               n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
+               n_port = skb_put(skb, sizeof(*n_port));
                n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
                n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_DPORT;
                n_port->sadb_x_nat_t_port_port = natt->encap_dport;
@@ -1017,8 +1010,8 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
 
        /* security context */
        if (xfrm_ctx) {
-               sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb,
-                               sizeof(struct sadb_x_sec_ctx) + ctx_size);
+               sec_ctx = skb_put(skb,
+                                 sizeof(struct sadb_x_sec_ctx) + ctx_size);
                sec_ctx->sadb_x_sec_len =
                  (sizeof(struct sadb_x_sec_ctx) + ctx_size) / sizeof(uint64_t);
                sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX;
@@ -1626,7 +1619,7 @@ static struct sk_buff *compose_sadb_supported(const struct sadb_msg *orig,
        if (!skb)
                goto out_put_algs;
 
-       hdr = (struct sadb_msg *) skb_put(skb, sizeof(*hdr));
+       hdr = skb_put(skb, sizeof(*hdr));
        pfkey_hdr_dup(hdr, orig);
        hdr->sadb_msg_errno = 0;
        hdr->sadb_msg_len = len / sizeof(uint64_t);
@@ -1635,7 +1628,7 @@ static struct sk_buff *compose_sadb_supported(const struct sadb_msg *orig,
                struct sadb_supported *sp;
                struct sadb_alg *ap;
 
-               sp = (struct sadb_supported *) skb_put(skb, auth_len);
+               sp = skb_put(skb, auth_len);
                ap = (struct sadb_alg *) (sp + 1);
 
                sp->sadb_supported_len = auth_len / sizeof(uint64_t);
@@ -1656,7 +1649,7 @@ static struct sk_buff *compose_sadb_supported(const struct sadb_msg *orig,
                struct sadb_supported *sp;
                struct sadb_alg *ap;
 
-               sp = (struct sadb_supported *) skb_put(skb, enc_len);
+               sp = skb_put(skb, enc_len);
                ap = (struct sadb_alg *) (sp + 1);
 
                sp->sadb_supported_len = enc_len / sizeof(uint64_t);
@@ -1715,8 +1708,7 @@ static int unicast_flush_resp(struct sock *sk, const struct sadb_msg *ihdr)
        if (!skb)
                return -ENOBUFS;
 
-       hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
-       memcpy(hdr, ihdr, sizeof(struct sadb_msg));
+       hdr = skb_put_data(skb, ihdr, sizeof(struct sadb_msg));
        hdr->sadb_msg_errno = (uint8_t) 0;
        hdr->sadb_msg_len = (sizeof(struct sadb_msg) / sizeof(uint64_t));
 
@@ -1731,7 +1723,7 @@ static int key_notify_sa_flush(const struct km_event *c)
        skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
        if (!skb)
                return -ENOBUFS;
-       hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+       hdr = skb_put(skb, sizeof(struct sadb_msg));
        hdr->sadb_msg_satype = pfkey_proto2satype(c->data.proto);
        hdr->sadb_msg_type = SADB_FLUSH;
        hdr->sadb_msg_seq = c->seq;
@@ -2056,12 +2048,11 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
        size = pfkey_xfrm_policy2msg_size(xp);
 
        /* call should fill header later */
-       hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+       hdr = skb_put(skb, sizeof(struct sadb_msg));
        memset(hdr, 0, size);   /* XXX do we need this ? */
 
        /* src address */
-       addr = (struct sadb_address*) skb_put(skb,
-                                             sizeof(struct sadb_address)+sockaddr_size);
+       addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
        addr->sadb_address_len =
                (sizeof(struct sadb_address)+sockaddr_size)/
                        sizeof(uint64_t);
@@ -2076,8 +2067,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
                BUG();
 
        /* dst address */
-       addr = (struct sadb_address*) skb_put(skb,
-                                             sizeof(struct sadb_address)+sockaddr_size);
+       addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
        addr->sadb_address_len =
                (sizeof(struct sadb_address)+sockaddr_size)/
                        sizeof(uint64_t);
@@ -2091,8 +2081,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
                            xp->family);
 
        /* hard time */
-       lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                    sizeof(struct sadb_lifetime));
+       lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
        lifetime->sadb_lifetime_len =
                sizeof(struct sadb_lifetime)/sizeof(uint64_t);
        lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD;
@@ -2101,8 +2090,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
        lifetime->sadb_lifetime_addtime = xp->lft.hard_add_expires_seconds;
        lifetime->sadb_lifetime_usetime = xp->lft.hard_use_expires_seconds;
        /* soft time */
-       lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                    sizeof(struct sadb_lifetime));
+       lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
        lifetime->sadb_lifetime_len =
                sizeof(struct sadb_lifetime)/sizeof(uint64_t);
        lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_SOFT;
@@ -2111,8 +2099,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
        lifetime->sadb_lifetime_addtime = xp->lft.soft_add_expires_seconds;
        lifetime->sadb_lifetime_usetime = xp->lft.soft_use_expires_seconds;
        /* current time */
-       lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                    sizeof(struct sadb_lifetime));
+       lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
        lifetime->sadb_lifetime_len =
                sizeof(struct sadb_lifetime)/sizeof(uint64_t);
        lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
@@ -2121,7 +2108,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
        lifetime->sadb_lifetime_addtime = xp->curlft.add_time;
        lifetime->sadb_lifetime_usetime = xp->curlft.use_time;
 
-       pol = (struct sadb_x_policy *)  skb_put(skb, sizeof(struct sadb_x_policy));
+       pol = skb_put(skb, sizeof(struct sadb_x_policy));
        pol->sadb_x_policy_len = sizeof(struct sadb_x_policy)/sizeof(uint64_t);
        pol->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
        pol->sadb_x_policy_type = IPSEC_POLICY_DISCARD;
@@ -2149,7 +2136,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
                } else {
                        size -= 2*socklen;
                }
-               rq = (void*)skb_put(skb, req_size);
+               rq = skb_put(skb, req_size);
                pol->sadb_x_policy_len += req_size/8;
                memset(rq, 0, sizeof(*rq));
                rq->sadb_x_ipsecrequest_len = req_size;
@@ -2179,7 +2166,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
        if ((xfrm_ctx = xp->security)) {
                int ctx_size = pfkey_xfrm_policy2sec_ctx_size(xp);
 
-               sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb, ctx_size);
+               sec_ctx = skb_put(skb, ctx_size);
                sec_ctx->sadb_x_sec_len = ctx_size / sizeof(uint64_t);
                sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX;
                sec_ctx->sadb_x_ctx_doi = xfrm_ctx->ctx_doi;
@@ -2190,7 +2177,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
        }
 
        hdr->sadb_msg_len = size / sizeof(uint64_t);
-       hdr->sadb_msg_reserved = atomic_read(&xp->refcnt);
+       hdr->sadb_msg_reserved = refcount_read(&xp->refcnt);
 
        return 0;
 }
@@ -2611,7 +2598,7 @@ static int pfkey_migrate(struct sock *sk, struct sk_buff *skb,
        }
 
        return xfrm_migrate(&sel, dir, XFRM_POLICY_TYPE_MAIN, m, i,
-                           kma ? &k : NULL, net);
+                           kma ? &k : NULL, net, NULL);
 
  out:
        return err;
@@ -2743,7 +2730,7 @@ static int key_notify_policy_flush(const struct km_event *c)
        skb_out = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
        if (!skb_out)
                return -ENOBUFS;
-       hdr = (struct sadb_msg *) skb_put(skb_out, sizeof(struct sadb_msg));
+       hdr = skb_put(skb_out, sizeof(struct sadb_msg));
        hdr->sadb_msg_type = SADB_X_SPDFLUSH;
        hdr->sadb_msg_seq = c->seq;
        hdr->sadb_msg_pid = c->portid;
@@ -2929,7 +2916,7 @@ static void dump_ah_combs(struct sk_buff *skb, const struct xfrm_tmpl *t)
        struct sadb_prop *p;
        int i;
 
-       p = (struct sadb_prop*)skb_put(skb, sizeof(struct sadb_prop));
+       p = skb_put(skb, sizeof(struct sadb_prop));
        p->sadb_prop_len = sizeof(struct sadb_prop)/8;
        p->sadb_prop_exttype = SADB_EXT_PROPOSAL;
        p->sadb_prop_replay = 32;
@@ -2945,8 +2932,7 @@ static void dump_ah_combs(struct sk_buff *skb, const struct xfrm_tmpl *t)
 
                if (aalg_tmpl_set(t, aalg) && aalg->available) {
                        struct sadb_comb *c;
-                       c = (struct sadb_comb*)skb_put(skb, sizeof(struct sadb_comb));
-                       memset(c, 0, sizeof(*c));
+                       c = skb_put_zero(skb, sizeof(struct sadb_comb));
                        p->sadb_prop_len += sizeof(struct sadb_comb)/8;
                        c->sadb_comb_auth = aalg->desc.sadb_alg_id;
                        c->sadb_comb_auth_minbits = aalg->desc.sadb_alg_minbits;
@@ -2964,7 +2950,7 @@ static void dump_esp_combs(struct sk_buff *skb, const struct xfrm_tmpl *t)
        struct sadb_prop *p;
        int i, k;
 
-       p = (struct sadb_prop*)skb_put(skb, sizeof(struct sadb_prop));
+       p = skb_put(skb, sizeof(struct sadb_prop));
        p->sadb_prop_len = sizeof(struct sadb_prop)/8;
        p->sadb_prop_exttype = SADB_EXT_PROPOSAL;
        p->sadb_prop_replay = 32;
@@ -2990,7 +2976,7 @@ static void dump_esp_combs(struct sk_buff *skb, const struct xfrm_tmpl *t)
                                continue;
                        if (!(aalg_tmpl_set(t, aalg) && aalg->available))
                                continue;
-                       c = (struct sadb_comb*)skb_put(skb, sizeof(struct sadb_comb));
+                       c = skb_put(skb, sizeof(struct sadb_comb));
                        memset(c, 0, sizeof(*c));
                        p->sadb_prop_len += sizeof(struct sadb_comb)/8;
                        c->sadb_comb_auth = aalg->desc.sadb_alg_id;
@@ -3157,7 +3143,7 @@ static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct
        if (skb == NULL)
                return -ENOMEM;
 
-       hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+       hdr = skb_put(skb, sizeof(struct sadb_msg));
        hdr->sadb_msg_version = PF_KEY_V2;
        hdr->sadb_msg_type = SADB_ACQUIRE;
        hdr->sadb_msg_satype = pfkey_proto2satype(x->id.proto);
@@ -3168,8 +3154,7 @@ static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct
        hdr->sadb_msg_pid = 0;
 
        /* src address */
-       addr = (struct sadb_address*) skb_put(skb,
-                                             sizeof(struct sadb_address)+sockaddr_size);
+       addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
        addr->sadb_address_len =
                (sizeof(struct sadb_address)+sockaddr_size)/
                        sizeof(uint64_t);
@@ -3184,8 +3169,7 @@ static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct
                BUG();
 
        /* dst address */
-       addr = (struct sadb_address*) skb_put(skb,
-                                             sizeof(struct sadb_address)+sockaddr_size);
+       addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
        addr->sadb_address_len =
                (sizeof(struct sadb_address)+sockaddr_size)/
                        sizeof(uint64_t);
@@ -3199,7 +3183,7 @@ static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct
        if (!addr->sadb_address_prefixlen)
                BUG();
 
-       pol = (struct sadb_x_policy *)  skb_put(skb, sizeof(struct sadb_x_policy));
+       pol = skb_put(skb, sizeof(struct sadb_x_policy));
        pol->sadb_x_policy_len = sizeof(struct sadb_x_policy)/sizeof(uint64_t);
        pol->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
        pol->sadb_x_policy_type = IPSEC_POLICY_IPSEC;
@@ -3216,8 +3200,8 @@ static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct
 
        /* security context */
        if (xfrm_ctx) {
-               sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb,
-                               sizeof(struct sadb_x_sec_ctx) + ctx_size);
+               sec_ctx = skb_put(skb,
+                                 sizeof(struct sadb_x_sec_ctx) + ctx_size);
                sec_ctx->sadb_x_sec_len =
                  (sizeof(struct sadb_x_sec_ctx) + ctx_size) / sizeof(uint64_t);
                sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX;
@@ -3359,7 +3343,7 @@ static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
        if (skb == NULL)
                return -ENOMEM;
 
-       hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+       hdr = skb_put(skb, sizeof(struct sadb_msg));
        hdr->sadb_msg_version = PF_KEY_V2;
        hdr->sadb_msg_type = SADB_X_NAT_T_NEW_MAPPING;
        hdr->sadb_msg_satype = satype;
@@ -3370,7 +3354,7 @@ static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
        hdr->sadb_msg_pid = 0;
 
        /* SA */
-       sa = (struct sadb_sa *) skb_put(skb, sizeof(struct sadb_sa));
+       sa = skb_put(skb, sizeof(struct sadb_sa));
        sa->sadb_sa_len = sizeof(struct sadb_sa)/sizeof(uint64_t);
        sa->sadb_sa_exttype = SADB_EXT_SA;
        sa->sadb_sa_spi = x->id.spi;
@@ -3381,8 +3365,7 @@ static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
        sa->sadb_sa_flags = 0;
 
        /* ADDRESS_SRC (old addr) */
-       addr = (struct sadb_address*)
-               skb_put(skb, sizeof(struct sadb_address)+sockaddr_size);
+       addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
        addr->sadb_address_len =
                (sizeof(struct sadb_address)+sockaddr_size)/
                        sizeof(uint64_t);
@@ -3397,15 +3380,14 @@ static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
                BUG();
 
        /* NAT_T_SPORT (old port) */
-       n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
+       n_port = skb_put(skb, sizeof(*n_port));
        n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
        n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_SPORT;
        n_port->sadb_x_nat_t_port_port = natt->encap_sport;
        n_port->sadb_x_nat_t_port_reserved = 0;
 
        /* ADDRESS_DST (new addr) */
-       addr = (struct sadb_address*)
-               skb_put(skb, sizeof(struct sadb_address)+sockaddr_size);
+       addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
        addr->sadb_address_len =
                (sizeof(struct sadb_address)+sockaddr_size)/
                        sizeof(uint64_t);
@@ -3420,7 +3402,7 @@ static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
                BUG();
 
        /* NAT_T_DPORT (new port) */
-       n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
+       n_port = skb_put(skb, sizeof(*n_port));
        n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
        n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_DPORT;
        n_port->sadb_x_nat_t_port_port = sport;
@@ -3434,7 +3416,7 @@ static int set_sadb_address(struct sk_buff *skb, int sasize, int type,
                            const struct xfrm_selector *sel)
 {
        struct sadb_address *addr;
-       addr = (struct sadb_address *)skb_put(skb, sizeof(struct sadb_address) + sasize);
+       addr = skb_put(skb, sizeof(struct sadb_address) + sasize);
        addr->sadb_address_len = (sizeof(struct sadb_address) + sasize)/8;
        addr->sadb_address_exttype = type;
        addr->sadb_address_proto = sel->proto;
@@ -3472,8 +3454,7 @@ static int set_sadb_kmaddress(struct sk_buff *skb, const struct xfrm_kmaddress *
        size_req = (sizeof(struct sadb_x_kmaddress) +
                    pfkey_sockaddr_pair_size(family));
 
-       kma = (struct sadb_x_kmaddress *)skb_put(skb, size_req);
-       memset(kma, 0, size_req);
+       kma = skb_put_zero(skb, size_req);
        kma->sadb_x_kmaddress_len = size_req / 8;
        kma->sadb_x_kmaddress_exttype = SADB_X_EXT_KMADDRESS;
        kma->sadb_x_kmaddress_reserved = k->reserved;
@@ -3499,8 +3480,7 @@ static int set_ipsecrequest(struct sk_buff *skb,
        size_req = sizeof(struct sadb_x_ipsecrequest) +
                   pfkey_sockaddr_pair_size(family);
 
-       rq = (struct sadb_x_ipsecrequest *)skb_put(skb, size_req);
-       memset(rq, 0, size_req);
+       rq = skb_put_zero(skb, size_req);
        rq->sadb_x_ipsecrequest_len = size_req;
        rq->sadb_x_ipsecrequest_proto = proto;
        rq->sadb_x_ipsecrequest_mode = mode;
@@ -3519,7 +3499,8 @@ static int set_ipsecrequest(struct sk_buff *skb,
 #ifdef CONFIG_NET_KEY_MIGRATE
 static int pfkey_send_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
                              const struct xfrm_migrate *m, int num_bundles,
-                             const struct xfrm_kmaddress *k)
+                             const struct xfrm_kmaddress *k,
+                             const struct xfrm_encap_tmpl *encap)
 {
        int i;
        int sasize_sel;
@@ -3568,7 +3549,7 @@ static int pfkey_send_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
        if (skb == NULL)
                return -ENOMEM;
 
-       hdr = (struct sadb_msg *)skb_put(skb, sizeof(struct sadb_msg));
+       hdr = skb_put(skb, sizeof(struct sadb_msg));
        hdr->sadb_msg_version = PF_KEY_V2;
        hdr->sadb_msg_type = SADB_X_MIGRATE;
        hdr->sadb_msg_satype = pfkey_proto2satype(m->proto);
@@ -3589,7 +3570,7 @@ static int pfkey_send_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
        set_sadb_address(skb, sasize_sel, SADB_EXT_ADDRESS_DST, sel);
 
        /* policy information */
-       pol = (struct sadb_x_policy *)skb_put(skb, sizeof(struct sadb_x_policy));
+       pol = skb_put(skb, sizeof(struct sadb_x_policy));
        pol->sadb_x_policy_len = size_pol / 8;
        pol->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
        pol->sadb_x_policy_type = IPSEC_POLICY_IPSEC;
@@ -3629,7 +3610,8 @@ err:
 #else
 static int pfkey_send_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
                              const struct xfrm_migrate *m, int num_bundles,
-                             const struct xfrm_kmaddress *k)
+                             const struct xfrm_kmaddress *k,
+                             const struct xfrm_encap_tmpl *encap)
 {
        return -ENOPROTOOPT;
 }
@@ -3757,7 +3739,7 @@ static int pfkey_seq_show(struct seq_file *f, void *v)
        else
                seq_printf(f, "%pK %-6d %-6u %-6u %-6u %-6lu\n",
                               s,
-                              atomic_read(&s->sk_refcnt),
+                              refcount_read(&s->sk_refcnt),
                               sk_rmem_alloc_get(s),
                               sk_wmem_alloc_get(s),
                               from_kuid_munged(seq_user_ns(f), sock_i_uid(s)),