Release 4.10 fs/ncpfs/sock.c

Directory: fs/ncpfs
/*
 *  linux/fs/ncpfs/sock.c
 *
 *  Copyright (C) 1992, 1993  Rick Sladkey
 *
 *  Modified 1995, 1996 by Volker Lendecke to be usable for ncp
 *  Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
 *
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/time.h>
#include <linux/errno.h>
#include <linux/socket.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/uaccess.h>
#include <linux/in.h>
#include <linux/net.h>
#include <linux/mm.h>
#include <linux/netdevice.h>
#include <linux/signal.h>
#include <linux/slab.h>
#include <net/scm.h>
#include <net/sock.h>
#include <linux/ipx.h>
#include <linux/poll.h>
#include <linux/file.h>

#include "ncp_fs.h"

#include "ncpsign_kernel.h"



static int _recv(struct socket *sock, void *buf, int size, unsigned flags)
{
	struct msghdr msg = {NULL, };
	struct kvec iov = {buf, size};
	return kernel_recvmsg(sock, &msg, &iov, 1, size, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 30 52.63% 1 33.33%
pre-git pre-git 27 47.37% 2 66.67%
Total 57 100.00% 3 100.00%



static inline int do_send(struct socket *sock, struct kvec *vec, int count,
			  int len, unsigned flags)
{
	struct msghdr msg = { .msg_flags = flags };
	return kernel_sendmsg(sock, &msg, vec, count, len);
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 38 73.08% 1 50.00%
pre-git pre-git 14 26.92% 1 50.00%
Total 52 100.00% 2 100.00%



static int _send(struct socket *sock, const void *buff, int len)
{
	struct kvec vec;
	vec.iov_base = (void *) buff;
	vec.iov_len = len;
	return do_send(sock, &vec, 1, len, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 44 81.48% 3 75.00%
al viro al viro 10 18.52% 1 25.00%
Total 54 100.00% 4 100.00%


struct ncp_request_reply {
	
struct list_head req;
	
wait_queue_head_t wq;
	
atomic_t refs;
	
unsigned char* reply_buf;
	
size_t datalen;
	
int result;
	





enum { RQ_DONE, RQ_INPROGRESS, RQ_QUEUED, RQ_IDLE, RQ_ABANDONED } status;
	
struct kvec* tx_ciov;
	
size_t tx_totallen;
	
size_t tx_iovlen;
	
struct kvec tx_iov[3];
	
u_int16_t tx_type;
	
u_int32_t sign[6];
};



static inline struct ncp_request_reply* ncp_alloc_req(void)
{
	struct ncp_request_reply *req;

	req = kmalloc(sizeof(struct ncp_request_reply), GFP_KERNEL);
	if (!req)
		return NULL;

	init_waitqueue_head(&req->wq);
	atomic_set(&req->refs, (1));
	req->status = RQ_IDLE;

	return req;
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 66 100.00% 1 100.00%
Total 66 100.00% 1 100.00%



static void ncp_req_get(struct ncp_request_reply *req)
{
	atomic_inc(&req->refs);
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static void ncp_req_put(struct ncp_request_reply *req)
{
	if (atomic_dec_and_test(&req->refs))
		kfree(req);
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



void ncp_tcp_data_ready(struct sock *sk)
{
	struct ncp_server *server = sk->sk_user_data;

	server->data_ready(sk);
	schedule_work(&server->rcv.tq);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 21 58.33% 1 20.00%
pre-git pre-git 11 30.56% 1 20.00%
al viro al viro 2 5.56% 1 20.00%
ingo molnar ingo molnar 1 2.78% 1 20.00%
arnaldo carvalho de melo arnaldo carvalho de melo 1 2.78% 1 20.00%
Total 36 100.00% 5 100.00%



void ncp_tcp_error_report(struct sock *sk)
{
	struct ncp_server *server = sk->sk_user_data;
	
	server->error_report(sk);
	schedule_work(&server->rcv.tq);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 25 69.44% 1 25.00%
pre-git pre-git 9 25.00% 1 25.00%
ingo molnar ingo molnar 1 2.78% 1 25.00%
arnaldo carvalho de melo arnaldo carvalho de melo 1 2.78% 1 25.00%
Total 36 100.00% 4 100.00%



void ncp_tcp_write_space(struct sock *sk)
{
	struct ncp_server *server = sk->sk_user_data;
	
	/* We do not need any locking: we first set tx.creq, and then we do sendmsg,
           not vice versa... */
	server->write_space(sk);
	if (server->tx.creq)
		schedule_work(&server->tx.tq);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 33 73.33% 1 25.00%
pre-git pre-git 10 22.22% 1 25.00%
ingo molnar ingo molnar 1 2.22% 1 25.00%
arnaldo carvalho de melo arnaldo carvalho de melo 1 2.22% 1 25.00%
Total 45 100.00% 4 100.00%



void ncpdgram_timeout_call(unsigned long v)
{
	struct ncp_server *server = (void*)v;
	
	schedule_work(&server->timeout_tq);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 23 82.14% 1 20.00%
pre-git pre-git 4 14.29% 3 60.00%
ingo molnar ingo molnar 1 3.57% 1 20.00%
Total 28 100.00% 5 100.00%



static inline void ncp_finish_request(struct ncp_server *server, struct ncp_request_reply *req, int result)
{
	req->result = result;
	if (req->status != RQ_ABANDONED)
		memcpy(req->reply_buf, server->rxbuf, req->datalen);
	req->status = RQ_DONE;
	wake_up_all(&req->wq);
	ncp_req_put(req);
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 33 48.53% 1 25.00%
petr vandrovec* petr vandrovec* 30 44.12% 1 25.00%
pre-git pre-git 5 7.35% 2 50.00%
Total 68 100.00% 4 100.00%



static void __abort_ncp_connection(struct ncp_server *server)
{
	struct ncp_request_reply *req;

	ncp_invalidate_conn(server);
	del_timer(&server->timeout_tm);
	while (!list_empty(&server->tx.requests)) {
		req = list_entry(server->tx.requests.next, struct ncp_request_reply, req);
		
		list_del_init(&req->req);
		ncp_finish_request(server, req, -EIO);
	}
	req = server->rcv.creq;
	if (req) {
		server->rcv.creq = NULL;
		ncp_finish_request(server, req, -EIO);
		server->rcv.ptr = NULL;
		server->rcv.state = 0;
	}
	req = server->tx.creq;
	if (req) {
		server->tx.creq = NULL;
		ncp_finish_request(server, req, -EIO);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 113 70.62% 1 11.11%
pre-git pre-git 44 27.50% 7 77.78%
pierre ossman pierre ossman 3 1.88% 1 11.11%
Total 160 100.00% 9 100.00%



static inline int get_conn_number(struct ncp_reply_header *rp)
{
	return rp->conn_low | (rp->conn_high << 8);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 22 88.00% 1 50.00%
pre-git pre-git 3 12.00% 1 50.00%
Total 25 100.00% 2 100.00%



static inline void __ncp_abort_request(struct ncp_server *server, struct ncp_request_reply *req, int err)
{
	/* If req is done, we got signal, but we also received answer... */
	switch (req->status) {
		case RQ_IDLE:
		case RQ_DONE:
			break;
		case RQ_QUEUED:
			list_del_init(&req->req);
			ncp_finish_request(server, req, err);
			break;
		case RQ_INPROGRESS:
			req->status = RQ_ABANDONED;
			break;
		case RQ_ABANDONED:
			break;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 48 67.61% 1 33.33%
pre-git pre-git 13 18.31% 1 33.33%
pierre ossman pierre ossman 10 14.08% 1 33.33%
Total 71 100.00% 3 100.00%



static inline void ncp_abort_request(struct ncp_server *server, struct ncp_request_reply *req, int err)
{
	mutex_lock(&server->rcv.creq_mutex);
	__ncp_abort_request(server, req, err);
	mutex_unlock(&server->rcv.creq_mutex);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 36 73.47% 1 33.33%
pre-git pre-git 9 18.37% 1 33.33%
ingo molnar ingo molnar 4 8.16% 1 33.33%
Total 49 100.00% 3 100.00%



static inline void __ncptcp_abort(struct ncp_server *server)
{
	__abort_ncp_connection(server);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 15 88.24% 1 50.00%
pre-git pre-git 2 11.76% 1 50.00%
Total 17 100.00% 2 100.00%



static int ncpdgram_send(struct socket *sock, struct ncp_request_reply *req)
{
	struct kvec vec[3];
	/* sock_sendmsg updates iov pointers for us :-( */
	memcpy(vec, req->tx_ciov, req->tx_iovlen * sizeof(vec[0]));
	return do_send(sock, vec, req->tx_iovlen,
		       req->tx_totallen, MSG_DONTWAIT);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 48 76.19% 2 50.00%
al viro al viro 12 19.05% 1 25.00%
pre-git pre-git 3 4.76% 1 25.00%
Total 63 100.00% 4 100.00%



static void __ncptcp_try_send(struct ncp_server *server)
{
	struct ncp_request_reply *rq;
	struct kvec *iov;
	struct kvec iovc[3];
	int result;

	rq = server->tx.creq;
	if (!rq)
		return;

	/* sock_sendmsg updates iov pointers for us :-( */
	memcpy(iovc, rq->tx_ciov, rq->tx_iovlen * sizeof(iov[0]));
	result = do_send(server->ncp_sock, iovc, rq->tx_iovlen,
			 rq->tx_totallen, MSG_NOSIGNAL | MSG_DONTWAIT);

	if (result == -EAGAIN)
		return;

	if (result < 0) {
		pr_err("tcp: Send failed: %d\n", result);
		__ncp_abort_request(server, rq, result);
		return;
	}
	if (result >= rq->tx_totallen) {
		server->rcv.creq = rq;
		server->tx.creq = NULL;
		return;
	}
	rq->tx_totallen -= result;
	iov = rq->tx_ciov;
	while (iov->iov_len <= result) {
		result -= iov->iov_len;
		iov++;
		rq->tx_iovlen--;
	}
	iov->iov_base += result;
	iov->iov_len -= result;
	rq->tx_ciov = iov;
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 158 77.45% 2 40.00%
pre-git pre-git 32 15.69% 1 20.00%
al viro al viro 12 5.88% 1 20.00%
joe perches joe perches 2 0.98% 1 20.00%
Total 204 100.00% 5 100.00%



static inline void ncp_init_header(struct ncp_server *server, struct ncp_request_reply *req, struct ncp_request_header *h)
{
	req->status = RQ_INPROGRESS;
	h->conn_low = server->connection;
	h->conn_high = server->connection >> 8;
	h->sequence = ++server->sequence;
}
	
Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 33 60.00% 1 25.00%
pre-git pre-git 22 40.00% 3 75.00%
Total 55 100.00% 4 100.00%



static void ncpdgram_start_request(struct ncp_server *server, struct ncp_request_reply *req)
{
	size_t signlen;
	struct ncp_request_header* h;
	
	req->tx_ciov = req->tx_iov + 1;

	h = req->tx_iov[1].iov_base;
	ncp_init_header(server, req, h);
	signlen = sign_packet(server, req->tx_iov[1].iov_base + sizeof(struct ncp_request_header) - 1, 
			req->tx_iov[1].iov_len - sizeof(struct ncp_request_header) + 1,
			cpu_to_le32(req->tx_totallen), req->sign);
	if (signlen) {
		req->tx_ciov[1].iov_base = req->sign;
		req->tx_ciov[1].iov_len = signlen;
		req->tx_iovlen += 1;
		req->tx_totallen += signlen;
	}
	server->rcv.creq = req;
	server->timeout_last = server->m.time_out;
	server->timeout_retries = server->m.retry_count;
	ncpdgram_send(server->ncp_sock, req);
	mod_timer(&server->timeout_tm, jiffies + server->m.time_out);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 164 81.59% 1 50.00%
pre-git pre-git 37 18.41% 1 50.00%
Total 201 100.00% 2 100.00%


#define NCP_TCP_XMIT_MAGIC	(0x446D6454)

#define NCP_TCP_XMIT_VERSION	(1)

#define NCP_TCP_RCVD_MAGIC	(0x744E6350)



static void ncptcp_start_request(struct ncp_server *server, struct ncp_request_reply *req)
{
	size_t signlen;
	struct ncp_request_header* h;

	req->tx_ciov = req->tx_iov;
	h = req->tx_iov[1].iov_base;
	ncp_init_header(server, req, h);
	signlen = sign_packet(server, req->tx_iov[1].iov_base + sizeof(struct ncp_request_header) - 1,
			req->tx_iov[1].iov_len - sizeof(struct ncp_request_header) + 1,
			cpu_to_be32(req->tx_totallen + 24), req->sign + 4) + 16;

	req->sign[0] = htonl(NCP_TCP_XMIT_MAGIC);
	req->sign[1] = htonl(req->tx_totallen + signlen);
	req->sign[2] = htonl(NCP_TCP_XMIT_VERSION);
	req->sign[3] = htonl(req->datalen + 8);
	req->tx_iov[0].iov_base = req->sign;
	req->tx_iov[0].iov_len = signlen;
	req->tx_iovlen += 1;
	req->tx_totallen += signlen;

	server->tx.creq = req;
	__ncptcp_try_send(server);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 129 60.00% 1 33.33%
pre-git pre-git 84 39.07% 1 33.33%
al viro al viro 2 0.93% 1 33.33%
Total 215 100.00% 3 100.00%



static inline void __ncp_start_request(struct ncp_server *server, struct ncp_request_reply *req)
{
	/* we copy the data so that we do not depend on the caller
           staying alive */
	memcpy(server->txbuf, req->tx_iov[1].iov_base, req->tx_iov[1].iov_len);
	req->tx_iov[1].iov_base = server->txbuf;

	if (server->ncp_sock->type == SOCK_STREAM)
		ncptcp_start_request(server, req);
	else
		ncpdgram_start_request(server, req);
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 39 48.15% 1 33.33%
petr vandrovec* petr vandrovec* 29 35.80% 1 33.33%
pre-git pre-git 13 16.05% 1 33.33%
Total 81 100.00% 3 100.00%



static int ncp_add_request(struct ncp_server *server, struct ncp_request_reply *req)
{
	mutex_lock(&server->rcv.creq_mutex);
	if (!ncp_conn_valid(server)) {
		mutex_unlock(&server->rcv.creq_mutex);
		pr_err("tcp: Server died\n");
		return -EIO;
	}
	ncp_req_get(req);
	if (server->tx.creq || server->rcv.creq) {
		req->status = RQ_QUEUED;
		list_add_tail(&req->req, &server->tx.requests);
		mutex_unlock(&server->rcv.creq_mutex);
		return 0;
	}
	__ncp_start_request(server, req);
	mutex_unlock(&server->rcv.creq_mutex);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 74 56.92% 1 20.00%
pre-git pre-git 41 31.54% 1 20.00%
ingo molnar ingo molnar 8 6.15% 1 20.00%
pierre ossman pierre ossman 5 3.85% 1 20.00%
joe perches joe perches 2 1.54% 1 20.00%
Total 130 100.00% 5 100.00%



static void __ncp_next_request(struct ncp_server *server)
{
	struct ncp_request_reply *req;

	server->rcv.creq = NULL;
	if (list_empty(&server->tx.requests)) {
		return;
	}
	req = list_entry(server->tx.requests.next, struct ncp_request_reply, req);
	list_del_init(&req->req);
	__ncp_start_request(server, req);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 64 88.89% 1 50.00%
pre-git pre-git 8 11.11% 1 50.00%
Total 72 100.00% 2 100.00%



static void info_server(struct ncp_server *server, unsigned int id, const void * data, size_t len)
{
	if (server->info_sock) {
		struct kvec iov[2];
		__be32 hdr[2];
	
		hdr[0] = cpu_to_be32(len + 8);
		hdr[1] = cpu_to_be32(id);
	
		iov[0].iov_base = hdr;
		iov[0].iov_len = 8;
		iov[1].iov_base = (void *) data;
		iov[1].iov_len = len;

		do_send(server->info_sock, iov, 2, len + 8, MSG_NOSIGNAL);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 115 93.50% 1 33.33%
al viro al viro 8 6.50% 2 66.67%
Total 123 100.00% 3 100.00%



void ncpdgram_rcv_proc(struct work_struct *work)
{
	struct ncp_server *server =
		container_of(work, struct ncp_server, rcv.tq);
	struct socket* sock;
	
	sock = server->ncp_sock;
	
	while (1) {
		struct ncp_reply_header reply;
		int result;

		result = _recv(sock, &reply, sizeof(reply), MSG_PEEK | MSG_DONTWAIT);
		if (result < 0) {
			break;
		}
		if (result >= sizeof(reply)) {
			struct ncp_request_reply *req;
	
			if (reply.type == NCP_WATCHDOG) {
				unsigned char buf[10];

				if (server->connection != get_conn_number(&reply)) {
					goto drop;
				}
				result = _recv(sock, buf, sizeof(buf), MSG_DONTWAIT);
				if (result < 0) {
					ncp_dbg(1, "recv failed with %d\n", result);
					continue;
				}
				if (result < 10) {
					ncp_dbg(1, "too short (%u) watchdog packet\n", result);
					continue;
				}
				if (buf[9] != '?') {
					ncp_dbg(1, "bad signature (%02X) in watchdog packet\n", buf[9]);
					continue;
				}
				buf[9] = 'Y';
				_send(sock, buf, sizeof(buf));
				continue;
			}
			if (reply.type != NCP_POSITIVE_ACK && reply.type != NCP_REPLY) {
				result = _recv(sock, server->unexpected_packet.data, sizeof(server->unexpected_packet.data), MSG_DONTWAIT);
				if (result < 0) {
					continue;
				}
				info_server(server, 0, server->unexpected_packet.data, result);
				continue;
			}
			mutex_lock(&server->rcv.creq_mutex);
			req = server->rcv.creq;
			if (req && (req->tx_type == NCP_ALLOC_SLOT_REQUEST || (server->sequence == reply.sequence && 
					server->connection == get_conn_number(&reply)))) {
				if (reply.type == NCP_POSITIVE_ACK) {
					server->timeout_retries = server->m.retry_count;
					server->timeout_last = NCP_MAX_RPC_TIMEOUT;
					mod_timer(&server->timeout_tm, jiffies + NCP_MAX_RPC_TIMEOUT);
				} else if (reply.type == NCP_REPLY) {
					result = _recv(sock, server->rxbuf, req->datalen, MSG_DONTWAIT);
#ifdef CONFIG_NCPFS_PACKET_SIGNING
					if (result >= 0 && server->sign_active && req->tx_type != NCP_DEALLOC_SLOT_REQUEST) {
						if (result < 8 + 8) {
							result = -EIO;
						} else {
							unsigned int hdrl;
							
							result -= 8;
							hdrl = sock->sk->sk_family == AF_INET ? 8 : 6;
							if (sign_verify_reply(server, server->rxbuf + hdrl, result - hdrl, cpu_to_le32(result), server->rxbuf + result)) {
								pr_info("Signature violation\n");
								result = -EIO;
							}
						}
					}
#endif
					del_timer(&server->timeout_tm);
				     	server->rcv.creq = NULL;
					ncp_finish_request(server, req, result);
					__ncp_next_request(server);
					mutex_unlock(&server->rcv.creq_mutex);
					continue;
				}
			}
			mutex_unlock(&server->rcv.creq_mutex);
		}
drop:;		
		_recv(sock, &reply, sizeof(reply), MSG_DONTWAIT);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 534 92.07% 3 27.27%
david howells david howells 14 2.41% 1 9.09%
joe perches joe perches 11 1.90% 2 18.18%
pierre ossman pierre ossman 8 1.38% 1 9.09%
ingo molnar ingo molnar 6 1.03% 1 9.09%
pre-git pre-git 5 0.86% 1 9.09%
al viro al viro 1 0.17% 1 9.09%
arnaldo carvalho de melo arnaldo carvalho de melo 1 0.17% 1 9.09%
Total 580 100.00% 11 100.00%



static void __ncpdgram_timeout_proc(struct ncp_server *server)
{
	/* If timer is pending, we are processing another request... */
	if (!timer_pending(&server->timeout_tm)) {
		struct ncp_request_reply* req;
		
		req = server->rcv.creq;
		if (req) {
			int timeout;
			
			if (server->m.flags & NCP_MOUNT_SOFT) {
				if (server->timeout_retries-- == 0) {
					__ncp_abort_request(server, req, -ETIMEDOUT);
					return;
				}
			}
			/* Ignore errors */
			ncpdgram_send(server->ncp_sock, req);
			timeout = server->timeout_last << 1;
			if (timeout > NCP_MAX_RPC_TIMEOUT) {
				timeout = NCP_MAX_RPC_TIMEOUT;
			}
			server->timeout_last = timeout;
			mod_timer(&server->timeout_tm, jiffies + timeout);
		}
	}
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 129 100.00% 1 100.00%
Total 129 100.00% 1 100.00%



void ncpdgram_timeout_proc(struct work_struct *work)
{
	struct ncp_server *server =
		container_of(work, struct ncp_server, timeout_tq);
	mutex_lock(&server->rcv.creq_mutex);
	__ncpdgram_timeout_proc(server);
	mutex_unlock(&server->rcv.creq_mutex);
}

Contributors
Person Tokens Prop Commits CommitProp
petr vandrovec* petr vandrovec* 34 68.00% 1 33.33%
david howells david howells 12 24.00% 1 33.33%
ingo molnar ingo molnar 4 8.00% 1 33.33%
Total 50 100.00% 3 100.00%



static int do_tcp_rcv(struct ncp_server *server, void *buffer, size_t len)
{
	int result;
	
	if (buffer) {
		result = _recv(server->ncp_sock, buffer, len, MSG_DONTWAIT);
	} else {
	Person	Tokens	Prop	Commits	CommitProp
al viro	al viro	30	52.63%	1	33.33%
pre-git	pre-git	27	47.37%	2	66.67%
	Total	57	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 fs/ncpfs/sock.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
