[cfinck] 45686: We don't need "csq.h" twice in our tree. This ancient version didn't even receive the GCC 4.1 compatibility update from years ago, so it's safe to remove it.

Author: cfinck
Date: Fri Feb 26 16:22:39 2010
New Revision: 45686

URL: http://svn.reactos.org/svn/reactos?rev=45686&view=rev
Log:
We don't need "csq.h" twice in our tree.
This ancient version didn't even receive the GCC 4.1 compatibility update from years
ago, so it's safe to remove it.

Removed:
    trunk/reactos/lib/drivers/csq/csq.h

Removed: trunk/reactos/lib/drivers/csq/csq.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/lib/drivers/csq/csq.h?rev=…
==============================================================================
--- trunk/reactos/lib/drivers/csq/csq.h [iso-8859-1] (original)
+++ trunk/reactos/lib/drivers/csq/csq.h (removed)
@@ -1,286 +1,0 @@
-/*
- * Cancel-Safe Queue Library
- * Copyright (c) 2004, Vizzini (vizzini(a)plasmic.com)
- * Licensed under the GNU GPL for the ReactOS project
- *
- * This header defines the interface to the ReactOS Cancel-Safe Queue library.
- * This interface is based on and is similar to the Microsoft Cancel-Safe
- * Queue interface.
- *
- * BACKGROUND
- *
- * IRP queuing is a royal pain in the butt, due to the fact that there are
- * tons of built-in race conditions.  IRP handling is difficult in general,
- * but the cancel logic has been particularly complicated due to some subtle
- * races, coupled with the fact that the system interfaces have changed over
- * time.
- *
- * Walter Oney (2nd. Ed. of Programming the Windows Driver Model) states a
- * common opinion among driver developers when he says that it is foolish
- * to try to roll your own cancel logic.  There are only a very few people
- * who have gotten it right in the past.  He suggests, instead, that you
- * either use his own well-tested code, or use the code in the Microsoft
- * Cancel-Safe Queue Library.
- *
- * We cannot do either, of course, due to copyright issues.  I have therefore
- * created this clone of the Microsoft library in order to concentrate all
- * of the IRP-queuing bugs in one place.  I'm quite sure there are problems
- * here, so if you are a driver writer, I'd be glad to hear your feedback.
- *
- * Apart from that, please try to use these routines, rather than building
- * your own.  If you think you have found a bug, please bring it up with me
- * or on-list, as this is complicated and non-obvious stuff.  Don't just
- * change this and hope for the best!
- *
- * USAGE
- *
- * This library follows exactly the same interface as the Microsoft Cancel-Safe
- * Queue routines (IoCsqXxx()).  As such, the authoritative reference is the
- * current DDK.  There is also a DDK sample called "cancel" that has an
- * example of how to use this code.  I have also provided a sample driver
- * that makes use of this queue. Finally, please do read the header and the
- * source if you're curious about the inner workings of these routines.
- */
-
-#pragma once
-
-/*
- * Prevent including the CSQ definitions twice. They're present in NTDDK
- * now too, except the *_EX versions.
- */
-#ifndef IO_TYPE_CSQ_IRP_CONTEXT
-
-struct _IO_CSQ;
-
-
-/*
- * CSQ Callbacks
- *
- * The cancel-safe queue is implemented as a set of IoCsqXxx() OS routines
- * copuled with a set of driver callbacks to handle the basic operations of
- * the queue.  You need to supply one of each of these functions in your own
- * driver.  These routines are also documented in the DDK under CsqXxx().
- * That is the authoritative documentation.
- */
-
-/*
- * Function to insert an IRP in the queue.  No need to worry about locking;
- * just tack it onto your list or something.
- *
- * Sample implementation: 
- *
-	VOID NTAPI CsqInsertIrp(PIO_CSQ Csq, PIRP Irp)
-	{
-		KdPrint(("Inserting IRP 0x%x into CSQ\n", Irp));
-		InsertTailList(&IrpQueue, &Irp->Tail.Overlay.ListEntry);
-	}
- *
- */
-typedef VOID (NTAPI *PIO_CSQ_INSERT_IRP) (struct _IO_CSQ *Csq,
-                                          PIRP Irp);
-
-
-/*
- * Function to remove an IRP from the queue.
- *
- * Sample:
- *
-	VOID NTAPI CsqRemoveIrp(PIO_CSQ Csq, PIRP Irp)
-	{
-		KdPrint(("Removing IRP 0x%x from CSQ\n", Irp));
-		RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
-	}
- *
- */
-typedef VOID (NTAPI *PIO_CSQ_REMOVE_IRP) (struct _IO_CSQ *Csq,
-                                          PIRP Irp);
-
-/*
- * Function to look for an IRP in the queue
- *
- * Sample:
- *
-	PIRP NTAPI CsqPeekNextIrp(PIO_CSQ Csq, PIRP Irp, PVOID PeekContext)
-	{
-		KdPrint(("Peeking for next IRP\n"));
-
-		if(Irp)
-			return CONTAINING_RECORD(&Irp->Tail.Overlay.ListEntry.Flink, IRP,
Tail.Overlay.ListEntry);
-
-		if(IsListEmpty(&IrpQueue))
-			return NULL;
-
-		return CONTAINING_RECORD(IrpQueue.Flink, IRP, Tail.Overlay.ListEntry);
-	}
- *
- */
-typedef PIRP (NTAPI *PIO_CSQ_PEEK_NEXT_IRP) (struct _IO_CSQ *Csq,
-                                             PIRP Irp,
-                                             PVOID PeekContext);
-
-/*
- * Lock the queue.  This can be a spinlock, a mutex, or whatever
- * else floats your boat.
- *
- * Sample:
- *
-	VOID NTAPI CsqAcquireLock(PIO_CSQ Csq, PKIRQL Irql)
-	{
-		KdPrint(("Acquiring spin lock\n"));
-		KeAcquireSpinLock(&IrpQueueLock, Irql);
-	}
- *
- */
-typedef VOID (NTAPI *PIO_CSQ_ACQUIRE_LOCK) (struct _IO_CSQ *Csq,
-                                            PKIRQL Irql);
-
-/*
- * Unlock the queue:
- *
-	VOID NTAPI CsqReleaseLock(PIO_CSQ Csq, KIRQL Irql)
-	{
-		KdPrint(("Releasing spin lock\n"));
-		KeReleaseSpinLock(&IrpQueueLock, Irql);
-	}
- *
- */
-typedef VOID (NTAPI *PIO_CSQ_RELEASE_LOCK) (struct _IO_CSQ *Csq,
-                                            KIRQL Irql);
-
-/*
- * Finally, this is called by the queue library when it wants to complete
- * a canceled IRP.
- * 
- * Sample:
- *
-	VOID NTAPI CsqCompleteCancelledIrp(PIO_CSQ Csq, PIRP Irp)
-	{
-		KdPrint(("cancelling irp 0x%x\n", Irp));
-		Irp->IoStatus.Status = STATUS_CANCELLED;
-		Irp->IoStatus.Information = 0;
-		IoCompleteRequest(Irp, IO_NO_INCREMENT);
-	}
- *
- */
-typedef VOID (NTAPI *PIO_CSQ_COMPLETE_CANCELED_IRP) (struct _IO_CSQ *Csq,
-                                                     PIRP Irp);
-
-
-/*
- * STRUCTURES
- *
- * NOTE:  Please do not use these directly.  You will make incompatible code
- * if you do.  Always only use the documented IoCsqXxx() interfaces and you
- * will amass much Good Karma.
- */
-#define IO_TYPE_CSQ_IRP_CONTEXT 1
-#define IO_TYPE_CSQ 2
-
-/*
- * IO_CSQ - Queue control structure
- */
-typedef struct _IO_CSQ {
-	ULONG                          Type;
-	PIO_CSQ_INSERT_IRP             CsqInsertIrp;
-	PIO_CSQ_REMOVE_IRP             CsqRemoveIrp;
-	PIO_CSQ_PEEK_NEXT_IRP          CsqPeekNextIrp;
-	PIO_CSQ_ACQUIRE_LOCK           CsqAcquireLock;
-	PIO_CSQ_RELEASE_LOCK           CsqReleaseLock;
-	PIO_CSQ_COMPLETE_CANCELED_IRP  CsqCompleteCanceledIrp;
-	PVOID                          ReservePointer;	/* must be NULL */
-} IO_CSQ, *PIO_CSQ;
-
-/*
- * IO_CSQ_IRP_CONTEXT - Context used to track an IRP in the CSQ
- */
-typedef struct _IO_CSQ_IRP_CONTEXT {
-	ULONG   Type;
-	PIRP    Irp;
-	PIO_CSQ Csq;
-} IO_CSQ_IRP_CONTEXT, *PIO_CSQ_IRP_CONTEXT;
-
-#endif /* IO_TYPE_CSQ_IRP_CONTEXT */
-
-/* See IO_TYPE_CSQ_* above */
-#define IO_TYPE_CSQ_EX 3
-
-/*
- * Function to insert an IRP into the queue with extended context information.
- * This is useful if you need to be able to de-queue particular IRPs more
- * easily in some cases.
- *
- * Same deal as above; sample implementation:
- *
-	NTSTATUS NTAPI CsqInsertIrpEx(PIO_CSQ Csq, PIRP Irp, PVOID InsertContext)
-	{
-		CsqInsertIrp(Csq, Irp);
-		return STATUS_PENDING;
-	}
- *
- */
-typedef NTSTATUS (NTAPI *PIO_CSQ_INSERT_IRP_EX) (struct _IO_CSQ *Csq,
-                                                 PIRP Irp,
-                                                 PVOID InsertContext);
-
-/*
- * CANCEL-SAFE QUEUE DDIs
- *
- * These device driver interfaces are called to make use of the queue.  Again,
- * authoritative documentation for these functions is in the DDK.  The csqtest
- * driver also makes use of some of them.
- */
-
-
-/*
- * Call this in DriverEntry or similar in order to set up the Csq structure.
- * As long as the Csq struct and the functions you pass in are resident,
- * there are no IRQL restrictions.
- */
-NTSTATUS NTAPI IoCsqInitialize(PIO_CSQ Csq,
-                               PIO_CSQ_INSERT_IRP CsqInsertIrp,
-                               PIO_CSQ_REMOVE_IRP CsqRemoveIrp,
-                               PIO_CSQ_PEEK_NEXT_IRP CsqPeekNextIrp,
-                               PIO_CSQ_ACQUIRE_LOCK CsqAcquireLock,
-                               PIO_CSQ_RELEASE_LOCK CsqReleaseLock,
-                               PIO_CSQ_COMPLETE_CANCELED_IRP CsqCompleteCanceledIrp);
-
-/*
- * Same as above, except you provide a CsqInsertIrpEx routine instead of
- * CsqInsertIrp.  This eventually allows you to supply extra tracking
- * information for use with the queue.
- */
-NTSTATUS NTAPI IoCsqInitializeEx(PIO_CSQ Csq,
-                                 PIO_CSQ_INSERT_IRP_EX CsqInsertIrpEx,
-                                 PIO_CSQ_REMOVE_IRP CsqRemoveIrp,
-                                 PIO_CSQ_PEEK_NEXT_IRP CsqPeekNextIrp,
-                                 PIO_CSQ_ACQUIRE_LOCK CsqAcquireLock,
-                                 PIO_CSQ_RELEASE_LOCK CsqReleaseLock,
-                                 PIO_CSQ_COMPLETE_CANCELED_IRP CsqCompleteCanceledIrp);
-
-/*
- * Insert an IRP into the queue
- */
-VOID NTAPI IoCsqInsertIrp(PIO_CSQ Csq,
-                          PIRP Irp,
-                          PIO_CSQ_IRP_CONTEXT Context);
-
-/*
- * Insert an IRP into the queue, with special context maintained that
- * makes it easy to find IRPs in the queue
- */
-NTSTATUS NTAPI IoCsqInsertIrpEx(PIO_CSQ Csq,
-                                PIRP Irp,
-                                PIO_CSQ_IRP_CONTEXT Context,
-                                PVOID InsertContext);
-
-/*
- * Remove a particular IRP from the queue
- */
-PIRP NTAPI IoCsqRemoveIrp(PIO_CSQ Csq,
-                          PIO_CSQ_IRP_CONTEXT Context);
-
-/*
- * Remove the next IRP from the queue 
- */
-PIRP NTAPI IoCsqRemoveNextIrp(PIO_CSQ Csq,
-                              PVOID PeekContext);