[linux-2.6-block.git] / net / phonet / socket.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * File: socket.c
 *
 * Phonet sockets
 *
 * Copyright (C) 2008 Nokia Corporation.
 *
 * Authors: Sakari Ailus <sakari.ailus@nokia.com>
 *          Rémi Denis-Courmont
 */

#include <linux/gfp.h>
#include <linux/kernel.h>
#include <linux/net.h>
#include <linux/poll.h>
#include <linux/sched/signal.h>

#include <net/sock.h>
#include <net/tcp_states.h>

#include <linux/phonet.h>
#include <linux/export.h>
#include <net/phonet/phonet.h>
#include <net/phonet/pep.h>
#include <net/phonet/pn_dev.h>

static int pn_socket_release(struct socket *sock)
{
	struct sock *sk = sock->sk;

	if (sk) {
		sock->sk = NULL;
		sk->sk_prot->close(sk, 0);
	}
	return 0;
}

#define PN_HASHSIZE	16
#define PN_HASHMASK	(PN_HASHSIZE-1)


static struct  {
	struct hlist_head hlist[PN_HASHSIZE];
	struct mutex lock;
} pnsocks;

void __init pn_sock_init(void)
{
	unsigned int i;

	for (i = 0; i < PN_HASHSIZE; i++)
		INIT_HLIST_HEAD(pnsocks.hlist + i);
	mutex_init(&pnsocks.lock);
}

static struct hlist_head *pn_hash_list(u16 obj)
{
	return pnsocks.hlist + (obj & PN_HASHMASK);
}

/*
 * Find address based on socket address, match only certain fields.
 * Also grab sock if it was found. Remember to sock_put it later.
 */
struct sock *pn_find_sock_by_sa(struct net *net, const struct sockaddr_pn *spn)
{
	struct sock *sknode;
	struct sock *rval = NULL;
	u16 obj = pn_sockaddr_get_object(spn);
	u8 res = spn->spn_resource;
	struct hlist_head *hlist = pn_hash_list(obj);

	rcu_read_lock();
	sk_for_each_rcu(sknode, hlist) {
		struct pn_sock *pn = pn_sk(sknode);
		BUG_ON(!pn->sobject); /* unbound socket */

		if (!net_eq(sock_net(sknode), net))
			continue;
		if (pn_port(obj)) {
			/* Look up socket by port */
			if (pn_port(pn->sobject) != pn_port(obj))
				continue;
		} else {
			/* If port is zero, look up by resource */
			if (pn->resource != res)
				continue;
		}
		if (pn_addr(pn->sobject) &&
		    pn_addr(pn->sobject) != pn_addr(obj))
			continue;

		rval = sknode;
		sock_hold(sknode);
		break;
	}
	rcu_read_unlock();

	return rval;
}

/* Deliver a broadcast packet (only in bottom-half) */
void pn_deliver_sock_broadcast(struct net *net, struct sk_buff *skb)
{
	struct hlist_head *hlist = pnsocks.hlist;
	unsigned int h;

	rcu_read_lock();
	for (h = 0; h < PN_HASHSIZE; h++) {
		struct sock *sknode;

		sk_for_each(sknode, hlist) {
			struct sk_buff *clone;

			if (!net_eq(sock_net(sknode), net))
				continue;
			if (!sock_flag(sknode, SOCK_BROADCAST))
				continue;

			clone = skb_clone(skb, GFP_ATOMIC);
			if (clone) {
				sock_hold(sknode);
				sk_receive_skb(sknode, clone, 0);
			}
		}
		hlist++;
	}
	rcu_read_unlock();
}

int pn_sock_hash(struct sock *sk)
{
	struct hlist_head *hlist = pn_hash_list(pn_sk(sk)->sobject);

	mutex_lock(&pnsocks.lock);
	sk_add_node_rcu(sk, hlist);
	mutex_unlock(&pnsocks.lock);

	return 0;
}
EXPORT_SYMBOL(pn_sock_hash);

void pn_sock_unhash(struct sock *sk)
{
	mutex_lock(&pnsocks.lock);
	sk_del_node_init_rcu(sk);
	mutex_unlock(&pnsocks.lock);
	pn_sock_unbind_all_res(sk);
	synchronize_rcu();
}
EXPORT_SYMBOL(pn_sock_unhash);

static DEFINE_MUTEX(port_mutex);

static int pn_socket_bind(struct socket *sock, struct sockaddr *addr, int len)
{
	struct sock *sk = sock->sk;
	struct pn_sock *pn = pn_sk(sk);
	struct sockaddr_pn *spn = (struct sockaddr_pn *)addr;
	int err;
	u16 handle;
	u8 saddr;

	if (sk->sk_prot->bind)
		return sk->sk_prot->bind(sk, addr, len);

	if (len < sizeof(struct sockaddr_pn))
		return -EINVAL;
	if (spn->spn_family != AF_PHONET)
		return -EAFNOSUPPORT;

	handle = pn_sockaddr_get_object((struct sockaddr_pn *)addr);
	saddr = pn_addr(handle);
	if (saddr && phonet_address_lookup(sock_net(sk), saddr))
		return -EADDRNOTAVAIL;

	lock_sock(sk);
	if (sk->sk_state != TCP_CLOSE || pn_port(pn->sobject)) {
		err = -EINVAL; /* attempt to rebind */
		goto out;
	}
	WARN_ON(sk_hashed(sk));
	mutex_lock(&port_mutex);
	err = sk->sk_prot->get_port(sk, pn_port(handle));
	if (err)
		goto out_port;

	/* get_port() sets the port, bind() sets the address if applicable */
	pn->sobject = pn_object(saddr, pn_port(pn->sobject));
	pn->resource = spn->spn_resource;

	/* Enable RX on the socket */
	err = sk->sk_prot->hash(sk);
out_port:
	mutex_unlock(&port_mutex);
out:
	release_sock(sk);
	return err;
}

static int pn_socket_autobind(struct socket *sock)
{
	struct sockaddr_pn sa;
	int err;

	memset(&sa, 0, sizeof(sa));
	sa.spn_family = AF_PHONET;
	err = pn_socket_bind(sock, (struct sockaddr *)&sa,
				sizeof(struct sockaddr_pn));
	if (err != -EINVAL)
		return err;
	BUG_ON(!pn_port(pn_sk(sock->sk)->sobject));
	return 0; /* socket was already bound */
}

static int pn_socket_connect(struct socket *sock, struct sockaddr *addr,
		int len, int flags)
{
	struct sock *sk = sock->sk;
	struct pn_sock *pn = pn_sk(sk);
	struct sockaddr_pn *spn = (struct sockaddr_pn *)addr;
	struct task_struct *tsk = current;
	long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
	int err;

	if (pn_socket_autobind(sock))
		return -ENOBUFS;
	if (len < sizeof(struct sockaddr_pn))
		return -EINVAL;
	if (spn->spn_family != AF_PHONET)
		return -EAFNOSUPPORT;

	lock_sock(sk);

	switch (sock->state) {
	case SS_UNCONNECTED:
		if (sk->sk_state != TCP_CLOSE) {
			err = -EISCONN;
			goto out;
		}
		break;
	case SS_CONNECTING:
		err = -EALREADY;
		goto out;
	default:
		err = -EISCONN;
		goto out;
	}

	pn->dobject = pn_sockaddr_get_object(spn);
	pn->resource = pn_sockaddr_get_resource(spn);
	sock->state = SS_CONNECTING;

	err = sk->sk_prot->connect(sk, addr, len);
	if (err) {
		sock->state = SS_UNCONNECTED;
		pn->dobject = 0;
		goto out;
	}

	while (sk->sk_state == TCP_SYN_SENT) {
		DEFINE_WAIT(wait);

		if (!timeo) {
			err = -EINPROGRESS;
			goto out;
		}
		if (signal_pending(tsk)) {
			err = sock_intr_errno(timeo);
			goto out;
		}

		prepare_to_wait_exclusive(sk_sleep(sk), &wait,
						TASK_INTERRUPTIBLE);
		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);
		finish_wait(sk_sleep(sk), &wait);
	}

	if ((1 << sk->sk_state) & (TCPF_SYN_RECV|TCPF_ESTABLISHED))
		err = 0;
	else if (sk->sk_state == TCP_CLOSE_WAIT)
		err = -ECONNRESET;
	else
		err = -ECONNREFUSED;
	sock->state = err ? SS_UNCONNECTED : SS_CONNECTED;
out:
	release_sock(sk);
	return err;
}

static int pn_socket_accept(struct socket *sock, struct socket *newsock,
			    int flags, bool kern)
{
	struct sock *sk = sock->sk;
	struct sock *newsk;
	int err;

	if (unlikely(sk->sk_state != TCP_LISTEN))
		return -EINVAL;

	newsk = sk->sk_prot->accept(sk, flags, &err, kern);
	if (!newsk)
		return err;

	lock_sock(newsk);
	sock_graft(newsk, newsock);
	newsock->state = SS_CONNECTED;
	release_sock(newsk);
	return 0;
}

static int pn_socket_getname(struct socket *sock, struct sockaddr *addr,
				int peer)
{
	struct sock *sk = sock->sk;
	struct pn_sock *pn = pn_sk(sk);

	memset(addr, 0, sizeof(struct sockaddr_pn));
	addr->sa_family = AF_PHONET;
	if (!peer) /* Race with bind() here is userland's problem. */
		pn_sockaddr_set_object((struct sockaddr_pn *)addr,
					pn->sobject);

	return sizeof(struct sockaddr_pn);
}

static __poll_t pn_socket_poll(struct file *file, struct socket *sock,
					poll_table *wait)
{
	struct sock *sk = sock->sk;
	struct pep_sock *pn = pep_sk(sk);
	__poll_t mask = 0;

	poll_wait(file, sk_sleep(sk), wait);

	if (sk->sk_state == TCP_CLOSE)
		return EPOLLERR;
	if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
		mask |= EPOLLIN | EPOLLRDNORM;
	if (!skb_queue_empty_lockless(&pn->ctrlreq_queue))
		mask |= EPOLLPRI;
	if (!mask && sk->sk_state == TCP_CLOSE_WAIT)
		return EPOLLHUP;

	if (sk->sk_state == TCP_ESTABLISHED &&
		refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf &&
		atomic_read(&pn->tx_credits))
		mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;

	return mask;
}

static int pn_socket_ioctl(struct socket *sock, unsigned int cmd,
				unsigned long arg)
{
	struct sock *sk = sock->sk;
	struct pn_sock *pn = pn_sk(sk);

	if (cmd == SIOCPNGETOBJECT) {
		struct net_device *dev;
		u16 handle;
		u8 saddr;

		if (get_user(handle, (__u16 __user *)arg))
			return -EFAULT;

		lock_sock(sk);
		if (sk->sk_bound_dev_if)
			dev = dev_get_by_index(sock_net(sk),
						sk->sk_bound_dev_if);
		else
			dev = phonet_device_get(sock_net(sk));
		if (dev && (dev->flags & IFF_UP))
			saddr = phonet_address_get(dev, pn_addr(handle));
		else
			saddr = PN_NO_ADDR;
		release_sock(sk);

		if (dev)
			dev_put(dev);
		if (saddr == PN_NO_ADDR)
			return -EHOSTUNREACH;

		handle = pn_object(saddr, pn_port(pn->sobject));
		return put_user(handle, (__u16 __user *)arg);
	}

	return sk->sk_prot->ioctl(sk, cmd, arg);
}

static int pn_socket_listen(struct socket *sock, int backlog)
{
	struct sock *sk = sock->sk;
	int err = 0;

	if (pn_socket_autobind(sock))
		return -ENOBUFS;

	lock_sock(sk);
	if (sock->state != SS_UNCONNECTED) {
		err = -EINVAL;
		goto out;
	}

	if (sk->sk_state != TCP_LISTEN) {
		sk->sk_state = TCP_LISTEN;
		sk->sk_ack_backlog = 0;
	}
	sk->sk_max_ack_backlog = backlog;
out:
	release_sock(sk);
	return err;
}

static int pn_socket_sendmsg(struct socket *sock, struct msghdr *m,
			     size_t total_len)
{
	struct sock *sk = sock->sk;

	if (pn_socket_autobind(sock))
		return -EAGAIN;

	return sk->sk_prot->sendmsg(sk, m, total_len);
}

const struct proto_ops phonet_dgram_ops = {
	.family		= AF_PHONET,
	.owner		= THIS_MODULE,
	.release	= pn_socket_release,
	.bind		= pn_socket_bind,
	.connect	= sock_no_connect,
	.socketpair	= sock_no_socketpair,
	.accept		= sock_no_accept,
	.getname	= pn_socket_getname,
	.poll		= datagram_poll,
	.ioctl		= pn_socket_ioctl,
	.listen		= sock_no_listen,
	.shutdown	= sock_no_shutdown,
	.sendmsg	= pn_socket_sendmsg,
	.recvmsg	= sock_common_recvmsg,
	.mmap		= sock_no_mmap,
	.sendpage	= sock_no_sendpage,
};

const struct proto_ops phonet_stream_ops = {
	.family		= AF_PHONET,
	.owner		= THIS_MODULE,
	.release	= pn_socket_release,
	.bind		= pn_socket_bind,
	.connect	= pn_socket_connect,
	.socketpair	= sock_no_socketpair,
	.accept		= pn_socket_accept,
	.getname	= pn_socket_getname,
	.poll		= pn_socket_poll,
	.ioctl		= pn_socket_ioctl,
	.listen		= pn_socket_listen,
	.shutdown	= sock_no_shutdown,
	.setsockopt	= sock_common_setsockopt,
	.getsockopt	= sock_common_getsockopt,
	.sendmsg	= pn_socket_sendmsg,
	.recvmsg	= sock_common_recvmsg,
	.mmap		= sock_no_mmap,
	.sendpage	= sock_no_sendpage,
};
EXPORT_SYMBOL(phonet_stream_ops);

/* allocate port for a socket */
int pn_sock_get_port(struct sock *sk, unsigned short sport)
{
	static int port_cur;
	struct net *net = sock_net(sk);
	struct pn_sock *pn = pn_sk(sk);
	struct sockaddr_pn try_sa;
	struct sock *tmpsk;

	memset(&try_sa, 0, sizeof(struct sockaddr_pn));
	try_sa.spn_family = AF_PHONET;
	WARN_ON(!mutex_is_locked(&port_mutex));
	if (!sport) {
		/* search free port */
		int port, pmin, pmax;

		phonet_get_local_port_range(&pmin, &pmax);
		for (port = pmin; port <= pmax; port++) {
			port_cur++;
			if (port_cur < pmin || port_cur > pmax)
				port_cur = pmin;

			pn_sockaddr_set_port(&try_sa, port_cur);
			tmpsk = pn_find_sock_by_sa(net, &try_sa);
			if (tmpsk == NULL) {
				sport = port_cur;
				goto found;
			} else
				sock_put(tmpsk);
		}
	} else {
		/* try to find specific port */
		pn_sockaddr_set_port(&try_sa, sport);
		tmpsk = pn_find_sock_by_sa(net, &try_sa);
		if (tmpsk == NULL)
			/* No sock there! We can use that port... */
			goto found;
		else
			sock_put(tmpsk);
	}
	/* the port must be in use already */
	return -EADDRINUSE;

found:
	pn->sobject = pn_object(pn_addr(pn->sobject), sport);
	return 0;
}
EXPORT_SYMBOL(pn_sock_get_port);

#ifdef CONFIG_PROC_FS
static struct sock *pn_sock_get_idx(struct seq_file *seq, loff_t pos)
{
	struct net *net = seq_file_net(seq);
	struct hlist_head *hlist = pnsocks.hlist;
	struct sock *sknode;
	unsigned int h;

	for (h = 0; h < PN_HASHSIZE; h++) {
		sk_for_each_rcu(sknode, hlist) {
			if (!net_eq(net, sock_net(sknode)))
				continue;
			if (!pos)
				return sknode;
			pos--;
		}
		hlist++;
	}
	return NULL;
}

static struct sock *pn_sock_get_next(struct seq_file *seq, struct sock *sk)
{
	struct net *net = seq_file_net(seq);

	do
		sk = sk_next(sk);
	while (sk && !net_eq(net, sock_net(sk)));

	return sk;
}

static void *pn_sock_seq_start(struct seq_file *seq, loff_t *pos)
	__acquires(rcu)
{
	rcu_read_lock();
	return *pos ? pn_sock_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
}

static void *pn_sock_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct sock *sk;

	if (v == SEQ_START_TOKEN)
		sk = pn_sock_get_idx(seq, 0);
	else
		sk = pn_sock_get_next(seq, v);
	(*pos)++;
	return sk;
}

static void pn_sock_seq_stop(struct seq_file *seq, void *v)
	__releases(rcu)
{
	rcu_read_unlock();
}

static int pn_sock_seq_show(struct seq_file *seq, void *v)
{
	seq_setwidth(seq, 127);
	if (v == SEQ_START_TOKEN)
		seq_puts(seq, "pt  loc  rem rs st tx_queue rx_queue "
			"  uid inode ref pointer drops");
	else {
		struct sock *sk = v;
		struct pn_sock *pn = pn_sk(sk);

		seq_printf(seq, "%2d %04X:%04X:%02X %02X %08X:%08X %5d %lu "
			"%d %pK %u",
			sk->sk_protocol, pn->sobject, pn->dobject,
			pn->resource, sk->sk_state,
			sk_wmem_alloc_get(sk), sk_rmem_alloc_get(sk),
			from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
			sock_i_ino(sk),
			refcount_read(&sk->sk_refcnt), sk,
			atomic_read(&sk->sk_drops));
	}
	seq_pad(seq, '\n');
	return 0;
}

const struct seq_operations pn_sock_seq_ops = {
	.start = pn_sock_seq_start,
	.next = pn_sock_seq_next,
	.stop = pn_sock_seq_stop,
	.show = pn_sock_seq_show,
};
#endif

static struct  {
	struct sock *sk[256];
} pnres;

/*
 * Find and hold socket based on resource.
 */
struct sock *pn_find_sock_by_res(struct net *net, u8 res)
{
	struct sock *sk;

	if (!net_eq(net, &init_net))
		return NULL;

	rcu_read_lock();
	sk = rcu_dereference(pnres.sk[res]);
	if (sk)
		sock_hold(sk);
	rcu_read_unlock();
	return sk;
}

static DEFINE_MUTEX(resource_mutex);

int pn_sock_bind_res(struct sock *sk, u8 res)
{
	int ret = -EADDRINUSE;

	if (!net_eq(sock_net(sk), &init_net))
		return -ENOIOCTLCMD;
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
	if (pn_socket_autobind(sk->sk_socket))
		return -EAGAIN;

	mutex_lock(&resource_mutex);
	if (pnres.sk[res] == NULL) {
		sock_hold(sk);
		rcu_assign_pointer(pnres.sk[res], sk);
		ret = 0;
	}
	mutex_unlock(&resource_mutex);
	return ret;
}

int pn_sock_unbind_res(struct sock *sk, u8 res)
{
	int ret = -ENOENT;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	mutex_lock(&resource_mutex);
	if (pnres.sk[res] == sk) {
		RCU_INIT_POINTER(pnres.sk[res], NULL);
		ret = 0;
	}
	mutex_unlock(&resource_mutex);

	if (ret == 0) {
		synchronize_rcu();
		sock_put(sk);
	}
	return ret;
}

void pn_sock_unbind_all_res(struct sock *sk)
{
	unsigned int res, match = 0;

	mutex_lock(&resource_mutex);
	for (res = 0; res < 256; res++) {
		if (pnres.sk[res] == sk) {
			RCU_INIT_POINTER(pnres.sk[res], NULL);
			match++;
		}
	}
	mutex_unlock(&resource_mutex);

	while (match > 0) {
		__sock_put(sk);
		match--;
	}
	/* Caller is responsible for RCU sync before final sock_put() */
}

#ifdef CONFIG_PROC_FS
static struct sock **pn_res_get_idx(struct seq_file *seq, loff_t pos)
{
	struct net *net = seq_file_net(seq);
	unsigned int i;

	if (!net_eq(net, &init_net))
		return NULL;

	for (i = 0; i < 256; i++) {
		if (pnres.sk[i] == NULL)
			continue;
		if (!pos)
			return pnres.sk + i;
		pos--;
	}
	return NULL;
}

static struct sock **pn_res_get_next(struct seq_file *seq, struct sock **sk)
{
	struct net *net = seq_file_net(seq);
	unsigned int i;

	BUG_ON(!net_eq(net, &init_net));

	for (i = (sk - pnres.sk) + 1; i < 256; i++)
		if (pnres.sk[i])
			return pnres.sk + i;
	return NULL;
}

static void *pn_res_seq_start(struct seq_file *seq, loff_t *pos)
	__acquires(resource_mutex)
{
	mutex_lock(&resource_mutex);
	return *pos ? pn_res_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
}

static void *pn_res_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct sock **sk;

	if (v == SEQ_START_TOKEN)
		sk = pn_res_get_idx(seq, 0);
	else
		sk = pn_res_get_next(seq, v);
	(*pos)++;
	return sk;
}

static void pn_res_seq_stop(struct seq_file *seq, void *v)
	__releases(resource_mutex)
{
	mutex_unlock(&resource_mutex);
}

static int pn_res_seq_show(struct seq_file *seq, void *v)
{
	seq_setwidth(seq, 63);
	if (v == SEQ_START_TOKEN)
		seq_puts(seq, "rs   uid inode");
	else {
		struct sock **psk = v;
		struct sock *sk = *psk;

		seq_printf(seq, "%02X %5u %lu",
			   (int) (psk - pnres.sk),
			   from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
			   sock_i_ino(sk));
	}
	seq_pad(seq, '\n');
	return 0;
}

const struct seq_operations pn_res_seq_ops = {
	.start = pn_res_seq_start,
	.next = pn_res_seq_next,
	.stop = pn_res_seq_stop,
	.show = pn_res_seq_show,
};
#endif
Commit	Line	Data
2b27bdcc	1	// SPDX-License-Identifier: GPL-2.0-only
ba113a94 RDC	2	/*
	3	* File: socket.c
	4	*
	5	* Phonet sockets
	6	*
	7	* Copyright (C) 2008 Nokia Corporation.
	8	*
31fdc555 RDC	9	* Authors: Sakari Ailus <sakari.ailus@nokia.com>
31fdc555 RDC	10	* Rémi Denis-Courmont
ba113a94 RDC	11	*/
ba113a94 RDC	12
5a0e3ad6	13	#include <linux/gfp.h>
ba113a94 RDC	14	#include <linux/kernel.h>
ba113a94 RDC	15	#include <linux/net.h>
9995a32b	16	#include <linux/poll.h>
174cd4b1 IM	17	#include <linux/sched/signal.h>
174cd4b1 IM	18
ba113a94 RDC	19	#include <net/sock.h>
	20	#include <net/tcp_states.h>
	21
	22	#include <linux/phonet.h>
bc3b2d7f	23	#include <linux/export.h>
ba113a94	24	#include <net/phonet/phonet.h>
9995a32b	25	#include <net/phonet/pep.h>
ba113a94 RDC	26	#include <net/phonet/pn_dev.h>
	27
	28	static int pn_socket_release(struct socket *sock)
	29	{
	30	struct sock *sk = sock->sk;
	31
	32	if (sk) {
	33	sock->sk = NULL;
	34	sk->sk_prot->close(sk, 0);
	35	}
	36	return 0;
	37	}
	38
6b0d07ba RDC	39	#define PN_HASHSIZE 16
	40	#define PN_HASHMASK (PN_HASHSIZE-1)
	41
	42
ba113a94	43	static struct {
6b0d07ba	44	struct hlist_head hlist[PN_HASHSIZE];
44f4d5a2	45	struct mutex lock;
6b0d07ba RDC	46	} pnsocks;
	47
	48	void __init pn_sock_init(void)
	49	{
95c96174	50	unsigned int i;
6b0d07ba RDC	51
	52	for (i = 0; i < PN_HASHSIZE; i++)
	53	INIT_HLIST_HEAD(pnsocks.hlist + i);
44f4d5a2	54	mutex_init(&pnsocks.lock);
6b0d07ba RDC	55	}
	56
	57	static struct hlist_head *pn_hash_list(u16 obj)
	58	{
	59	return pnsocks.hlist + (obj & PN_HASHMASK);
	60	}
ba113a94 RDC	61
	62	/*
	63	* Find address based on socket address, match only certain fields.
	64	* Also grab sock if it was found. Remember to sock_put it later.
	65	*/
52404881	66	struct sock pn_find_sock_by_sa(struct net net, const struct sockaddr_pn *spn)
ba113a94	67	{
ba113a94 RDC	68	struct sock *sknode;
	69	struct sock *rval = NULL;
	70	u16 obj = pn_sockaddr_get_object(spn);
	71	u8 res = spn->spn_resource;
6b0d07ba	72	struct hlist_head *hlist = pn_hash_list(obj);
ba113a94	73
44f4d5a2	74	rcu_read_lock();
b67bfe0d	75	sk_for_each_rcu(sknode, hlist) {
ba113a94 RDC	76	struct pn_sock *pn = pn_sk(sknode);
	77	BUG_ON(!pn->sobject); /* unbound socket */
	78
52404881 RDC	79	if (!net_eq(sock_net(sknode), net))
52404881 RDC	80	continue;
ba113a94 RDC	81	if (pn_port(obj)) {
	82	/* Look up socket by port */
	83	if (pn_port(pn->sobject) != pn_port(obj))
	84	continue;
	85	} else {
	86	/* If port is zero, look up by resource */
	87	if (pn->resource != res)
	88	continue;
	89	}
f64f9e71 JP	90	if (pn_addr(pn->sobject) &&
f64f9e71 JP	91	pn_addr(pn->sobject) != pn_addr(obj))
ba113a94 RDC	92	continue;
	93
	94	rval = sknode;
	95	sock_hold(sknode);
	96	break;
	97	}
44f4d5a2	98	rcu_read_unlock();
ba113a94 RDC	99
ba113a94 RDC	100	return rval;
f14001fc RDC	101	}
	102
	103	/* Deliver a broadcast packet (only in bottom-half) */
	104	void pn_deliver_sock_broadcast(struct net net, struct sk_buff skb)
	105	{
6b0d07ba	106	struct hlist_head *hlist = pnsocks.hlist;
95c96174	107	unsigned int h;
f14001fc	108
44f4d5a2	109	rcu_read_lock();
6b0d07ba	110	for (h = 0; h < PN_HASHSIZE; h++) {
6b0d07ba	111	struct sock *sknode;
f14001fc	112
b67bfe0d	113	sk_for_each(sknode, hlist) {
6b0d07ba	114	struct sk_buff *clone;
ba113a94	115
6b0d07ba RDC	116	if (!net_eq(sock_net(sknode), net))
	117	continue;
	118	if (!sock_flag(sknode, SOCK_BROADCAST))
	119	continue;
	120
	121	clone = skb_clone(skb, GFP_ATOMIC);
	122	if (clone) {
	123	sock_hold(sknode);
	124	sk_receive_skb(sknode, clone, 0);
	125	}
21912d1c	126	}
6b0d07ba	127	hlist++;
f14001fc	128	}
44f4d5a2	129	rcu_read_unlock();
ba113a94 RDC	130	}
ba113a94 RDC	131
086c653f	132	int pn_sock_hash(struct sock *sk)
ba113a94	133	{
6b0d07ba RDC	134	struct hlist_head *hlist = pn_hash_list(pn_sk(sk)->sobject);
6b0d07ba RDC	135
44f4d5a2 RDC	136	mutex_lock(&pnsocks.lock);
	137	sk_add_node_rcu(sk, hlist);
	138	mutex_unlock(&pnsocks.lock);
086c653f CG	139
086c653f CG	140	return 0;
ba113a94 RDC	141	}
	142	EXPORT_SYMBOL(pn_sock_hash);
	143
	144	void pn_sock_unhash(struct sock *sk)
	145	{
44f4d5a2 RDC	146	mutex_lock(&pnsocks.lock);
	147	sk_del_node_init_rcu(sk);
	148	mutex_unlock(&pnsocks.lock);
7417fa83	149	pn_sock_unbind_all_res(sk);
44f4d5a2	150	synchronize_rcu();
ba113a94 RDC	151	}
	152	EXPORT_SYMBOL(pn_sock_unhash);
	153
582b0b61 RDC	154	static DEFINE_MUTEX(port_mutex);
582b0b61 RDC	155
ba113a94 RDC	156	static int pn_socket_bind(struct socket sock, struct sockaddr addr, int len)
	157	{
	158	struct sock *sk = sock->sk;
	159	struct pn_sock *pn = pn_sk(sk);
	160	struct sockaddr_pn spn = (struct sockaddr_pn )addr;
	161	int err;
	162	u16 handle;
	163	u8 saddr;
	164
	165	if (sk->sk_prot->bind)
	166	return sk->sk_prot->bind(sk, addr, len);
	167
	168	if (len < sizeof(struct sockaddr_pn))
	169	return -EINVAL;
	170	if (spn->spn_family != AF_PHONET)
	171	return -EAFNOSUPPORT;
	172
	173	handle = pn_sockaddr_get_object((struct sockaddr_pn *)addr);
	174	saddr = pn_addr(handle);
52404881	175	if (saddr && phonet_address_lookup(sock_net(sk), saddr))
ba113a94 RDC	176	return -EADDRNOTAVAIL;
	177
	178	lock_sock(sk);
	179	if (sk->sk_state != TCP_CLOSE \|\| pn_port(pn->sobject)) {
	180	err = -EINVAL; /* attempt to rebind */
	181	goto out;
	182	}
582b0b61 RDC	183	WARN_ON(sk_hashed(sk));
582b0b61 RDC	184	mutex_lock(&port_mutex);
ba113a94 RDC	185	err = sk->sk_prot->get_port(sk, pn_port(handle));
ba113a94 RDC	186	if (err)
582b0b61	187	goto out_port;
ba113a94 RDC	188
	189	/* get_port() sets the port, bind() sets the address if applicable */
	190	pn->sobject = pn_object(saddr, pn_port(pn->sobject));
	191	pn->resource = spn->spn_resource;
	192
	193	/* Enable RX on the socket */
086c653f	194	err = sk->sk_prot->hash(sk);
582b0b61 RDC	195	out_port:
582b0b61 RDC	196	mutex_unlock(&port_mutex);
ba113a94 RDC	197	out:
	198	release_sock(sk);
	199	return err;
	200	}
	201
	202	static int pn_socket_autobind(struct socket *sock)
	203	{
	204	struct sockaddr_pn sa;
	205	int err;
	206
	207	memset(&sa, 0, sizeof(sa));
	208	sa.spn_family = AF_PHONET;
	209	err = pn_socket_bind(sock, (struct sockaddr *)&sa,
	210	sizeof(struct sockaddr_pn));
	211	if (err != -EINVAL)
	212	return err;
	213	BUG_ON(!pn_port(pn_sk(sock->sk)->sobject));
	214	return 0; /* socket was already bound */
	215	}
	216
b3d62553 KS	217	static int pn_socket_connect(struct socket sock, struct sockaddr addr,
	218	int len, int flags)
	219	{
	220	struct sock *sk = sock->sk;
297edb60	221	struct pn_sock *pn = pn_sk(sk);
b3d62553	222	struct sockaddr_pn spn = (struct sockaddr_pn )addr;
297edb60 RDC	223	struct task_struct *tsk = current;
297edb60 RDC	224	long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
b3d62553 KS	225	int err;
b3d62553 KS	226
297edb60 RDC	227	if (pn_socket_autobind(sock))
297edb60 RDC	228	return -ENOBUFS;
b3d62553 KS	229	if (len < sizeof(struct sockaddr_pn))
	230	return -EINVAL;
	231	if (spn->spn_family != AF_PHONET)
	232	return -EAFNOSUPPORT;
	233
	234	lock_sock(sk);
	235
	236	switch (sock->state) {
	237	case SS_UNCONNECTED:
297edb60	238	if (sk->sk_state != TCP_CLOSE) {
b3d62553 KS	239	err = -EISCONN;
b3d62553 KS	240	goto out;
b3d62553 KS	241	}
b3d62553 KS	242	break;
297edb60 RDC	243	case SS_CONNECTING:
	244	err = -EALREADY;
	245	goto out;
	246	default:
	247	err = -EISCONN;
	248	goto out;
b3d62553	249	}
b3d62553	250
297edb60 RDC	251	pn->dobject = pn_sockaddr_get_object(spn);
297edb60 RDC	252	pn->resource = pn_sockaddr_get_resource(spn);
b3d62553	253	sock->state = SS_CONNECTING;
297edb60	254
b3d62553	255	err = sk->sk_prot->connect(sk, addr, len);
297edb60	256	if (err) {
b3d62553	257	sock->state = SS_UNCONNECTED;
297edb60	258	pn->dobject = 0;
b3d62553 KS	259	goto out;
	260	}
	261
297edb60 RDC	262	while (sk->sk_state == TCP_SYN_SENT) {
297edb60 RDC	263	DEFINE_WAIT(wait);
b3d62553	264
297edb60 RDC	265	if (!timeo) {
	266	err = -EINPROGRESS;
	267	goto out;
	268	}
	269	if (signal_pending(tsk)) {
	270	err = sock_intr_errno(timeo);
	271	goto out;
	272	}
b3d62553	273
297edb60 RDC	274	prepare_to_wait_exclusive(sk_sleep(sk), &wait,
	275	TASK_INTERRUPTIBLE);
	276	release_sock(sk);
	277	timeo = schedule_timeout(timeo);
	278	lock_sock(sk);
	279	finish_wait(sk_sleep(sk), &wait);
b3d62553	280	}
b3d62553	281
297edb60 RDC	282	if ((1 << sk->sk_state) & (TCPF_SYN_RECV\|TCPF_ESTABLISHED))
	283	err = 0;
	284	else if (sk->sk_state == TCP_CLOSE_WAIT)
	285	err = -ECONNRESET;
	286	else
	287	err = -ECONNREFUSED;
	288	sock->state = err ? SS_UNCONNECTED : SS_CONNECTED;
b3d62553 KS	289	out:
	290	release_sock(sk);
	291	return err;
	292	}
b3d62553	293
9995a32b	294	static int pn_socket_accept(struct socket sock, struct socket newsock,
cdfbabfb	295	int flags, bool kern)
9995a32b RDC	296	{
	297	struct sock *sk = sock->sk;
	298	struct sock *newsk;
	299	int err;
	300
f7ae8d59 RDC	301	if (unlikely(sk->sk_state != TCP_LISTEN))
	302	return -EINVAL;
	303
cdfbabfb	304	newsk = sk->sk_prot->accept(sk, flags, &err, kern);
9995a32b RDC	305	if (!newsk)
	306	return err;
	307
	308	lock_sock(newsk);
	309	sock_graft(newsk, newsock);
	310	newsock->state = SS_CONNECTED;
	311	release_sock(newsk);
	312	return 0;
	313	}
	314
ba113a94	315	static int pn_socket_getname(struct socket sock, struct sockaddr addr,
9b2c45d4	316	int peer)
ba113a94 RDC	317	{
	318	struct sock *sk = sock->sk;
	319	struct pn_sock *pn = pn_sk(sk);
	320
	321	memset(addr, 0, sizeof(struct sockaddr_pn));
	322	addr->sa_family = AF_PHONET;
	323	if (!peer) /* Race with bind() here is userland's problem. */
	324	pn_sockaddr_set_object((struct sockaddr_pn *)addr,
	325	pn->sobject);
	326
9b2c45d4	327	return sizeof(struct sockaddr_pn);
ba113a94 RDC	328	}
ba113a94 RDC	329
a11e1d43 LT	330	static __poll_t pn_socket_poll(struct file file, struct socket sock,
a11e1d43 LT	331	poll_table *wait)
9995a32b RDC	332	{
	333	struct sock *sk = sock->sk;
	334	struct pep_sock *pn = pep_sk(sk);
ade994f4	335	__poll_t mask = 0;
9995a32b	336
a11e1d43 LT	337	poll_wait(file, sk_sleep(sk), wait);
a11e1d43 LT	338
f7ae8d59	339	if (sk->sk_state == TCP_CLOSE)
a9a08845	340	return EPOLLERR;
3ef7cf57	341	if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
a9a08845	342	mask \|= EPOLLIN \| EPOLLRDNORM;
3ef7cf57	343	if (!skb_queue_empty_lockless(&pn->ctrlreq_queue))
a9a08845	344	mask \|= EPOLLPRI;
c41bd97f	345	if (!mask && sk->sk_state == TCP_CLOSE_WAIT)
a9a08845	346	return EPOLLHUP;
9995a32b	347
01b38606	348	if (sk->sk_state == TCP_ESTABLISHED &&
14afee4b	349	refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf &&
01b38606	350	atomic_read(&pn->tx_credits))
a9a08845	351	mask \|= EPOLLOUT \| EPOLLWRNORM \| EPOLLWRBAND;
9995a32b RDC	352
	353	return mask;
	354	}
	355
ba113a94 RDC	356	static int pn_socket_ioctl(struct socket *sock, unsigned int cmd,
	357	unsigned long arg)
	358	{
	359	struct sock *sk = sock->sk;
	360	struct pn_sock *pn = pn_sk(sk);
	361
	362	if (cmd == SIOCPNGETOBJECT) {
	363	struct net_device *dev;
	364	u16 handle;
	365	u8 saddr;
	366
	367	if (get_user(handle, (__u16 __user *)arg))
	368	return -EFAULT;
	369
	370	lock_sock(sk);
	371	if (sk->sk_bound_dev_if)
	372	dev = dev_get_by_index(sock_net(sk),
	373	sk->sk_bound_dev_if);
	374	else
	375	dev = phonet_device_get(sock_net(sk));
	376	if (dev && (dev->flags & IFF_UP))
	377	saddr = phonet_address_get(dev, pn_addr(handle));
	378	else
	379	saddr = PN_NO_ADDR;
	380	release_sock(sk);
	381
	382	if (dev)
	383	dev_put(dev);
	384	if (saddr == PN_NO_ADDR)
	385	return -EHOSTUNREACH;
	386
	387	handle = pn_object(saddr, pn_port(pn->sobject));
	388	return put_user(handle, (__u16 __user *)arg);
	389	}
	390
	391	return sk->sk_prot->ioctl(sk, cmd, arg);
	392	}
	393
9995a32b RDC	394	static int pn_socket_listen(struct socket *sock, int backlog)
	395	{
	396	struct sock *sk = sock->sk;
	397	int err = 0;
	398
9995a32b RDC	399	if (pn_socket_autobind(sock))
	400	return -ENOBUFS;
	401
	402	lock_sock(sk);
96241544	403	if (sock->state != SS_UNCONNECTED) {
9995a32b RDC	404	err = -EINVAL;
	405	goto out;
	406	}
	407
96241544 RDC	408	if (sk->sk_state != TCP_LISTEN) {
	409	sk->sk_state = TCP_LISTEN;
	410	sk->sk_ack_backlog = 0;
	411	}
9995a32b RDC	412	sk->sk_max_ack_backlog = backlog;
	413	out:
	414	release_sock(sk);
	415	return err;
	416	}
	417
1b784140 YX	418	static int pn_socket_sendmsg(struct socket sock, struct msghdr m,
1b784140 YX	419	size_t total_len)
ba113a94 RDC	420	{
	421	struct sock *sk = sock->sk;
	422
	423	if (pn_socket_autobind(sock))
	424	return -EAGAIN;
	425
1b784140	426	return sk->sk_prot->sendmsg(sk, m, total_len);
ba113a94 RDC	427	}
	428
	429	const struct proto_ops phonet_dgram_ops = {
	430	.family = AF_PHONET,
	431	.owner = THIS_MODULE,
	432	.release = pn_socket_release,
	433	.bind = pn_socket_bind,
	434	.connect = sock_no_connect,
	435	.socketpair = sock_no_socketpair,
	436	.accept = sock_no_accept,
	437	.getname = pn_socket_getname,
a11e1d43	438	.poll = datagram_poll,
ba113a94 RDC	439	.ioctl = pn_socket_ioctl,
	440	.listen = sock_no_listen,
	441	.shutdown = sock_no_shutdown,
ba113a94 RDC	442	.sendmsg = pn_socket_sendmsg,
	443	.recvmsg = sock_common_recvmsg,
	444	.mmap = sock_no_mmap,
	445	.sendpage = sock_no_sendpage,
	446	};
	447
9995a32b RDC	448	const struct proto_ops phonet_stream_ops = {
	449	.family = AF_PHONET,
	450	.owner = THIS_MODULE,
	451	.release = pn_socket_release,
	452	.bind = pn_socket_bind,
b3d62553	453	.connect = pn_socket_connect,
9995a32b RDC	454	.socketpair = sock_no_socketpair,
	455	.accept = pn_socket_accept,
	456	.getname = pn_socket_getname,
a11e1d43	457	.poll = pn_socket_poll,
9995a32b RDC	458	.ioctl = pn_socket_ioctl,
	459	.listen = pn_socket_listen,
	460	.shutdown = sock_no_shutdown,
02a47617 RDC	461	.setsockopt = sock_common_setsockopt,
02a47617 RDC	462	.getsockopt = sock_common_getsockopt,
9995a32b RDC	463	.sendmsg = pn_socket_sendmsg,
	464	.recvmsg = sock_common_recvmsg,
	465	.mmap = sock_no_mmap,
	466	.sendpage = sock_no_sendpage,
	467	};
	468	EXPORT_SYMBOL(phonet_stream_ops);
	469
ba113a94 RDC	470	/* allocate port for a socket */
	471	int pn_sock_get_port(struct sock *sk, unsigned short sport)
	472	{
	473	static int port_cur;
52404881	474	struct net *net = sock_net(sk);
ba113a94 RDC	475	struct pn_sock *pn = pn_sk(sk);
	476	struct sockaddr_pn try_sa;
	477	struct sock *tmpsk;
	478
	479	memset(&try_sa, 0, sizeof(struct sockaddr_pn));
	480	try_sa.spn_family = AF_PHONET;
582b0b61	481	WARN_ON(!mutex_is_locked(&port_mutex));
ba113a94 RDC	482	if (!sport) {
ba113a94 RDC	483	/* search free port */
87ab4e20	484	int port, pmin, pmax;
ba113a94	485
87ab4e20	486	phonet_get_local_port_range(&pmin, &pmax);
ba113a94 RDC	487	for (port = pmin; port <= pmax; port++) {
	488	port_cur++;
	489	if (port_cur < pmin \|\| port_cur > pmax)
	490	port_cur = pmin;
	491
	492	pn_sockaddr_set_port(&try_sa, port_cur);
52404881	493	tmpsk = pn_find_sock_by_sa(net, &try_sa);
ba113a94 RDC	494	if (tmpsk == NULL) {
	495	sport = port_cur;
	496	goto found;
	497	} else
	498	sock_put(tmpsk);
	499	}
	500	} else {
	501	/* try to find specific port */
	502	pn_sockaddr_set_port(&try_sa, sport);
52404881	503	tmpsk = pn_find_sock_by_sa(net, &try_sa);
ba113a94 RDC	504	if (tmpsk == NULL)
	505	/* No sock there! We can use that port... */
	506	goto found;
	507	else
	508	sock_put(tmpsk);
	509	}
ba113a94 RDC	510	/* the port must be in use already */
	511	return -EADDRINUSE;
	512
	513	found:
ba113a94 RDC	514	pn->sobject = pn_object(pn_addr(pn->sobject), sport);
	515	return 0;
	516	}
	517	EXPORT_SYMBOL(pn_sock_get_port);
c1dc13e9	518
ae6e2aef	519	#ifdef CONFIG_PROC_FS
c1dc13e9 RDC	520	static struct sock pn_sock_get_idx(struct seq_file seq, loff_t pos)
	521	{
	522	struct net *net = seq_file_net(seq);
6b0d07ba	523	struct hlist_head *hlist = pnsocks.hlist;
c1dc13e9	524	struct sock *sknode;
95c96174	525	unsigned int h;
c1dc13e9	526
6b0d07ba	527	for (h = 0; h < PN_HASHSIZE; h++) {
b67bfe0d	528	sk_for_each_rcu(sknode, hlist) {
6b0d07ba RDC	529	if (!net_eq(net, sock_net(sknode)))
	530	continue;
	531	if (!pos)
	532	return sknode;
	533	pos--;
	534	}
	535	hlist++;
c1dc13e9 RDC	536	}
	537	return NULL;
	538	}
	539
	540	static struct sock pn_sock_get_next(struct seq_file seq, struct sock *sk)
	541	{
	542	struct net *net = seq_file_net(seq);
	543
	544	do
	545	sk = sk_next(sk);
	546	while (sk && !net_eq(net, sock_net(sk)));
	547
	548	return sk;
	549	}
	550
	551	static void pn_sock_seq_start(struct seq_file seq, loff_t *pos)
44f4d5a2	552	__acquires(rcu)
c1dc13e9	553	{
44f4d5a2	554	rcu_read_lock();
c1dc13e9 RDC	555	return pos ? pn_sock_get_idx(seq, pos - 1) : SEQ_START_TOKEN;
	556	}
	557
	558	static void pn_sock_seq_next(struct seq_file seq, void v, loff_t pos)
	559	{
	560	struct sock *sk;
	561
	562	if (v == SEQ_START_TOKEN)
	563	sk = pn_sock_get_idx(seq, 0);
	564	else
	565	sk = pn_sock_get_next(seq, v);
	566	(*pos)++;
	567	return sk;
	568	}
	569
	570	static void pn_sock_seq_stop(struct seq_file seq, void v)
44f4d5a2	571	__releases(rcu)
c1dc13e9	572	{
44f4d5a2	573	rcu_read_unlock();
c1dc13e9 RDC	574	}
	575
	576	static int pn_sock_seq_show(struct seq_file seq, void v)
	577	{
652586df	578	seq_setwidth(seq, 127);
c1dc13e9	579	if (v == SEQ_START_TOKEN)
652586df TH	580	seq_puts(seq, "pt loc rem rs st tx_queue rx_queue "
652586df TH	581	" uid inode ref pointer drops");
c1dc13e9 RDC	582	else {
	583	struct sock *sk = v;
	584	struct pn_sock *pn = pn_sk(sk);
	585
	586	seq_printf(seq, "%2d %04X:%04X:%02X %02X %08X:%08X %5d %lu "
ea9a0379	587	"%d %pK %u",
a8059512 RDC	588	sk->sk_protocol, pn->sobject, pn->dobject,
a8059512 RDC	589	pn->resource, sk->sk_state,
c1dc13e9	590	sk_wmem_alloc_get(sk), sk_rmem_alloc_get(sk),
a7cb5a49 EB	591	from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
a7cb5a49 EB	592	sock_i_ino(sk),
41c6d650	593	refcount_read(&sk->sk_refcnt), sk,
652586df	594	atomic_read(&sk->sk_drops));
c1dc13e9	595	}
652586df	596	seq_pad(seq, '\n');
c1dc13e9 RDC	597	return 0;
	598	}
	599
c3506372	600	const struct seq_operations pn_sock_seq_ops = {
c1dc13e9 RDC	601	.start = pn_sock_seq_start,
	602	.next = pn_sock_seq_next,
	603	.stop = pn_sock_seq_stop,
	604	.show = pn_sock_seq_show,
	605	};
ae6e2aef	606	#endif
4e3d16ce RDC	607
	608	static struct {
	609	struct sock *sk[256];
	610	} pnres;
	611
	612	/*
	613	* Find and hold socket based on resource.
	614	*/
	615	struct sock pn_find_sock_by_res(struct net net, u8 res)
	616	{
	617	struct sock *sk;
	618
	619	if (!net_eq(net, &init_net))
	620	return NULL;
	621
	622	rcu_read_lock();
	623	sk = rcu_dereference(pnres.sk[res]);
	624	if (sk)
	625	sock_hold(sk);
	626	rcu_read_unlock();
	627	return sk;
	628	}
	629
	630	static DEFINE_MUTEX(resource_mutex);
	631
	632	int pn_sock_bind_res(struct sock *sk, u8 res)
	633	{
	634	int ret = -EADDRINUSE;
	635
	636	if (!net_eq(sock_net(sk), &init_net))
	637	return -ENOIOCTLCMD;
	638	if (!capable(CAP_SYS_ADMIN))
	639	return -EPERM;
	640	if (pn_socket_autobind(sk->sk_socket))
	641	return -EAGAIN;
	642
	643	mutex_lock(&resource_mutex);
	644	if (pnres.sk[res] == NULL) {
	645	sock_hold(sk);
cf778b00	646	rcu_assign_pointer(pnres.sk[res], sk);
4e3d16ce RDC	647	ret = 0;
	648	}
	649	mutex_unlock(&resource_mutex);
	650	return ret;
	651	}
	652
	653	int pn_sock_unbind_res(struct sock *sk, u8 res)
	654	{
	655	int ret = -ENOENT;
	656
	657	if (!capable(CAP_SYS_ADMIN))
	658	return -EPERM;
	659
	660	mutex_lock(&resource_mutex);
	661	if (pnres.sk[res] == sk) {
a9b3cd7f	662	RCU_INIT_POINTER(pnres.sk[res], NULL);
4e3d16ce RDC	663	ret = 0;
	664	}
	665	mutex_unlock(&resource_mutex);
	666
	667	if (ret == 0) {
	668	synchronize_rcu();
	669	sock_put(sk);
	670	}
	671	return ret;
	672	}
	673
	674	void pn_sock_unbind_all_res(struct sock *sk)
	675	{
95c96174	676	unsigned int res, match = 0;
4e3d16ce RDC	677
	678	mutex_lock(&resource_mutex);
	679	for (res = 0; res < 256; res++) {
	680	if (pnres.sk[res] == sk) {
a9b3cd7f	681	RCU_INIT_POINTER(pnres.sk[res], NULL);
4e3d16ce RDC	682	match++;
	683	}
	684	}
	685	mutex_unlock(&resource_mutex);
	686
4e3d16ce	687	while (match > 0) {
44f4d5a2	688	__sock_put(sk);
4e3d16ce RDC	689	match--;
4e3d16ce RDC	690	}
44f4d5a2	691	/* Caller is responsible for RCU sync before final sock_put() */
4e3d16ce	692	}
507215f8 RDC	693
	694	#ifdef CONFIG_PROC_FS
	695	static struct sock *pn_res_get_idx(struct seq_file seq, loff_t pos)
	696	{
	697	struct net *net = seq_file_net(seq);
95c96174	698	unsigned int i;
507215f8 RDC	699
	700	if (!net_eq(net, &init_net))
	701	return NULL;
	702
	703	for (i = 0; i < 256; i++) {
	704	if (pnres.sk[i] == NULL)
	705	continue;
	706	if (!pos)
	707	return pnres.sk + i;
	708	pos--;
	709	}
	710	return NULL;
	711	}
	712
	713	static struct sock *pn_res_get_next(struct seq_file seq, struct sock **sk)
	714	{
	715	struct net *net = seq_file_net(seq);
95c96174	716	unsigned int i;
507215f8 RDC	717
	718	BUG_ON(!net_eq(net, &init_net));
	719
	720	for (i = (sk - pnres.sk) + 1; i < 256; i++)
	721	if (pnres.sk[i])
	722	return pnres.sk + i;
	723	return NULL;
	724	}
	725
	726	static void pn_res_seq_start(struct seq_file seq, loff_t *pos)
	727	__acquires(resource_mutex)
	728	{
	729	mutex_lock(&resource_mutex);
	730	return pos ? pn_res_get_idx(seq, pos - 1) : SEQ_START_TOKEN;
	731	}
	732
	733	static void pn_res_seq_next(struct seq_file seq, void v, loff_t pos)
	734	{
	735	struct sock **sk;
	736
	737	if (v == SEQ_START_TOKEN)
	738	sk = pn_res_get_idx(seq, 0);
	739	else
	740	sk = pn_res_get_next(seq, v);
	741	(*pos)++;
	742	return sk;
	743	}
	744
	745	static void pn_res_seq_stop(struct seq_file seq, void v)
	746	__releases(resource_mutex)
	747	{
	748	mutex_unlock(&resource_mutex);
	749	}
	750
	751	static int pn_res_seq_show(struct seq_file seq, void v)
	752	{
652586df	753	seq_setwidth(seq, 63);
507215f8	754	if (v == SEQ_START_TOKEN)
652586df	755	seq_puts(seq, "rs uid inode");
507215f8 RDC	756	else {
	757	struct sock **psk = v;
	758	struct sock sk = psk;
	759
652586df	760	seq_printf(seq, "%02X %5u %lu",
a7cb5a49 EB	761	(int) (psk - pnres.sk),
a7cb5a49 EB	762	from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
652586df	763	sock_i_ino(sk));
507215f8	764	}
652586df	765	seq_pad(seq, '\n');
507215f8 RDC	766	return 0;
	767	}
	768
c3506372	769	const struct seq_operations pn_res_seq_ops = {
507215f8 RDC	770	.start = pn_res_seq_start,
	771	.next = pn_res_seq_next,
	772	.stop = pn_res_seq_stop,
	773	.show = pn_res_seq_show,
	774	};
507215f8	775	#endif