← Back to branch summary

~ubuntu-branches/ubuntu/quantal/open-vm-tools/quantal-201207201942

« back to all changes in this revision

Viewing changes to modules/linux/vmhgfs/bdhandler.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2009-10-18 12:28:19 UTC
  • mfrom: (1.1.7 upstream) (2.4.9 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091018122819-00vqew6m0ztpqcqp
Tags: 2009.10.15-201664-1
Merging upstream version 2009.10.15-201664.

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/linux/vmhgfs/bdhandler.c
37
37
#include "transport.h"
38
38
#include "vm_assert.h"
39
39
 
40
 
HgfsTransportChannel bdChannel;
41
 
 
42
40
 
43
41
/*
44
42
 *-----------------------------------------------------------------------------
61
59
{
62
60
   Bool ret = FALSE;
63
61
 
64
 
   compat_mutex_lock(&channel->connLock);
65
 
   switch (channel->status) {
66
 
   case HGFS_CHANNEL_UNINITIALIZED:
67
 
      ret = FALSE;
68
 
      break;
69
 
   case HGFS_CHANNEL_CONNECTED:
 
62
   ASSERT(channel->status == HGFS_CHANNEL_NOTCONNECTED);
 
63
 
 
64
   if (HgfsBd_OpenBackdoor((RpcOut **)&channel->priv)) {
 
65
      LOG(8, ("VMware hgfs: %s: backdoor opened.\n", __func__));
70
66
      ret = TRUE;
71
 
      break;
72
 
   case HGFS_CHANNEL_NOTCONNECTED:
73
 
      if (HgfsBd_OpenBackdoor((RpcOut **)&channel->priv)) {
74
 
         LOG(8, ("VMware hgfs: %s: backdoor opened.\n", __func__));
75
 
         bdChannel.status = HGFS_CHANNEL_CONNECTED;
76
 
         ret = TRUE;
77
 
         ASSERT(channel->priv != NULL);
78
 
      } else {
79
 
         ret = FALSE;
80
 
      }
81
 
      break;
82
 
   default:
83
 
      ASSERT(0); /* Not reached. */
 
67
      ASSERT(channel->priv != NULL);
84
68
   }
85
69
 
86
 
   compat_mutex_unlock(&channel->connLock);
87
70
   return ret;
88
71
}
89
72
 
107
90
static void
108
91
HgfsBdChannelClose(HgfsTransportChannel *channel) // IN: Channel
109
92
{
110
 
   compat_mutex_lock(&channel->connLock);
111
 
   if (channel->status == HGFS_CHANNEL_CONNECTED) {
112
 
      ASSERT(channel->priv != NULL);
113
 
      HgfsBd_CloseBackdoor((RpcOut **)&channel->priv);
114
 
      ASSERT(channel->priv == NULL);
115
 
      channel->status = HGFS_CHANNEL_NOTCONNECTED;
116
 
   }
117
 
   compat_mutex_unlock(&channel->connLock);
 
93
   ASSERT(channel->priv != NULL);
 
94
 
 
95
   HgfsBd_CloseBackdoor((RpcOut **)&channel->priv);
 
96
   ASSERT(channel->priv == NULL);
 
97
 
118
98
   LOG(8, ("VMware hgfs: %s: backdoor closed.\n", __func__));
119
99
}
120
100
 
121
101
 
122
102
/*
 
103
 *-----------------------------------------------------------------------------
 
104
 *
 
105
 * HgfsBdChannelAllocate --
 
106
 *
 
107
 *      Allocate request uin the way that is suitable for sending through
 
108
 *      backdoor.
 
109
 *
 
110
 * Results:
 
111
 *      NULL on failure; otherwise address of the new request.
 
112
 *
 
113
 * Side effects:
 
114
 *      None
 
115
 *
 
116
 *-----------------------------------------------------------------------------
 
117
 */
 
118
 
 
119
static HgfsReq *
 
120
HgfsBdChannelAllocate(size_t payloadSize) // IN: size of requests payload
 
121
{
 
122
   HgfsReq *req;
 
123
 
 
124
   req = kmalloc(sizeof(*req) + HGFS_SYNC_REQREP_CLIENT_CMD_LEN + payloadSize,
 
125
                 GFP_KERNEL);
 
126
   if (likely(req)) {
 
127
      /* Setup the packet prefix. */
 
128
      memcpy(req->buffer, HGFS_SYNC_REQREP_CLIENT_CMD,
 
129
             HGFS_SYNC_REQREP_CLIENT_CMD_LEN);
 
130
 
 
131
      req->payload = req->buffer + HGFS_SYNC_REQREP_CLIENT_CMD_LEN;
 
132
   }
 
133
 
 
134
   return req;
 
135
}
 
136
 
 
137
 
 
138
/*
123
139
 *----------------------------------------------------------------------
124
140
 *
125
141
 * HgfsBdChannelSend --
147
163
   ASSERT(req->state == HGFS_REQ_STATE_UNSENT);
148
164
   ASSERT(req->payloadSize <= HGFS_PACKET_MAX);
149
165
 
150
 
   compat_mutex_lock(&channel->connLock);
151
 
 
152
 
   if (channel->status != HGFS_CHANNEL_CONNECTED) {
153
 
      LOG(6, (KERN_DEBUG "VMware hgfs: %s: Backdoor not opened\n", __func__));
154
 
      compat_mutex_unlock(&channel->connLock);
155
 
      return -ENOTCONN;
156
 
   }
157
 
 
 
166
   LOG(8, ("VMware hgfs: %s: backdoor sending.\n", __func__));
158
167
   payloadSize = req->payloadSize;
159
 
   LOG(8, ("VMware hgfs: %s: backdoor sending.\n", __func__));
160
168
   ret = HgfsBd_Dispatch(channel->priv, HGFS_REQ_PAYLOAD(req), &payloadSize,
161
169
                         &replyPacket);
162
170
   if (ret == 0) {
163
171
      LOG(8, ("VMware hgfs: %s: Backdoor reply received.\n", __func__));
164
172
      /* Request sent successfully. Copy the reply and wake the client. */
165
173
      ASSERT(replyPacket);
166
 
      HgfsCompleteReq(req, replyPacket, payloadSize);
167
 
   } else {
168
 
      channel->priv = NULL;
169
 
      channel->status = HGFS_CHANNEL_NOTCONNECTED;
 
174
      ASSERT(payloadSize <= req->bufferSize);
 
175
      memcpy(HGFS_REQ_PAYLOAD(req), replyPacket, payloadSize);
 
176
      req->payloadSize = payloadSize;
 
177
      HgfsCompleteReq(req);
170
178
   }
171
 
   compat_mutex_unlock(&channel->connLock);
172
179
 
173
180
   return ret;
174
181
}
177
184
/*
178
185
 *----------------------------------------------------------------------
179
186
 *
180
 
 * HgfsBdChannelExit --
181
 
 *
182
 
 *     Tear down the channel.
183
 
 *
184
 
 * Results:
185
 
 *     None
186
 
 *
187
 
 * Side effects:
188
 
 *     None
189
 
 *
190
 
 *----------------------------------------------------------------------
191
 
 */
192
 
 
193
 
static void
194
 
HgfsBdChannelExit(HgfsTransportChannel *channel)  // IN
195
 
{
196
 
   compat_mutex_lock(&channel->connLock);
197
 
   if (channel->priv != NULL) {
198
 
      HgfsBd_CloseBackdoor((RpcOut **)&channel->priv);
199
 
      ASSERT(channel->priv == NULL);
200
 
   }
201
 
   channel->status = HGFS_CHANNEL_UNINITIALIZED;
202
 
   compat_mutex_unlock(&channel->connLock);
203
 
}
204
 
 
205
 
 
206
 
/*
207
 
 *----------------------------------------------------------------------
208
 
 *
209
187
 * HgfsGetBdChannel --
210
188
 *
211
189
 *     Initialize backdoor channel.
222
200
HgfsTransportChannel*
223
201
HgfsGetBdChannel(void)
224
202
{
225
 
   bdChannel.name = "backdoor";
226
 
   bdChannel.ops.open = HgfsBdChannelOpen;
227
 
   bdChannel.ops.close = HgfsBdChannelClose;
228
 
   bdChannel.ops.send = HgfsBdChannelSend;
229
 
   bdChannel.ops.recv = NULL;
230
 
   bdChannel.ops.exit = HgfsBdChannelExit;
231
 
   bdChannel.priv = NULL;
232
 
   compat_mutex_init(&bdChannel.connLock);
233
 
   bdChannel.status = HGFS_CHANNEL_NOTCONNECTED;
234
 
   return &bdChannel;
 
203
   static HgfsTransportChannel channel;
 
204
 
 
205
   channel.name = "backdoor";
 
206
   channel.ops.open = HgfsBdChannelOpen;
 
207
   channel.ops.close = HgfsBdChannelClose;
 
208
   channel.ops.allocate = HgfsBdChannelAllocate;
 
209
   channel.ops.send = HgfsBdChannelSend;
 
210
   channel.priv = NULL;
 
211
   channel.status = HGFS_CHANNEL_NOTCONNECTED;
 
212
 
 
213
   return &channel;
235
214
}