1d021c344SAndy King /* 2d021c344SAndy King * VMware vSockets Driver 3d021c344SAndy King * 4d021c344SAndy King * Copyright (C) 2007-2013 VMware, Inc. All rights reserved. 5d021c344SAndy King * 6d021c344SAndy King * This program is free software; you can redistribute it and/or modify it 7d021c344SAndy King * under the terms of the GNU General Public License as published by the Free 8d021c344SAndy King * Software Foundation version 2 and no later version. 9d021c344SAndy King * 10d021c344SAndy King * This program is distributed in the hope that it will be useful, but WITHOUT 11d021c344SAndy King * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12d021c344SAndy King * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13d021c344SAndy King * more details. 14d021c344SAndy King */ 15d021c344SAndy King 16d021c344SAndy King #include <linux/types.h> 17d021c344SAndy King 18d021c344SAndy King #define EXPORT_SYMTAB 19d021c344SAndy King #include <linux/bitops.h> 20d021c344SAndy King #include <linux/cred.h> 21d021c344SAndy King #include <linux/init.h> 22d021c344SAndy King #include <linux/io.h> 23d021c344SAndy King #include <linux/kernel.h> 24d021c344SAndy King #include <linux/kmod.h> 25d021c344SAndy King #include <linux/list.h> 26d021c344SAndy King #include <linux/miscdevice.h> 27d021c344SAndy King #include <linux/module.h> 28d021c344SAndy King #include <linux/mutex.h> 29d021c344SAndy King #include <linux/net.h> 30d021c344SAndy King #include <linux/poll.h> 31d021c344SAndy King #include <linux/skbuff.h> 32d021c344SAndy King #include <linux/smp.h> 33d021c344SAndy King #include <linux/socket.h> 34d021c344SAndy King #include <linux/stddef.h> 35d021c344SAndy King #include <linux/unistd.h> 36d021c344SAndy King #include <linux/wait.h> 37d021c344SAndy King #include <linux/workqueue.h> 38d021c344SAndy King #include <net/sock.h> 39d021c344SAndy King 40d021c344SAndy King #include "af_vsock.h" 41d021c344SAndy King #include "vmci_transport_notify.h" 42d021c344SAndy King 43d021c344SAndy King static int vmci_transport_recv_dgram_cb(void *data, struct vmci_datagram *dg); 44d021c344SAndy King static int vmci_transport_recv_stream_cb(void *data, struct vmci_datagram *dg); 45d021c344SAndy King static void vmci_transport_peer_attach_cb(u32 sub_id, 46d021c344SAndy King const struct vmci_event_data *ed, 47d021c344SAndy King void *client_data); 48d021c344SAndy King static void vmci_transport_peer_detach_cb(u32 sub_id, 49d021c344SAndy King const struct vmci_event_data *ed, 50d021c344SAndy King void *client_data); 51d021c344SAndy King static void vmci_transport_recv_pkt_work(struct work_struct *work); 52d021c344SAndy King static int vmci_transport_recv_listen(struct sock *sk, 53d021c344SAndy King struct vmci_transport_packet *pkt); 54d021c344SAndy King static int vmci_transport_recv_connecting_server( 55d021c344SAndy King struct sock *sk, 56d021c344SAndy King struct sock *pending, 57d021c344SAndy King struct vmci_transport_packet *pkt); 58d021c344SAndy King static int vmci_transport_recv_connecting_client( 59d021c344SAndy King struct sock *sk, 60d021c344SAndy King struct vmci_transport_packet *pkt); 61d021c344SAndy King static int vmci_transport_recv_connecting_client_negotiate( 62d021c344SAndy King struct sock *sk, 63d021c344SAndy King struct vmci_transport_packet *pkt); 64d021c344SAndy King static int vmci_transport_recv_connecting_client_invalid( 65d021c344SAndy King struct sock *sk, 66d021c344SAndy King struct vmci_transport_packet *pkt); 67d021c344SAndy King static int vmci_transport_recv_connected(struct sock *sk, 68d021c344SAndy King struct vmci_transport_packet *pkt); 69d021c344SAndy King static bool vmci_transport_old_proto_override(bool *old_pkt_proto); 70d021c344SAndy King static u16 vmci_transport_new_proto_supported_versions(void); 71d021c344SAndy King static bool vmci_transport_proto_to_notify_struct(struct sock *sk, u16 *proto, 72d021c344SAndy King bool old_pkt_proto); 73d021c344SAndy King 74d021c344SAndy King struct vmci_transport_recv_pkt_info { 75d021c344SAndy King struct work_struct work; 76d021c344SAndy King struct sock *sk; 77d021c344SAndy King struct vmci_transport_packet pkt; 78d021c344SAndy King }; 79d021c344SAndy King 80d021c344SAndy King static struct vmci_handle vmci_transport_stream_handle = { VMCI_INVALID_ID, 81d021c344SAndy King VMCI_INVALID_ID }; 82d021c344SAndy King static u32 vmci_transport_qp_resumed_sub_id = VMCI_INVALID_ID; 83d021c344SAndy King 84d021c344SAndy King static int PROTOCOL_OVERRIDE = -1; 85d021c344SAndy King 86d021c344SAndy King #define VMCI_TRANSPORT_DEFAULT_QP_SIZE_MIN 128 87d021c344SAndy King #define VMCI_TRANSPORT_DEFAULT_QP_SIZE 262144 88d021c344SAndy King #define VMCI_TRANSPORT_DEFAULT_QP_SIZE_MAX 262144 89d021c344SAndy King 90d021c344SAndy King /* The default peer timeout indicates how long we will wait for a peer response 91d021c344SAndy King * to a control message. 92d021c344SAndy King */ 93d021c344SAndy King #define VSOCK_DEFAULT_CONNECT_TIMEOUT (2 * HZ) 94d021c344SAndy King 95d021c344SAndy King #define SS_LISTEN 255 96d021c344SAndy King 97d021c344SAndy King /* Helper function to convert from a VMCI error code to a VSock error code. */ 98d021c344SAndy King 99d021c344SAndy King static s32 vmci_transport_error_to_vsock_error(s32 vmci_error) 100d021c344SAndy King { 101d021c344SAndy King int err; 102d021c344SAndy King 103d021c344SAndy King switch (vmci_error) { 104d021c344SAndy King case VMCI_ERROR_NO_MEM: 105d021c344SAndy King err = ENOMEM; 106d021c344SAndy King break; 107d021c344SAndy King case VMCI_ERROR_DUPLICATE_ENTRY: 108d021c344SAndy King case VMCI_ERROR_ALREADY_EXISTS: 109d021c344SAndy King err = EADDRINUSE; 110d021c344SAndy King break; 111d021c344SAndy King case VMCI_ERROR_NO_ACCESS: 112d021c344SAndy King err = EPERM; 113d021c344SAndy King break; 114d021c344SAndy King case VMCI_ERROR_NO_RESOURCES: 115d021c344SAndy King err = ENOBUFS; 116d021c344SAndy King break; 117d021c344SAndy King case VMCI_ERROR_INVALID_RESOURCE: 118d021c344SAndy King err = EHOSTUNREACH; 119d021c344SAndy King break; 120d021c344SAndy King case VMCI_ERROR_INVALID_ARGS: 121d021c344SAndy King default: 122d021c344SAndy King err = EINVAL; 123d021c344SAndy King } 124d021c344SAndy King 125d021c344SAndy King return err > 0 ? -err : err; 126d021c344SAndy King } 127d021c344SAndy King 128d021c344SAndy King static inline void 129d021c344SAndy King vmci_transport_packet_init(struct vmci_transport_packet *pkt, 130d021c344SAndy King struct sockaddr_vm *src, 131d021c344SAndy King struct sockaddr_vm *dst, 132d021c344SAndy King u8 type, 133d021c344SAndy King u64 size, 134d021c344SAndy King u64 mode, 135d021c344SAndy King struct vmci_transport_waiting_info *wait, 136d021c344SAndy King u16 proto, 137d021c344SAndy King struct vmci_handle handle) 138d021c344SAndy King { 139d021c344SAndy King /* We register the stream control handler as an any cid handle so we 140d021c344SAndy King * must always send from a source address of VMADDR_CID_ANY 141d021c344SAndy King */ 142d021c344SAndy King pkt->dg.src = vmci_make_handle(VMADDR_CID_ANY, 143d021c344SAndy King VMCI_TRANSPORT_PACKET_RID); 144d021c344SAndy King pkt->dg.dst = vmci_make_handle(dst->svm_cid, 145d021c344SAndy King VMCI_TRANSPORT_PACKET_RID); 146d021c344SAndy King pkt->dg.payload_size = sizeof(*pkt) - sizeof(pkt->dg); 147d021c344SAndy King pkt->version = VMCI_TRANSPORT_PACKET_VERSION; 148d021c344SAndy King pkt->type = type; 149d021c344SAndy King pkt->src_port = src->svm_port; 150d021c344SAndy King pkt->dst_port = dst->svm_port; 151d021c344SAndy King memset(&pkt->proto, 0, sizeof(pkt->proto)); 152d021c344SAndy King memset(&pkt->_reserved2, 0, sizeof(pkt->_reserved2)); 153d021c344SAndy King 154d021c344SAndy King switch (pkt->type) { 155d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_INVALID: 156d021c344SAndy King pkt->u.size = 0; 157d021c344SAndy King break; 158d021c344SAndy King 159d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_REQUEST: 160d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE: 161d021c344SAndy King pkt->u.size = size; 162d021c344SAndy King break; 163d021c344SAndy King 164d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_OFFER: 165d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_ATTACH: 166d021c344SAndy King pkt->u.handle = handle; 167d021c344SAndy King break; 168d021c344SAndy King 169d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_WROTE: 170d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_READ: 171d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_RST: 172d021c344SAndy King pkt->u.size = 0; 173d021c344SAndy King break; 174d021c344SAndy King 175d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_SHUTDOWN: 176d021c344SAndy King pkt->u.mode = mode; 177d021c344SAndy King break; 178d021c344SAndy King 179d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_WAITING_READ: 180d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_WAITING_WRITE: 181d021c344SAndy King memcpy(&pkt->u.wait, wait, sizeof(pkt->u.wait)); 182d021c344SAndy King break; 183d021c344SAndy King 184d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_REQUEST2: 185d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2: 186d021c344SAndy King pkt->u.size = size; 187d021c344SAndy King pkt->proto = proto; 188d021c344SAndy King break; 189d021c344SAndy King } 190d021c344SAndy King } 191d021c344SAndy King 192d021c344SAndy King static inline void 193d021c344SAndy King vmci_transport_packet_get_addresses(struct vmci_transport_packet *pkt, 194d021c344SAndy King struct sockaddr_vm *local, 195d021c344SAndy King struct sockaddr_vm *remote) 196d021c344SAndy King { 197d021c344SAndy King vsock_addr_init(local, pkt->dg.dst.context, pkt->dst_port); 198d021c344SAndy King vsock_addr_init(remote, pkt->dg.src.context, pkt->src_port); 199d021c344SAndy King } 200d021c344SAndy King 201d021c344SAndy King static int 202d021c344SAndy King __vmci_transport_send_control_pkt(struct vmci_transport_packet *pkt, 203d021c344SAndy King struct sockaddr_vm *src, 204d021c344SAndy King struct sockaddr_vm *dst, 205d021c344SAndy King enum vmci_transport_packet_type type, 206d021c344SAndy King u64 size, 207d021c344SAndy King u64 mode, 208d021c344SAndy King struct vmci_transport_waiting_info *wait, 209d021c344SAndy King u16 proto, 210d021c344SAndy King struct vmci_handle handle, 211d021c344SAndy King bool convert_error) 212d021c344SAndy King { 213d021c344SAndy King int err; 214d021c344SAndy King 215d021c344SAndy King vmci_transport_packet_init(pkt, src, dst, type, size, mode, wait, 216d021c344SAndy King proto, handle); 217d021c344SAndy King err = vmci_datagram_send(&pkt->dg); 218d021c344SAndy King if (convert_error && (err < 0)) 219d021c344SAndy King return vmci_transport_error_to_vsock_error(err); 220d021c344SAndy King 221d021c344SAndy King return err; 222d021c344SAndy King } 223d021c344SAndy King 224d021c344SAndy King static int 225d021c344SAndy King vmci_transport_reply_control_pkt_fast(struct vmci_transport_packet *pkt, 226d021c344SAndy King enum vmci_transport_packet_type type, 227d021c344SAndy King u64 size, 228d021c344SAndy King u64 mode, 229d021c344SAndy King struct vmci_transport_waiting_info *wait, 230d021c344SAndy King struct vmci_handle handle) 231d021c344SAndy King { 232d021c344SAndy King struct vmci_transport_packet reply; 233d021c344SAndy King struct sockaddr_vm src, dst; 234d021c344SAndy King 235d021c344SAndy King if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST) { 236d021c344SAndy King return 0; 237d021c344SAndy King } else { 238d021c344SAndy King vmci_transport_packet_get_addresses(pkt, &src, &dst); 239d021c344SAndy King return __vmci_transport_send_control_pkt(&reply, &src, &dst, 240d021c344SAndy King type, 241d021c344SAndy King size, mode, wait, 242d021c344SAndy King VSOCK_PROTO_INVALID, 243d021c344SAndy King handle, true); 244d021c344SAndy King } 245d021c344SAndy King } 246d021c344SAndy King 247d021c344SAndy King static int 248d021c344SAndy King vmci_transport_send_control_pkt_bh(struct sockaddr_vm *src, 249d021c344SAndy King struct sockaddr_vm *dst, 250d021c344SAndy King enum vmci_transport_packet_type type, 251d021c344SAndy King u64 size, 252d021c344SAndy King u64 mode, 253d021c344SAndy King struct vmci_transport_waiting_info *wait, 254d021c344SAndy King struct vmci_handle handle) 255d021c344SAndy King { 256d021c344SAndy King /* Note that it is safe to use a single packet across all CPUs since 257d021c344SAndy King * two tasklets of the same type are guaranteed to not ever run 258d021c344SAndy King * simultaneously. If that ever changes, or VMCI stops using tasklets, 259d021c344SAndy King * we can use per-cpu packets. 260d021c344SAndy King */ 261d021c344SAndy King static struct vmci_transport_packet pkt; 262d021c344SAndy King 263d021c344SAndy King return __vmci_transport_send_control_pkt(&pkt, src, dst, type, 264d021c344SAndy King size, mode, wait, 265d021c344SAndy King VSOCK_PROTO_INVALID, handle, 266d021c344SAndy King false); 267d021c344SAndy King } 268d021c344SAndy King 269d021c344SAndy King static int 270d021c344SAndy King vmci_transport_send_control_pkt(struct sock *sk, 271d021c344SAndy King enum vmci_transport_packet_type type, 272d021c344SAndy King u64 size, 273d021c344SAndy King u64 mode, 274d021c344SAndy King struct vmci_transport_waiting_info *wait, 275d021c344SAndy King u16 proto, 276d021c344SAndy King struct vmci_handle handle) 277d021c344SAndy King { 278d021c344SAndy King struct vmci_transport_packet *pkt; 279d021c344SAndy King struct vsock_sock *vsk; 280d021c344SAndy King int err; 281d021c344SAndy King 282d021c344SAndy King vsk = vsock_sk(sk); 283d021c344SAndy King 284d021c344SAndy King if (!vsock_addr_bound(&vsk->local_addr)) 285d021c344SAndy King return -EINVAL; 286d021c344SAndy King 287d021c344SAndy King if (!vsock_addr_bound(&vsk->remote_addr)) 288d021c344SAndy King return -EINVAL; 289d021c344SAndy King 290d021c344SAndy King pkt = kmalloc(sizeof(*pkt), GFP_KERNEL); 291d021c344SAndy King if (!pkt) 292d021c344SAndy King return -ENOMEM; 293d021c344SAndy King 294d021c344SAndy King err = __vmci_transport_send_control_pkt(pkt, &vsk->local_addr, 295d021c344SAndy King &vsk->remote_addr, type, size, 296d021c344SAndy King mode, wait, proto, handle, 297d021c344SAndy King true); 298d021c344SAndy King kfree(pkt); 299d021c344SAndy King 300d021c344SAndy King return err; 301d021c344SAndy King } 302d021c344SAndy King 303d021c344SAndy King static int vmci_transport_send_reset_bh(struct sockaddr_vm *dst, 304d021c344SAndy King struct sockaddr_vm *src, 305d021c344SAndy King struct vmci_transport_packet *pkt) 306d021c344SAndy King { 307d021c344SAndy King if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST) 308d021c344SAndy King return 0; 309d021c344SAndy King return vmci_transport_send_control_pkt_bh( 310d021c344SAndy King dst, src, 311d021c344SAndy King VMCI_TRANSPORT_PACKET_TYPE_RST, 0, 312d021c344SAndy King 0, NULL, VMCI_INVALID_HANDLE); 313d021c344SAndy King } 314d021c344SAndy King 315d021c344SAndy King static int vmci_transport_send_reset(struct sock *sk, 316d021c344SAndy King struct vmci_transport_packet *pkt) 317d021c344SAndy King { 318d021c344SAndy King if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST) 319d021c344SAndy King return 0; 320d021c344SAndy King return vmci_transport_send_control_pkt(sk, 321d021c344SAndy King VMCI_TRANSPORT_PACKET_TYPE_RST, 322d021c344SAndy King 0, 0, NULL, VSOCK_PROTO_INVALID, 323d021c344SAndy King VMCI_INVALID_HANDLE); 324d021c344SAndy King } 325d021c344SAndy King 326d021c344SAndy King static int vmci_transport_send_negotiate(struct sock *sk, size_t size) 327d021c344SAndy King { 328d021c344SAndy King return vmci_transport_send_control_pkt( 329d021c344SAndy King sk, 330d021c344SAndy King VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE, 331d021c344SAndy King size, 0, NULL, 332d021c344SAndy King VSOCK_PROTO_INVALID, 333d021c344SAndy King VMCI_INVALID_HANDLE); 334d021c344SAndy King } 335d021c344SAndy King 336d021c344SAndy King static int vmci_transport_send_negotiate2(struct sock *sk, size_t size, 337d021c344SAndy King u16 version) 338d021c344SAndy King { 339d021c344SAndy King return vmci_transport_send_control_pkt( 340d021c344SAndy King sk, 341d021c344SAndy King VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2, 342d021c344SAndy King size, 0, NULL, version, 343d021c344SAndy King VMCI_INVALID_HANDLE); 344d021c344SAndy King } 345d021c344SAndy King 346d021c344SAndy King static int vmci_transport_send_qp_offer(struct sock *sk, 347d021c344SAndy King struct vmci_handle handle) 348d021c344SAndy King { 349d021c344SAndy King return vmci_transport_send_control_pkt( 350d021c344SAndy King sk, VMCI_TRANSPORT_PACKET_TYPE_OFFER, 0, 351d021c344SAndy King 0, NULL, 352d021c344SAndy King VSOCK_PROTO_INVALID, handle); 353d021c344SAndy King } 354d021c344SAndy King 355d021c344SAndy King static int vmci_transport_send_attach(struct sock *sk, 356d021c344SAndy King struct vmci_handle handle) 357d021c344SAndy King { 358d021c344SAndy King return vmci_transport_send_control_pkt( 359d021c344SAndy King sk, VMCI_TRANSPORT_PACKET_TYPE_ATTACH, 360d021c344SAndy King 0, 0, NULL, VSOCK_PROTO_INVALID, 361d021c344SAndy King handle); 362d021c344SAndy King } 363d021c344SAndy King 364d021c344SAndy King static int vmci_transport_reply_reset(struct vmci_transport_packet *pkt) 365d021c344SAndy King { 366d021c344SAndy King return vmci_transport_reply_control_pkt_fast( 367d021c344SAndy King pkt, 368d021c344SAndy King VMCI_TRANSPORT_PACKET_TYPE_RST, 369d021c344SAndy King 0, 0, NULL, 370d021c344SAndy King VMCI_INVALID_HANDLE); 371d021c344SAndy King } 372d021c344SAndy King 373d021c344SAndy King static int vmci_transport_send_invalid_bh(struct sockaddr_vm *dst, 374d021c344SAndy King struct sockaddr_vm *src) 375d021c344SAndy King { 376d021c344SAndy King return vmci_transport_send_control_pkt_bh( 377d021c344SAndy King dst, src, 378d021c344SAndy King VMCI_TRANSPORT_PACKET_TYPE_INVALID, 379d021c344SAndy King 0, 0, NULL, VMCI_INVALID_HANDLE); 380d021c344SAndy King } 381d021c344SAndy King 382d021c344SAndy King int vmci_transport_send_wrote_bh(struct sockaddr_vm *dst, 383d021c344SAndy King struct sockaddr_vm *src) 384d021c344SAndy King { 385d021c344SAndy King return vmci_transport_send_control_pkt_bh( 386d021c344SAndy King dst, src, 387d021c344SAndy King VMCI_TRANSPORT_PACKET_TYPE_WROTE, 0, 388d021c344SAndy King 0, NULL, VMCI_INVALID_HANDLE); 389d021c344SAndy King } 390d021c344SAndy King 391d021c344SAndy King int vmci_transport_send_read_bh(struct sockaddr_vm *dst, 392d021c344SAndy King struct sockaddr_vm *src) 393d021c344SAndy King { 394d021c344SAndy King return vmci_transport_send_control_pkt_bh( 395d021c344SAndy King dst, src, 396d021c344SAndy King VMCI_TRANSPORT_PACKET_TYPE_READ, 0, 397d021c344SAndy King 0, NULL, VMCI_INVALID_HANDLE); 398d021c344SAndy King } 399d021c344SAndy King 400d021c344SAndy King int vmci_transport_send_wrote(struct sock *sk) 401d021c344SAndy King { 402d021c344SAndy King return vmci_transport_send_control_pkt( 403d021c344SAndy King sk, VMCI_TRANSPORT_PACKET_TYPE_WROTE, 0, 404d021c344SAndy King 0, NULL, VSOCK_PROTO_INVALID, 405d021c344SAndy King VMCI_INVALID_HANDLE); 406d021c344SAndy King } 407d021c344SAndy King 408d021c344SAndy King int vmci_transport_send_read(struct sock *sk) 409d021c344SAndy King { 410d021c344SAndy King return vmci_transport_send_control_pkt( 411d021c344SAndy King sk, VMCI_TRANSPORT_PACKET_TYPE_READ, 0, 412d021c344SAndy King 0, NULL, VSOCK_PROTO_INVALID, 413d021c344SAndy King VMCI_INVALID_HANDLE); 414d021c344SAndy King } 415d021c344SAndy King 416d021c344SAndy King int vmci_transport_send_waiting_write(struct sock *sk, 417d021c344SAndy King struct vmci_transport_waiting_info *wait) 418d021c344SAndy King { 419d021c344SAndy King return vmci_transport_send_control_pkt( 420d021c344SAndy King sk, VMCI_TRANSPORT_PACKET_TYPE_WAITING_WRITE, 421d021c344SAndy King 0, 0, wait, VSOCK_PROTO_INVALID, 422d021c344SAndy King VMCI_INVALID_HANDLE); 423d021c344SAndy King } 424d021c344SAndy King 425d021c344SAndy King int vmci_transport_send_waiting_read(struct sock *sk, 426d021c344SAndy King struct vmci_transport_waiting_info *wait) 427d021c344SAndy King { 428d021c344SAndy King return vmci_transport_send_control_pkt( 429d021c344SAndy King sk, VMCI_TRANSPORT_PACKET_TYPE_WAITING_READ, 430d021c344SAndy King 0, 0, wait, VSOCK_PROTO_INVALID, 431d021c344SAndy King VMCI_INVALID_HANDLE); 432d021c344SAndy King } 433d021c344SAndy King 434d021c344SAndy King static int vmci_transport_shutdown(struct vsock_sock *vsk, int mode) 435d021c344SAndy King { 436d021c344SAndy King return vmci_transport_send_control_pkt( 437d021c344SAndy King &vsk->sk, 438d021c344SAndy King VMCI_TRANSPORT_PACKET_TYPE_SHUTDOWN, 439d021c344SAndy King 0, mode, NULL, 440d021c344SAndy King VSOCK_PROTO_INVALID, 441d021c344SAndy King VMCI_INVALID_HANDLE); 442d021c344SAndy King } 443d021c344SAndy King 444d021c344SAndy King static int vmci_transport_send_conn_request(struct sock *sk, size_t size) 445d021c344SAndy King { 446d021c344SAndy King return vmci_transport_send_control_pkt(sk, 447d021c344SAndy King VMCI_TRANSPORT_PACKET_TYPE_REQUEST, 448d021c344SAndy King size, 0, NULL, 449d021c344SAndy King VSOCK_PROTO_INVALID, 450d021c344SAndy King VMCI_INVALID_HANDLE); 451d021c344SAndy King } 452d021c344SAndy King 453d021c344SAndy King static int vmci_transport_send_conn_request2(struct sock *sk, size_t size, 454d021c344SAndy King u16 version) 455d021c344SAndy King { 456d021c344SAndy King return vmci_transport_send_control_pkt( 457d021c344SAndy King sk, VMCI_TRANSPORT_PACKET_TYPE_REQUEST2, 458d021c344SAndy King size, 0, NULL, version, 459d021c344SAndy King VMCI_INVALID_HANDLE); 460d021c344SAndy King } 461d021c344SAndy King 462d021c344SAndy King static struct sock *vmci_transport_get_pending( 463d021c344SAndy King struct sock *listener, 464d021c344SAndy King struct vmci_transport_packet *pkt) 465d021c344SAndy King { 466d021c344SAndy King struct vsock_sock *vlistener; 467d021c344SAndy King struct vsock_sock *vpending; 468d021c344SAndy King struct sock *pending; 469d021c344SAndy King 470d021c344SAndy King vlistener = vsock_sk(listener); 471d021c344SAndy King 472d021c344SAndy King list_for_each_entry(vpending, &vlistener->pending_links, 473d021c344SAndy King pending_links) { 474d021c344SAndy King struct sockaddr_vm src; 475d021c344SAndy King struct sockaddr_vm dst; 476d021c344SAndy King 477d021c344SAndy King vsock_addr_init(&src, pkt->dg.src.context, pkt->src_port); 478d021c344SAndy King vsock_addr_init(&dst, pkt->dg.dst.context, pkt->dst_port); 479d021c344SAndy King 480d021c344SAndy King if (vsock_addr_equals_addr(&src, &vpending->remote_addr) && 481d021c344SAndy King vsock_addr_equals_addr(&dst, &vpending->local_addr)) { 482d021c344SAndy King pending = sk_vsock(vpending); 483d021c344SAndy King sock_hold(pending); 484d021c344SAndy King goto found; 485d021c344SAndy King } 486d021c344SAndy King } 487d021c344SAndy King 488d021c344SAndy King pending = NULL; 489d021c344SAndy King found: 490d021c344SAndy King return pending; 491d021c344SAndy King 492d021c344SAndy King } 493d021c344SAndy King 494d021c344SAndy King static void vmci_transport_release_pending(struct sock *pending) 495d021c344SAndy King { 496d021c344SAndy King sock_put(pending); 497d021c344SAndy King } 498d021c344SAndy King 499d021c344SAndy King /* We allow two kinds of sockets to communicate with a restricted VM: 1) 500d021c344SAndy King * trusted sockets 2) sockets from applications running as the same user as the 501d021c344SAndy King * VM (this is only true for the host side and only when using hosted products) 502d021c344SAndy King */ 503d021c344SAndy King 504d021c344SAndy King static bool vmci_transport_is_trusted(struct vsock_sock *vsock, u32 peer_cid) 505d021c344SAndy King { 506d021c344SAndy King return vsock->trusted || 507d021c344SAndy King vmci_is_context_owner(peer_cid, vsock->owner->uid); 508d021c344SAndy King } 509d021c344SAndy King 510d021c344SAndy King /* We allow sending datagrams to and receiving datagrams from a restricted VM 511d021c344SAndy King * only if it is trusted as described in vmci_transport_is_trusted. 512d021c344SAndy King */ 513d021c344SAndy King 514d021c344SAndy King static bool vmci_transport_allow_dgram(struct vsock_sock *vsock, u32 peer_cid) 515d021c344SAndy King { 516d021c344SAndy King if (vsock->cached_peer != peer_cid) { 517d021c344SAndy King vsock->cached_peer = peer_cid; 518d021c344SAndy King if (!vmci_transport_is_trusted(vsock, peer_cid) && 519d021c344SAndy King (vmci_context_get_priv_flags(peer_cid) & 520d021c344SAndy King VMCI_PRIVILEGE_FLAG_RESTRICTED)) { 521d021c344SAndy King vsock->cached_peer_allow_dgram = false; 522d021c344SAndy King } else { 523d021c344SAndy King vsock->cached_peer_allow_dgram = true; 524d021c344SAndy King } 525d021c344SAndy King } 526d021c344SAndy King 527d021c344SAndy King return vsock->cached_peer_allow_dgram; 528d021c344SAndy King } 529d021c344SAndy King 530d021c344SAndy King static int 531d021c344SAndy King vmci_transport_queue_pair_alloc(struct vmci_qp **qpair, 532d021c344SAndy King struct vmci_handle *handle, 533d021c344SAndy King u64 produce_size, 534d021c344SAndy King u64 consume_size, 535d021c344SAndy King u32 peer, u32 flags, bool trusted) 536d021c344SAndy King { 537d021c344SAndy King int err = 0; 538d021c344SAndy King 539d021c344SAndy King if (trusted) { 540d021c344SAndy King /* Try to allocate our queue pair as trusted. This will only 541d021c344SAndy King * work if vsock is running in the host. 542d021c344SAndy King */ 543d021c344SAndy King 544d021c344SAndy King err = vmci_qpair_alloc(qpair, handle, produce_size, 545d021c344SAndy King consume_size, 546d021c344SAndy King peer, flags, 547d021c344SAndy King VMCI_PRIVILEGE_FLAG_TRUSTED); 548d021c344SAndy King if (err != VMCI_ERROR_NO_ACCESS) 549d021c344SAndy King goto out; 550d021c344SAndy King 551d021c344SAndy King } 552d021c344SAndy King 553d021c344SAndy King err = vmci_qpair_alloc(qpair, handle, produce_size, consume_size, 554d021c344SAndy King peer, flags, VMCI_NO_PRIVILEGE_FLAGS); 555d021c344SAndy King out: 556d021c344SAndy King if (err < 0) { 557d021c344SAndy King pr_err("Could not attach to queue pair with %d\n", 558d021c344SAndy King err); 559d021c344SAndy King err = vmci_transport_error_to_vsock_error(err); 560d021c344SAndy King } 561d021c344SAndy King 562d021c344SAndy King return err; 563d021c344SAndy King } 564d021c344SAndy King 565d021c344SAndy King static int 566d021c344SAndy King vmci_transport_datagram_create_hnd(u32 resource_id, 567d021c344SAndy King u32 flags, 568d021c344SAndy King vmci_datagram_recv_cb recv_cb, 569d021c344SAndy King void *client_data, 570d021c344SAndy King struct vmci_handle *out_handle) 571d021c344SAndy King { 572d021c344SAndy King int err = 0; 573d021c344SAndy King 574d021c344SAndy King /* Try to allocate our datagram handler as trusted. This will only work 575d021c344SAndy King * if vsock is running in the host. 576d021c344SAndy King */ 577d021c344SAndy King 578d021c344SAndy King err = vmci_datagram_create_handle_priv(resource_id, flags, 579d021c344SAndy King VMCI_PRIVILEGE_FLAG_TRUSTED, 580d021c344SAndy King recv_cb, 581d021c344SAndy King client_data, out_handle); 582d021c344SAndy King 583d021c344SAndy King if (err == VMCI_ERROR_NO_ACCESS) 584d021c344SAndy King err = vmci_datagram_create_handle(resource_id, flags, 585d021c344SAndy King recv_cb, client_data, 586d021c344SAndy King out_handle); 587d021c344SAndy King 588d021c344SAndy King return err; 589d021c344SAndy King } 590d021c344SAndy King 591d021c344SAndy King /* This is invoked as part of a tasklet that's scheduled when the VMCI 592d021c344SAndy King * interrupt fires. This is run in bottom-half context and if it ever needs to 593d021c344SAndy King * sleep it should defer that work to a work queue. 594d021c344SAndy King */ 595d021c344SAndy King 596d021c344SAndy King static int vmci_transport_recv_dgram_cb(void *data, struct vmci_datagram *dg) 597d021c344SAndy King { 598d021c344SAndy King struct sock *sk; 599d021c344SAndy King size_t size; 600d021c344SAndy King struct sk_buff *skb; 601d021c344SAndy King struct vsock_sock *vsk; 602d021c344SAndy King 603d021c344SAndy King sk = (struct sock *)data; 604d021c344SAndy King 605d021c344SAndy King /* This handler is privileged when this module is running on the host. 606d021c344SAndy King * We will get datagrams from all endpoints (even VMs that are in a 607d021c344SAndy King * restricted context). If we get one from a restricted context then 608d021c344SAndy King * the destination socket must be trusted. 609d021c344SAndy King * 610d021c344SAndy King * NOTE: We access the socket struct without holding the lock here. 611d021c344SAndy King * This is ok because the field we are interested is never modified 612d021c344SAndy King * outside of the create and destruct socket functions. 613d021c344SAndy King */ 614d021c344SAndy King vsk = vsock_sk(sk); 615d021c344SAndy King if (!vmci_transport_allow_dgram(vsk, dg->src.context)) 616d021c344SAndy King return VMCI_ERROR_NO_ACCESS; 617d021c344SAndy King 618d021c344SAndy King size = VMCI_DG_SIZE(dg); 619d021c344SAndy King 620d021c344SAndy King /* Attach the packet to the socket's receive queue as an sk_buff. */ 621d021c344SAndy King skb = alloc_skb(size, GFP_ATOMIC); 622d021c344SAndy King if (skb) { 623d021c344SAndy King /* sk_receive_skb() will do a sock_put(), so hold here. */ 624d021c344SAndy King sock_hold(sk); 625d021c344SAndy King skb_put(skb, size); 626d021c344SAndy King memcpy(skb->data, dg, size); 627d021c344SAndy King sk_receive_skb(sk, skb, 0); 628d021c344SAndy King } 629d021c344SAndy King 630d021c344SAndy King return VMCI_SUCCESS; 631d021c344SAndy King } 632d021c344SAndy King 633d021c344SAndy King static bool vmci_transport_stream_allow(u32 cid, u32 port) 634d021c344SAndy King { 635d021c344SAndy King static const u32 non_socket_contexts[] = { 636d021c344SAndy King VMADDR_CID_HYPERVISOR, 637d021c344SAndy King VMADDR_CID_RESERVED, 638d021c344SAndy King }; 639d021c344SAndy King int i; 640d021c344SAndy King 641d021c344SAndy King BUILD_BUG_ON(sizeof(cid) != sizeof(*non_socket_contexts)); 642d021c344SAndy King 643d021c344SAndy King for (i = 0; i < ARRAY_SIZE(non_socket_contexts); i++) { 644d021c344SAndy King if (cid == non_socket_contexts[i]) 645d021c344SAndy King return false; 646d021c344SAndy King } 647d021c344SAndy King 648d021c344SAndy King return true; 649d021c344SAndy King } 650d021c344SAndy King 651d021c344SAndy King /* This is invoked as part of a tasklet that's scheduled when the VMCI 652d021c344SAndy King * interrupt fires. This is run in bottom-half context but it defers most of 653d021c344SAndy King * its work to the packet handling work queue. 654d021c344SAndy King */ 655d021c344SAndy King 656d021c344SAndy King static int vmci_transport_recv_stream_cb(void *data, struct vmci_datagram *dg) 657d021c344SAndy King { 658d021c344SAndy King struct sock *sk; 659d021c344SAndy King struct sockaddr_vm dst; 660d021c344SAndy King struct sockaddr_vm src; 661d021c344SAndy King struct vmci_transport_packet *pkt; 662d021c344SAndy King struct vsock_sock *vsk; 663d021c344SAndy King bool bh_process_pkt; 664d021c344SAndy King int err; 665d021c344SAndy King 666d021c344SAndy King sk = NULL; 667d021c344SAndy King err = VMCI_SUCCESS; 668d021c344SAndy King bh_process_pkt = false; 669d021c344SAndy King 670d021c344SAndy King /* Ignore incoming packets from contexts without sockets, or resources 671d021c344SAndy King * that aren't vsock implementations. 672d021c344SAndy King */ 673d021c344SAndy King 674d021c344SAndy King if (!vmci_transport_stream_allow(dg->src.context, -1) 675d021c344SAndy King || VMCI_TRANSPORT_PACKET_RID != dg->src.resource) 676d021c344SAndy King return VMCI_ERROR_NO_ACCESS; 677d021c344SAndy King 678d021c344SAndy King if (VMCI_DG_SIZE(dg) < sizeof(*pkt)) 679d021c344SAndy King /* Drop datagrams that do not contain full VSock packets. */ 680d021c344SAndy King return VMCI_ERROR_INVALID_ARGS; 681d021c344SAndy King 682d021c344SAndy King pkt = (struct vmci_transport_packet *)dg; 683d021c344SAndy King 684d021c344SAndy King /* Find the socket that should handle this packet. First we look for a 685d021c344SAndy King * connected socket and if there is none we look for a socket bound to 686d021c344SAndy King * the destintation address. 687d021c344SAndy King */ 688d021c344SAndy King vsock_addr_init(&src, pkt->dg.src.context, pkt->src_port); 689d021c344SAndy King vsock_addr_init(&dst, pkt->dg.dst.context, pkt->dst_port); 690d021c344SAndy King 691d021c344SAndy King sk = vsock_find_connected_socket(&src, &dst); 692d021c344SAndy King if (!sk) { 693d021c344SAndy King sk = vsock_find_bound_socket(&dst); 694d021c344SAndy King if (!sk) { 695d021c344SAndy King /* We could not find a socket for this specified 696d021c344SAndy King * address. If this packet is a RST, we just drop it. 697d021c344SAndy King * If it is another packet, we send a RST. Note that 698d021c344SAndy King * we do not send a RST reply to RSTs so that we do not 699d021c344SAndy King * continually send RSTs between two endpoints. 700d021c344SAndy King * 701d021c344SAndy King * Note that since this is a reply, dst is src and src 702d021c344SAndy King * is dst. 703d021c344SAndy King */ 704d021c344SAndy King if (vmci_transport_send_reset_bh(&dst, &src, pkt) < 0) 705d021c344SAndy King pr_err("unable to send reset\n"); 706d021c344SAndy King 707d021c344SAndy King err = VMCI_ERROR_NOT_FOUND; 708d021c344SAndy King goto out; 709d021c344SAndy King } 710d021c344SAndy King } 711d021c344SAndy King 712d021c344SAndy King /* If the received packet type is beyond all types known to this 713d021c344SAndy King * implementation, reply with an invalid message. Hopefully this will 714d021c344SAndy King * help when implementing backwards compatibility in the future. 715d021c344SAndy King */ 716d021c344SAndy King if (pkt->type >= VMCI_TRANSPORT_PACKET_TYPE_MAX) { 717d021c344SAndy King vmci_transport_send_invalid_bh(&dst, &src); 718d021c344SAndy King err = VMCI_ERROR_INVALID_ARGS; 719d021c344SAndy King goto out; 720d021c344SAndy King } 721d021c344SAndy King 722d021c344SAndy King /* This handler is privileged when this module is running on the host. 723d021c344SAndy King * We will get datagram connect requests from all endpoints (even VMs 724d021c344SAndy King * that are in a restricted context). If we get one from a restricted 725d021c344SAndy King * context then the destination socket must be trusted. 726d021c344SAndy King * 727d021c344SAndy King * NOTE: We access the socket struct without holding the lock here. 728d021c344SAndy King * This is ok because the field we are interested is never modified 729d021c344SAndy King * outside of the create and destruct socket functions. 730d021c344SAndy King */ 731d021c344SAndy King vsk = vsock_sk(sk); 732d021c344SAndy King if (!vmci_transport_allow_dgram(vsk, pkt->dg.src.context)) { 733d021c344SAndy King err = VMCI_ERROR_NO_ACCESS; 734d021c344SAndy King goto out; 735d021c344SAndy King } 736d021c344SAndy King 737d021c344SAndy King /* We do most everything in a work queue, but let's fast path the 738d021c344SAndy King * notification of reads and writes to help data transfer performance. 739d021c344SAndy King * We can only do this if there is no process context code executing 740d021c344SAndy King * for this socket since that may change the state. 741d021c344SAndy King */ 742d021c344SAndy King bh_lock_sock(sk); 743d021c344SAndy King 744d021c344SAndy King if (!sock_owned_by_user(sk) && sk->sk_state == SS_CONNECTED) 745d021c344SAndy King vmci_trans(vsk)->notify_ops->handle_notify_pkt( 746d021c344SAndy King sk, pkt, true, &dst, &src, 747d021c344SAndy King &bh_process_pkt); 748d021c344SAndy King 749d021c344SAndy King bh_unlock_sock(sk); 750d021c344SAndy King 751d021c344SAndy King if (!bh_process_pkt) { 752d021c344SAndy King struct vmci_transport_recv_pkt_info *recv_pkt_info; 753d021c344SAndy King 754d021c344SAndy King recv_pkt_info = kmalloc(sizeof(*recv_pkt_info), GFP_ATOMIC); 755d021c344SAndy King if (!recv_pkt_info) { 756d021c344SAndy King if (vmci_transport_send_reset_bh(&dst, &src, pkt) < 0) 757d021c344SAndy King pr_err("unable to send reset\n"); 758d021c344SAndy King 759d021c344SAndy King err = VMCI_ERROR_NO_MEM; 760d021c344SAndy King goto out; 761d021c344SAndy King } 762d021c344SAndy King 763d021c344SAndy King recv_pkt_info->sk = sk; 764d021c344SAndy King memcpy(&recv_pkt_info->pkt, pkt, sizeof(recv_pkt_info->pkt)); 765d021c344SAndy King INIT_WORK(&recv_pkt_info->work, vmci_transport_recv_pkt_work); 766d021c344SAndy King 767d021c344SAndy King schedule_work(&recv_pkt_info->work); 768d021c344SAndy King /* Clear sk so that the reference count incremented by one of 769d021c344SAndy King * the Find functions above is not decremented below. We need 770d021c344SAndy King * that reference count for the packet handler we've scheduled 771d021c344SAndy King * to run. 772d021c344SAndy King */ 773d021c344SAndy King sk = NULL; 774d021c344SAndy King } 775d021c344SAndy King 776d021c344SAndy King out: 777d021c344SAndy King if (sk) 778d021c344SAndy King sock_put(sk); 779d021c344SAndy King 780d021c344SAndy King return err; 781d021c344SAndy King } 782d021c344SAndy King 783d021c344SAndy King static void vmci_transport_peer_attach_cb(u32 sub_id, 784d021c344SAndy King const struct vmci_event_data *e_data, 785d021c344SAndy King void *client_data) 786d021c344SAndy King { 787d021c344SAndy King struct sock *sk = client_data; 788d021c344SAndy King const struct vmci_event_payload_qp *e_payload; 789d021c344SAndy King struct vsock_sock *vsk; 790d021c344SAndy King 791d021c344SAndy King e_payload = vmci_event_data_const_payload(e_data); 792d021c344SAndy King 793d021c344SAndy King vsk = vsock_sk(sk); 794d021c344SAndy King 795d021c344SAndy King /* We don't ask for delayed CBs when we subscribe to this event (we 796d021c344SAndy King * pass 0 as flags to vmci_event_subscribe()). VMCI makes no 797d021c344SAndy King * guarantees in that case about what context we might be running in, 798d021c344SAndy King * so it could be BH or process, blockable or non-blockable. So we 799d021c344SAndy King * need to account for all possible contexts here. 800d021c344SAndy King */ 801d021c344SAndy King local_bh_disable(); 802d021c344SAndy King bh_lock_sock(sk); 803d021c344SAndy King 804d021c344SAndy King /* XXX This is lame, we should provide a way to lookup sockets by 805d021c344SAndy King * qp_handle. 806d021c344SAndy King */ 807d021c344SAndy King if (vmci_handle_is_equal(vmci_trans(vsk)->qp_handle, 808d021c344SAndy King e_payload->handle)) { 809d021c344SAndy King /* XXX This doesn't do anything, but in the future we may want 810d021c344SAndy King * to set a flag here to verify the attach really did occur and 811d021c344SAndy King * we weren't just sent a datagram claiming it was. 812d021c344SAndy King */ 813d021c344SAndy King goto out; 814d021c344SAndy King } 815d021c344SAndy King 816d021c344SAndy King out: 817d021c344SAndy King bh_unlock_sock(sk); 818d021c344SAndy King local_bh_enable(); 819d021c344SAndy King } 820d021c344SAndy King 821d021c344SAndy King static void vmci_transport_handle_detach(struct sock *sk) 822d021c344SAndy King { 823d021c344SAndy King struct vsock_sock *vsk; 824d021c344SAndy King 825d021c344SAndy King vsk = vsock_sk(sk); 826d021c344SAndy King if (!vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle)) { 827d021c344SAndy King sock_set_flag(sk, SOCK_DONE); 828d021c344SAndy King 829d021c344SAndy King /* On a detach the peer will not be sending or receiving 830d021c344SAndy King * anymore. 831d021c344SAndy King */ 832d021c344SAndy King vsk->peer_shutdown = SHUTDOWN_MASK; 833d021c344SAndy King 834d021c344SAndy King /* We should not be sending anymore since the peer won't be 835d021c344SAndy King * there to receive, but we can still receive if there is data 836d021c344SAndy King * left in our consume queue. 837d021c344SAndy King */ 838d021c344SAndy King if (vsock_stream_has_data(vsk) <= 0) { 839d021c344SAndy King if (sk->sk_state == SS_CONNECTING) { 840d021c344SAndy King /* The peer may detach from a queue pair while 841d021c344SAndy King * we are still in the connecting state, i.e., 842d021c344SAndy King * if the peer VM is killed after attaching to 843d021c344SAndy King * a queue pair, but before we complete the 844d021c344SAndy King * handshake. In that case, we treat the detach 845d021c344SAndy King * event like a reset. 846d021c344SAndy King */ 847d021c344SAndy King 848d021c344SAndy King sk->sk_state = SS_UNCONNECTED; 849d021c344SAndy King sk->sk_err = ECONNRESET; 850d021c344SAndy King sk->sk_error_report(sk); 851d021c344SAndy King return; 852d021c344SAndy King } 853d021c344SAndy King sk->sk_state = SS_UNCONNECTED; 854d021c344SAndy King } 855d021c344SAndy King sk->sk_state_change(sk); 856d021c344SAndy King } 857d021c344SAndy King } 858d021c344SAndy King 859d021c344SAndy King static void vmci_transport_peer_detach_cb(u32 sub_id, 860d021c344SAndy King const struct vmci_event_data *e_data, 861d021c344SAndy King void *client_data) 862d021c344SAndy King { 863d021c344SAndy King struct sock *sk = client_data; 864d021c344SAndy King const struct vmci_event_payload_qp *e_payload; 865d021c344SAndy King struct vsock_sock *vsk; 866d021c344SAndy King 867d021c344SAndy King e_payload = vmci_event_data_const_payload(e_data); 868d021c344SAndy King vsk = vsock_sk(sk); 869d021c344SAndy King if (vmci_handle_is_invalid(e_payload->handle)) 870d021c344SAndy King return; 871d021c344SAndy King 872d021c344SAndy King /* Same rules for locking as for peer_attach_cb(). */ 873d021c344SAndy King local_bh_disable(); 874d021c344SAndy King bh_lock_sock(sk); 875d021c344SAndy King 876d021c344SAndy King /* XXX This is lame, we should provide a way to lookup sockets by 877d021c344SAndy King * qp_handle. 878d021c344SAndy King */ 879d021c344SAndy King if (vmci_handle_is_equal(vmci_trans(vsk)->qp_handle, 880d021c344SAndy King e_payload->handle)) 881d021c344SAndy King vmci_transport_handle_detach(sk); 882d021c344SAndy King 883d021c344SAndy King bh_unlock_sock(sk); 884d021c344SAndy King local_bh_enable(); 885d021c344SAndy King } 886d021c344SAndy King 887d021c344SAndy King static void vmci_transport_qp_resumed_cb(u32 sub_id, 888d021c344SAndy King const struct vmci_event_data *e_data, 889d021c344SAndy King void *client_data) 890d021c344SAndy King { 891d021c344SAndy King vsock_for_each_connected_socket(vmci_transport_handle_detach); 892d021c344SAndy King } 893d021c344SAndy King 894d021c344SAndy King static void vmci_transport_recv_pkt_work(struct work_struct *work) 895d021c344SAndy King { 896d021c344SAndy King struct vmci_transport_recv_pkt_info *recv_pkt_info; 897d021c344SAndy King struct vmci_transport_packet *pkt; 898d021c344SAndy King struct sock *sk; 899d021c344SAndy King 900d021c344SAndy King recv_pkt_info = 901d021c344SAndy King container_of(work, struct vmci_transport_recv_pkt_info, work); 902d021c344SAndy King sk = recv_pkt_info->sk; 903d021c344SAndy King pkt = &recv_pkt_info->pkt; 904d021c344SAndy King 905d021c344SAndy King lock_sock(sk); 906d021c344SAndy King 907d021c344SAndy King switch (sk->sk_state) { 908d021c344SAndy King case SS_LISTEN: 909d021c344SAndy King vmci_transport_recv_listen(sk, pkt); 910d021c344SAndy King break; 911d021c344SAndy King case SS_CONNECTING: 912d021c344SAndy King /* Processing of pending connections for servers goes through 913d021c344SAndy King * the listening socket, so see vmci_transport_recv_listen() 914d021c344SAndy King * for that path. 915d021c344SAndy King */ 916d021c344SAndy King vmci_transport_recv_connecting_client(sk, pkt); 917d021c344SAndy King break; 918d021c344SAndy King case SS_CONNECTED: 919d021c344SAndy King vmci_transport_recv_connected(sk, pkt); 920d021c344SAndy King break; 921d021c344SAndy King default: 922d021c344SAndy King /* Because this function does not run in the same context as 923d021c344SAndy King * vmci_transport_recv_stream_cb it is possible that the 924d021c344SAndy King * socket has closed. We need to let the other side know or it 925d021c344SAndy King * could be sitting in a connect and hang forever. Send a 926d021c344SAndy King * reset to prevent that. 927d021c344SAndy King */ 928d021c344SAndy King vmci_transport_send_reset(sk, pkt); 929d021c344SAndy King goto out; 930d021c344SAndy King } 931d021c344SAndy King 932d021c344SAndy King out: 933d021c344SAndy King release_sock(sk); 934d021c344SAndy King kfree(recv_pkt_info); 935d021c344SAndy King /* Release reference obtained in the stream callback when we fetched 936d021c344SAndy King * this socket out of the bound or connected list. 937d021c344SAndy King */ 938d021c344SAndy King sock_put(sk); 939d021c344SAndy King } 940d021c344SAndy King 941d021c344SAndy King static int vmci_transport_recv_listen(struct sock *sk, 942d021c344SAndy King struct vmci_transport_packet *pkt) 943d021c344SAndy King { 944d021c344SAndy King struct sock *pending; 945d021c344SAndy King struct vsock_sock *vpending; 946d021c344SAndy King int err; 947d021c344SAndy King u64 qp_size; 948d021c344SAndy King bool old_request = false; 949d021c344SAndy King bool old_pkt_proto = false; 950d021c344SAndy King 951d021c344SAndy King err = 0; 952d021c344SAndy King 953d021c344SAndy King /* Because we are in the listen state, we could be receiving a packet 954d021c344SAndy King * for ourself or any previous connection requests that we received. 955d021c344SAndy King * If it's the latter, we try to find a socket in our list of pending 956d021c344SAndy King * connections and, if we do, call the appropriate handler for the 957d021c344SAndy King * state that that socket is in. Otherwise we try to service the 958d021c344SAndy King * connection request. 959d021c344SAndy King */ 960d021c344SAndy King pending = vmci_transport_get_pending(sk, pkt); 961d021c344SAndy King if (pending) { 962d021c344SAndy King lock_sock(pending); 963d021c344SAndy King switch (pending->sk_state) { 964d021c344SAndy King case SS_CONNECTING: 965d021c344SAndy King err = vmci_transport_recv_connecting_server(sk, 966d021c344SAndy King pending, 967d021c344SAndy King pkt); 968d021c344SAndy King break; 969d021c344SAndy King default: 970d021c344SAndy King vmci_transport_send_reset(pending, pkt); 971d021c344SAndy King err = -EINVAL; 972d021c344SAndy King } 973d021c344SAndy King 974d021c344SAndy King if (err < 0) 975d021c344SAndy King vsock_remove_pending(sk, pending); 976d021c344SAndy King 977d021c344SAndy King release_sock(pending); 978d021c344SAndy King vmci_transport_release_pending(pending); 979d021c344SAndy King 980d021c344SAndy King return err; 981d021c344SAndy King } 982d021c344SAndy King 983d021c344SAndy King /* The listen state only accepts connection requests. Reply with a 984d021c344SAndy King * reset unless we received a reset. 985d021c344SAndy King */ 986d021c344SAndy King 987d021c344SAndy King if (!(pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST || 988d021c344SAndy King pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST2)) { 989d021c344SAndy King vmci_transport_reply_reset(pkt); 990d021c344SAndy King return -EINVAL; 991d021c344SAndy King } 992d021c344SAndy King 993d021c344SAndy King if (pkt->u.size == 0) { 994d021c344SAndy King vmci_transport_reply_reset(pkt); 995d021c344SAndy King return -EINVAL; 996d021c344SAndy King } 997d021c344SAndy King 998d021c344SAndy King /* If this socket can't accommodate this connection request, we send a 999d021c344SAndy King * reset. Otherwise we create and initialize a child socket and reply 1000d021c344SAndy King * with a connection negotiation. 1001d021c344SAndy King */ 1002d021c344SAndy King if (sk->sk_ack_backlog >= sk->sk_max_ack_backlog) { 1003d021c344SAndy King vmci_transport_reply_reset(pkt); 1004d021c344SAndy King return -ECONNREFUSED; 1005d021c344SAndy King } 1006d021c344SAndy King 1007d021c344SAndy King pending = __vsock_create(sock_net(sk), NULL, sk, GFP_KERNEL, 1008d021c344SAndy King sk->sk_type); 1009d021c344SAndy King if (!pending) { 1010d021c344SAndy King vmci_transport_send_reset(sk, pkt); 1011d021c344SAndy King return -ENOMEM; 1012d021c344SAndy King } 1013d021c344SAndy King 1014d021c344SAndy King vpending = vsock_sk(pending); 1015d021c344SAndy King 1016d021c344SAndy King vsock_addr_init(&vpending->local_addr, pkt->dg.dst.context, 1017d021c344SAndy King pkt->dst_port); 1018d021c344SAndy King vsock_addr_init(&vpending->remote_addr, pkt->dg.src.context, 1019d021c344SAndy King pkt->src_port); 1020d021c344SAndy King 1021d021c344SAndy King /* If the proposed size fits within our min/max, accept it. Otherwise 1022d021c344SAndy King * propose our own size. 1023d021c344SAndy King */ 1024d021c344SAndy King if (pkt->u.size >= vmci_trans(vpending)->queue_pair_min_size && 1025d021c344SAndy King pkt->u.size <= vmci_trans(vpending)->queue_pair_max_size) { 1026d021c344SAndy King qp_size = pkt->u.size; 1027d021c344SAndy King } else { 1028d021c344SAndy King qp_size = vmci_trans(vpending)->queue_pair_size; 1029d021c344SAndy King } 1030d021c344SAndy King 1031d021c344SAndy King /* Figure out if we are using old or new requests based on the 1032d021c344SAndy King * overrides pkt types sent by our peer. 1033d021c344SAndy King */ 1034d021c344SAndy King if (vmci_transport_old_proto_override(&old_pkt_proto)) { 1035d021c344SAndy King old_request = old_pkt_proto; 1036d021c344SAndy King } else { 1037d021c344SAndy King if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST) 1038d021c344SAndy King old_request = true; 1039d021c344SAndy King else if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST2) 1040d021c344SAndy King old_request = false; 1041d021c344SAndy King 1042d021c344SAndy King } 1043d021c344SAndy King 1044d021c344SAndy King if (old_request) { 1045d021c344SAndy King /* Handle a REQUEST (or override) */ 1046d021c344SAndy King u16 version = VSOCK_PROTO_INVALID; 1047d021c344SAndy King if (vmci_transport_proto_to_notify_struct( 1048d021c344SAndy King pending, &version, true)) 1049d021c344SAndy King err = vmci_transport_send_negotiate(pending, qp_size); 1050d021c344SAndy King else 1051d021c344SAndy King err = -EINVAL; 1052d021c344SAndy King 1053d021c344SAndy King } else { 1054d021c344SAndy King /* Handle a REQUEST2 (or override) */ 1055d021c344SAndy King int proto_int = pkt->proto; 1056d021c344SAndy King int pos; 1057d021c344SAndy King u16 active_proto_version = 0; 1058d021c344SAndy King 1059d021c344SAndy King /* The list of possible protocols is the intersection of all 1060d021c344SAndy King * protocols the client supports ... plus all the protocols we 1061d021c344SAndy King * support. 1062d021c344SAndy King */ 1063d021c344SAndy King proto_int &= vmci_transport_new_proto_supported_versions(); 1064d021c344SAndy King 1065d021c344SAndy King /* We choose the highest possible protocol version and use that 1066d021c344SAndy King * one. 1067d021c344SAndy King */ 1068d021c344SAndy King pos = fls(proto_int); 1069d021c344SAndy King if (pos) { 1070d021c344SAndy King active_proto_version = (1 << (pos - 1)); 1071d021c344SAndy King if (vmci_transport_proto_to_notify_struct( 1072d021c344SAndy King pending, &active_proto_version, false)) 1073d021c344SAndy King err = vmci_transport_send_negotiate2(pending, 1074d021c344SAndy King qp_size, 1075d021c344SAndy King active_proto_version); 1076d021c344SAndy King else 1077d021c344SAndy King err = -EINVAL; 1078d021c344SAndy King 1079d021c344SAndy King } else { 1080d021c344SAndy King err = -EINVAL; 1081d021c344SAndy King } 1082d021c344SAndy King } 1083d021c344SAndy King 1084d021c344SAndy King if (err < 0) { 1085d021c344SAndy King vmci_transport_send_reset(sk, pkt); 1086d021c344SAndy King sock_put(pending); 1087d021c344SAndy King err = vmci_transport_error_to_vsock_error(err); 1088d021c344SAndy King goto out; 1089d021c344SAndy King } 1090d021c344SAndy King 1091d021c344SAndy King vsock_add_pending(sk, pending); 1092d021c344SAndy King sk->sk_ack_backlog++; 1093d021c344SAndy King 1094d021c344SAndy King pending->sk_state = SS_CONNECTING; 1095d021c344SAndy King vmci_trans(vpending)->produce_size = 1096d021c344SAndy King vmci_trans(vpending)->consume_size = qp_size; 1097d021c344SAndy King vmci_trans(vpending)->queue_pair_size = qp_size; 1098d021c344SAndy King 1099d021c344SAndy King vmci_trans(vpending)->notify_ops->process_request(pending); 1100d021c344SAndy King 1101d021c344SAndy King /* We might never receive another message for this socket and it's not 1102d021c344SAndy King * connected to any process, so we have to ensure it gets cleaned up 1103d021c344SAndy King * ourself. Our delayed work function will take care of that. Note 1104d021c344SAndy King * that we do not ever cancel this function since we have few 1105d021c344SAndy King * guarantees about its state when calling cancel_delayed_work(). 1106d021c344SAndy King * Instead we hold a reference on the socket for that function and make 1107d021c344SAndy King * it capable of handling cases where it needs to do nothing but 1108d021c344SAndy King * release that reference. 1109d021c344SAndy King */ 1110d021c344SAndy King vpending->listener = sk; 1111d021c344SAndy King sock_hold(sk); 1112d021c344SAndy King sock_hold(pending); 1113d021c344SAndy King INIT_DELAYED_WORK(&vpending->dwork, vsock_pending_work); 1114d021c344SAndy King schedule_delayed_work(&vpending->dwork, HZ); 1115d021c344SAndy King 1116d021c344SAndy King out: 1117d021c344SAndy King return err; 1118d021c344SAndy King } 1119d021c344SAndy King 1120d021c344SAndy King static int 1121d021c344SAndy King vmci_transport_recv_connecting_server(struct sock *listener, 1122d021c344SAndy King struct sock *pending, 1123d021c344SAndy King struct vmci_transport_packet *pkt) 1124d021c344SAndy King { 1125d021c344SAndy King struct vsock_sock *vpending; 1126d021c344SAndy King struct vmci_handle handle; 1127d021c344SAndy King struct vmci_qp *qpair; 1128d021c344SAndy King bool is_local; 1129d021c344SAndy King u32 flags; 1130d021c344SAndy King u32 detach_sub_id; 1131d021c344SAndy King int err; 1132d021c344SAndy King int skerr; 1133d021c344SAndy King 1134d021c344SAndy King vpending = vsock_sk(pending); 1135d021c344SAndy King detach_sub_id = VMCI_INVALID_ID; 1136d021c344SAndy King 1137d021c344SAndy King switch (pkt->type) { 1138d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_OFFER: 1139d021c344SAndy King if (vmci_handle_is_invalid(pkt->u.handle)) { 1140d021c344SAndy King vmci_transport_send_reset(pending, pkt); 1141d021c344SAndy King skerr = EPROTO; 1142d021c344SAndy King err = -EINVAL; 1143d021c344SAndy King goto destroy; 1144d021c344SAndy King } 1145d021c344SAndy King break; 1146d021c344SAndy King default: 1147d021c344SAndy King /* Close and cleanup the connection. */ 1148d021c344SAndy King vmci_transport_send_reset(pending, pkt); 1149d021c344SAndy King skerr = EPROTO; 1150d021c344SAndy King err = pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST ? 0 : -EINVAL; 1151d021c344SAndy King goto destroy; 1152d021c344SAndy King } 1153d021c344SAndy King 1154d021c344SAndy King /* In order to complete the connection we need to attach to the offered 1155d021c344SAndy King * queue pair and send an attach notification. We also subscribe to the 1156d021c344SAndy King * detach event so we know when our peer goes away, and we do that 1157d021c344SAndy King * before attaching so we don't miss an event. If all this succeeds, 1158d021c344SAndy King * we update our state and wakeup anything waiting in accept() for a 1159d021c344SAndy King * connection. 1160d021c344SAndy King */ 1161d021c344SAndy King 1162d021c344SAndy King /* We don't care about attach since we ensure the other side has 1163d021c344SAndy King * attached by specifying the ATTACH_ONLY flag below. 1164d021c344SAndy King */ 1165d021c344SAndy King err = vmci_event_subscribe(VMCI_EVENT_QP_PEER_DETACH, 1166d021c344SAndy King vmci_transport_peer_detach_cb, 1167d021c344SAndy King pending, &detach_sub_id); 1168d021c344SAndy King if (err < VMCI_SUCCESS) { 1169d021c344SAndy King vmci_transport_send_reset(pending, pkt); 1170d021c344SAndy King err = vmci_transport_error_to_vsock_error(err); 1171d021c344SAndy King skerr = -err; 1172d021c344SAndy King goto destroy; 1173d021c344SAndy King } 1174d021c344SAndy King 1175d021c344SAndy King vmci_trans(vpending)->detach_sub_id = detach_sub_id; 1176d021c344SAndy King 1177d021c344SAndy King /* Now attach to the queue pair the client created. */ 1178d021c344SAndy King handle = pkt->u.handle; 1179d021c344SAndy King 1180d021c344SAndy King /* vpending->local_addr always has a context id so we do not need to 1181d021c344SAndy King * worry about VMADDR_CID_ANY in this case. 1182d021c344SAndy King */ 1183d021c344SAndy King is_local = 1184d021c344SAndy King vpending->remote_addr.svm_cid == vpending->local_addr.svm_cid; 1185d021c344SAndy King flags = VMCI_QPFLAG_ATTACH_ONLY; 1186d021c344SAndy King flags |= is_local ? VMCI_QPFLAG_LOCAL : 0; 1187d021c344SAndy King 1188d021c344SAndy King err = vmci_transport_queue_pair_alloc( 1189d021c344SAndy King &qpair, 1190d021c344SAndy King &handle, 1191d021c344SAndy King vmci_trans(vpending)->produce_size, 1192d021c344SAndy King vmci_trans(vpending)->consume_size, 1193d021c344SAndy King pkt->dg.src.context, 1194d021c344SAndy King flags, 1195d021c344SAndy King vmci_transport_is_trusted( 1196d021c344SAndy King vpending, 1197d021c344SAndy King vpending->remote_addr.svm_cid)); 1198d021c344SAndy King if (err < 0) { 1199d021c344SAndy King vmci_transport_send_reset(pending, pkt); 1200d021c344SAndy King skerr = -err; 1201d021c344SAndy King goto destroy; 1202d021c344SAndy King } 1203d021c344SAndy King 1204d021c344SAndy King vmci_trans(vpending)->qp_handle = handle; 1205d021c344SAndy King vmci_trans(vpending)->qpair = qpair; 1206d021c344SAndy King 1207d021c344SAndy King /* When we send the attach message, we must be ready to handle incoming 1208d021c344SAndy King * control messages on the newly connected socket. So we move the 1209d021c344SAndy King * pending socket to the connected state before sending the attach 1210d021c344SAndy King * message. Otherwise, an incoming packet triggered by the attach being 1211d021c344SAndy King * received by the peer may be processed concurrently with what happens 1212d021c344SAndy King * below after sending the attach message, and that incoming packet 1213d021c344SAndy King * will find the listening socket instead of the (currently) pending 1214d021c344SAndy King * socket. Note that enqueueing the socket increments the reference 1215d021c344SAndy King * count, so even if a reset comes before the connection is accepted, 1216d021c344SAndy King * the socket will be valid until it is removed from the queue. 1217d021c344SAndy King * 1218d021c344SAndy King * If we fail sending the attach below, we remove the socket from the 1219d021c344SAndy King * connected list and move the socket to SS_UNCONNECTED before 1220d021c344SAndy King * releasing the lock, so a pending slow path processing of an incoming 1221d021c344SAndy King * packet will not see the socket in the connected state in that case. 1222d021c344SAndy King */ 1223d021c344SAndy King pending->sk_state = SS_CONNECTED; 1224d021c344SAndy King 1225d021c344SAndy King vsock_insert_connected(vpending); 1226d021c344SAndy King 1227d021c344SAndy King /* Notify our peer of our attach. */ 1228d021c344SAndy King err = vmci_transport_send_attach(pending, handle); 1229d021c344SAndy King if (err < 0) { 1230d021c344SAndy King vsock_remove_connected(vpending); 1231d021c344SAndy King pr_err("Could not send attach\n"); 1232d021c344SAndy King vmci_transport_send_reset(pending, pkt); 1233d021c344SAndy King err = vmci_transport_error_to_vsock_error(err); 1234d021c344SAndy King skerr = -err; 1235d021c344SAndy King goto destroy; 1236d021c344SAndy King } 1237d021c344SAndy King 1238d021c344SAndy King /* We have a connection. Move the now connected socket from the 1239d021c344SAndy King * listener's pending list to the accept queue so callers of accept() 1240d021c344SAndy King * can find it. 1241d021c344SAndy King */ 1242d021c344SAndy King vsock_remove_pending(listener, pending); 1243d021c344SAndy King vsock_enqueue_accept(listener, pending); 1244d021c344SAndy King 1245d021c344SAndy King /* Callers of accept() will be be waiting on the listening socket, not 1246d021c344SAndy King * the pending socket. 1247d021c344SAndy King */ 1248d021c344SAndy King listener->sk_state_change(listener); 1249d021c344SAndy King 1250d021c344SAndy King return 0; 1251d021c344SAndy King 1252d021c344SAndy King destroy: 1253d021c344SAndy King pending->sk_err = skerr; 1254d021c344SAndy King pending->sk_state = SS_UNCONNECTED; 1255d021c344SAndy King /* As long as we drop our reference, all necessary cleanup will handle 1256d021c344SAndy King * when the cleanup function drops its reference and our destruct 1257d021c344SAndy King * implementation is called. Note that since the listen handler will 1258d021c344SAndy King * remove pending from the pending list upon our failure, the cleanup 1259d021c344SAndy King * function won't drop the additional reference, which is why we do it 1260d021c344SAndy King * here. 1261d021c344SAndy King */ 1262d021c344SAndy King sock_put(pending); 1263d021c344SAndy King 1264d021c344SAndy King return err; 1265d021c344SAndy King } 1266d021c344SAndy King 1267d021c344SAndy King static int 1268d021c344SAndy King vmci_transport_recv_connecting_client(struct sock *sk, 1269d021c344SAndy King struct vmci_transport_packet *pkt) 1270d021c344SAndy King { 1271d021c344SAndy King struct vsock_sock *vsk; 1272d021c344SAndy King int err; 1273d021c344SAndy King int skerr; 1274d021c344SAndy King 1275d021c344SAndy King vsk = vsock_sk(sk); 1276d021c344SAndy King 1277d021c344SAndy King switch (pkt->type) { 1278d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_ATTACH: 1279d021c344SAndy King if (vmci_handle_is_invalid(pkt->u.handle) || 1280d021c344SAndy King !vmci_handle_is_equal(pkt->u.handle, 1281d021c344SAndy King vmci_trans(vsk)->qp_handle)) { 1282d021c344SAndy King skerr = EPROTO; 1283d021c344SAndy King err = -EINVAL; 1284d021c344SAndy King goto destroy; 1285d021c344SAndy King } 1286d021c344SAndy King 1287d021c344SAndy King /* Signify the socket is connected and wakeup the waiter in 1288d021c344SAndy King * connect(). Also place the socket in the connected table for 1289d021c344SAndy King * accounting (it can already be found since it's in the bound 1290d021c344SAndy King * table). 1291d021c344SAndy King */ 1292d021c344SAndy King sk->sk_state = SS_CONNECTED; 1293d021c344SAndy King sk->sk_socket->state = SS_CONNECTED; 1294d021c344SAndy King vsock_insert_connected(vsk); 1295d021c344SAndy King sk->sk_state_change(sk); 1296d021c344SAndy King 1297d021c344SAndy King break; 1298d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE: 1299d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2: 1300d021c344SAndy King if (pkt->u.size == 0 1301d021c344SAndy King || pkt->dg.src.context != vsk->remote_addr.svm_cid 1302d021c344SAndy King || pkt->src_port != vsk->remote_addr.svm_port 1303d021c344SAndy King || !vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle) 1304d021c344SAndy King || vmci_trans(vsk)->qpair 1305d021c344SAndy King || vmci_trans(vsk)->produce_size != 0 1306d021c344SAndy King || vmci_trans(vsk)->consume_size != 0 1307d021c344SAndy King || vmci_trans(vsk)->attach_sub_id != VMCI_INVALID_ID 1308d021c344SAndy King || vmci_trans(vsk)->detach_sub_id != VMCI_INVALID_ID) { 1309d021c344SAndy King skerr = EPROTO; 1310d021c344SAndy King err = -EINVAL; 1311d021c344SAndy King 1312d021c344SAndy King goto destroy; 1313d021c344SAndy King } 1314d021c344SAndy King 1315d021c344SAndy King err = vmci_transport_recv_connecting_client_negotiate(sk, pkt); 1316d021c344SAndy King if (err) { 1317d021c344SAndy King skerr = -err; 1318d021c344SAndy King goto destroy; 1319d021c344SAndy King } 1320d021c344SAndy King 1321d021c344SAndy King break; 1322d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_INVALID: 1323d021c344SAndy King err = vmci_transport_recv_connecting_client_invalid(sk, pkt); 1324d021c344SAndy King if (err) { 1325d021c344SAndy King skerr = -err; 1326d021c344SAndy King goto destroy; 1327d021c344SAndy King } 1328d021c344SAndy King 1329d021c344SAndy King break; 1330d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_RST: 1331d021c344SAndy King /* Older versions of the linux code (WS 6.5 / ESX 4.0) used to 1332d021c344SAndy King * continue processing here after they sent an INVALID packet. 1333d021c344SAndy King * This meant that we got a RST after the INVALID. We ignore a 1334d021c344SAndy King * RST after an INVALID. The common code doesn't send the RST 1335d021c344SAndy King * ... so we can hang if an old version of the common code 1336d021c344SAndy King * fails between getting a REQUEST and sending an OFFER back. 1337d021c344SAndy King * Not much we can do about it... except hope that it doesn't 1338d021c344SAndy King * happen. 1339d021c344SAndy King */ 1340d021c344SAndy King if (vsk->ignore_connecting_rst) { 1341d021c344SAndy King vsk->ignore_connecting_rst = false; 1342d021c344SAndy King } else { 1343d021c344SAndy King skerr = ECONNRESET; 1344d021c344SAndy King err = 0; 1345d021c344SAndy King goto destroy; 1346d021c344SAndy King } 1347d021c344SAndy King 1348d021c344SAndy King break; 1349d021c344SAndy King default: 1350d021c344SAndy King /* Close and cleanup the connection. */ 1351d021c344SAndy King skerr = EPROTO; 1352d021c344SAndy King err = -EINVAL; 1353d021c344SAndy King goto destroy; 1354d021c344SAndy King } 1355d021c344SAndy King 1356d021c344SAndy King return 0; 1357d021c344SAndy King 1358d021c344SAndy King destroy: 1359d021c344SAndy King vmci_transport_send_reset(sk, pkt); 1360d021c344SAndy King 1361d021c344SAndy King sk->sk_state = SS_UNCONNECTED; 1362d021c344SAndy King sk->sk_err = skerr; 1363d021c344SAndy King sk->sk_error_report(sk); 1364d021c344SAndy King return err; 1365d021c344SAndy King } 1366d021c344SAndy King 1367d021c344SAndy King static int vmci_transport_recv_connecting_client_negotiate( 1368d021c344SAndy King struct sock *sk, 1369d021c344SAndy King struct vmci_transport_packet *pkt) 1370d021c344SAndy King { 1371d021c344SAndy King int err; 1372d021c344SAndy King struct vsock_sock *vsk; 1373d021c344SAndy King struct vmci_handle handle; 1374d021c344SAndy King struct vmci_qp *qpair; 1375d021c344SAndy King u32 attach_sub_id; 1376d021c344SAndy King u32 detach_sub_id; 1377d021c344SAndy King bool is_local; 1378d021c344SAndy King u32 flags; 1379d021c344SAndy King bool old_proto = true; 1380d021c344SAndy King bool old_pkt_proto; 1381d021c344SAndy King u16 version; 1382d021c344SAndy King 1383d021c344SAndy King vsk = vsock_sk(sk); 1384d021c344SAndy King handle = VMCI_INVALID_HANDLE; 1385d021c344SAndy King attach_sub_id = VMCI_INVALID_ID; 1386d021c344SAndy King detach_sub_id = VMCI_INVALID_ID; 1387d021c344SAndy King 1388d021c344SAndy King /* If we have gotten here then we should be past the point where old 1389d021c344SAndy King * linux vsock could have sent the bogus rst. 1390d021c344SAndy King */ 1391d021c344SAndy King vsk->sent_request = false; 1392d021c344SAndy King vsk->ignore_connecting_rst = false; 1393d021c344SAndy King 1394d021c344SAndy King /* Verify that we're OK with the proposed queue pair size */ 1395d021c344SAndy King if (pkt->u.size < vmci_trans(vsk)->queue_pair_min_size || 1396d021c344SAndy King pkt->u.size > vmci_trans(vsk)->queue_pair_max_size) { 1397d021c344SAndy King err = -EINVAL; 1398d021c344SAndy King goto destroy; 1399d021c344SAndy King } 1400d021c344SAndy King 1401d021c344SAndy King /* At this point we know the CID the peer is using to talk to us. */ 1402d021c344SAndy King 1403d021c344SAndy King if (vsk->local_addr.svm_cid == VMADDR_CID_ANY) 1404d021c344SAndy King vsk->local_addr.svm_cid = pkt->dg.dst.context; 1405d021c344SAndy King 1406d021c344SAndy King /* Setup the notify ops to be the highest supported version that both 1407d021c344SAndy King * the server and the client support. 1408d021c344SAndy King */ 1409d021c344SAndy King 1410d021c344SAndy King if (vmci_transport_old_proto_override(&old_pkt_proto)) { 1411d021c344SAndy King old_proto = old_pkt_proto; 1412d021c344SAndy King } else { 1413d021c344SAndy King if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE) 1414d021c344SAndy King old_proto = true; 1415d021c344SAndy King else if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2) 1416d021c344SAndy King old_proto = false; 1417d021c344SAndy King 1418d021c344SAndy King } 1419d021c344SAndy King 1420d021c344SAndy King if (old_proto) 1421d021c344SAndy King version = VSOCK_PROTO_INVALID; 1422d021c344SAndy King else 1423d021c344SAndy King version = pkt->proto; 1424d021c344SAndy King 1425d021c344SAndy King if (!vmci_transport_proto_to_notify_struct(sk, &version, old_proto)) { 1426d021c344SAndy King err = -EINVAL; 1427d021c344SAndy King goto destroy; 1428d021c344SAndy King } 1429d021c344SAndy King 1430d021c344SAndy King /* Subscribe to attach and detach events first. 1431d021c344SAndy King * 1432d021c344SAndy King * XXX We attach once for each queue pair created for now so it is easy 1433d021c344SAndy King * to find the socket (it's provided), but later we should only 1434d021c344SAndy King * subscribe once and add a way to lookup sockets by queue pair handle. 1435d021c344SAndy King */ 1436d021c344SAndy King err = vmci_event_subscribe(VMCI_EVENT_QP_PEER_ATTACH, 1437d021c344SAndy King vmci_transport_peer_attach_cb, 1438d021c344SAndy King sk, &attach_sub_id); 1439d021c344SAndy King if (err < VMCI_SUCCESS) { 1440d021c344SAndy King err = vmci_transport_error_to_vsock_error(err); 1441d021c344SAndy King goto destroy; 1442d021c344SAndy King } 1443d021c344SAndy King 1444d021c344SAndy King err = vmci_event_subscribe(VMCI_EVENT_QP_PEER_DETACH, 1445d021c344SAndy King vmci_transport_peer_detach_cb, 1446d021c344SAndy King sk, &detach_sub_id); 1447d021c344SAndy King if (err < VMCI_SUCCESS) { 1448d021c344SAndy King err = vmci_transport_error_to_vsock_error(err); 1449d021c344SAndy King goto destroy; 1450d021c344SAndy King } 1451d021c344SAndy King 1452d021c344SAndy King /* Make VMCI select the handle for us. */ 1453d021c344SAndy King handle = VMCI_INVALID_HANDLE; 1454d021c344SAndy King is_local = vsk->remote_addr.svm_cid == vsk->local_addr.svm_cid; 1455d021c344SAndy King flags = is_local ? VMCI_QPFLAG_LOCAL : 0; 1456d021c344SAndy King 1457d021c344SAndy King err = vmci_transport_queue_pair_alloc(&qpair, 1458d021c344SAndy King &handle, 1459d021c344SAndy King pkt->u.size, 1460d021c344SAndy King pkt->u.size, 1461d021c344SAndy King vsk->remote_addr.svm_cid, 1462d021c344SAndy King flags, 1463d021c344SAndy King vmci_transport_is_trusted( 1464d021c344SAndy King vsk, 1465d021c344SAndy King vsk-> 1466d021c344SAndy King remote_addr.svm_cid)); 1467d021c344SAndy King if (err < 0) 1468d021c344SAndy King goto destroy; 1469d021c344SAndy King 1470d021c344SAndy King err = vmci_transport_send_qp_offer(sk, handle); 1471d021c344SAndy King if (err < 0) { 1472d021c344SAndy King err = vmci_transport_error_to_vsock_error(err); 1473d021c344SAndy King goto destroy; 1474d021c344SAndy King } 1475d021c344SAndy King 1476d021c344SAndy King vmci_trans(vsk)->qp_handle = handle; 1477d021c344SAndy King vmci_trans(vsk)->qpair = qpair; 1478d021c344SAndy King 1479d021c344SAndy King vmci_trans(vsk)->produce_size = vmci_trans(vsk)->consume_size = 1480d021c344SAndy King pkt->u.size; 1481d021c344SAndy King 1482d021c344SAndy King vmci_trans(vsk)->attach_sub_id = attach_sub_id; 1483d021c344SAndy King vmci_trans(vsk)->detach_sub_id = detach_sub_id; 1484d021c344SAndy King 1485d021c344SAndy King vmci_trans(vsk)->notify_ops->process_negotiate(sk); 1486d021c344SAndy King 1487d021c344SAndy King return 0; 1488d021c344SAndy King 1489d021c344SAndy King destroy: 1490d021c344SAndy King if (attach_sub_id != VMCI_INVALID_ID) 1491d021c344SAndy King vmci_event_unsubscribe(attach_sub_id); 1492d021c344SAndy King 1493d021c344SAndy King if (detach_sub_id != VMCI_INVALID_ID) 1494d021c344SAndy King vmci_event_unsubscribe(detach_sub_id); 1495d021c344SAndy King 1496d021c344SAndy King if (!vmci_handle_is_invalid(handle)) 1497d021c344SAndy King vmci_qpair_detach(&qpair); 1498d021c344SAndy King 1499d021c344SAndy King return err; 1500d021c344SAndy King } 1501d021c344SAndy King 1502d021c344SAndy King static int 1503d021c344SAndy King vmci_transport_recv_connecting_client_invalid(struct sock *sk, 1504d021c344SAndy King struct vmci_transport_packet *pkt) 1505d021c344SAndy King { 1506d021c344SAndy King int err = 0; 1507d021c344SAndy King struct vsock_sock *vsk = vsock_sk(sk); 1508d021c344SAndy King 1509d021c344SAndy King if (vsk->sent_request) { 1510d021c344SAndy King vsk->sent_request = false; 1511d021c344SAndy King vsk->ignore_connecting_rst = true; 1512d021c344SAndy King 1513d021c344SAndy King err = vmci_transport_send_conn_request( 1514d021c344SAndy King sk, vmci_trans(vsk)->queue_pair_size); 1515d021c344SAndy King if (err < 0) 1516d021c344SAndy King err = vmci_transport_error_to_vsock_error(err); 1517d021c344SAndy King else 1518d021c344SAndy King err = 0; 1519d021c344SAndy King 1520d021c344SAndy King } 1521d021c344SAndy King 1522d021c344SAndy King return err; 1523d021c344SAndy King } 1524d021c344SAndy King 1525d021c344SAndy King static int vmci_transport_recv_connected(struct sock *sk, 1526d021c344SAndy King struct vmci_transport_packet *pkt) 1527d021c344SAndy King { 1528d021c344SAndy King struct vsock_sock *vsk; 1529d021c344SAndy King bool pkt_processed = false; 1530d021c344SAndy King 1531d021c344SAndy King /* In cases where we are closing the connection, it's sufficient to 1532d021c344SAndy King * mark the state change (and maybe error) and wake up any waiting 1533d021c344SAndy King * threads. Since this is a connected socket, it's owned by a user 1534d021c344SAndy King * process and will be cleaned up when the failure is passed back on 1535d021c344SAndy King * the current or next system call. Our system call implementations 1536d021c344SAndy King * must therefore check for error and state changes on entry and when 1537d021c344SAndy King * being awoken. 1538d021c344SAndy King */ 1539d021c344SAndy King switch (pkt->type) { 1540d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_SHUTDOWN: 1541d021c344SAndy King if (pkt->u.mode) { 1542d021c344SAndy King vsk = vsock_sk(sk); 1543d021c344SAndy King 1544d021c344SAndy King vsk->peer_shutdown |= pkt->u.mode; 1545d021c344SAndy King sk->sk_state_change(sk); 1546d021c344SAndy King } 1547d021c344SAndy King break; 1548d021c344SAndy King 1549d021c344SAndy King case VMCI_TRANSPORT_PACKET_TYPE_RST: 1550d021c344SAndy King vsk = vsock_sk(sk); 1551d021c344SAndy King /* It is possible that we sent our peer a message (e.g a 1552d021c344SAndy King * WAITING_READ) right before we got notified that the peer had 1553d021c344SAndy King * detached. If that happens then we can get a RST pkt back 1554d021c344SAndy King * from our peer even though there is data available for us to 1555d021c344SAndy King * read. In that case, don't shutdown the socket completely but 1556d021c344SAndy King * instead allow the local client to finish reading data off 1557d021c344SAndy King * the queuepair. Always treat a RST pkt in connected mode like 1558d021c344SAndy King * a clean shutdown. 1559d021c344SAndy King */ 1560d021c344SAndy King sock_set_flag(sk, SOCK_DONE); 1561d021c344SAndy King vsk->peer_shutdown = SHUTDOWN_MASK; 1562d021c344SAndy King if (vsock_stream_has_data(vsk) <= 0) 1563d021c344SAndy King sk->sk_state = SS_DISCONNECTING; 1564d021c344SAndy King 1565d021c344SAndy King sk->sk_state_change(sk); 1566d021c344SAndy King break; 1567d021c344SAndy King 1568d021c344SAndy King default: 1569d021c344SAndy King vsk = vsock_sk(sk); 1570d021c344SAndy King vmci_trans(vsk)->notify_ops->handle_notify_pkt( 1571d021c344SAndy King sk, pkt, false, NULL, NULL, 1572d021c344SAndy King &pkt_processed); 1573d021c344SAndy King if (!pkt_processed) 1574d021c344SAndy King return -EINVAL; 1575d021c344SAndy King 1576d021c344SAndy King break; 1577d021c344SAndy King } 1578d021c344SAndy King 1579d021c344SAndy King return 0; 1580d021c344SAndy King } 1581d021c344SAndy King 1582d021c344SAndy King static int vmci_transport_socket_init(struct vsock_sock *vsk, 1583d021c344SAndy King struct vsock_sock *psk) 1584d021c344SAndy King { 1585d021c344SAndy King vsk->trans = kmalloc(sizeof(struct vmci_transport), GFP_KERNEL); 1586d021c344SAndy King if (!vsk->trans) 1587d021c344SAndy King return -ENOMEM; 1588d021c344SAndy King 1589d021c344SAndy King vmci_trans(vsk)->dg_handle = VMCI_INVALID_HANDLE; 1590d021c344SAndy King vmci_trans(vsk)->qp_handle = VMCI_INVALID_HANDLE; 1591d021c344SAndy King vmci_trans(vsk)->qpair = NULL; 1592d021c344SAndy King vmci_trans(vsk)->produce_size = vmci_trans(vsk)->consume_size = 0; 1593d021c344SAndy King vmci_trans(vsk)->attach_sub_id = vmci_trans(vsk)->detach_sub_id = 1594d021c344SAndy King VMCI_INVALID_ID; 1595d021c344SAndy King vmci_trans(vsk)->notify_ops = NULL; 1596d021c344SAndy King if (psk) { 1597d021c344SAndy King vmci_trans(vsk)->queue_pair_size = 1598d021c344SAndy King vmci_trans(psk)->queue_pair_size; 1599d021c344SAndy King vmci_trans(vsk)->queue_pair_min_size = 1600d021c344SAndy King vmci_trans(psk)->queue_pair_min_size; 1601d021c344SAndy King vmci_trans(vsk)->queue_pair_max_size = 1602d021c344SAndy King vmci_trans(psk)->queue_pair_max_size; 1603d021c344SAndy King } else { 1604d021c344SAndy King vmci_trans(vsk)->queue_pair_size = 1605d021c344SAndy King VMCI_TRANSPORT_DEFAULT_QP_SIZE; 1606d021c344SAndy King vmci_trans(vsk)->queue_pair_min_size = 1607d021c344SAndy King VMCI_TRANSPORT_DEFAULT_QP_SIZE_MIN; 1608d021c344SAndy King vmci_trans(vsk)->queue_pair_max_size = 1609d021c344SAndy King VMCI_TRANSPORT_DEFAULT_QP_SIZE_MAX; 1610d021c344SAndy King } 1611d021c344SAndy King 1612d021c344SAndy King return 0; 1613d021c344SAndy King } 1614d021c344SAndy King 1615d021c344SAndy King static void vmci_transport_destruct(struct vsock_sock *vsk) 1616d021c344SAndy King { 1617d021c344SAndy King if (vmci_trans(vsk)->attach_sub_id != VMCI_INVALID_ID) { 1618d021c344SAndy King vmci_event_unsubscribe(vmci_trans(vsk)->attach_sub_id); 1619d021c344SAndy King vmci_trans(vsk)->attach_sub_id = VMCI_INVALID_ID; 1620d021c344SAndy King } 1621d021c344SAndy King 1622d021c344SAndy King if (vmci_trans(vsk)->detach_sub_id != VMCI_INVALID_ID) { 1623d021c344SAndy King vmci_event_unsubscribe(vmci_trans(vsk)->detach_sub_id); 1624d021c344SAndy King vmci_trans(vsk)->detach_sub_id = VMCI_INVALID_ID; 1625d021c344SAndy King } 1626d021c344SAndy King 1627d021c344SAndy King if (!vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle)) { 1628d021c344SAndy King vmci_qpair_detach(&vmci_trans(vsk)->qpair); 1629d021c344SAndy King vmci_trans(vsk)->qp_handle = VMCI_INVALID_HANDLE; 1630d021c344SAndy King vmci_trans(vsk)->produce_size = 0; 1631d021c344SAndy King vmci_trans(vsk)->consume_size = 0; 1632d021c344SAndy King } 1633d021c344SAndy King 1634d021c344SAndy King if (vmci_trans(vsk)->notify_ops) 1635d021c344SAndy King vmci_trans(vsk)->notify_ops->socket_destruct(vsk); 1636d021c344SAndy King 1637d021c344SAndy King kfree(vsk->trans); 1638d021c344SAndy King vsk->trans = NULL; 1639d021c344SAndy King } 1640d021c344SAndy King 1641d021c344SAndy King static void vmci_transport_release(struct vsock_sock *vsk) 1642d021c344SAndy King { 1643d021c344SAndy King if (!vmci_handle_is_invalid(vmci_trans(vsk)->dg_handle)) { 1644d021c344SAndy King vmci_datagram_destroy_handle(vmci_trans(vsk)->dg_handle); 1645d021c344SAndy King vmci_trans(vsk)->dg_handle = VMCI_INVALID_HANDLE; 1646d021c344SAndy King } 1647d021c344SAndy King } 1648d021c344SAndy King 1649d021c344SAndy King static int vmci_transport_dgram_bind(struct vsock_sock *vsk, 1650d021c344SAndy King struct sockaddr_vm *addr) 1651d021c344SAndy King { 1652d021c344SAndy King u32 port; 1653d021c344SAndy King u32 flags; 1654d021c344SAndy King int err; 1655d021c344SAndy King 1656d021c344SAndy King /* VMCI will select a resource ID for us if we provide 1657d021c344SAndy King * VMCI_INVALID_ID. 1658d021c344SAndy King */ 1659d021c344SAndy King port = addr->svm_port == VMADDR_PORT_ANY ? 1660d021c344SAndy King VMCI_INVALID_ID : addr->svm_port; 1661d021c344SAndy King 1662d021c344SAndy King if (port <= LAST_RESERVED_PORT && !capable(CAP_NET_BIND_SERVICE)) 1663d021c344SAndy King return -EACCES; 1664d021c344SAndy King 1665d021c344SAndy King flags = addr->svm_cid == VMADDR_CID_ANY ? 1666d021c344SAndy King VMCI_FLAG_ANYCID_DG_HND : 0; 1667d021c344SAndy King 1668d021c344SAndy King err = vmci_transport_datagram_create_hnd(port, flags, 1669d021c344SAndy King vmci_transport_recv_dgram_cb, 1670d021c344SAndy King &vsk->sk, 1671d021c344SAndy King &vmci_trans(vsk)->dg_handle); 1672d021c344SAndy King if (err < VMCI_SUCCESS) 1673d021c344SAndy King return vmci_transport_error_to_vsock_error(err); 1674d021c344SAndy King vsock_addr_init(&vsk->local_addr, addr->svm_cid, 1675d021c344SAndy King vmci_trans(vsk)->dg_handle.resource); 1676d021c344SAndy King 1677d021c344SAndy King return 0; 1678d021c344SAndy King } 1679d021c344SAndy King 1680d021c344SAndy King static int vmci_transport_dgram_enqueue( 1681d021c344SAndy King struct vsock_sock *vsk, 1682d021c344SAndy King struct sockaddr_vm *remote_addr, 1683d021c344SAndy King struct iovec *iov, 1684d021c344SAndy King size_t len) 1685d021c344SAndy King { 1686d021c344SAndy King int err; 1687d021c344SAndy King struct vmci_datagram *dg; 1688d021c344SAndy King 1689d021c344SAndy King if (len > VMCI_MAX_DG_PAYLOAD_SIZE) 1690d021c344SAndy King return -EMSGSIZE; 1691d021c344SAndy King 1692d021c344SAndy King if (!vmci_transport_allow_dgram(vsk, remote_addr->svm_cid)) 1693d021c344SAndy King return -EPERM; 1694d021c344SAndy King 1695d021c344SAndy King /* Allocate a buffer for the user's message and our packet header. */ 1696d021c344SAndy King dg = kmalloc(len + sizeof(*dg), GFP_KERNEL); 1697d021c344SAndy King if (!dg) 1698d021c344SAndy King return -ENOMEM; 1699d021c344SAndy King 1700d021c344SAndy King memcpy_fromiovec(VMCI_DG_PAYLOAD(dg), iov, len); 1701d021c344SAndy King 1702d021c344SAndy King dg->dst = vmci_make_handle(remote_addr->svm_cid, 1703d021c344SAndy King remote_addr->svm_port); 1704d021c344SAndy King dg->src = vmci_make_handle(vsk->local_addr.svm_cid, 1705d021c344SAndy King vsk->local_addr.svm_port); 1706d021c344SAndy King dg->payload_size = len; 1707d021c344SAndy King 1708d021c344SAndy King err = vmci_datagram_send(dg); 1709d021c344SAndy King kfree(dg); 1710d021c344SAndy King if (err < 0) 1711d021c344SAndy King return vmci_transport_error_to_vsock_error(err); 1712d021c344SAndy King 1713d021c344SAndy King return err - sizeof(*dg); 1714d021c344SAndy King } 1715d021c344SAndy King 1716d021c344SAndy King static int vmci_transport_dgram_dequeue(struct kiocb *kiocb, 1717d021c344SAndy King struct vsock_sock *vsk, 1718d021c344SAndy King struct msghdr *msg, size_t len, 1719d021c344SAndy King int flags) 1720d021c344SAndy King { 1721d021c344SAndy King int err; 1722d021c344SAndy King int noblock; 1723d021c344SAndy King struct vmci_datagram *dg; 1724d021c344SAndy King size_t payload_len; 1725d021c344SAndy King struct sk_buff *skb; 1726d021c344SAndy King 1727d021c344SAndy King noblock = flags & MSG_DONTWAIT; 1728d021c344SAndy King 1729d021c344SAndy King if (flags & MSG_OOB || flags & MSG_ERRQUEUE) 1730d021c344SAndy King return -EOPNOTSUPP; 1731d021c344SAndy King 1732d021c344SAndy King /* Retrieve the head sk_buff from the socket's receive queue. */ 1733d021c344SAndy King err = 0; 1734d021c344SAndy King skb = skb_recv_datagram(&vsk->sk, flags, noblock, &err); 1735d021c344SAndy King if (err) 1736d021c344SAndy King return err; 1737d021c344SAndy King 1738d021c344SAndy King if (!skb) 1739d021c344SAndy King return -EAGAIN; 1740d021c344SAndy King 1741d021c344SAndy King dg = (struct vmci_datagram *)skb->data; 1742d021c344SAndy King if (!dg) 1743d021c344SAndy King /* err is 0, meaning we read zero bytes. */ 1744d021c344SAndy King goto out; 1745d021c344SAndy King 1746d021c344SAndy King payload_len = dg->payload_size; 1747d021c344SAndy King /* Ensure the sk_buff matches the payload size claimed in the packet. */ 1748d021c344SAndy King if (payload_len != skb->len - sizeof(*dg)) { 1749d021c344SAndy King err = -EINVAL; 1750d021c344SAndy King goto out; 1751d021c344SAndy King } 1752d021c344SAndy King 1753d021c344SAndy King if (payload_len > len) { 1754d021c344SAndy King payload_len = len; 1755d021c344SAndy King msg->msg_flags |= MSG_TRUNC; 1756d021c344SAndy King } 1757d021c344SAndy King 1758d021c344SAndy King /* Place the datagram payload in the user's iovec. */ 1759d021c344SAndy King err = skb_copy_datagram_iovec(skb, sizeof(*dg), msg->msg_iov, 1760d021c344SAndy King payload_len); 1761d021c344SAndy King if (err) 1762d021c344SAndy King goto out; 1763d021c344SAndy King 1764d021c344SAndy King msg->msg_namelen = 0; 1765d021c344SAndy King if (msg->msg_name) { 1766d021c344SAndy King struct sockaddr_vm *vm_addr; 1767d021c344SAndy King 1768d021c344SAndy King /* Provide the address of the sender. */ 1769d021c344SAndy King vm_addr = (struct sockaddr_vm *)msg->msg_name; 1770d021c344SAndy King vsock_addr_init(vm_addr, dg->src.context, dg->src.resource); 1771d021c344SAndy King msg->msg_namelen = sizeof(*vm_addr); 1772d021c344SAndy King } 1773d021c344SAndy King err = payload_len; 1774d021c344SAndy King 1775d021c344SAndy King out: 1776d021c344SAndy King skb_free_datagram(&vsk->sk, skb); 1777d021c344SAndy King return err; 1778d021c344SAndy King } 1779d021c344SAndy King 1780d021c344SAndy King static bool vmci_transport_dgram_allow(u32 cid, u32 port) 1781d021c344SAndy King { 1782d021c344SAndy King if (cid == VMADDR_CID_HYPERVISOR) { 1783d021c344SAndy King /* Registrations of PBRPC Servers do not modify VMX/Hypervisor 1784d021c344SAndy King * state and are allowed. 1785d021c344SAndy King */ 1786d021c344SAndy King return port == VMCI_UNITY_PBRPC_REGISTER; 1787d021c344SAndy King } 1788d021c344SAndy King 1789d021c344SAndy King return true; 1790d021c344SAndy King } 1791d021c344SAndy King 1792d021c344SAndy King static int vmci_transport_connect(struct vsock_sock *vsk) 1793d021c344SAndy King { 1794d021c344SAndy King int err; 1795d021c344SAndy King bool old_pkt_proto = false; 1796d021c344SAndy King struct sock *sk = &vsk->sk; 1797d021c344SAndy King 1798d021c344SAndy King if (vmci_transport_old_proto_override(&old_pkt_proto) && 1799d021c344SAndy King old_pkt_proto) { 1800d021c344SAndy King err = vmci_transport_send_conn_request( 1801d021c344SAndy King sk, vmci_trans(vsk)->queue_pair_size); 1802d021c344SAndy King if (err < 0) { 1803d021c344SAndy King sk->sk_state = SS_UNCONNECTED; 1804d021c344SAndy King return err; 1805d021c344SAndy King } 1806d021c344SAndy King } else { 1807d021c344SAndy King int supported_proto_versions = 1808d021c344SAndy King vmci_transport_new_proto_supported_versions(); 1809d021c344SAndy King err = vmci_transport_send_conn_request2( 1810d021c344SAndy King sk, vmci_trans(vsk)->queue_pair_size, 1811d021c344SAndy King supported_proto_versions); 1812d021c344SAndy King if (err < 0) { 1813d021c344SAndy King sk->sk_state = SS_UNCONNECTED; 1814d021c344SAndy King return err; 1815d021c344SAndy King } 1816d021c344SAndy King 1817d021c344SAndy King vsk->sent_request = true; 1818d021c344SAndy King } 1819d021c344SAndy King 1820d021c344SAndy King return err; 1821d021c344SAndy King } 1822d021c344SAndy King 1823d021c344SAndy King static ssize_t vmci_transport_stream_dequeue( 1824d021c344SAndy King struct vsock_sock *vsk, 1825d021c344SAndy King struct iovec *iov, 1826d021c344SAndy King size_t len, 1827d021c344SAndy King int flags) 1828d021c344SAndy King { 1829d021c344SAndy King if (flags & MSG_PEEK) 1830d021c344SAndy King return vmci_qpair_peekv(vmci_trans(vsk)->qpair, iov, len, 0); 1831d021c344SAndy King else 1832d021c344SAndy King return vmci_qpair_dequev(vmci_trans(vsk)->qpair, iov, len, 0); 1833d021c344SAndy King } 1834d021c344SAndy King 1835d021c344SAndy King static ssize_t vmci_transport_stream_enqueue( 1836d021c344SAndy King struct vsock_sock *vsk, 1837d021c344SAndy King struct iovec *iov, 1838d021c344SAndy King size_t len) 1839d021c344SAndy King { 1840d021c344SAndy King return vmci_qpair_enquev(vmci_trans(vsk)->qpair, iov, len, 0); 1841d021c344SAndy King } 1842d021c344SAndy King 1843d021c344SAndy King static s64 vmci_transport_stream_has_data(struct vsock_sock *vsk) 1844d021c344SAndy King { 1845d021c344SAndy King return vmci_qpair_consume_buf_ready(vmci_trans(vsk)->qpair); 1846d021c344SAndy King } 1847d021c344SAndy King 1848d021c344SAndy King static s64 vmci_transport_stream_has_space(struct vsock_sock *vsk) 1849d021c344SAndy King { 1850d021c344SAndy King return vmci_qpair_produce_free_space(vmci_trans(vsk)->qpair); 1851d021c344SAndy King } 1852d021c344SAndy King 1853d021c344SAndy King static u64 vmci_transport_stream_rcvhiwat(struct vsock_sock *vsk) 1854d021c344SAndy King { 1855d021c344SAndy King return vmci_trans(vsk)->consume_size; 1856d021c344SAndy King } 1857d021c344SAndy King 1858d021c344SAndy King static bool vmci_transport_stream_is_active(struct vsock_sock *vsk) 1859d021c344SAndy King { 1860d021c344SAndy King return !vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle); 1861d021c344SAndy King } 1862d021c344SAndy King 1863d021c344SAndy King static u64 vmci_transport_get_buffer_size(struct vsock_sock *vsk) 1864d021c344SAndy King { 1865d021c344SAndy King return vmci_trans(vsk)->queue_pair_size; 1866d021c344SAndy King } 1867d021c344SAndy King 1868d021c344SAndy King static u64 vmci_transport_get_min_buffer_size(struct vsock_sock *vsk) 1869d021c344SAndy King { 1870d021c344SAndy King return vmci_trans(vsk)->queue_pair_min_size; 1871d021c344SAndy King } 1872d021c344SAndy King 1873d021c344SAndy King static u64 vmci_transport_get_max_buffer_size(struct vsock_sock *vsk) 1874d021c344SAndy King { 1875d021c344SAndy King return vmci_trans(vsk)->queue_pair_max_size; 1876d021c344SAndy King } 1877d021c344SAndy King 1878d021c344SAndy King static void vmci_transport_set_buffer_size(struct vsock_sock *vsk, u64 val) 1879d021c344SAndy King { 1880d021c344SAndy King if (val < vmci_trans(vsk)->queue_pair_min_size) 1881d021c344SAndy King vmci_trans(vsk)->queue_pair_min_size = val; 1882d021c344SAndy King if (val > vmci_trans(vsk)->queue_pair_max_size) 1883d021c344SAndy King vmci_trans(vsk)->queue_pair_max_size = val; 1884d021c344SAndy King vmci_trans(vsk)->queue_pair_size = val; 1885d021c344SAndy King } 1886d021c344SAndy King 1887d021c344SAndy King static void vmci_transport_set_min_buffer_size(struct vsock_sock *vsk, 1888d021c344SAndy King u64 val) 1889d021c344SAndy King { 1890d021c344SAndy King if (val > vmci_trans(vsk)->queue_pair_size) 1891d021c344SAndy King vmci_trans(vsk)->queue_pair_size = val; 1892d021c344SAndy King vmci_trans(vsk)->queue_pair_min_size = val; 1893d021c344SAndy King } 1894d021c344SAndy King 1895d021c344SAndy King static void vmci_transport_set_max_buffer_size(struct vsock_sock *vsk, 1896d021c344SAndy King u64 val) 1897d021c344SAndy King { 1898d021c344SAndy King if (val < vmci_trans(vsk)->queue_pair_size) 1899d021c344SAndy King vmci_trans(vsk)->queue_pair_size = val; 1900d021c344SAndy King vmci_trans(vsk)->queue_pair_max_size = val; 1901d021c344SAndy King } 1902d021c344SAndy King 1903d021c344SAndy King static int vmci_transport_notify_poll_in( 1904d021c344SAndy King struct vsock_sock *vsk, 1905d021c344SAndy King size_t target, 1906d021c344SAndy King bool *data_ready_now) 1907d021c344SAndy King { 1908d021c344SAndy King return vmci_trans(vsk)->notify_ops->poll_in( 1909d021c344SAndy King &vsk->sk, target, data_ready_now); 1910d021c344SAndy King } 1911d021c344SAndy King 1912d021c344SAndy King static int vmci_transport_notify_poll_out( 1913d021c344SAndy King struct vsock_sock *vsk, 1914d021c344SAndy King size_t target, 1915d021c344SAndy King bool *space_available_now) 1916d021c344SAndy King { 1917d021c344SAndy King return vmci_trans(vsk)->notify_ops->poll_out( 1918d021c344SAndy King &vsk->sk, target, space_available_now); 1919d021c344SAndy King } 1920d021c344SAndy King 1921d021c344SAndy King static int vmci_transport_notify_recv_init( 1922d021c344SAndy King struct vsock_sock *vsk, 1923d021c344SAndy King size_t target, 1924d021c344SAndy King struct vsock_transport_recv_notify_data *data) 1925d021c344SAndy King { 1926d021c344SAndy King return vmci_trans(vsk)->notify_ops->recv_init( 1927d021c344SAndy King &vsk->sk, target, 1928d021c344SAndy King (struct vmci_transport_recv_notify_data *)data); 1929d021c344SAndy King } 1930d021c344SAndy King 1931d021c344SAndy King static int vmci_transport_notify_recv_pre_block( 1932d021c344SAndy King struct vsock_sock *vsk, 1933d021c344SAndy King size_t target, 1934d021c344SAndy King struct vsock_transport_recv_notify_data *data) 1935d021c344SAndy King { 1936d021c344SAndy King return vmci_trans(vsk)->notify_ops->recv_pre_block( 1937d021c344SAndy King &vsk->sk, target, 1938d021c344SAndy King (struct vmci_transport_recv_notify_data *)data); 1939d021c344SAndy King } 1940d021c344SAndy King 1941d021c344SAndy King static int vmci_transport_notify_recv_pre_dequeue( 1942d021c344SAndy King struct vsock_sock *vsk, 1943d021c344SAndy King size_t target, 1944d021c344SAndy King struct vsock_transport_recv_notify_data *data) 1945d021c344SAndy King { 1946d021c344SAndy King return vmci_trans(vsk)->notify_ops->recv_pre_dequeue( 1947d021c344SAndy King &vsk->sk, target, 1948d021c344SAndy King (struct vmci_transport_recv_notify_data *)data); 1949d021c344SAndy King } 1950d021c344SAndy King 1951d021c344SAndy King static int vmci_transport_notify_recv_post_dequeue( 1952d021c344SAndy King struct vsock_sock *vsk, 1953d021c344SAndy King size_t target, 1954d021c344SAndy King ssize_t copied, 1955d021c344SAndy King bool data_read, 1956d021c344SAndy King struct vsock_transport_recv_notify_data *data) 1957d021c344SAndy King { 1958d021c344SAndy King return vmci_trans(vsk)->notify_ops->recv_post_dequeue( 1959d021c344SAndy King &vsk->sk, target, copied, data_read, 1960d021c344SAndy King (struct vmci_transport_recv_notify_data *)data); 1961d021c344SAndy King } 1962d021c344SAndy King 1963d021c344SAndy King static int vmci_transport_notify_send_init( 1964d021c344SAndy King struct vsock_sock *vsk, 1965d021c344SAndy King struct vsock_transport_send_notify_data *data) 1966d021c344SAndy King { 1967d021c344SAndy King return vmci_trans(vsk)->notify_ops->send_init( 1968d021c344SAndy King &vsk->sk, 1969d021c344SAndy King (struct vmci_transport_send_notify_data *)data); 1970d021c344SAndy King } 1971d021c344SAndy King 1972d021c344SAndy King static int vmci_transport_notify_send_pre_block( 1973d021c344SAndy King struct vsock_sock *vsk, 1974d021c344SAndy King struct vsock_transport_send_notify_data *data) 1975d021c344SAndy King { 1976d021c344SAndy King return vmci_trans(vsk)->notify_ops->send_pre_block( 1977d021c344SAndy King &vsk->sk, 1978d021c344SAndy King (struct vmci_transport_send_notify_data *)data); 1979d021c344SAndy King } 1980d021c344SAndy King 1981d021c344SAndy King static int vmci_transport_notify_send_pre_enqueue( 1982d021c344SAndy King struct vsock_sock *vsk, 1983d021c344SAndy King struct vsock_transport_send_notify_data *data) 1984d021c344SAndy King { 1985d021c344SAndy King return vmci_trans(vsk)->notify_ops->send_pre_enqueue( 1986d021c344SAndy King &vsk->sk, 1987d021c344SAndy King (struct vmci_transport_send_notify_data *)data); 1988d021c344SAndy King } 1989d021c344SAndy King 1990d021c344SAndy King static int vmci_transport_notify_send_post_enqueue( 1991d021c344SAndy King struct vsock_sock *vsk, 1992d021c344SAndy King ssize_t written, 1993d021c344SAndy King struct vsock_transport_send_notify_data *data) 1994d021c344SAndy King { 1995d021c344SAndy King return vmci_trans(vsk)->notify_ops->send_post_enqueue( 1996d021c344SAndy King &vsk->sk, written, 1997d021c344SAndy King (struct vmci_transport_send_notify_data *)data); 1998d021c344SAndy King } 1999d021c344SAndy King 2000d021c344SAndy King static bool vmci_transport_old_proto_override(bool *old_pkt_proto) 2001d021c344SAndy King { 2002d021c344SAndy King if (PROTOCOL_OVERRIDE != -1) { 2003d021c344SAndy King if (PROTOCOL_OVERRIDE == 0) 2004d021c344SAndy King *old_pkt_proto = true; 2005d021c344SAndy King else 2006d021c344SAndy King *old_pkt_proto = false; 2007d021c344SAndy King 2008d021c344SAndy King pr_info("Proto override in use\n"); 2009d021c344SAndy King return true; 2010d021c344SAndy King } 2011d021c344SAndy King 2012d021c344SAndy King return false; 2013d021c344SAndy King } 2014d021c344SAndy King 2015d021c344SAndy King static bool vmci_transport_proto_to_notify_struct(struct sock *sk, 2016d021c344SAndy King u16 *proto, 2017d021c344SAndy King bool old_pkt_proto) 2018d021c344SAndy King { 2019d021c344SAndy King struct vsock_sock *vsk = vsock_sk(sk); 2020d021c344SAndy King 2021d021c344SAndy King if (old_pkt_proto) { 2022d021c344SAndy King if (*proto != VSOCK_PROTO_INVALID) { 2023d021c344SAndy King pr_err("Can't set both an old and new protocol\n"); 2024d021c344SAndy King return false; 2025d021c344SAndy King } 2026d021c344SAndy King vmci_trans(vsk)->notify_ops = &vmci_transport_notify_pkt_ops; 2027d021c344SAndy King goto exit; 2028d021c344SAndy King } 2029d021c344SAndy King 2030d021c344SAndy King switch (*proto) { 2031d021c344SAndy King case VSOCK_PROTO_PKT_ON_NOTIFY: 2032d021c344SAndy King vmci_trans(vsk)->notify_ops = 2033d021c344SAndy King &vmci_transport_notify_pkt_q_state_ops; 2034d021c344SAndy King break; 2035d021c344SAndy King default: 2036d021c344SAndy King pr_err("Unknown notify protocol version\n"); 2037d021c344SAndy King return false; 2038d021c344SAndy King } 2039d021c344SAndy King 2040d021c344SAndy King exit: 2041d021c344SAndy King vmci_trans(vsk)->notify_ops->socket_init(sk); 2042d021c344SAndy King return true; 2043d021c344SAndy King } 2044d021c344SAndy King 2045d021c344SAndy King static u16 vmci_transport_new_proto_supported_versions(void) 2046d021c344SAndy King { 2047d021c344SAndy King if (PROTOCOL_OVERRIDE != -1) 2048d021c344SAndy King return PROTOCOL_OVERRIDE; 2049d021c344SAndy King 2050d021c344SAndy King return VSOCK_PROTO_ALL_SUPPORTED; 2051d021c344SAndy King } 2052d021c344SAndy King 2053d021c344SAndy King static u32 vmci_transport_get_local_cid(void) 2054d021c344SAndy King { 2055d021c344SAndy King return vmci_get_context_id(); 2056d021c344SAndy King } 2057d021c344SAndy King 2058d021c344SAndy King static struct vsock_transport vmci_transport = { 2059d021c344SAndy King .init = vmci_transport_socket_init, 2060d021c344SAndy King .destruct = vmci_transport_destruct, 2061d021c344SAndy King .release = vmci_transport_release, 2062d021c344SAndy King .connect = vmci_transport_connect, 2063d021c344SAndy King .dgram_bind = vmci_transport_dgram_bind, 2064d021c344SAndy King .dgram_dequeue = vmci_transport_dgram_dequeue, 2065d021c344SAndy King .dgram_enqueue = vmci_transport_dgram_enqueue, 2066d021c344SAndy King .dgram_allow = vmci_transport_dgram_allow, 2067d021c344SAndy King .stream_dequeue = vmci_transport_stream_dequeue, 2068d021c344SAndy King .stream_enqueue = vmci_transport_stream_enqueue, 2069d021c344SAndy King .stream_has_data = vmci_transport_stream_has_data, 2070d021c344SAndy King .stream_has_space = vmci_transport_stream_has_space, 2071d021c344SAndy King .stream_rcvhiwat = vmci_transport_stream_rcvhiwat, 2072d021c344SAndy King .stream_is_active = vmci_transport_stream_is_active, 2073d021c344SAndy King .stream_allow = vmci_transport_stream_allow, 2074d021c344SAndy King .notify_poll_in = vmci_transport_notify_poll_in, 2075d021c344SAndy King .notify_poll_out = vmci_transport_notify_poll_out, 2076d021c344SAndy King .notify_recv_init = vmci_transport_notify_recv_init, 2077d021c344SAndy King .notify_recv_pre_block = vmci_transport_notify_recv_pre_block, 2078d021c344SAndy King .notify_recv_pre_dequeue = vmci_transport_notify_recv_pre_dequeue, 2079d021c344SAndy King .notify_recv_post_dequeue = vmci_transport_notify_recv_post_dequeue, 2080d021c344SAndy King .notify_send_init = vmci_transport_notify_send_init, 2081d021c344SAndy King .notify_send_pre_block = vmci_transport_notify_send_pre_block, 2082d021c344SAndy King .notify_send_pre_enqueue = vmci_transport_notify_send_pre_enqueue, 2083d021c344SAndy King .notify_send_post_enqueue = vmci_transport_notify_send_post_enqueue, 2084d021c344SAndy King .shutdown = vmci_transport_shutdown, 2085d021c344SAndy King .set_buffer_size = vmci_transport_set_buffer_size, 2086d021c344SAndy King .set_min_buffer_size = vmci_transport_set_min_buffer_size, 2087d021c344SAndy King .set_max_buffer_size = vmci_transport_set_max_buffer_size, 2088d021c344SAndy King .get_buffer_size = vmci_transport_get_buffer_size, 2089d021c344SAndy King .get_min_buffer_size = vmci_transport_get_min_buffer_size, 2090d021c344SAndy King .get_max_buffer_size = vmci_transport_get_max_buffer_size, 2091d021c344SAndy King .get_local_cid = vmci_transport_get_local_cid, 2092d021c344SAndy King }; 2093d021c344SAndy King 2094d021c344SAndy King static int __init vmci_transport_init(void) 2095d021c344SAndy King { 2096d021c344SAndy King int err; 2097d021c344SAndy King 2098d021c344SAndy King /* Create the datagram handle that we will use to send and receive all 2099d021c344SAndy King * VSocket control messages for this context. 2100d021c344SAndy King */ 2101d021c344SAndy King err = vmci_transport_datagram_create_hnd(VMCI_TRANSPORT_PACKET_RID, 2102d021c344SAndy King VMCI_FLAG_ANYCID_DG_HND, 2103d021c344SAndy King vmci_transport_recv_stream_cb, 2104d021c344SAndy King NULL, 2105d021c344SAndy King &vmci_transport_stream_handle); 2106d021c344SAndy King if (err < VMCI_SUCCESS) { 2107d021c344SAndy King pr_err("Unable to create datagram handle. (%d)\n", err); 2108d021c344SAndy King return vmci_transport_error_to_vsock_error(err); 2109d021c344SAndy King } 2110d021c344SAndy King 2111d021c344SAndy King err = vmci_event_subscribe(VMCI_EVENT_QP_RESUMED, 2112d021c344SAndy King vmci_transport_qp_resumed_cb, 2113d021c344SAndy King NULL, &vmci_transport_qp_resumed_sub_id); 2114d021c344SAndy King if (err < VMCI_SUCCESS) { 2115d021c344SAndy King pr_err("Unable to subscribe to resumed event. (%d)\n", err); 2116d021c344SAndy King err = vmci_transport_error_to_vsock_error(err); 2117d021c344SAndy King vmci_transport_qp_resumed_sub_id = VMCI_INVALID_ID; 2118d021c344SAndy King goto err_destroy_stream_handle; 2119d021c344SAndy King } 2120d021c344SAndy King 2121d021c344SAndy King err = vsock_core_init(&vmci_transport); 2122d021c344SAndy King if (err < 0) 2123d021c344SAndy King goto err_unsubscribe; 2124d021c344SAndy King 2125d021c344SAndy King return 0; 2126d021c344SAndy King 2127d021c344SAndy King err_unsubscribe: 2128d021c344SAndy King vmci_event_unsubscribe(vmci_transport_qp_resumed_sub_id); 2129d021c344SAndy King err_destroy_stream_handle: 2130d021c344SAndy King vmci_datagram_destroy_handle(vmci_transport_stream_handle); 2131d021c344SAndy King return err; 2132d021c344SAndy King } 2133d021c344SAndy King module_init(vmci_transport_init); 2134d021c344SAndy King 2135d021c344SAndy King static void __exit vmci_transport_exit(void) 2136d021c344SAndy King { 2137d021c344SAndy King if (!vmci_handle_is_invalid(vmci_transport_stream_handle)) { 2138d021c344SAndy King if (vmci_datagram_destroy_handle( 2139d021c344SAndy King vmci_transport_stream_handle) != VMCI_SUCCESS) 2140d021c344SAndy King pr_err("Couldn't destroy datagram handle\n"); 2141d021c344SAndy King vmci_transport_stream_handle = VMCI_INVALID_HANDLE; 2142d021c344SAndy King } 2143d021c344SAndy King 2144d021c344SAndy King if (vmci_transport_qp_resumed_sub_id != VMCI_INVALID_ID) { 2145d021c344SAndy King vmci_event_unsubscribe(vmci_transport_qp_resumed_sub_id); 2146d021c344SAndy King vmci_transport_qp_resumed_sub_id = VMCI_INVALID_ID; 2147d021c344SAndy King } 2148d021c344SAndy King 2149d021c344SAndy King vsock_core_exit(); 2150d021c344SAndy King } 2151d021c344SAndy King module_exit(vmci_transport_exit); 2152d021c344SAndy King 2153d021c344SAndy King MODULE_AUTHOR("VMware, Inc."); 2154d021c344SAndy King MODULE_DESCRIPTION("VMCI transport for Virtual Sockets"); 2155d021c344SAndy King MODULE_LICENSE("GPL v2"); 2156d021c344SAndy King MODULE_ALIAS("vmware_vsock"); 2157d021c344SAndy King MODULE_ALIAS_NETPROTO(PF_VSOCK); 2158