From: VMware, Inc <> Date: Fri, 12 Apr 2013 19:53:40 +0000 (-0700) Subject: HGFS: Remove socket and vsocket from Linux client X-Git-Tag: 2013.04.16-1098359~20 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=8e7d40cc3cd5dfa7e8cfe64d289691725ed82024;p=thirdparty%2Fopen-vm-tools.git HGFS: Remove socket and vsocket from Linux client The server side has removed the TCP socket and VSocket support for HGFS so now remove the code from the Linux client. Signed-off-by: Dmitry Torokhov --- diff --git a/open-vm-tools/modules/linux/vmhgfs/tcp.c b/open-vm-tools/modules/linux/vmhgfs/tcp.c deleted file mode 100644 index 31a40dfa4..000000000 --- a/open-vm-tools/modules/linux/vmhgfs/tcp.c +++ /dev/null @@ -1,972 +0,0 @@ -/********************************************************* - * Copyright (C) 2009 VMware, Inc. All rights reserved. - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation version 2 and no later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY - * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - * - *********************************************************/ - -/* - * tcp.c -- - * - * Provides TCP channel to the HGFS client. - * - * Compiled conditionally. - * Need to specify host ip at module load to enable the channel. - */ - -/* Must come before any kernel header file. */ -#include "driver-config.h" - -#include -#include -#include -#include -#include -#include -#include - -#include "compat_kernel.h" -#include "compat_mutex.h" -#include "compat_version.h" -#include "compat_sched.h" -#include "compat_sock.h" -#include "compat_timer.h" - -#include "vm_assert.h" - -#include "hgfsProto.h" -#include "hgfsDevLinux.h" -#include "module.h" -#include "transport.h" - -static char *HOST_IP; -module_param(HOST_IP, charp, 0444); - -static int HOST_PORT = 2000; /* Defaulted to 2000. */ -module_param(HOST_PORT, int, 0444); - -static int HOST_VSOCKET_PORT = 0; /* Disabled by default. */ -module_param(HOST_VSOCKET_PORT, int, 0444); - -#ifdef INCLUDE_VSOCKETS - -#include "vmci_defs.h" -#include "vmci_sockets.h" - -#else -/* - * At the moment I can't check in HGFS that is dependent on vsock - * because of unresolved installer problems. Installer need to properly handle - * dependecies between vmhgfs and vsock modules. - * Following stub functions must be removed when installer problems are resolved. - * Stubs for undefined functions. - */ - -void -VMCISock_KernelDeregister(void) -{ -} - -void -VMCISock_KernelRegister(void) -{ -} - -#endif - -/* Indicates that data is ready to be received */ -#define HGFS_REQ_THREAD_RECV (1 << 0) - -/* Recv states for the recvBuffer. */ -typedef enum { - HGFS_CONN_RECV_SOCK_HDR, /* Waiting for socket header */ - HGFS_CONN_RECV_REP_HDR, /* Waiting for HgfsReply header */ - HGFS_CONN_RECV_REP_PAYLOAD, /* Waiting for reply payload */ -} HgfsSocketRecvState; - -/* HGFS receive buffer. */ -typedef struct HgfsSocketRecvBuffer { - HgfsSocketHeader header; /* Buffer for receiving header. */ - HgfsReply reply; /* Buffer for receiving reply */ - HgfsReq *req; /* Request currently being received. */ - char sink[HGFS_PACKET_MAX]; /* Buffer for data to be discarded. */ - HgfsSocketRecvState state; /* Reply receive state. */ - int len; /* Number of bytes to receive. */ - char *buf; /* Pointer to the buffer. */ -} HgfsSocketRecvBuffer; - -static HgfsSocketRecvBuffer recvBuffer; /* Accessed only by the recv thread. */ - -static struct task_struct *recvThread; /* The recv thread. */ -static DECLARE_WAIT_QUEUE_HEAD(hgfsRecvThreadWait); /* Wait queue for recv thread. */ -static unsigned long hgfsRecvThreadFlags; /* Used to signal recv data availability. */ - -static void (*oldSocketDataReady)(struct sock *, int); - -static Bool HgfsVSocketChannelOpen(HgfsTransportChannel *channel); -static int HgfsSocketChannelSend(HgfsTransportChannel *channel, HgfsReq *req); -static void HgfsVSocketChannelClose(HgfsTransportChannel *channel); -static Bool HgfsTcpChannelOpen(HgfsTransportChannel *channel); -static void HgfsTcpChannelClose(HgfsTransportChannel *channel); -static HgfsReq * HgfsSocketChannelAllocate(size_t payloadSize); -void HgfsSocketChannelFree(HgfsReq *req); - -static HgfsTransportChannel vsockChannel = { - .name = "vsocket", - .ops.close = HgfsVSocketChannelClose, - .ops.send = HgfsSocketChannelSend, - .ops.open = HgfsVSocketChannelOpen, - .ops.allocate = NULL, - .ops.free = NULL, - .priv = NULL, - .status = HGFS_CHANNEL_NOTCONNECTED -}; - -static HgfsTransportChannel tcpChannel = { - .name = "tcp", - .ops.open = HgfsTcpChannelOpen, - .ops.close = HgfsTcpChannelClose, - .ops.allocate = HgfsSocketChannelAllocate, - .ops.free = HgfsSocketChannelFree, - .ops.send = HgfsSocketChannelSend, - .priv = NULL, - .status = HGFS_CHANNEL_NOTCONNECTED -}; - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketDataReady -- - * - * Called when there is data to read on the connected socket. - * - * Results: - * None. - * - * Side effects: - * Wakes up the receiving thread. - * - *---------------------------------------------------------------------- - */ - -static void -HgfsSocketDataReady(struct sock *sk, // IN: Server socket - int len) // IN: Data length -{ - LOG(4, (KERN_DEBUG "VMware hgfs: %s: data ready\n", __func__)); - - /* Call the original data_ready function. */ - oldSocketDataReady(sk, len); - - /* Wake up the recv thread. */ - set_bit(HGFS_REQ_THREAD_RECV, &hgfsRecvThreadFlags); - wake_up_interruptible(&hgfsRecvThreadWait); -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketResetRecvBuffer -- - * - * Reset recv buffer. - * - * Results: - * None - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static void -HgfsSocketResetRecvBuffer(void) -{ - recvBuffer.state = HGFS_CONN_RECV_SOCK_HDR; - recvBuffer.req = NULL; - recvBuffer.len = sizeof recvBuffer.header; - recvBuffer.buf = (char *)&recvBuffer.header; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketIsReceiverIdle -- - * - * Checks whether we are in the middle of receiving a packet. - * - * Results: - * FALSE if receiving thread is in the middle of receiving packet, - * otherwise TRUE. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static Bool -HgfsSocketIsReceiverIdle(void) -{ - return recvBuffer.state == HGFS_CONN_RECV_SOCK_HDR && - recvBuffer.len == sizeof recvBuffer.header; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketRecvMsg -- - * - * Receive the message on the socket. - * - * Results: - * On success returns number of bytes received. - * On failure returns the negative errno. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static int -HgfsSocketRecvMsg(struct socket *socket, // IN: TCP socket - char *buffer, // IN: Buffer to recv the message - size_t bufferLen) // IN: Buffer length -{ - struct iovec iov; - struct msghdr msg; - int ret; - int flags = MSG_DONTWAIT | MSG_NOSIGNAL; - mm_segment_t oldfs = get_fs(); - - memset(&msg, 0, sizeof msg); - msg.msg_flags = flags; - msg.msg_iov = &iov; - msg.msg_iovlen = 1; - iov.iov_base = buffer; - iov.iov_len = bufferLen; - - set_fs(KERNEL_DS); - ret = sock_recvmsg(socket, &msg, bufferLen, flags); - set_fs(oldfs); - - return ret; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketChannelRecvAsync -- - * - * Receive as much data from the socket as possible without blocking. - * Note, that we may return early with just a part of the packet - * received. - * - * Results: - * On failure returns the negative errno, otherwise 0. - * - * Side effects: - * Changes state of the receive buffer depending on what part of - * the packet has been received so far. - * - *---------------------------------------------------------------------- - */ - -static int -HgfsSocketChannelRecvAsync(HgfsTransportChannel *channel) // IN: Channel -{ - int ret; - - if (channel->status != HGFS_CHANNEL_CONNECTED) { - LOG(6, (KERN_DEBUG "VMware hgfs: %s: Connection lost.\n", __func__)); - return -ENOTCONN; - } - - /* We want to read as much data as possible without blocking */ - for (;;) { - - LOG(10, (KERN_DEBUG "VMware hgfs: %s: receiving %s\n", __func__, - recvBuffer.state == HGFS_CONN_RECV_SOCK_HDR ? "header" : - recvBuffer.state == HGFS_CONN_RECV_REP_HDR ? "reply" : "data")); - ret = HgfsSocketRecvMsg(channel->priv, recvBuffer.buf, recvBuffer.len); - LOG(10, (KERN_DEBUG "VMware hgfs: %s: sock_recvmsg returns: %d\n", - __func__, ret)); - - if (ret <= 0) { - break; - } - - ASSERT(ret <= recvBuffer.len); - recvBuffer.len -= ret; - recvBuffer.buf += ret; - - if (recvBuffer.len != 0) { - continue; - } - - /* Complete segment received. */ - switch (recvBuffer.state) { - - case HGFS_CONN_RECV_SOCK_HDR: - LOG(10, (KERN_DEBUG "VMware hgfs: %s: received packet header\n", - __func__)); - ASSERT(recvBuffer.header.version == HGFS_SOCKET_VERSION1); - ASSERT(recvBuffer.header.size == sizeof recvBuffer.header); - ASSERT(recvBuffer.header.status == HGFS_SOCKET_STATUS_SUCCESS); - - recvBuffer.state = HGFS_CONN_RECV_REP_HDR; - recvBuffer.len = sizeof recvBuffer.reply; - recvBuffer.buf = (char *)&recvBuffer.reply; - break; - - case HGFS_CONN_RECV_REP_HDR: - LOG(10, (KERN_DEBUG "VMware hgfs: %s: received packet reply\n", - __func__)); - recvBuffer.req = HgfsTransportGetPendingRequest(recvBuffer.reply.id); - if (recvBuffer.req) { - ASSERT(recvBuffer.header.packetLen <= recvBuffer.req->bufferSize); - recvBuffer.req->payloadSize = recvBuffer.header.packetLen; - memcpy(recvBuffer.req->payload, &recvBuffer.reply, sizeof recvBuffer.reply); - recvBuffer.buf = recvBuffer.req->payload + sizeof recvBuffer.reply; - } else { - recvBuffer.buf = recvBuffer.sink; - } - - recvBuffer.state = HGFS_CONN_RECV_REP_PAYLOAD; - recvBuffer.len = recvBuffer.header.packetLen - sizeof recvBuffer.reply; - if (recvBuffer.len) - break; - - /* There is no actual payload, fall through */ - - case HGFS_CONN_RECV_REP_PAYLOAD: - LOG(10, (KERN_DEBUG "VMware hgfs: %s: received packet payload\n", - __func__)); - if (recvBuffer.req) { - HgfsCompleteReq(recvBuffer.req); - HgfsRequestPutRef(recvBuffer.req); - recvBuffer.req = NULL; - } - HgfsSocketResetRecvBuffer(); - break; - - default: - ASSERT(0); - } - } - - return ret; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketReceiveHandler -- - * - * Function run in background thread and wait on the data in the - * connected channel. - * - * Results: - * Always returns zero. - * - * Side effects: - * Can be many. - * - *---------------------------------------------------------------------- - */ - -static int -HgfsSocketReceiveHandler(void *data) -{ - HgfsTransportChannel *channel = data; - int ret; - - LOG(6, (KERN_DEBUG "VMware hgfs: %s: thread started\n", __func__)); - - compat_set_freezable(); - - for (;;) { - - /* Wait for data to become available */ - wait_event_interruptible(hgfsRecvThreadWait, - (HgfsSocketIsReceiverIdle() && kthread_should_stop()) || - test_bit(HGFS_REQ_THREAD_RECV, &hgfsRecvThreadFlags)); - - /* Kill yourself if told so. */ - if (kthread_should_stop()) { - LOG(6, (KERN_DEBUG "VMware hgfs: %s: told to exit\n", __func__)); - break; - } - - /* Check for suspend. */ - if (compat_try_to_freeze()) { - LOG(6, (KERN_DEBUG "VMware hgfs: %s: continuing after resume.\n", - __func__)); - continue; - } - - if (test_and_clear_bit(HGFS_REQ_THREAD_RECV, &hgfsRecvThreadFlags)) { - - /* There is some data witing for us, let's read it */ - ret = HgfsSocketChannelRecvAsync(channel); - - if (ret < 0 && ret != -EINTR && ret != -ERESTARTSYS && ret != -EAGAIN) { - - if (recvBuffer.req) { - HgfsFailReq(recvBuffer.req, -EIO); - HgfsRequestPutRef(recvBuffer.req); - recvBuffer.req = NULL; - } - - /* The connection is broken, leave it to the senders to restore it. */ - HgfsTransportMarkDead(); - } - } - } - - LOG(6, (KERN_DEBUG "VMware hgfs: %s: thread exited\n", __func__)); - recvThread = NULL; - - return 0; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsCreateTcpSocket -- - * - * Connect to HGFS TCP server. - * - * Results: - * NULL on failure; otherwise address of the newly created and - * connected TCP socket. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static struct socket * -HgfsCreateTcpSocket(void) -{ - struct socket *socket; - struct sockaddr_in addr; - int error; - - addr.sin_family = AF_INET; - addr.sin_addr.s_addr = in_aton(HOST_IP); - addr.sin_port = htons(HOST_PORT); - - error = sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &socket); - if (error < 0) { - LOG(8, ("%s: sock_create_kern failed: %d.\n", __func__, error)); - return NULL; - } - - error = socket->ops->connect(socket, (struct sockaddr *)&addr, - sizeof addr, 0); - if (error < 0) { - LOG(8, ("%s: connect failed: %d.\n", __func__, error)); - sock_release(socket); - return NULL; - } - - return socket; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsCreateVsockSocket -- - * - * Connect to HGFS VSocket server. - * - * Results: - * NULL on failure; otherwise address of the newly created and - * connected VSock socket. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static struct socket * -HgfsCreateVsockSocket(void) -{ -#ifdef INCLUDE_VSOCKETS - struct socket *socket; - struct sockaddr_vm addr; - int family = VMCISock_GetAFValue(); - int error; - - memset(&addr, 0, sizeof addr); - addr.svm_family = family; - addr.svm_cid = VMCI_HOST_CONTEXT_ID; - addr.svm_port = HOST_VSOCKET_PORT; - - error = sock_create_kern(family, SOCK_STREAM, IPPROTO_TCP, &socket); - if (error < 0) { - LOG(8, ("%s: sock_create_kern failed: %d.\n", __func__, error)); - return NULL; - } - - error = socket->ops->connect(socket, (struct sockaddr *)&addr, - sizeof addr, 0); - if (error < 0) { - LOG(8, ("%s: connect failed: %d.\n", __func__, error)); - sock_release(socket); - return NULL; - } - - return socket; - -#else - return NULL; -#endif -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketChannelOpen -- - * - * Connect to HGFS TCP or VSocket server in an idempotent way. - * - * Results: - * TRUE on success, FALSE on failure. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static Bool -HgfsSocketChannelOpen(HgfsTransportChannel *channel, - struct socket *(*create_socket)(void)) -{ - struct socket *socket; - - ASSERT(channel->status == HGFS_CHANNEL_NOTCONNECTED); - ASSERT(!recvThread); - - socket = create_socket(); - if (socket == NULL) - return FALSE; - - /* - * Install the new "data ready" handler that will wake up the - * receiving thread. - */ - oldSocketDataReady = xchg(&socket->sk->sk_data_ready, - HgfsSocketDataReady); - - /* Reset receive buffer when a new connection is connected. */ - HgfsSocketResetRecvBuffer(); - - channel->priv = socket; - - LOG(8, ("%s: socket channel connected.\n", __func__)); - - /* Create the recv thread. */ - recvThread = kthread_run(HgfsSocketReceiveHandler, channel, "vmhgfs-rep"); - if (IS_ERR(recvThread)) { - LOG(4, (KERN_ERR "VMware hgfs: %s: " - "failed to create recv thread, err %ld\n", - __func__, PTR_ERR(recvThread))); - recvThread = NULL; - sock_release(channel->priv); - channel->priv = NULL; - return FALSE; - } - - return TRUE; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsTcpChannelOpen -- - * - * Connect to HGFS TCP server in an idempotent way. - * - * Results: - * TRUE on success, FALSE on failure. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static Bool -HgfsTcpChannelOpen(HgfsTransportChannel *channel) -{ - return HgfsSocketChannelOpen(channel, HgfsCreateTcpSocket); -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsVSocketChannelOpen -- - * - * Connect to HGFS VSocket server in an idempotent way. - * - * Results: - * TRUE on success, FALSE on failure. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static Bool -HgfsVSocketChannelOpen(HgfsTransportChannel *channel) -{ - VMCISock_KernelRegister(); - - if (!HgfsSocketChannelOpen(channel, HgfsCreateVsockSocket)) { - VMCISock_KernelDeregister(); - return FALSE; - } - - return TRUE; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketChannelClose -- - * - * Closes socket-based channel by closing socket and stopping the - * receiving thread. - * - * Results: - * None - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static void -HgfsSocketChannelClose(HgfsTransportChannel *channel) -{ - /* Stop the recv thread before we change the channel status. */ - ASSERT(recvThread != NULL); - kthread_stop(recvThread); - - sock_release(channel->priv); - channel->priv = NULL; - - LOG(8, ("VMware hgfs: %s: socket channel closed.\n", __func__)); -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsTcpChannelClose -- - * - * Closes TCP channel. - * - * Results: - * None - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static void -HgfsTcpChannelClose(HgfsTransportChannel *channel) -{ - HgfsSocketChannelClose(channel); - - LOG(8, ("VMware hgfs: %s: tcp channel closed.\n", __func__)); -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsVSocketChannelClose -- - * - * See above. - * - * Results: - * None - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static void -HgfsVSocketChannelClose(HgfsTransportChannel *channel) -{ - HgfsSocketChannelClose(channel); - VMCISock_KernelDeregister(); - - LOG(8, ("VMware hgfs: %s: VSock channel closed.\n", __func__)); -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketSendMsg -- - * - * Send the message via the socket. Add the header before sending. - * - * Results: - * On success returns 0; - * On failure returns the negative errno. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static int -HgfsSocketSendMsg(struct socket *socket, // IN: socket - void *buffer, // IN: Buffer to send - size_t bufferLen) // IN: Buffer length -{ - struct iovec iov; - struct msghdr msg; - int ret = 0; - int i = 0; - mm_segment_t oldfs = get_fs(); - - memset(&msg, 0, sizeof msg); - iov.iov_base = buffer; - iov.iov_len = bufferLen; - msg.msg_iov = &iov; - msg.msg_iovlen = 1; - - while (bufferLen > 0) { - set_fs(KERNEL_DS); - ret = sock_sendmsg(socket, &msg, bufferLen); - set_fs(oldfs); - LOG(6, (KERN_DEBUG "VMware hgfs: %s: sock_sendmsg returns %d.\n", - __func__, ret)); - - if (likely(ret == bufferLen)) { /* Common case. */ - break; - } else if (ret < 0) { - if (ret == -ENOSPC || ret == -EAGAIN) { - if (++i <= 12) { - LOG(6, (KERN_DEBUG "VMware hgfs: %s: " - "Sleep for %d milliseconds before retry.\n", - __func__, (1 << i))); - compat_msleep(1 << i); - continue; - } - - LOG(2, ("VMware hgfs: %s: send stuck for 8 seconds.\n", __func__)); - ret = -EIO; - } - break; - } else if (ret >= bufferLen) { - LOG(2, ("VMware hgfs: %s: sent more than expected bytes. Sent: %d, " - "expected: %d\n", __func__, ret, (int)bufferLen)); - break; - } else { - i = 0; - bufferLen -= ret; - iov.iov_base += ret; - iov.iov_len -= ret; - } - } - - if (ret > 0) { - ret = 0; /* Indicate success. */ - } - - return ret; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketChannelSend -- - * - * Send the request via a socket channel. - * - * Results: - * 0 on success, negative error on failure. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static int -HgfsSocketChannelSend(HgfsTransportChannel *channel, // IN: Channel - HgfsReq *req) // IN: request to send -{ - int result; - - ASSERT(req); - - HgfsSocketHeaderInit((HgfsSocketHeader *)req->buffer, HGFS_SOCKET_VERSION1, - sizeof(HgfsSocketHeader), HGFS_SOCKET_STATUS_SUCCESS, - req->payloadSize, 0); - - req->state = HGFS_REQ_STATE_SUBMITTED; - result = HgfsSocketSendMsg((struct socket *)channel->priv, req->buffer, - sizeof(HgfsSocketHeader) + req->payloadSize); - if (result < 0) { - LOG(4, (KERN_DEBUG "VMware hgfs: %s: sendmsg, err: %d.\n", - __func__, result)); - req->state = HGFS_REQ_STATE_UNSENT; - } - - return result; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsSocketChannelAllocate -- - * - * Allocates memory for HgfsReq, its payload plus additional memory - * needed for the socket transport itself. - * - * Results: - * NULL on failure otherwise address of allocated memory. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -static HgfsReq * -HgfsSocketChannelAllocate(size_t payloadSize) // IN: size of the payload -{ - HgfsReq *req; - - req = kmalloc(sizeof(*req) + sizeof(HgfsSocketHeader) + payloadSize, - GFP_KERNEL); - if (likely(req)) { - req->payload = req->buffer + sizeof(HgfsSocketHeader); - req->bufferSize = payloadSize; - } - - return req; -} - - -/* - *----------------------------------------------------------------------------- - * - * HgfsSocketChannelFree -- - * - * Free previously allocated request. - * - * Results: - * none - * - * Side effects: - * Object is freed - * - *----------------------------------------------------------------------------- - */ - -void -HgfsSocketChannelFree(HgfsReq *req) -{ - ASSERT(req); - kfree(req); -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsGetTcpChannel -- - * - * Initialize TCP channel. - * - * Results: - * Pointer to a channel on success, otherwise NULL. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -HgfsTransportChannel * -HgfsGetTcpChannel(void) -{ - if (!HOST_IP) { - return NULL; - } - - return &tcpChannel; -} - - -/* - *---------------------------------------------------------------------- - * - * HgfsGetVSocketChannel -- - * - * Initialize VSocket channel. - * - * Results: - * Pointer to a channel on success, otherwise NULL. - * - * Side effects: - * None - * - *---------------------------------------------------------------------- - */ - -HgfsTransportChannel * -HgfsGetVSocketChannel(void) -{ - if (!HOST_VSOCKET_PORT) { - return NULL; - } - - return &vsockChannel; -} - diff --git a/open-vm-tools/modules/linux/vmhgfs/transport.c b/open-vm-tools/modules/linux/vmhgfs/transport.c index c257d695d..a45e3e77d 100644 --- a/open-vm-tools/modules/linux/vmhgfs/transport.c +++ b/open-vm-tools/modules/linux/vmhgfs/transport.c @@ -167,24 +167,6 @@ HgfsTransportSetupNewChannel(void) USE_VMCI = 0; - newChannel = HgfsGetVSocketChannel(); - if (newChannel != NULL) { - if (HgfsTransportOpenChannel(newChannel)) { - hgfsChannel = newChannel; - LOG(10, ("CHANNEL: Vsocket channel\n")); - return TRUE; - } - } - - newChannel = HgfsGetTcpChannel(); - if (newChannel != NULL) { - if (HgfsTransportOpenChannel(newChannel)) { - hgfsChannel = newChannel; - LOG(10, ("CHANNEL: Tcp channel\n")); - return TRUE; - } - } - newChannel = HgfsGetBdChannel(); LOG(10, ("CHANNEL: Bd channel\n")); ASSERT(newChannel); diff --git a/open-vm-tools/modules/linux/vmhgfs/transport.h b/open-vm-tools/modules/linux/vmhgfs/transport.h index f2b39bd6c..7caac3e8c 100644 --- a/open-vm-tools/modules/linux/vmhgfs/transport.h +++ b/open-vm-tools/modules/linux/vmhgfs/transport.h @@ -67,8 +67,6 @@ void HgfsTransportFlushRequests(void); void HgfsTransportMarkDead(void); HgfsTransportChannel* HgfsGetVmciChannel(void); -HgfsTransportChannel* HgfsGetTcpChannel(void); -HgfsTransportChannel* HgfsGetVSocketChannel(void); HgfsTransportChannel *HgfsGetBdChannel(void); #endif // _HGFS_DRIVER_TRANSPORT_H_