atomic_t inet6_sock_nr;
#endif
-/* Per protocol sock slabcache */
-kmem_cache_t *tcp6_sk_cachep;
-kmem_cache_t *udp6_sk_cachep;
-kmem_cache_t *raw6_sk_cachep;
-
/* The inetsw table contains everything that inet_create needs to
* build a new socket.
*/
static struct list_head inetsw6[SOCK_MAX];
-static spinlock_t inetsw6_lock = SPIN_LOCK_UNLOCKED;
+static DEFINE_SPINLOCK(inetsw6_lock);
static void inet6_sock_destruct(struct sock *sk)
{
#endif
}
-static __inline__ kmem_cache_t *inet6_sk_slab(int protocol)
-{
- kmem_cache_t* rc = tcp6_sk_cachep;
-
- if (protocol == IPPROTO_UDP)
- rc = udp6_sk_cachep;
- else if (protocol == IPPROTO_RAW)
- rc = raw6_sk_cachep;
- return rc;
-}
-
-static __inline__ int inet6_sk_size(int protocol)
-{
- int rc = sizeof(struct tcp6_sock);
-
- if (protocol == IPPROTO_UDP)
- rc = sizeof(struct udp6_sock);
- else if (protocol == IPPROTO_RAW)
- rc = sizeof(struct raw6_sock);
- return rc;
-}
-
static __inline__ struct ipv6_pinfo *inet6_sk_generic(struct sock *sk)
{
- struct ipv6_pinfo *rc = (&((struct tcp6_sock *)sk)->inet6);
+ const int offset = sk->sk_prot->slab_obj_size - sizeof(struct ipv6_pinfo);
- if (sk->sk_protocol == IPPROTO_UDP)
- rc = (&((struct udp6_sock *)sk)->inet6);
- else if (sk->sk_protocol == IPPROTO_RAW)
- rc = (&((struct raw6_sock *)sk)->inet6);
- return rc;
+ return (struct ipv6_pinfo *)(((u8 *)sk) + offset);
}
static int inet6_create(struct socket *sock, int protocol)
{
- struct inet_opt *inet;
+ struct inet_sock *inet;
struct ipv6_pinfo *np;
struct sock *sk;
- struct tcp6_sock* tcp6sk;
struct list_head *p;
struct inet_protosw *answer;
-
- sk = sk_alloc(PF_INET6, GFP_KERNEL, inet6_sk_size(protocol),
- inet6_sk_slab(protocol));
- if (sk == NULL)
- goto do_oom;
+ struct proto *answer_prot;
+ unsigned char answer_flags;
+ char answer_no_check;
+ int rc;
/* Look for the requested type/protocol pair. */
answer = NULL;
answer = NULL;
}
+ rc = -ESOCKTNOSUPPORT;
if (!answer)
- goto free_and_badtype;
+ goto out_rcu_unlock;
+ rc = -EPERM;
if (answer->capability > 0 && !capable(answer->capability))
- goto free_and_badperm;
+ goto out_rcu_unlock;
+ rc = -EPROTONOSUPPORT;
if (!protocol)
- goto free_and_noproto;
+ goto out_rcu_unlock;
sock->ops = answer->ops;
+
+ answer_prot = answer->prot;
+ answer_no_check = answer->no_check;
+ answer_flags = answer->flags;
+ rcu_read_unlock();
+
+ BUG_TRAP(answer_prot->slab != NULL);
+
+ rc = -ENOBUFS;
+ sk = sk_alloc(PF_INET6, GFP_KERNEL,
+ answer_prot->slab_obj_size,
+ answer_prot->slab);
+ if (sk == NULL)
+ goto out;
+
sock_init_data(sock, sk);
- sk_set_owner(sk, THIS_MODULE);
+ sk->sk_prot = answer_prot;
+ sk_set_owner(sk, sk->sk_prot->owner);
- sk->sk_prot = answer->prot;
- sk->sk_no_check = answer->no_check;
- if (INET_PROTOSW_REUSE & answer->flags)
+ rc = 0;
+ sk->sk_no_check = answer_no_check;
+ if (INET_PROTOSW_REUSE & answer_flags)
sk->sk_reuse = 1;
- rcu_read_unlock();
inet = inet_sk(sk);
}
sk->sk_destruct = inet6_sock_destruct;
- sk->sk_zapped = 0;
sk->sk_family = PF_INET6;
sk->sk_protocol = protocol;
sk->sk_backlog_rcv = answer->prot->backlog_rcv;
- tcp6sk = (struct tcp6_sock *)sk;
- tcp6sk->pinet6 = np = inet6_sk_generic(sk);
+ inet_sk(sk)->pinet6 = np = inet6_sk_generic(sk);
np->hop_limit = -1;
np->mcast_hops = -1;
np->mc_loop = 1;
sk->sk_prot->hash(sk);
}
if (sk->sk_prot->init) {
- int err = sk->sk_prot->init(sk);
- if (err != 0) {
- inet_sock_release(sk);
- return err;
+ rc = sk->sk_prot->init(sk);
+ if (rc) {
+ sk_common_release(sk);
+ goto out;
}
}
- return 0;
-
-free_and_badtype:
- rcu_read_unlock();
- sk_free(sk);
- return -ESOCKTNOSUPPORT;
-free_and_badperm:
- rcu_read_unlock();
- sk_free(sk);
- return -EPERM;
-free_and_noproto:
+out:
+ return rc;
+out_rcu_unlock:
rcu_read_unlock();
- sk_free(sk);
- return -EPROTONOSUPPORT;
-do_oom:
- return -ENOBUFS;
+ goto out;
}
{
struct sockaddr_in6 *addr=(struct sockaddr_in6 *)uaddr;
struct sock *sk = sock->sk;
- struct inet_opt *inet = inet_sk(sk);
+ struct inet_sock *inet = inet_sk(sk);
struct ipv6_pinfo *np = inet6_sk(sk);
__u32 v4addr = 0;
unsigned short snum;
{
struct sockaddr_in6 *sin=(struct sockaddr_in6 *)uaddr;
struct sock *sk = sock->sk;
- struct inet_opt *inet = inet_sk(sk);
+ struct inet_sock *inet = inet_sk(sk);
struct ipv6_pinfo *np = inet6_sk(sk);
sin->sin6_family = AF_INET6;
switch(cmd)
{
case SIOCGSTAMP:
- return sock_get_timestamp(sk, (struct timeval *)arg);
+ return sock_get_timestamp(sk, (struct timeval __user *)arg);
case SIOCADDRT:
case SIOCDELRT:
- return(ipv6_route_ioctl(cmd,(void *)arg));
+ return(ipv6_route_ioctl(cmd,(void __user *)arg));
case SIOCSIFADDR:
- return addrconf_add_ifaddr((void *) arg);
+ return addrconf_add_ifaddr((void __user *) arg);
case SIOCDIFADDR:
- return addrconf_del_ifaddr((void *) arg);
+ return addrconf_del_ifaddr((void __user *) arg);
case SIOCSIFDSTADDR:
- return addrconf_set_dstaddr((void *) arg);
+ return addrconf_set_dstaddr((void __user *) arg);
default:
if (!sk->sk_prot->ioctl ||
(err = sk->sk_prot->ioctl(sk, cmd, arg)) == -ENOIOCTLCMD)
- return(dev_ioctl(cmd,(void *) arg));
+ return(dev_ioctl(cmd,(void __user *) arg));
return err;
}
/*NOTREACHED*/
.ioctl = inet6_ioctl, /* must change */
.listen = inet_listen, /* ok */
.shutdown = inet_shutdown, /* ok */
- .setsockopt = inet_setsockopt, /* ok */
- .getsockopt = inet_getsockopt, /* ok */
+ .setsockopt = sock_common_setsockopt, /* ok */
+ .getsockopt = sock_common_getsockopt, /* ok */
.sendmsg = inet_sendmsg, /* ok */
- .recvmsg = inet_recvmsg, /* ok */
+ .recvmsg = sock_common_recvmsg, /* ok */
.mmap = sock_no_mmap,
.sendpage = tcp_sendpage
};
.socketpair = sock_no_socketpair, /* a do nothing */
.accept = sock_no_accept, /* a do nothing */
.getname = inet6_getname,
- .poll = datagram_poll, /* ok */
+ .poll = udp_poll, /* ok */
.ioctl = inet6_ioctl, /* must change */
.listen = sock_no_listen, /* ok */
.shutdown = inet_shutdown, /* ok */
- .setsockopt = inet_setsockopt, /* ok */
- .getsockopt = inet_getsockopt, /* ok */
+ .setsockopt = sock_common_setsockopt, /* ok */
+ .getsockopt = sock_common_getsockopt, /* ok */
.sendmsg = inet_sendmsg, /* ok */
- .recvmsg = inet_recvmsg, /* ok */
+ .recvmsg = sock_common_recvmsg, /* ok */
.mmap = sock_no_mmap,
.sendpage = sock_no_sendpage,
};
extern void ipv6_sysctl_unregister(void);
#endif
+/* Same as inet6_dgram_ops, sans udp_poll. */
+static struct proto_ops inet6_sockraw_ops = {
+ .family = PF_INET6,
+ .owner = THIS_MODULE,
+ .release = inet6_release,
+ .bind = inet6_bind,
+ .connect = inet_dgram_connect, /* ok */
+ .socketpair = sock_no_socketpair, /* a do nothing */
+ .accept = sock_no_accept, /* a do nothing */
+ .getname = inet6_getname,
+ .poll = datagram_poll, /* ok */
+ .ioctl = inet6_ioctl, /* must change */
+ .listen = sock_no_listen, /* ok */
+ .shutdown = inet_shutdown, /* ok */
+ .setsockopt = sock_common_setsockopt, /* ok */
+ .getsockopt = sock_common_getsockopt, /* ok */
+ .sendmsg = inet_sendmsg, /* ok */
+ .recvmsg = sock_common_recvmsg, /* ok */
+ .mmap = sock_no_mmap,
+ .sendpage = sock_no_sendpage,
+};
+
static struct inet_protosw rawv6_protosw = {
.type = SOCK_RAW,
.protocol = IPPROTO_IP, /* wild card */
.prot = &rawv6_prot,
- .ops = &inet6_dgram_ops,
+ .ops = &inet6_sockraw_ops,
.capability = CAP_NET_RAW,
.no_check = UDP_CSUM_DEFAULT,
.flags = INET_PROTOSW_REUSE,
};
-#define INETSW6_ARRAY_LEN (sizeof(inetsw6_array) / sizeof(struct inet_protosw))
-
void
inet6_register_protosw(struct inet_protosw *p)
{
spin_lock_bh(&inetsw6_lock);
- if (p->type > SOCK_MAX)
+ if (p->type >= SOCK_MAX)
goto out_illegal;
/* If we are trying to override a permanent protocol, bail. */
{
if (ptr == NULL)
return;
- free_percpu(ptr[0]);
- free_percpu(ptr[1]);
+ if (ptr[0])
+ free_percpu(ptr[0]);
+ if (ptr[1])
+ free_percpu(ptr[1]);
ptr[0] = ptr[1] = NULL;
}
static int __init init_ipv6_mibs(void)
{
- if (snmp6_mib_init((void **)ipv6_statistics, sizeof (struct ipv6_mib),
- __alignof__(struct ipv6_mib)) < 0)
+ if (snmp6_mib_init((void **)ipv6_statistics, sizeof (struct ipstats_mib),
+ __alignof__(struct ipstats_mib)) < 0)
goto err_ip_mib;
if (snmp6_mib_init((void **)icmpv6_statistics, sizeof (struct icmpv6_mib),
- __alignof__(struct ipv6_mib)) < 0)
+ __alignof__(struct icmpv6_mib)) < 0)
goto err_icmp_mib;
if (snmp6_mib_init((void **)udp_stats_in6, sizeof (struct udp_mib),
- __alignof__(struct ipv6_mib)) < 0)
+ __alignof__(struct udp_mib)) < 0)
goto err_udp_mib;
return 0;
#endif
#endif
- if (sizeof(struct inet6_skb_parm) > sizeof(dummy_skb->cb))
- {
+ if (sizeof(struct inet6_skb_parm) > sizeof(dummy_skb->cb)) {
printk(KERN_CRIT "inet6_proto_init: size fault\n");
return -EINVAL;
}
- /* allocate our sock slab caches */
- tcp6_sk_cachep = kmem_cache_create("tcp6_sock",
- sizeof(struct tcp6_sock), 0,
- SLAB_HWCACHE_ALIGN, 0, 0);
- udp6_sk_cachep = kmem_cache_create("udp6_sock",
- sizeof(struct udp6_sock), 0,
- SLAB_HWCACHE_ALIGN, 0, 0);
- raw6_sk_cachep = kmem_cache_create("raw6_sock",
- sizeof(struct raw6_sock), 0,
- SLAB_HWCACHE_ALIGN, 0, 0);
- if (!tcp6_sk_cachep || !udp6_sk_cachep || !raw6_sk_cachep)
- printk(KERN_CRIT "%s: Can't create protocol sock SLAB "
- "caches!\n", __FUNCTION__);
+
+ err = sk_alloc_slab(&tcpv6_prot, "tcpv6_sock");
+ if (err) {
+ sk_alloc_slab_error(&tcpv6_prot);
+ goto out;
+ }
+ err = sk_alloc_slab(&udpv6_prot, "udpv6_sock");
+ if (err) {
+ sk_alloc_slab_error(&udpv6_prot);
+ goto out_tcp_free_slab;
+ }
+ err = sk_alloc_slab(&rawv6_prot, "rawv6_sock");
+ if (err) {
+ sk_alloc_slab_error(&rawv6_prot);
+ goto out_udp_free_slab;
+ }
/* Register the socket-side information for inet6_create. */
for(r = &inetsw6[0]; r < &inetsw6[SOCK_MAX]; ++r)
/* Initialise ipv6 mibs */
err = init_ipv6_mibs();
if (err)
- goto init_mib_fail;
+ goto out_raw_free_slab;
/*
* ipngwg API draft makes clear that the correct semantics
/* Init v6 transport protocols. */
udpv6_init();
tcpv6_init();
-
- return 0;
+ err = 0;
+out:
+ return err;
#ifdef CONFIG_PROC_FS
proc_if6_fail:
ipv6_sysctl_unregister();
#endif
cleanup_ipv6_mibs();
-init_mib_fail:
- return err;
+out_raw_free_slab:
+ sk_free_slab(&rawv6_prot);
+out_udp_free_slab:
+ sk_free_slab(&udpv6_prot);
+out_tcp_free_slab:
+ sk_free_slab(&tcpv6_prot);
+ goto out;
}
module_init(inet6_init);
ipv6_sysctl_unregister();
#endif
cleanup_ipv6_mibs();
- kmem_cache_destroy(tcp6_sk_cachep);
- kmem_cache_destroy(udp6_sk_cachep);
- kmem_cache_destroy(raw6_sk_cachep);
+ sk_free_slab(&rawv6_prot);
+ sk_free_slab(&udpv6_prot);
+ sk_free_slab(&tcpv6_prot);
}
module_exit(inet6_exit);
git://git.onelab.eu / linux-2.6.git / blobdiff