host/windows/usb/winusb/adb_winusb_endpoint_object.cpp - platform/development - Git at Google

 /*
  * 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;
 }
	/*
	* 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;
	}