cregit-Linux how code gets into the kernel

Release 4.8 net/vmw_vsock/af_vsock.c

Directory: net/vmw_vsock
/*
 * VMware vSockets Driver
 *
 * Copyright (C) 2007-2013 VMware, Inc. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation version 2 and no later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 */

/* Implementation notes:
 *
 * - There are two kinds of sockets: those created by user action (such as
 * calling socket(2)) and those created by incoming connection request packets.
 *
 * - There are two "global" tables, one for bound sockets (sockets that have
 * specified an address that they are responsible for) and one for connected
 * sockets (sockets that have established a connection with another socket).
 * These tables are "global" in that all sockets on the system are placed
 * within them. - Note, though, that the bound table contains an extra entry
 * for a list of unbound sockets and SOCK_DGRAM sockets will always remain in
 * that list. The bound table is used solely for lookup of sockets when packets
 * are received and that's not necessary for SOCK_DGRAM sockets since we create
 * a datagram handle for each and need not perform a lookup.  Keeping SOCK_DGRAM
 * sockets out of the bound hash buckets will reduce the chance of collisions
 * when looking for SOCK_STREAM sockets and prevents us from having to check the
 * socket type in the hash table lookups.
 *
 * - Sockets created by user action will either be "client" sockets that
 * initiate a connection or "server" sockets that listen for connections; we do
 * not support simultaneous connects (two "client" sockets connecting).
 *
 * - "Server" sockets are referred to as listener sockets throughout this
 * implementation because they are in the VSOCK_SS_LISTEN state.  When a
 * connection request is received (the second kind of socket mentioned above),
 * we create a new socket and refer to it as a pending socket.  These pending
 * sockets are placed on the pending connection list of the listener socket.
 * When future packets are received for the address the listener socket is
 * bound to, we check if the source of the packet is from one that has an
 * existing pending connection.  If it does, we process the packet for the
 * pending socket.  When that socket reaches the connected state, it is removed
 * from the listener socket's pending list and enqueued in the listener
 * socket's accept queue.  Callers of accept(2) will accept connected sockets
 * from the listener socket's accept queue.  If the socket cannot be accepted
 * for some reason then it is marked rejected.  Once the connection is
 * accepted, it is owned by the user process and the responsibility for cleanup
 * falls with that user process.
 *
 * - It is possible that these pending sockets will never reach the connected
 * state; in fact, we may never receive another packet after the connection
 * request.  Because of this, we must schedule a cleanup function to run in the
 * future, after some amount of time passes where a connection should have been
 * established.  This function ensures that the socket is off all lists so it
 * cannot be retrieved, then drops all references to the socket so it is cleaned
 * up (sock_put() -> sk_free() -> our sk_destruct implementation).  Note this
 * function will also cleanup rejected sockets, those that reach the connected
 * state but leave it before they have been accepted.
 *
 * - Lock ordering for pending or accept queue sockets is:
 *
 *     lock_sock(listener);
 *     lock_sock_nested(pending, SINGLE_DEPTH_NESTING);
 *
 * Using explicit nested locking keeps lockdep happy since normally only one
 * lock of a given class may be taken at a time.
 *
 * - Sockets created by user action will be cleaned up when the user process
 * calls close(2), causing our release implementation to be called. Our release
 * implementation will perform some cleanup then drop the last reference so our
 * sk_destruct implementation is invoked.  Our sk_destruct implementation will
 * perform additional cleanup that's common for both types of sockets.
 *
 * - A socket's reference count is what ensures that the structure won't be
 * freed.  Each entry in a list (such as the "global" bound and connected tables
 * and the listener socket's pending list and connected queue) ensures a
 * reference.  When we defer work until process context and pass a socket as our
 * argument, we must ensure the reference count is increased to ensure the
 * socket isn't freed before the function is run; the deferred function will
 * then drop the reference.
 */

#include <linux/types.h>
#include <linux/bitops.h>
#include <linux/cred.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/kmod.h>
#include <linux/list.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/net.h>
#include <linux/poll.h>
#include <linux/skbuff.h>
#include <linux/smp.h>
#include <linux/socket.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
#include <net/sock.h>
#include <net/af_vsock.h>

static int __vsock_bind(struct sock *sk, struct sockaddr_vm *addr);
static void vsock_sk_destruct(struct sock *sk);
static int vsock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);

/* Protocol family. */

static struct proto vsock_proto = {
	.name = "AF_VSOCK",
	.owner = THIS_MODULE,
	.obj_size = sizeof(struct vsock_sock),
};

/* The default peer timeout indicates how long we will wait for a peer response
 * to a control message.
 */

#define VSOCK_DEFAULT_CONNECT_TIMEOUT (2 * HZ)


static const struct vsock_transport *transport;
static DEFINE_MUTEX(vsock_register_mutex);

/**** EXPORTS ****/

/* Get the ID of the local context.  This is transport dependent. */


int vm_sockets_get_local_cid(void) { return transport->get_local_cid(); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king13100.00%1100.00%
Total13100.00%1100.00%

EXPORT_SYMBOL_GPL(vm_sockets_get_local_cid); /**** UTILS ****/ /* Each bound VSocket is stored in the bind hash table and each connected * VSocket is stored in the connected hash table. * * Unbound sockets are all put on the same list attached to the end of the hash * table (vsock_unbound_sockets). Bound sockets are added to the hash table in * the bucket that their local address hashes to (vsock_bound_sockets(addr) * represents the list that addr hashes to). * * Specifically, we initialize the vsock_bind_table array to a size of * VSOCK_HASH_SIZE + 1 so that vsock_bind_table[0] through * vsock_bind_table[VSOCK_HASH_SIZE - 1] are for bound sockets and * vsock_bind_table[VSOCK_HASH_SIZE] is for unbound sockets. The hash function * mods with VSOCK_HASH_SIZE to ensure this. */ #define VSOCK_HASH_SIZE 251 #define MAX_PORT_RETRIES 24 #define VSOCK_HASH(addr) ((addr)->svm_port % VSOCK_HASH_SIZE) #define vsock_bound_sockets(addr) (&vsock_bind_table[VSOCK_HASH(addr)]) #define vsock_unbound_sockets (&vsock_bind_table[VSOCK_HASH_SIZE]) /* XXX This can probably be implemented in a better way. */ #define VSOCK_CONN_HASH(src, dst) \ (((src)->svm_cid ^ (dst)->svm_port) % VSOCK_HASH_SIZE) #define vsock_connected_sockets(src, dst) \ (&vsock_connected_table[VSOCK_CONN_HASH(src, dst)]) #define vsock_connected_sockets_vsk(vsk) \ vsock_connected_sockets(&(vsk)->remote_addr, &(vsk)->local_addr) static struct list_head vsock_bind_table[VSOCK_HASH_SIZE + 1]; static struct list_head vsock_connected_table[VSOCK_HASH_SIZE]; static DEFINE_SPINLOCK(vsock_table_lock); /* Autobind this socket to the local address if necessary. */
static int vsock_auto_bind(struct vsock_sock *vsk) { struct sock *sk = sk_vsock(vsk); struct sockaddr_vm local_addr; if (vsock_addr_bound(&vsk->local_addr)) return 0; vsock_addr_init(&local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY); return __vsock_bind(sk, &local_addr); }

Contributors

PersonTokensPropCommitsCommitProp
asias heasias he57100.00%1100.00%
Total57100.00%1100.00%


static void vsock_init_tables(void) { int i; for (i = 0; i < ARRAY_SIZE(vsock_bind_table); i++) INIT_LIST_HEAD(&vsock_bind_table[i]); for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++) INIT_LIST_HEAD(&vsock_connected_table[i]); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king61100.00%1100.00%
Total61100.00%1100.00%


static void __vsock_insert_bound(struct list_head *list, struct vsock_sock *vsk) { sock_hold(&vsk->sk); list_add(&vsk->bound_table, list); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king34100.00%1100.00%
Total34100.00%1100.00%


static void __vsock_insert_connected(struct list_head *list, struct vsock_sock *vsk) { sock_hold(&vsk->sk); list_add(&vsk->connected_table, list); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king34100.00%1100.00%
Total34100.00%1100.00%


static void __vsock_remove_bound(struct vsock_sock *vsk) { list_del_init(&vsk->bound_table); sock_put(&vsk->sk); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king27100.00%1100.00%
Total27100.00%1100.00%


static void __vsock_remove_connected(struct vsock_sock *vsk) { list_del_init(&vsk->connected_table); sock_put(&vsk->sk); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king27100.00%1100.00%
Total27100.00%1100.00%


static struct sock *__vsock_find_bound_socket(struct sockaddr_vm *addr) { struct vsock_sock *vsk; list_for_each_entry(vsk, vsock_bound_sockets(addr), bound_table) if (addr->svm_port == vsk->local_addr.svm_port) return sk_vsock(vsk); return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king4289.36%150.00%
reilly grantreilly grant510.64%150.00%
Total47100.00%2100.00%


static struct sock *__vsock_find_connected_socket(struct sockaddr_vm *src, struct sockaddr_vm *dst) { struct vsock_sock *vsk; list_for_each_entry(vsk, vsock_connected_sockets(src, dst), connected_table) { if (vsock_addr_equals_addr(src, &vsk->remote_addr) && dst->svm_port == vsk->local_addr.svm_port) { return sk_vsock(vsk); } } return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king6192.42%150.00%
reilly grantreilly grant57.58%150.00%
Total66100.00%2100.00%


static bool __vsock_in_bound_table(struct vsock_sock *vsk) { return !list_empty(&vsk->bound_table); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king21100.00%1100.00%
Total21100.00%1100.00%


static bool __vsock_in_connected_table(struct vsock_sock *vsk) { return !list_empty(&vsk->connected_table); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king21100.00%1100.00%
Total21100.00%1100.00%


static void vsock_insert_unbound(struct vsock_sock *vsk) { spin_lock_bh(&vsock_table_lock); __vsock_insert_bound(vsock_unbound_sockets, vsk); spin_unlock_bh(&vsock_table_lock); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king30100.00%1100.00%
Total30100.00%1100.00%


void vsock_insert_connected(struct vsock_sock *vsk) { struct list_head *list = vsock_connected_sockets( &vsk->remote_addr, &vsk->local_addr); spin_lock_bh(&vsock_table_lock); __vsock_insert_connected(list, vsk); spin_unlock_bh(&vsock_table_lock); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king47100.00%1100.00%
Total47100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_insert_connected);
void vsock_remove_bound(struct vsock_sock *vsk) { spin_lock_bh(&vsock_table_lock); __vsock_remove_bound(vsk); spin_unlock_bh(&vsock_table_lock); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king27100.00%1100.00%
Total27100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_remove_bound);
void vsock_remove_connected(struct vsock_sock *vsk) { spin_lock_bh(&vsock_table_lock); __vsock_remove_connected(vsk); spin_unlock_bh(&vsock_table_lock); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king27100.00%1100.00%
Total27100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_remove_connected);
struct sock *vsock_find_bound_socket(struct sockaddr_vm *addr) { struct sock *sk; spin_lock_bh(&vsock_table_lock); sk = __vsock_find_bound_socket(addr); if (sk) sock_hold(sk); spin_unlock_bh(&vsock_table_lock); return sk; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king48100.00%1100.00%
Total48100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_find_bound_socket);
struct sock *vsock_find_connected_socket(struct sockaddr_vm *src, struct sockaddr_vm *dst) { struct sock *sk; spin_lock_bh(&vsock_table_lock); sk = __vsock_find_connected_socket(src, dst); if (sk) sock_hold(sk); spin_unlock_bh(&vsock_table_lock); return sk; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king55100.00%1100.00%
Total55100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_find_connected_socket);
static bool vsock_in_bound_table(struct vsock_sock *vsk) { bool ret; spin_lock_bh(&vsock_table_lock); ret = __vsock_in_bound_table(vsk); spin_unlock_bh(&vsock_table_lock); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king36100.00%1100.00%
Total36100.00%1100.00%


static bool vsock_in_connected_table(struct vsock_sock *vsk) { bool ret; spin_lock_bh(&vsock_table_lock); ret = __vsock_in_connected_table(vsk); spin_unlock_bh(&vsock_table_lock); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king36100.00%1100.00%
Total36100.00%1100.00%


void vsock_remove_sock(struct vsock_sock *vsk) { if (vsock_in_bound_table(vsk)) vsock_remove_bound(vsk); if (vsock_in_connected_table(vsk)) vsock_remove_connected(vsk); }

Contributors

PersonTokensPropCommitsCommitProp
stefan hajnoczistefan hajnoczi34100.00%1100.00%
Total34100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_remove_sock);
void vsock_for_each_connected_socket(void (*fn)(struct sock *sk)) { int i; spin_lock_bh(&vsock_table_lock); for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++) { struct vsock_sock *vsk; list_for_each_entry(vsk, &vsock_connected_table[i], connected_table) fn(sk_vsock(vsk)); } spin_unlock_bh(&vsock_table_lock); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king6895.77%150.00%
julia lawalljulia lawall34.23%150.00%
Total71100.00%2100.00%

EXPORT_SYMBOL_GPL(vsock_for_each_connected_socket);
void vsock_add_pending(struct sock *listener, struct sock *pending) { struct vsock_sock *vlistener; struct vsock_sock *vpending; vlistener = vsock_sk(listener); vpending = vsock_sk(pending); sock_hold(pending); sock_hold(listener); list_add_tail(&vpending->pending_links, &vlistener->pending_links); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king62100.00%1100.00%
Total62100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_add_pending);
void vsock_remove_pending(struct sock *listener, struct sock *pending) { struct vsock_sock *vpending = vsock_sk(pending); list_del_init(&vpending->pending_links); sock_put(listener); sock_put(pending); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king43100.00%1100.00%
Total43100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_remove_pending);
void vsock_enqueue_accept(struct sock *listener, struct sock *connected) { struct vsock_sock *vlistener; struct vsock_sock *vconnected; vlistener = vsock_sk(listener); vconnected = vsock_sk(connected); sock_hold(connected); sock_hold(listener); list_add_tail(&vconnected->accept_queue, &vlistener->accept_queue); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king62100.00%1100.00%
Total62100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_enqueue_accept);
static struct sock *vsock_dequeue_accept(struct sock *listener) { struct vsock_sock *vlistener; struct vsock_sock *vconnected; vlistener = vsock_sk(listener); if (list_empty(&vlistener->accept_queue)) return NULL; vconnected = list_entry(vlistener->accept_queue.next, struct vsock_sock, accept_queue); list_del_init(&vconnected->accept_queue); sock_put(listener); /* The caller will need a reference on the connected socket so we let * it call sock_put(). */ return sk_vsock(vconnected); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king79100.00%1100.00%
Total79100.00%1100.00%


static bool vsock_is_accept_queue_empty(struct sock *sk) { struct vsock_sock *vsk = vsock_sk(sk); return list_empty(&vsk->accept_queue); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king30100.00%1100.00%
Total30100.00%1100.00%


static bool vsock_is_pending(struct sock *sk) { struct vsock_sock *vsk = vsock_sk(sk); return !list_empty(&vsk->pending_links); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king31100.00%1100.00%
Total31100.00%1100.00%


static int vsock_send_shutdown(struct sock *sk, int mode) { return transport->shutdown(vsock_sk(sk), mode); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king27100.00%1100.00%
Total27100.00%1100.00%


void vsock_pending_work(struct work_struct *work) { struct sock *sk; struct sock *listener; struct vsock_sock *vsk; bool cleanup; vsk = container_of(work, struct vsock_sock, dwork.work); sk = sk_vsock(vsk); listener = vsk->listener; cleanup = true; lock_sock(listener); lock_sock_nested(sk, SINGLE_DEPTH_NESTING); if (vsock_is_pending(sk)) { vsock_remove_pending(listener, sk); listener->sk_ack_backlog--; } else if (!vsk->rejected) { /* We are not on the pending list and accept() did not reject * us, so we must have been accepted by our user process. We * just need to drop our references to the sockets and be on * our way. */ cleanup = false; goto out; } /* We need to remove ourself from the global connected sockets list so * incoming packets can't find this socket, and to reduce the reference * count. */ if (vsock_in_connected_table(vsk)) vsock_remove_connected(vsk); sk->sk_state = SS_FREE; out: release_sock(sk); release_sock(listener); if (cleanup) sock_put(sk); sock_put(sk); sock_put(listener); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king15295.00%133.33%
jorgen hansenjorgen hansen53.12%133.33%
stefan hajnoczistefan hajnoczi31.88%133.33%
Total160100.00%3100.00%

EXPORT_SYMBOL_GPL(vsock_pending_work); /**** SOCKET OPERATIONS ****/
static int __vsock_bind_stream(struct vsock_sock *vsk, struct sockaddr_vm *addr) { static u32 port = LAST_RESERVED_PORT + 1; struct sockaddr_vm new_addr; vsock_addr_init(&new_addr, addr->svm_cid, addr->svm_port); if (addr->svm_port == VMADDR_PORT_ANY) { bool found = false; unsigned int i; for (i = 0; i < MAX_PORT_RETRIES; i++) { if (port <= LAST_RESERVED_PORT) port = LAST_RESERVED_PORT + 1; new_addr.svm_port = port++; if (!__vsock_find_bound_socket(&new_addr)) { found = true; break; } } if (!found) return -EADDRNOTAVAIL; } else { /* If port is in reserved range, ensure caller * has necessary privileges. */ if (addr->svm_port <= LAST_RESERVED_PORT && !capable(CAP_NET_BIND_SERVICE)) { return -EACCES; } if (__vsock_find_bound_socket(&new_addr)) return -EADDRINUSE; } vsock_addr_init(&vsk->local_addr, new_addr.svm_cid, new_addr.svm_port); /* Remove stream sockets from the unbound list and add them to the hash * table for easy lookup by its address. The unbound list is simply an * extra entry at the end of the hash table, a trick used by AF_UNIX. */ __vsock_remove_bound(vsk); __vsock_insert_bound(vsock_bound_sockets(&vsk->local_addr), vsk); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king194100.00%1100.00%
Total194100.00%1100.00%


static int __vsock_bind_dgram(struct vsock_sock *vsk, struct sockaddr_vm *addr) { return transport->dgram_bind(vsk, addr); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king26100.00%1100.00%
Total26100.00%1100.00%


static int __vsock_bind(struct sock *sk, struct sockaddr_vm *addr) { struct vsock_sock *vsk = vsock_sk(sk); u32 cid; int retval; /* First ensure this socket isn't already bound. */ if (vsock_addr_bound(&vsk->local_addr)) return -EINVAL; /* Now bind to the provided address or select appropriate values if * none are provided (VMADDR_CID_ANY and VMADDR_PORT_ANY). Note that * like AF_INET prevents binding to a non-local IP address (in most * cases), we only allow binding to the local CID. */ cid = transport->get_local_cid(); if (addr->svm_cid != cid && addr->svm_cid != VMADDR_CID_ANY) return -EADDRNOTAVAIL; switch (sk->sk_socket->type) { case SOCK_STREAM: spin_lock_bh(&vsock_table_lock); retval = __vsock_bind_stream(vsk, addr); spin_unlock_bh(&vsock_table_lock); break; case SOCK_DGRAM: retval = __vsock_bind_dgram(vsk, addr); break; default: retval = -EINVAL; break; } return retval; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king131100.00%1100.00%
Total131100.00%1100.00%


struct sock *__vsock_create(struct net *net, struct socket *sock, struct sock *parent, gfp_t priority, unsigned short type, int kern) { struct sock *sk; struct vsock_sock *psk; struct vsock_sock *vsk; sk = sk_alloc(net, AF_VSOCK, priority, &vsock_proto, kern); if (!sk) return NULL; sock_init_data(sock, sk); /* sk->sk_type is normally set in sock_init_data, but only if sock is * non-NULL. We make sure that our sockets always have a type by * setting it here if needed. */ if (!sock) sk->sk_type = type; vsk = vsock_sk(sk); vsock_addr_init(&vsk->local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY); vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY); sk->sk_destruct = vsock_sk_destruct; sk->sk_backlog_rcv = vsock_queue_rcv_skb; sk->sk_state = 0; sock_reset_flag(sk, SOCK_DONE); INIT_LIST_HEAD(&vsk->bound_table); INIT_LIST_HEAD(&vsk->connected_table); vsk->listener = NULL; INIT_LIST_HEAD(&vsk->pending_links); INIT_LIST_HEAD(&vsk->accept_queue); vsk->rejected = false; vsk->sent_request = false; vsk->ignore_connecting_rst = false; vsk->peer_shutdown = 0; psk = parent ? vsock_sk(parent) : NULL; if (parent) { vsk->trusted = psk->trusted; vsk->owner = get_cred(psk->owner); vsk->connect_timeout = psk->connect_timeout; } else { vsk->trusted = capable(CAP_NET_ADMIN); vsk->owner = get_current_cred(); vsk->connect_timeout = VSOCK_DEFAULT_CONNECT_TIMEOUT; } if (transport->init(vsk, psk) < 0) { sk_free(sk); return NULL; } if (sock) vsock_insert_unbound(vsk); return sk; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king30798.40%150.00%
eric w. biedermaneric w. biederman51.60%150.00%
Total312100.00%2100.00%

EXPORT_SYMBOL_GPL(__vsock_create);
static void __vsock_release(struct sock *sk) { if (sk) { struct sk_buff *skb; struct sock *pending; struct vsock_sock *vsk; vsk = vsock_sk(sk); pending = NULL; /* Compiler warning. */ transport->release(vsk); lock_sock(sk); sock_orphan(sk); sk->sk_shutdown = SHUTDOWN_MASK; while ((skb = skb_dequeue(&sk->sk_receive_queue))) kfree_skb(skb); /* Clean up any sockets that never were accepted. */ while ((pending = vsock_dequeue_accept(sk)) != NULL) { __vsock_release(pending); sock_put(pending); } release_sock(sk); sock_put(sk); } }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king122100.00%1100.00%
Total122100.00%1100.00%


static void vsock_sk_destruct(struct sock *sk) { struct vsock_sock *vsk = vsock_sk(sk); transport->destruct(vsk); /* When clearing these addresses, there's no need to set the family and * possibly register the address family with the kernel. */ vsock_addr_init(&vsk->local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY); vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY); put_cred(vsk->owner); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king60100.00%1100.00%
Total60100.00%1100.00%


static int vsock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) { int err; err = sock_queue_rcv_skb(sk, skb); if (err) kfree_skb(skb); return err; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king40100.00%1100.00%
Total40100.00%1100.00%


s64 vsock_stream_has_data(struct vsock_sock *vsk) { return transport->stream_has_data(vsk); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king18100.00%1100.00%
Total18100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_stream_has_data);
s64 vsock_stream_has_space(struct vsock_sock *vsk) { return transport->stream_has_space(vsk); }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king18100.00%1100.00%
Total18100.00%1100.00%

EXPORT_SYMBOL_GPL(vsock_stream_has_space);
static int vsock_release(struct socket *sock) { __vsock_release(sock->sk); sock->sk = NULL; sock->state = SS_FREE; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king33100.00%1100.00%
Total33100.00%1100.00%


static int vsock_bind(struct socket *sock, struct sockaddr *addr, int addr_len) { int err; struct sock *sk; struct sockaddr_vm *vm_addr; sk = sock->sk; if (vsock_addr_cast(addr, addr_len, &vm_addr) != 0) return -EINVAL; lock_sock(sk); err = __vsock_bind(sk, vm_addr); release_sock(sk); return err; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king78100.00%1100.00%
Total78100.00%1100.00%


static int vsock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer) { int err; struct sock *sk; struct vsock_sock *vsk; struct sockaddr_vm *vm_addr; sk = sock->sk; vsk = vsock_sk(sk); err = 0; lock_sock(sk); if (peer) { if (sock->state != SS_CONNECTED) { err = -ENOTCONN; goto out; } vm_addr = &vsk->remote_addr; } else { vm_addr = &vsk->local_addr; } if (!vm_addr) { err = -EINVAL; goto out; } /* sys_getsockname() and sys_getpeername() pass us a * MAX_SOCK_ADDR-sized buffer and don't set addr_len. Unfortunately * that macro is defined in socket.c instead of .h, so we hardcode its * value here. */ BUILD_BUG_ON(sizeof(*vm_addr) > 128); memcpy(addr, vm_addr, sizeof(*vm_addr)); *addr_len = sizeof(*vm_addr); out: release_sock(sk); return err; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king163100.00%1100.00%
Total163100.00%1100.00%


static int vsock_shutdown(struct socket *sock, int mode) { int err; struct sock *sk; /* User level uses SHUT_RD (0) and SHUT_WR (1), but the kernel uses * RCV_SHUTDOWN (1) and SEND_SHUTDOWN (2), so we must increment mode * here like the other address families do. Note also that the * increment makes SHUT_RDWR (2) into RCV_SHUTDOWN | SEND_SHUTDOWN (3), * which is what we want. */ mode++; if ((mode & ~SHUTDOWN_MASK) || !mode) return -EINVAL; /* If this is a STREAM socket and it is not connected then bail out * immediately. If it is a DGRAM socket then we must first kick the * socket so that it wakes up from any sleeping calls, for example * recv(), and then afterwards return the error. */ sk = sock->sk; if (sock->state == SS_UNCONNECTED) { err = -ENOTCONN; if (sk->sk_type == SOCK_STREAM) return err; } else { sock->state = SS_DISCONNECTING; err = 0; } /* Receive and send shutdowns are treated alike. */ mode = mode & (RCV_SHUTDOWN | SEND_SHUTDOWN); if (mode) { lock_sock(sk); sk->sk_shutdown |= mode; sk->sk_state_change(sk); release_sock(sk); if (sk->sk_type == SOCK_STREAM) { sock_reset_flag(sk, SOCK_DONE); vsock_send_shutdown(sk, mode); } } return err; }

Contributors

PersonTokensPropCommitsCommitProp
andy kingandy king155100.00%1100.00%
Total155100.00%1100.00%


static unsigned int vsock_poll(struct file *file, struct socket *sock, poll_table *wait) { struct sock *sk; unsigned int mask; struct vsock_sock *vsk; sk = sock->sk; vsk = vsock_sk(sk); poll_wait(file, sk_sleep(sk), wait); mask = 0; if (sk->sk_err) /* Signify that there has been an error on this socket. */ mask |= POLLERR; /* INET sockets treat local write shutdown and peer write shutdown as a * case of POLLHUP set. */ if ((sk->sk_shutdown == SHUTDOWN_MASK