socket.c

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