mm: Remove slab destructors from kmem_cache_create().

Slab destructors were no longer supported after Christoph's
c59def9f222d44bb7e2f0a559f2906191a0862d7 change. They've been
BUGs for both slab and slub, and slob never supported them
either.

This rips out support for the dtor pointer from kmem_cache_create()
completely and fixes up every single callsite in the kernel (there were
about 224, not including the slab allocator definitions themselves,
or the documentation references).

Signed-off-by: Paul Mundt <lethal@linux-sh.org>

33 files changed, 41 insertions, 42 deletions

diff --git a/net/bridge/br_fdb.c b/net/bridge/br_fdb.c
index 3fc6972938..69b70977f0 100644
--- a/net/bridge/br_fdb.c
+++ b/net/bridge/br_fdb.c
@@ -36,7 +36,7 @@ int __init br_fdb_init(void)
         br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
                                          sizeof(struct net_bridge_fdb_entry),
                                          0,
-                                         SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                         SLAB_HWCACHE_ALIGN, NULL);
         if (!br_fdb_cache)
                 return -ENOMEM;
 
diff --git a/net/core/flow.c b/net/core/flow.c
index 051430545a..0ab5234b17 100644
--- a/net/core/flow.c
+++ b/net/core/flow.c
@@ -350,7 +350,7 @@ static int __init flow_cache_init(void)
         flow_cachep = kmem_cache_create("flow_cache",
                                         sizeof(struct flow_cache_entry),
                                         0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                        NULL, NULL);
+                                        NULL);
         flow_hash_shift = 10;
         flow_lwm = 2 * flow_hash_size;
         flow_hwm = 4 * flow_hash_size;
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index 9df26a07f0..ca2a153313 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -1347,7 +1347,7 @@ void neigh_table_init_no_netlink(struct neigh_table *tbl)
                 tbl->kmem_cachep =
                         kmem_cache_create(tbl->id, tbl->entry_size, 0,
                                           SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                          NULL, NULL);
+                                          NULL);
         tbl->stats = alloc_percpu(struct neigh_statistics);
         if (!tbl->stats)
                 panic("cannot create neighbour cache statistics");
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 0583e8498f..35021eb3ed 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -2021,13 +2021,13 @@ void __init skb_init(void)
                                               sizeof(struct sk_buff),
                                               0,
                                               SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                              NULL, NULL);
+                                              NULL);
         skbuff_fclone_cache = kmem_cache_create("skbuff_fclone_cache",
                                                 (2*sizeof(struct sk_buff)) +
                                                 sizeof(atomic_t),
                                                 0,
                                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                                NULL, NULL);
+                                                NULL);
 }
 
 /**
diff --git a/net/core/sock.c b/net/core/sock.c
index 239a08a6ff..bd209c4477 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -1767,7 +1767,7 @@ int proto_register(struct proto *prot, int alloc_slab)
 
         if (alloc_slab) {
                 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
-                                               SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                               SLAB_HWCACHE_ALIGN, NULL);
 
                 if (prot->slab == NULL) {
                         printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
@@ -1785,7 +1785,7 @@ int proto_register(struct proto *prot, int alloc_slab)
                         sprintf(request_sock_slab_name, mask, prot->name);
                         prot->rsk_prot->slab = kmem_cache_create(request_sock_slab_name,
                                                                  prot->rsk_prot->obj_size, 0,
-                                                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                                                 SLAB_HWCACHE_ALIGN, NULL);
 
                         if (prot->rsk_prot->slab == NULL) {
                                 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
@@ -1807,7 +1807,7 @@ int proto_register(struct proto *prot, int alloc_slab)
                                 kmem_cache_create(timewait_sock_slab_name,
                                                   prot->twsk_prot->twsk_obj_size,
                                                   0, SLAB_HWCACHE_ALIGN,
-                                                  NULL, NULL);
+                                                  NULL);
                         if (prot->twsk_prot->twsk_slab == NULL)
                                 goto out_free_timewait_sock_slab_name;
                 }
diff --git a/net/dccp/ackvec.c b/net/dccp/ackvec.c
index 01030f3461..7ac775f9a6 100644
--- a/net/dccp/ackvec.c
+++ b/net/dccp/ackvec.c
@@ -481,14 +481,14 @@ int __init dccp_ackvec_init(void)
 {
         dccp_ackvec_slab = kmem_cache_create("dccp_ackvec",
                                              sizeof(struct dccp_ackvec), 0,
-                                             SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                             SLAB_HWCACHE_ALIGN, NULL);
         if (dccp_ackvec_slab == NULL)
                 goto out_err;
 
         dccp_ackvec_record_slab =
                         kmem_cache_create("dccp_ackvec_record",
                                           sizeof(struct dccp_ackvec_record),
-                                          0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                          0, SLAB_HWCACHE_ALIGN, NULL);
         if (dccp_ackvec_record_slab == NULL)
                 goto out_destroy_slab;
 
diff --git a/net/dccp/ccid.c b/net/dccp/ccid.c
index d8cf92f09e..ccbf72c793 100644
--- a/net/dccp/ccid.c
+++ b/net/dccp/ccid.c
@@ -69,7 +69,7 @@ static struct kmem_cache *ccid_kmem_cache_create(int obj_size, const char *fmt,.
         if (slab_name == NULL)
                 return NULL;
         slab = kmem_cache_create(slab_name, sizeof(struct ccid) + obj_size, 0,
-                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                 SLAB_HWCACHE_ALIGN, NULL);
         if (slab == NULL)
                 kfree(slab_name);
         return slab;
diff --git a/net/dccp/ccids/lib/loss_interval.c b/net/dccp/ccids/lib/loss_interval.c
index dd0fc992b0..174d3f13d9 100644
--- a/net/dccp/ccids/lib/loss_interval.c
+++ b/net/dccp/ccids/lib/loss_interval.c
@@ -282,7 +282,7 @@ static __init int dccp_li_init(void)
 {
         dccp_li_cachep = kmem_cache_create("dccp_li_hist",
                                            sizeof(struct dccp_li_hist_entry),
-                                           0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                           0, SLAB_HWCACHE_ALIGN, NULL);
         return dccp_li_cachep == NULL ? -ENOBUFS : 0;
 }
 
diff --git a/net/dccp/ccids/lib/packet_history.c b/net/dccp/ccids/lib/packet_history.c
index 2e8ef42721..34c4f60477 100644
--- a/net/dccp/ccids/lib/packet_history.c
+++ b/net/dccp/ccids/lib/packet_history.c
@@ -59,7 +59,7 @@ struct dccp_tx_hist *dccp_tx_hist_new(const char *name)
         hist->dccptxh_slab = kmem_cache_create(slab_name,
                                              sizeof(struct dccp_tx_hist_entry),
                                                0, SLAB_HWCACHE_ALIGN,
-                                               NULL, NULL);
+                                               NULL);
         if (hist->dccptxh_slab == NULL)
                 goto out_free_slab_name;
 out:
@@ -148,7 +148,7 @@ struct dccp_rx_hist *dccp_rx_hist_new(const char *name)
         hist->dccprxh_slab = kmem_cache_create(slab_name,
                                              sizeof(struct dccp_rx_hist_entry),
                                                0, SLAB_HWCACHE_ALIGN,
-                                               NULL, NULL);
+                                               NULL);
         if (hist->dccprxh_slab == NULL)
                 goto out_free_slab_name;
 out:
diff --git a/net/dccp/proto.c b/net/dccp/proto.c
index 6607b7b14f..04b59ec4f5 100644
--- a/net/dccp/proto.c
+++ b/net/dccp/proto.c
@@ -1003,7 +1003,7 @@ static int __init dccp_init(void)
         dccp_hashinfo.bind_bucket_cachep =
                 kmem_cache_create("dccp_bind_bucket",
                                   sizeof(struct inet_bind_bucket), 0,
-                                  SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                  SLAB_HWCACHE_ALIGN, NULL);
         if (!dccp_hashinfo.bind_bucket_cachep)
                 goto out;
 
diff --git a/net/decnet/dn_route.c b/net/decnet/dn_route.c
index 82622fb6f6..f2a61ef2af 100644
--- a/net/decnet/dn_route.c
+++ b/net/decnet/dn_route.c
@@ -1770,7 +1770,7 @@ void __init dn_route_init(void)
 
         dn_dst_ops.kmem_cachep =
                 kmem_cache_create("dn_dst_cache", sizeof(struct dn_route), 0,
-                                  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                                  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
         init_timer(&dn_route_timer);
         dn_route_timer.function = dn_dst_check_expire;
         dn_route_timer.expires = jiffies + decnet_dst_gc_interval * HZ;
diff --git a/net/decnet/dn_table.c b/net/decnet/dn_table.c
index d6615c9361..fda0772fa2 100644
--- a/net/decnet/dn_table.c
+++ b/net/decnet/dn_table.c
@@ -881,7 +881,7 @@ void __init dn_fib_table_init(void)
         dn_hash_kmem = kmem_cache_create("dn_fib_info_cache",
                                         sizeof(struct dn_fib_info),
                                         0, SLAB_HWCACHE_ALIGN,
-                                        NULL, NULL);
+                                        NULL);
 }
 
 void __exit dn_fib_table_cleanup(void)
diff --git a/net/ipv4/fib_hash.c b/net/ipv4/fib_hash.c
index 07e843a47d..9ad1d9ff9c 100644
--- a/net/ipv4/fib_hash.c
+++ b/net/ipv4/fib_hash.c
@@ -771,13 +771,13 @@ struct fib_table * __init fib_hash_init(u32 id)
                 fn_hash_kmem = kmem_cache_create("ip_fib_hash",
                                                  sizeof(struct fib_node),
                                                  0, SLAB_HWCACHE_ALIGN,
-                                                 NULL, NULL);
+                                                 NULL);
 
         if (fn_alias_kmem == NULL)
                 fn_alias_kmem = kmem_cache_create("ip_fib_alias",
                                                   sizeof(struct fib_alias),
                                                   0, SLAB_HWCACHE_ALIGN,
-                                                  NULL, NULL);
+                                                  NULL);
 
         tb = kmalloc(sizeof(struct fib_table) + sizeof(struct fn_hash),
                      GFP_KERNEL);
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index 30e332ade6..9ca786a6fd 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -1970,7 +1970,7 @@ struct fib_table * __init fib_hash_init(u32 id)
                 fn_alias_kmem = kmem_cache_create("ip_fib_alias",
                                                   sizeof(struct fib_alias),
                                                   0, SLAB_HWCACHE_ALIGN,
-                                                  NULL, NULL);
+                                                  NULL);
 
         tb = kmalloc(sizeof(struct fib_table) + sizeof(struct trie),
                      GFP_KERNEL);
diff --git a/net/ipv4/inetpeer.c b/net/ipv4/inetpeer.c
index 2f44e61280..6cbce96a54 100644
--- a/net/ipv4/inetpeer.c
+++ b/net/ipv4/inetpeer.c
@@ -123,7 +123,7 @@ void __init inet_initpeers(void)
         peer_cachep = kmem_cache_create("inet_peer_cache",
                         sizeof(struct inet_peer),
                         0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                        NULL, NULL);
+                        NULL);
 
         /* All the timers, started at system startup tend
            to synchronize. Perturb it a bit.
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index d96582acdf..7003cc1b7f 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -1917,7 +1917,7 @@ void __init ip_mr_init(void)
         mrt_cachep = kmem_cache_create("ip_mrt_cache",
                                        sizeof(struct mfc_cache),
                                        0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                       NULL, NULL);
+                                       NULL);
         init_timer(&ipmr_expire_timer);
         ipmr_expire_timer.function=ipmr_expire_process;
         register_netdevice_notifier(&ip_mr_notifier);
diff --git a/net/ipv4/ipvs/ip_vs_conn.c b/net/ipv4/ipvs/ip_vs_conn.c
index 3b446b1a6b..d612a6a5d9 100644
--- a/net/ipv4/ipvs/ip_vs_conn.c
+++ b/net/ipv4/ipvs/ip_vs_conn.c
@@ -901,7 +901,7 @@ int ip_vs_conn_init(void)
         /* Allocate ip_vs_conn slab cache */
         ip_vs_conn_cachep = kmem_cache_create("ip_vs_conn",
                                               sizeof(struct ip_vs_conn), 0,
-                                              SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                              SLAB_HWCACHE_ALIGN, NULL);
         if (!ip_vs_conn_cachep) {
                 vfree(ip_vs_conn_tab);
                 return -ENOMEM;
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index 88fa648d7b..df42b7fb32 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -2967,7 +2967,7 @@ int __init ip_rt_init(void)
 
         ipv4_dst_ops.kmem_cachep =
                 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
-                                  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                                  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 
         ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
 
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 987b94403b..da4c0b6ab7 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -2430,7 +2430,7 @@ void __init tcp_init(void)
         tcp_hashinfo.bind_bucket_cachep =
                 kmem_cache_create("tcp_bind_bucket",
                                   sizeof(struct inet_bind_bucket), 0,
-                                  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                                  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 
         /* Size and allocate the main established and bind bucket
          * hash tables.
diff --git a/net/ipv6/ip6_fib.c b/net/ipv6/ip6_fib.c
index 662a7d9681..6a612a701e 100644
--- a/net/ipv6/ip6_fib.c
+++ b/net/ipv6/ip6_fib.c
@@ -1474,7 +1474,7 @@ void __init fib6_init(void)
         fib6_node_kmem = kmem_cache_create("fib6_nodes",
                                            sizeof(struct fib6_node),
                                            0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                           NULL, NULL);
+                                           NULL);
 
         fib6_tables_init();
 
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index fe8d9837f9..919de682b3 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -2555,7 +2555,7 @@ void __init ip6_route_init(void)
 #endif
         ip6_dst_ops.kmem_cachep =
                 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
-                                  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                                  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
         ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops.kmem_cachep;
 
         fib6_init();
diff --git a/net/ipv6/xfrm6_tunnel.c b/net/ipv6/xfrm6_tunnel.c
index 6f87dd568d..30f3236c40 100644
--- a/net/ipv6/xfrm6_tunnel.c
+++ b/net/ipv6/xfrm6_tunnel.c
@@ -84,7 +84,7 @@ static int xfrm6_tunnel_spi_init(void)
         xfrm6_tunnel_spi_kmem = kmem_cache_create("xfrm6_tunnel_spi",
                                                   sizeof(struct xfrm6_tunnel_spi),
                                                   0, SLAB_HWCACHE_ALIGN,
-                                                  NULL, NULL);
+                                                  NULL);
         if (!xfrm6_tunnel_spi_kmem)
                 return -ENOMEM;
 
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index 8cce814f6b..aa086c83af 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -1108,7 +1108,7 @@ int __init nf_conntrack_init(void)
 
         nf_conntrack_cachep = kmem_cache_create("nf_conntrack",
                                                 sizeof(struct nf_conn),
-                                                0, 0, NULL, NULL);
+                                                0, 0, NULL);
         if (!nf_conntrack_cachep) {
                 printk(KERN_ERR "Unable to create nf_conn slab cache\n");
                 goto err_free_hash;
diff --git a/net/netfilter/nf_conntrack_expect.c b/net/netfilter/nf_conntrack_expect.c
index 2191fe008f..1aa6229ca9 100644
--- a/net/netfilter/nf_conntrack_expect.c
+++ b/net/netfilter/nf_conntrack_expect.c
@@ -540,7 +540,7 @@ int __init nf_conntrack_expect_init(void)
 
         nf_ct_expect_cachep = kmem_cache_create("nf_conntrack_expect",
                                         sizeof(struct nf_conntrack_expect),
-                                        0, 0, NULL, NULL);
+                                        0, 0, NULL);
         if (!nf_ct_expect_cachep)
                 goto err2;
 
diff --git a/net/netfilter/xt_hashlimit.c b/net/netfilter/xt_hashlimit.c
index d6b3d01975..bd45f9d3f7 100644
--- a/net/netfilter/xt_hashlimit.c
+++ b/net/netfilter/xt_hashlimit.c
@@ -738,7 +738,7 @@ static int __init xt_hashlimit_init(void)
         err = -ENOMEM;
         hashlimit_cachep = kmem_cache_create("xt_hashlimit",
                                             sizeof(struct dsthash_ent), 0, 0,
-                                            NULL, NULL);
+                                            NULL);
         if (!hashlimit_cachep) {
                 printk(KERN_ERR "xt_hashlimit: unable to create slab cache\n");
                 goto err2;
diff --git a/net/rxrpc/af_rxrpc.c b/net/rxrpc/af_rxrpc.c
index 46f6d572ad..16a68df4e3 100644
--- a/net/rxrpc/af_rxrpc.c
+++ b/net/rxrpc/af_rxrpc.c
@@ -792,7 +792,7 @@ static int __init af_rxrpc_init(void)
         ret = -ENOMEM;
         rxrpc_call_jar = kmem_cache_create(
                 "rxrpc_call_jar", sizeof(struct rxrpc_call), 0,
-                SLAB_HWCACHE_ALIGN, NULL, NULL);
+                SLAB_HWCACHE_ALIGN, NULL);
         if (!rxrpc_call_jar) {
                 printk(KERN_NOTICE "RxRPC: Failed to allocate call jar\n");
                 goto error_call_jar;
diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
index 34bab36637..e98579b788 100644
--- a/net/sctp/protocol.c
+++ b/net/sctp/protocol.c
@@ -980,14 +980,14 @@ SCTP_STATIC __init int sctp_init(void)
         sctp_bucket_cachep = kmem_cache_create("sctp_bind_bucket",
                                                sizeof(struct sctp_bind_bucket),
                                                0, SLAB_HWCACHE_ALIGN,
-                                               NULL, NULL);
+                                               NULL);
         if (!sctp_bucket_cachep)
                 goto out;
 
         sctp_chunk_cachep = kmem_cache_create("sctp_chunk",
                                                sizeof(struct sctp_chunk),
                                                0, SLAB_HWCACHE_ALIGN,
-                                               NULL, NULL);
+                                               NULL);
         if (!sctp_chunk_cachep)
                 goto err_chunk_cachep;
 
diff --git a/net/socket.c b/net/socket.c
index b711142500..ec077037f5 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -272,8 +272,7 @@ static int init_inodecache(void)
                                               (SLAB_HWCACHE_ALIGN |
                                                SLAB_RECLAIM_ACCOUNT |
                                                SLAB_MEM_SPREAD),
-                                              init_once,
-                                              NULL);
+                                              init_once);
         if (sock_inode_cachep == NULL)
                 return -ENOMEM;
         return 0;
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 5b2b6fb244..650af064ff 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -867,7 +867,7 @@ int register_rpc_pipefs(void)
                                 sizeof(struct rpc_inode),
                                 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
                                                 SLAB_MEM_SPREAD),
-                                init_once, NULL);
+                                init_once);
         if (!rpc_inode_cachep)
                 return -ENOMEM;
         err = register_filesystem(&rpc_pipe_fs_type);
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index 2ac43c41c3..b5723c262a 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -1031,13 +1031,13 @@ rpc_init_mempool(void)
         rpc_task_slabp = kmem_cache_create("rpc_tasks",
                                              sizeof(struct rpc_task),
                                              0, SLAB_HWCACHE_ALIGN,
-                                             NULL, NULL);
+                                             NULL);
         if (!rpc_task_slabp)
                 goto err_nomem;
         rpc_buffer_slabp = kmem_cache_create("rpc_buffers",
                                              RPC_BUFFER_MAXSIZE,
                                              0, SLAB_HWCACHE_ALIGN,
-                                             NULL, NULL);
+                                             NULL);
         if (!rpc_buffer_slabp)
                 goto err_nomem;
         rpc_task_mempool = mempool_create_slab_pool(RPC_TASK_POOLSIZE,
diff --git a/net/tipc/handler.c b/net/tipc/handler.c
index e1dcf663f8..0c70010a7d 100644
--- a/net/tipc/handler.c
+++ b/net/tipc/handler.c
@@ -97,7 +97,7 @@ int tipc_handler_start(void)
 {
         tipc_queue_item_cache =
                 kmem_cache_create("tipc_queue_items", sizeof(struct queue_item),
-                                  0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                  0, SLAB_HWCACHE_ALIGN, NULL);
         if (!tipc_queue_item_cache)
                 return -ENOMEM;
 
diff --git a/net/xfrm/xfrm_input.c b/net/xfrm/xfrm_input.c
index 5c4695840c..113f444299 100644
--- a/net/xfrm/xfrm_input.c
+++ b/net/xfrm/xfrm_input.c
@@ -83,5 +83,5 @@ void __init xfrm_input_init(void)
         secpath_cachep = kmem_cache_create("secpath_cache",
                                            sizeof(struct sec_path),
                                            0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                           NULL, NULL);
+                                           NULL);
 }
diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
index cfaf17c885..c3a4b0a186 100644
--- a/net/xfrm/xfrm_policy.c
+++ b/net/xfrm/xfrm_policy.c
@@ -2378,7 +2378,7 @@ static void __init xfrm_policy_init(void)
         xfrm_dst_cache = kmem_cache_create("xfrm_dst_cache",
                                            sizeof(struct xfrm_dst),
                                            0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                           NULL, NULL);
+                                           NULL);
 
         hmask = 8 - 1;
         sz = (hmask+1) * sizeof(struct hlist_head);