static int
HgfsUnpackOpenReply(HgfsReq *req, // IN: Packet with reply inside
HgfsOp opUsed, // IN: What request op did we send
HgfsHandle *file, // OUT: Handle in reply packet
HgfsServerLock *lock) // OUT: The server lock we got
{
HgfsReplyOpenV3 *replyV3;
HgfsReplyOpenV2 *replyV2;
HgfsReplyOpen *replyV1;
size_t replySize;
ASSERT(req);
ASSERT(file);
ASSERT(lock);
switch (opUsed) {
case HGFS_OP_OPEN_V3:
replyV3 = (HgfsReplyOpenV3 *)HGFS_REP_PAYLOAD_V3(req);
replySize = HGFS_REP_PAYLOAD_SIZE_V3(replyV3);
*file = replyV3->file;
*lock = replyV3->acquiredLock;
break;
case HGFS_OP_OPEN_V2:
replyV2 = (HgfsReplyOpenV2 *)(HGFS_REQ_PAYLOAD(req));
replySize = sizeof *replyV2;
*file = replyV2->file;
*lock = replyV2->acquiredLock;
break;
case HGFS_OP_OPEN:
replyV1 = (HgfsReplyOpen *)(HGFS_REQ_PAYLOAD(req));
replySize = sizeof *replyV1;
*file = replyV1->file;
*lock = HGFS_LOCK_NONE;
break;
default:
/* This really shouldn't happen since we set opUsed ourselves. */
LOG(4, (KERN_DEBUG "VMware hgfs: HgfsUnpackOpenReply: unexpected "
"OP type encountered\n"));
ASSERT(FALSE);
return -EPROTO;
}
if (req->payloadSize != replySize) {
/*
* The reply to Open is a fixed size. So the size of the payload
* really ought to match the expected size of an HgfsReplyOpen[V2].
*/
LOG(4, (KERN_DEBUG "VMware hgfs: HgfsUnpackOpenReply: wrong packet "
"size\n"));
return -EPROTO;
}
return 0;
}
int
HgfsStatfsInt(struct vnode *vp, // IN: vnode
HgfsStatfs *stat) // IN: statfs structure to fill in
{
HgfsSuperInfo *sip;
HgfsKReqHandle req;
HgfsRequest *requestHeader;
HgfsReply *replyHeader;
HgfsRequestQueryVolumeV3 *request;
HgfsReplyQueryVolumeV3 *reply;
uint32 reqSize;
uint32 reqBufferSize;
uint32 repSize;
char *fullPath = NULL;
uint32 fullPathLen;
int ret = 0;
/* Get pointer to the superinfo. */
sip = HGFS_VP_TO_SIP(vp);
if (!sip) {
DEBUG(VM_DEBUG_FAIL, "couldn't acquire superinfo\n");
return ENOTSUP;
}
/* Prepare the request */
req = HgfsKReq_AllocateRequest(sip->reqs, &ret);
if (!req) {
return ret;
}
requestHeader = (HgfsRequest *)HgfsKReq_GetPayload(req);
request = (HgfsRequestQueryVolumeV3 *)HGFS_REQ_GET_PAYLOAD_V3(requestHeader);
/* Initialize the request header */
requestHeader->id = HgfsKReq_GetId(req);
requestHeader->op = HGFS_OP_QUERY_VOLUME_INFO_V3;
request->fileName.flags = 0;
request->fileName.fid = HGFS_INVALID_HANDLE;
request->fileName.caseType = HGFS_FILE_NAME_CASE_SENSITIVE;
request->reserved = 0;
reqSize = HGFS_REQ_PAYLOAD_SIZE_V3(request);
reqBufferSize = HGFS_NAME_BUFFER_SIZET(HGFS_PACKET_MAX, reqSize);
fullPath = HGFS_VP_TO_FILENAME(vp);
fullPathLen = HGFS_VP_TO_FILENAME_LENGTH(vp);
ret = HgfsNameToWireEncoding(fullPath, fullPathLen + 1,
request->fileName.name,
reqBufferSize);
if (ret < 0) {
DEBUG(VM_DEBUG_FAIL, "Could not encode to wire format");
ret = -ret;
goto destroyOut;
}
request->fileName.length = ret;
reqSize += ret;
/* The request size includes header, request and file length */
HgfsKReq_SetPayloadSize(req, reqSize);
ret = HgfsSubmitRequest(sip, req);
if (ret) {
/* HgfsSubmitRequest() destroys the request if necessary */
goto out;
}
replyHeader = (HgfsReply *)HgfsKReq_GetPayload(req);
reply = (HgfsReplyQueryVolumeV3 *)HGFS_REP_GET_PAYLOAD_V3(replyHeader);
repSize = HGFS_REP_PAYLOAD_SIZE_V3(reply);
ret = HgfsGetStatus(req, repSize);
if (ret) {
DEBUG(VM_DEBUG_FAIL, "reply was invalid");
goto destroyOut;
}
ret = HgfsStatusToBSD(replyHeader->status);
if (ret) {
goto destroyOut;
}
stat->f_bsize = HGFS_BLOCKSIZE;
stat->f_iosize = HGFS_BLOCKSIZE;
stat->f_blocks = HGFS_CONVERT_TO_BLOCKS(reply->totalBytes);
stat->f_bfree = HGFS_CONVERT_TO_BLOCKS(reply->freeBytes);
stat->f_bavail = stat->f_bfree;
destroyOut:
HgfsKReq_ReleaseRequest(sip->reqs, req);
out:
return ret;
}
/*
*----------------------------------------------------------------------
*
* HgfsUnpackSearchReadReply --
*
* This function abstracts the differences between a SearchReadV1 and
* a SearchReadV2. The caller provides the packet containing the reply
* and we populate the AttrInfo with version-independent information.
*
* Note that attr->requestType has already been populated so that we
* know whether to expect a V1 or V2 reply.
*
* Results:
* 0 on success, anything else on failure.
*
* Side effects:
* None
*
*----------------------------------------------------------------------
*/
static int
HgfsUnpackSearchReadReply(HgfsReq *req, // IN: Reply packet
HgfsAttrInfo *attr, // IN/OUT: Attributes
char **entryName) // OUT: file name
{
char *fileName;
uint32 fileNameLength;
uint32 replySize;
int result;
ASSERT(req);
ASSERT(attr);
result = HgfsUnpackCommonAttr(req, attr);
if (result != 0) {
return result;
}
switch(attr->requestType) {
case HGFS_OP_SEARCH_READ_V3: {
HgfsReplySearchReadV3 *replyV3;
HgfsDirEntry *dirent;
/* Currently V3 returns only 1 entry. */
replyV3 = (HgfsReplySearchReadV3 *)(HGFS_REP_PAYLOAD_V3(req));
replyV3->count = 1;
replySize = HGFS_REP_PAYLOAD_SIZE_V3(replyV3) + sizeof *dirent;
dirent = (HgfsDirEntry *)replyV3->payload;
fileName = dirent->fileName.name;
fileNameLength = dirent->fileName.length;
break;
}
case HGFS_OP_SEARCH_READ_V2: {
HgfsReplySearchReadV2 *replyV2;
replyV2 = (HgfsReplySearchReadV2 *)(HGFS_REQ_PAYLOAD(req));
replySize = sizeof *replyV2;
fileName = replyV2->fileName.name;
fileNameLength = replyV2->fileName.length;
break;
}
case HGFS_OP_SEARCH_READ: {
HgfsReplySearchRead *replyV1;
replyV1 = (HgfsReplySearchRead *)(HGFS_REQ_PAYLOAD(req));
replySize = sizeof *replyV1;
fileName = replyV1->fileName.name;
fileNameLength = replyV1->fileName.length;
break;
}
default:
LOG(4, (KERN_DEBUG "VMware hgfs: HgfsUnpackSearchReadReply: unexpected "
"OP type encountered\n"));
return -EPROTO;
}
/*
* Make sure name length is legal.
*/
if (fileNameLength > NAME_MAX ||
fileNameLength > req->bufferSize - replySize) {
return -ENAMETOOLONG;
}
/*
* If the size of the name is valid (meaning the end of the directory has
* not yet been reached), copy the name to the AttrInfo struct.
*
* XXX: This operation happens often and the length of the filename is
* bounded by NAME_MAX. Perhaps I should just put a statically-sized
* array in HgfsAttrInfo and use a slab allocator to allocate the struct.
*/
if (fileNameLength > 0) {
/* Sanity check on name length. */
if (fileNameLength != strlen(fileName)) {
LOG(4, (KERN_DEBUG "VMware hgfs: HgfsUnpackSearchReadReply: name "
"length mismatch %u/%Zu, name \"%s\"\n",
fileNameLength, strlen(fileName), fileName));
return -EPROTO;
}
*entryName = kmalloc(fileNameLength + 1, GFP_KERNEL);
if (*entryName == NULL) {
LOG(4, (KERN_DEBUG "VMware hgfs: HgfsUnpackSearchReadReply: out of "
"memory allocating filename, ignoring\n"));
return -ENOMEM;
}
memcpy(*entryName, fileName, fileNameLength + 1);
} else {
*entryName = NULL;
}
return 0;
}
