[linux-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);

		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
1160dfa1	382	dev_put(dev);
ba113a94 RDC	383	if (saddr == PN_NO_ADDR)
	384	return -EHOSTUNREACH;
	385
	386	handle = pn_object(saddr, pn_port(pn->sobject));
	387	return put_user(handle, (__u16 __user *)arg);
	388	}
	389
	390	return sk->sk_prot->ioctl(sk, cmd, arg);
	391	}
	392
9995a32b RDC	393	static int pn_socket_listen(struct socket *sock, int backlog)
	394	{
	395	struct sock *sk = sock->sk;
	396	int err = 0;
	397
9995a32b RDC	398	if (pn_socket_autobind(sock))
	399	return -ENOBUFS;
	400
	401	lock_sock(sk);
96241544	402	if (sock->state != SS_UNCONNECTED) {
9995a32b RDC	403	err = -EINVAL;
	404	goto out;
	405	}
	406
96241544 RDC	407	if (sk->sk_state != TCP_LISTEN) {
	408	sk->sk_state = TCP_LISTEN;
	409	sk->sk_ack_backlog = 0;
	410	}
9995a32b RDC	411	sk->sk_max_ack_backlog = backlog;
	412	out:
	413	release_sock(sk);
	414	return err;
	415	}
	416
1b784140 YX	417	static int pn_socket_sendmsg(struct socket sock, struct msghdr m,
1b784140 YX	418	size_t total_len)
ba113a94 RDC	419	{
	420	struct sock *sk = sock->sk;
	421
	422	if (pn_socket_autobind(sock))
	423	return -EAGAIN;
	424
1b784140	425	return sk->sk_prot->sendmsg(sk, m, total_len);
ba113a94 RDC	426	}
	427
	428	const struct proto_ops phonet_dgram_ops = {
	429	.family = AF_PHONET,
	430	.owner = THIS_MODULE,
	431	.release = pn_socket_release,
	432	.bind = pn_socket_bind,
	433	.connect = sock_no_connect,
	434	.socketpair = sock_no_socketpair,
	435	.accept = sock_no_accept,
	436	.getname = pn_socket_getname,
a11e1d43	437	.poll = datagram_poll,
ba113a94 RDC	438	.ioctl = pn_socket_ioctl,
	439	.listen = sock_no_listen,
	440	.shutdown = sock_no_shutdown,
ba113a94 RDC	441	.sendmsg = pn_socket_sendmsg,
	442	.recvmsg = sock_common_recvmsg,
	443	.mmap = sock_no_mmap,
	444	.sendpage = sock_no_sendpage,
	445	};
	446
9995a32b RDC	447	const struct proto_ops phonet_stream_ops = {
	448	.family = AF_PHONET,
	449	.owner = THIS_MODULE,
	450	.release = pn_socket_release,
	451	.bind = pn_socket_bind,
b3d62553	452	.connect = pn_socket_connect,
9995a32b RDC	453	.socketpair = sock_no_socketpair,
	454	.accept = pn_socket_accept,
	455	.getname = pn_socket_getname,
a11e1d43	456	.poll = pn_socket_poll,
9995a32b RDC	457	.ioctl = pn_socket_ioctl,
	458	.listen = pn_socket_listen,
	459	.shutdown = sock_no_shutdown,
02a47617 RDC	460	.setsockopt = sock_common_setsockopt,
02a47617 RDC	461	.getsockopt = sock_common_getsockopt,
9995a32b RDC	462	.sendmsg = pn_socket_sendmsg,
	463	.recvmsg = sock_common_recvmsg,
	464	.mmap = sock_no_mmap,
	465	.sendpage = sock_no_sendpage,
	466	};
	467	EXPORT_SYMBOL(phonet_stream_ops);
	468
ba113a94 RDC	469	/* allocate port for a socket */
	470	int pn_sock_get_port(struct sock *sk, unsigned short sport)
	471	{
	472	static int port_cur;
52404881	473	struct net *net = sock_net(sk);
ba113a94 RDC	474	struct pn_sock *pn = pn_sk(sk);
	475	struct sockaddr_pn try_sa;
	476	struct sock *tmpsk;
	477
	478	memset(&try_sa, 0, sizeof(struct sockaddr_pn));
	479	try_sa.spn_family = AF_PHONET;
582b0b61	480	WARN_ON(!mutex_is_locked(&port_mutex));
ba113a94 RDC	481	if (!sport) {
ba113a94 RDC	482	/* search free port */
87ab4e20	483	int port, pmin, pmax;
ba113a94	484
87ab4e20	485	phonet_get_local_port_range(&pmin, &pmax);
ba113a94 RDC	486	for (port = pmin; port <= pmax; port++) {
	487	port_cur++;
	488	if (port_cur < pmin \|\| port_cur > pmax)
	489	port_cur = pmin;
	490
	491	pn_sockaddr_set_port(&try_sa, port_cur);
52404881	492	tmpsk = pn_find_sock_by_sa(net, &try_sa);
ba113a94 RDC	493	if (tmpsk == NULL) {
	494	sport = port_cur;
	495	goto found;
	496	} else
	497	sock_put(tmpsk);
	498	}
	499	} else {
	500	/* try to find specific port */
	501	pn_sockaddr_set_port(&try_sa, sport);
52404881	502	tmpsk = pn_find_sock_by_sa(net, &try_sa);
ba113a94 RDC	503	if (tmpsk == NULL)
	504	/* No sock there! We can use that port... */
	505	goto found;
	506	else
	507	sock_put(tmpsk);
	508	}
ba113a94 RDC	509	/* the port must be in use already */
	510	return -EADDRINUSE;
	511
	512	found:
ba113a94 RDC	513	pn->sobject = pn_object(pn_addr(pn->sobject), sport);
	514	return 0;
	515	}
	516	EXPORT_SYMBOL(pn_sock_get_port);
c1dc13e9	517
ae6e2aef	518	#ifdef CONFIG_PROC_FS
c1dc13e9 RDC	519	static struct sock pn_sock_get_idx(struct seq_file seq, loff_t pos)
	520	{
	521	struct net *net = seq_file_net(seq);
6b0d07ba	522	struct hlist_head *hlist = pnsocks.hlist;
c1dc13e9	523	struct sock *sknode;
95c96174	524	unsigned int h;
c1dc13e9	525
6b0d07ba	526	for (h = 0; h < PN_HASHSIZE; h++) {
b67bfe0d	527	sk_for_each_rcu(sknode, hlist) {
6b0d07ba RDC	528	if (!net_eq(net, sock_net(sknode)))
	529	continue;
	530	if (!pos)
	531	return sknode;
	532	pos--;
	533	}
	534	hlist++;
c1dc13e9 RDC	535	}
	536	return NULL;
	537	}
	538
	539	static struct sock pn_sock_get_next(struct seq_file seq, struct sock *sk)
	540	{
	541	struct net *net = seq_file_net(seq);
	542
	543	do
	544	sk = sk_next(sk);
	545	while (sk && !net_eq(net, sock_net(sk)));
	546
	547	return sk;
	548	}
	549
	550	static void pn_sock_seq_start(struct seq_file seq, loff_t *pos)
44f4d5a2	551	__acquires(rcu)
c1dc13e9	552	{
44f4d5a2	553	rcu_read_lock();
c1dc13e9 RDC	554	return pos ? pn_sock_get_idx(seq, pos - 1) : SEQ_START_TOKEN;
	555	}
	556
	557	static void pn_sock_seq_next(struct seq_file seq, void v, loff_t pos)
	558	{
	559	struct sock *sk;
	560
	561	if (v == SEQ_START_TOKEN)
	562	sk = pn_sock_get_idx(seq, 0);
	563	else
	564	sk = pn_sock_get_next(seq, v);
	565	(*pos)++;
	566	return sk;
	567	}
	568
	569	static void pn_sock_seq_stop(struct seq_file seq, void v)
44f4d5a2	570	__releases(rcu)
c1dc13e9	571	{
44f4d5a2	572	rcu_read_unlock();
c1dc13e9 RDC	573	}
	574
	575	static int pn_sock_seq_show(struct seq_file seq, void v)
	576	{
652586df	577	seq_setwidth(seq, 127);
c1dc13e9	578	if (v == SEQ_START_TOKEN)
652586df TH	579	seq_puts(seq, "pt loc rem rs st tx_queue rx_queue "
652586df TH	580	" uid inode ref pointer drops");
c1dc13e9 RDC	581	else {
	582	struct sock *sk = v;
	583	struct pn_sock *pn = pn_sk(sk);
	584
	585	seq_printf(seq, "%2d %04X:%04X:%02X %02X %08X:%08X %5d %lu "
ea9a0379	586	"%d %pK %u",
a8059512 RDC	587	sk->sk_protocol, pn->sobject, pn->dobject,
a8059512 RDC	588	pn->resource, sk->sk_state,
c1dc13e9	589	sk_wmem_alloc_get(sk), sk_rmem_alloc_get(sk),
a7cb5a49 EB	590	from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
a7cb5a49 EB	591	sock_i_ino(sk),
41c6d650	592	refcount_read(&sk->sk_refcnt), sk,
652586df	593	atomic_read(&sk->sk_drops));
c1dc13e9	594	}
652586df	595	seq_pad(seq, '\n');
c1dc13e9 RDC	596	return 0;
	597	}
	598
c3506372	599	const struct seq_operations pn_sock_seq_ops = {
c1dc13e9 RDC	600	.start = pn_sock_seq_start,
	601	.next = pn_sock_seq_next,
	602	.stop = pn_sock_seq_stop,
	603	.show = pn_sock_seq_show,
	604	};
ae6e2aef	605	#endif
4e3d16ce RDC	606
	607	static struct {
	608	struct sock *sk[256];
	609	} pnres;
	610
	611	/*
	612	* Find and hold socket based on resource.
	613	*/
	614	struct sock pn_find_sock_by_res(struct net net, u8 res)
	615	{
	616	struct sock *sk;
	617
	618	if (!net_eq(net, &init_net))
	619	return NULL;
	620
	621	rcu_read_lock();
	622	sk = rcu_dereference(pnres.sk[res]);
	623	if (sk)
	624	sock_hold(sk);
	625	rcu_read_unlock();
	626	return sk;
	627	}
	628
	629	static DEFINE_MUTEX(resource_mutex);
	630
	631	int pn_sock_bind_res(struct sock *sk, u8 res)
	632	{
	633	int ret = -EADDRINUSE;
	634
	635	if (!net_eq(sock_net(sk), &init_net))
	636	return -ENOIOCTLCMD;
	637	if (!capable(CAP_SYS_ADMIN))
	638	return -EPERM;
	639	if (pn_socket_autobind(sk->sk_socket))
	640	return -EAGAIN;
	641
	642	mutex_lock(&resource_mutex);
	643	if (pnres.sk[res] == NULL) {
	644	sock_hold(sk);
cf778b00	645	rcu_assign_pointer(pnres.sk[res], sk);
4e3d16ce RDC	646	ret = 0;
	647	}
	648	mutex_unlock(&resource_mutex);
	649	return ret;
	650	}
	651
	652	int pn_sock_unbind_res(struct sock *sk, u8 res)
	653	{
	654	int ret = -ENOENT;
	655
	656	if (!capable(CAP_SYS_ADMIN))
	657	return -EPERM;
	658
	659	mutex_lock(&resource_mutex);
	660	if (pnres.sk[res] == sk) {
a9b3cd7f	661	RCU_INIT_POINTER(pnres.sk[res], NULL);
4e3d16ce RDC	662	ret = 0;
	663	}
	664	mutex_unlock(&resource_mutex);
	665
	666	if (ret == 0) {
	667	synchronize_rcu();
	668	sock_put(sk);
	669	}
	670	return ret;
	671	}
	672
	673	void pn_sock_unbind_all_res(struct sock *sk)
	674	{
95c96174	675	unsigned int res, match = 0;
4e3d16ce RDC	676
	677	mutex_lock(&resource_mutex);
	678	for (res = 0; res < 256; res++) {
	679	if (pnres.sk[res] == sk) {
a9b3cd7f	680	RCU_INIT_POINTER(pnres.sk[res], NULL);
4e3d16ce RDC	681	match++;
	682	}
	683	}
	684	mutex_unlock(&resource_mutex);
	685
4e3d16ce	686	while (match > 0) {
44f4d5a2	687	__sock_put(sk);
4e3d16ce RDC	688	match--;
4e3d16ce RDC	689	}
44f4d5a2	690	/* Caller is responsible for RCU sync before final sock_put() */
4e3d16ce	691	}
507215f8 RDC	692
	693	#ifdef CONFIG_PROC_FS
	694	static struct sock *pn_res_get_idx(struct seq_file seq, loff_t pos)
	695	{
	696	struct net *net = seq_file_net(seq);
95c96174	697	unsigned int i;
507215f8 RDC	698
	699	if (!net_eq(net, &init_net))
	700	return NULL;
	701
	702	for (i = 0; i < 256; i++) {
	703	if (pnres.sk[i] == NULL)
	704	continue;
	705	if (!pos)
	706	return pnres.sk + i;
	707	pos--;
	708	}
	709	return NULL;
	710	}
	711
	712	static struct sock *pn_res_get_next(struct seq_file seq, struct sock **sk)
	713	{
	714	struct net *net = seq_file_net(seq);
95c96174	715	unsigned int i;
507215f8 RDC	716
	717	BUG_ON(!net_eq(net, &init_net));
	718
	719	for (i = (sk - pnres.sk) + 1; i < 256; i++)
	720	if (pnres.sk[i])
	721	return pnres.sk + i;
	722	return NULL;
	723	}
	724
	725	static void pn_res_seq_start(struct seq_file seq, loff_t *pos)
	726	__acquires(resource_mutex)
	727	{
	728	mutex_lock(&resource_mutex);
	729	return pos ? pn_res_get_idx(seq, pos - 1) : SEQ_START_TOKEN;
	730	}
	731
	732	static void pn_res_seq_next(struct seq_file seq, void v, loff_t pos)
	733	{
	734	struct sock **sk;
	735
	736	if (v == SEQ_START_TOKEN)
	737	sk = pn_res_get_idx(seq, 0);
	738	else
	739	sk = pn_res_get_next(seq, v);
	740	(*pos)++;
	741	return sk;
	742	}
	743
	744	static void pn_res_seq_stop(struct seq_file seq, void v)
	745	__releases(resource_mutex)
	746	{
	747	mutex_unlock(&resource_mutex);
	748	}
	749
	750	static int pn_res_seq_show(struct seq_file seq, void v)
	751	{
652586df	752	seq_setwidth(seq, 63);
507215f8	753	if (v == SEQ_START_TOKEN)
652586df	754	seq_puts(seq, "rs uid inode");
507215f8 RDC	755	else {
	756	struct sock **psk = v;
	757	struct sock sk = psk;
	758
652586df	759	seq_printf(seq, "%02X %5u %lu",
a7cb5a49 EB	760	(int) (psk - pnres.sk),
a7cb5a49 EB	761	from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
652586df	762	sock_i_ino(sk));
507215f8	763	}
652586df	764	seq_pad(seq, '\n');
507215f8 RDC	765	return 0;
	766	}
	767
c3506372	768	const struct seq_operations pn_res_seq_ops = {
507215f8 RDC	769	.start = pn_res_seq_start,
	770	.next = pn_res_seq_next,
	771	.stop = pn_res_seq_stop,
	772	.show = pn_res_seq_show,
	773	};
507215f8	774	#endif