/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/** \file
This file consists of implementation of class AdbWinUsbEndpointObject that
encapsulates a handle opened to a WinUsb endpoint on our device.
*/
#include "stdafx.h"
#include "adb_winusb_endpoint_object.h"
#include "adb_winusb_io_completion.h"
AdbWinUsbEndpointObject::AdbWinUsbEndpointObject(
AdbWinUsbInterfaceObject* parent_interf,
UCHAR endpoint_id,
UCHAR endpoint_index)
: AdbEndpointObject(parent_interf, endpoint_id, endpoint_index),
lock_(), is_closing_(false), pending_io_count_(0) {
}
AdbWinUsbEndpointObject::~AdbWinUsbEndpointObject() {
}
LONG AdbWinUsbEndpointObject::Release() {
ATLASSERT(ref_count_ > 0);
LONG ret = InterlockedDecrement(&ref_count_);
ATLASSERT(ret >= 0);
if (0 == ret) {
LastReferenceReleased();
delete this;
}
return ret;
}
bool AdbWinUsbEndpointObject::CloseHandle() {
// This method only returns once all pending IOs are aborted and after
// preventing future pending IOs. This means that once CloseHandle()
// returns, threads using this object won't be using
// parent_winusb_interface()->winusb_handle(), so it can then be safely
// released.
lock_.Lock();
if (!is_closing_) {
// Set flag to prevent new I/Os from starting up.
is_closing_ = true;
}
// While there are pending IOs, keep aborting the pipe. We have to do this
// repeatedly because pending_ios_ is incremented before the IO has actually
// started, and abort (probably) only works if the IO has been started.
while (pending_io_count_ > 0) {
lock_.Unlock();
// It has been noticed that on Windows 7, if you only call
// WinUsb_AbortPipe(), without first calling WinUsb_ResetPipe(), the call
// to WinUsb_AbortPipe() hangs.
if (!WinUsb_ResetPipe(parent_winusb_interface()->winusb_handle(),
endpoint_id()) ||
!WinUsb_AbortPipe(parent_winusb_interface()->winusb_handle(),
endpoint_id())) {
// Reset or Abort failed for unexpected reason. We might not be able to
// abort pending IOs, so we shouldn't keep polling pending_io_count_ or
// else we might hang forever waiting for the IOs to abort. In this
// situation it is preferable to risk a race condition (which may or may
// not crash) and just break now.
lock_.Lock();
break;
}
// Give the IO threads time to break out of I/O calls and decrement
// pending_io_count_. They should finish up pretty quick. The amount of time
// "wasted" here (as opposed to if we did synchronization with an event)
// doesn't really matter since this is an uncommon corner-case.
Sleep(16); // 16 ms, old default OS scheduler granularity
lock_.Lock();
}
lock_.Unlock();
return AdbEndpointObject::CloseHandle();
}
ADBAPIHANDLE AdbWinUsbEndpointObject::CommonAsyncReadWrite(
bool is_read,
void* buffer,
ULONG bytes_to_transfer,
ULONG* bytes_transferred,
HANDLE event_handle,
ULONG time_out) {
// TODO: Do synchronization with is_closing_ and pending_io_count_ like
// CommonSyncReadWrite(). This is not yet implemented because there are no
// callers to Adb{Read,Write}EndpointAsync() in AOSP, and hence no testing.
if (!SetTimeout(time_out))
return false;
// Create completion i/o object
AdbIOCompletion* adb_io_completion = NULL;
try {
adb_io_completion = new AdbWinUsbIOCompletion(this,
bytes_to_transfer,
event_handle);
} catch (... ) {
SetLastError(ERROR_OUTOFMEMORY);
return NULL;
}
// Create a handle for it
ADBAPIHANDLE ret = adb_io_completion->CreateHandle();
ULONG transferred = 0;
if (NULL != ret) {
BOOL res = TRUE;
// Go the read / write file way
res = is_read ?
WinUsb_ReadPipe(parent_winusb_interface()->winusb_handle(),
endpoint_id(),
reinterpret_cast<PUCHAR>(buffer),
bytes_to_transfer,
&transferred,
adb_io_completion->overlapped()) :
WinUsb_WritePipe(parent_winusb_interface()->winusb_handle(),
endpoint_id(),
reinterpret_cast<PUCHAR>(buffer),
bytes_to_transfer,
&transferred,
adb_io_completion->overlapped());
if (NULL != bytes_transferred)
*bytes_transferred = transferred;
ULONG error = GetLastError();
if (!res && (ERROR_IO_PENDING != error)) {
// I/O failed immediatelly. We need to close i/o completion object
// before we return NULL to the caller.
adb_io_completion->CloseHandle();
ret = NULL;
SetLastError(error);
}
}
// Offseting 'new'
adb_io_completion->Release();
return ret;
}
bool AdbWinUsbEndpointObject::CommonSyncReadWrite(bool is_read,
void* buffer,
ULONG bytes_to_transfer,
ULONG* bytes_transferred,
ULONG time_out) {
lock_.Lock();
if (is_closing_) {
lock_.Unlock();
// AdbCloseHandle() is in progress, so don't start up any new IOs.
SetLastError(ERROR_HANDLES_CLOSED);
return false;
} else {
// Not closing down, so record the fact that we're doing IO. This will
// prevent CloseHandle() from returning until our IO completes or it aborts
// our IO.
++pending_io_count_;
lock_.Unlock();
}
// Because we've incremented pending_ios_, do the matching decrement when this
// object goes out of scope.
DecrementPendingIO dec(this);
if (!SetTimeout(time_out))
return false;
// This is synchronous I/O. Since we always open I/O items for
// overlapped I/O we're obligated to always provide OVERLAPPED
// structure to read / write routines. Prepare it now.
OVERLAPPED overlapped;
ZeroMemory(&overlapped, sizeof(overlapped));
overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
BOOL ret = TRUE;
ULONG transferred = 0;
// Go the read / write file way
ret = is_read ?
WinUsb_ReadPipe(parent_winusb_interface()->winusb_handle(),
endpoint_id(),
reinterpret_cast<PUCHAR>(buffer),
bytes_to_transfer,
&transferred,
&overlapped) :
WinUsb_WritePipe(parent_winusb_interface()->winusb_handle(),
endpoint_id(),
reinterpret_cast<PUCHAR>(buffer),
bytes_to_transfer,
&transferred,
&overlapped);
// Lets see the result
if (!ret && (ERROR_IO_PENDING != GetLastError())) {
// I/O failed.
if (NULL != overlapped.hEvent)
::CloseHandle(overlapped.hEvent);
return false;
}
// Lets wait till I/O completes
ret = WinUsb_GetOverlappedResult(parent_winusb_interface()->winusb_handle(), &overlapped,
&transferred, TRUE);
if (ret && (NULL != bytes_transferred)) {
*bytes_transferred = transferred;
}
if (NULL != overlapped.hEvent)
::CloseHandle(overlapped.hEvent);
return ret ? true : false;
}
bool AdbWinUsbEndpointObject::SetTimeout(ULONG timeout) {
if (!WinUsb_SetPipePolicy(parent_winusb_interface()->winusb_handle(),
endpoint_id(), PIPE_TRANSFER_TIMEOUT,
sizeof(ULONG), &timeout)) {
return false;
}
return true;
}