FreeBSD/Linux Kernel Cross Reference
sys/iokit/Kernel/IOCommandPool.cpp

     /*
      * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
      *
      * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
      * 
      * This file contains Original Code and/or Modifications of Original Code
      * as defined in and that are subject to the Apple Public Source License
      * Version 2.0 (the 'License'). You may not use this file except in
      * compliance with the License. The rights granted to you under the License
     * may not be used to create, or enable the creation or redistribution of,
     * unlawful or unlicensed copies of an Apple operating system, or to
     * circumvent, violate, or enable the circumvention or violation of, any
     * terms of an Apple operating system software license agreement.
     * 
     * Please obtain a copy of the License at
     * http://www.opensource.apple.com/apsl/ and read it before using this file.
     * 
     * The Original Code and all software distributed under the License are
     * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
     * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
     * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
     * Please see the License for the specific language governing rights and
     * limitations under the License.
     * 
     * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
     */
    
    /*
     *
     *      Copyright (c) 2000 Apple Computer, Inc.  All rights reserved.
     *
     *      HISTORY
     *
     *      2001-01-17      gvdl    Re-implement on IOCommandGate::commandSleep
     *      10/9/2000       CJS     Created IOCommandPool class and implementation
     *
     */
    
    #include <IOKit/IOCommandPool.h>
    
    #define super OSObject
    OSDefineMetaClassAndStructors(IOCommandPool, OSObject);
    OSMetaClassDefineReservedUnused(IOCommandPool, 0);
    OSMetaClassDefineReservedUnused(IOCommandPool, 1);
    OSMetaClassDefineReservedUnused(IOCommandPool, 2);
    OSMetaClassDefineReservedUnused(IOCommandPool, 3);
    OSMetaClassDefineReservedUnused(IOCommandPool, 4);
    OSMetaClassDefineReservedUnused(IOCommandPool, 5);
    OSMetaClassDefineReservedUnused(IOCommandPool, 6);
    OSMetaClassDefineReservedUnused(IOCommandPool, 7);
    
    //--------------------------------------------------------------------------
    //      withWorkLoop -  primary initializer and factory method
    //--------------------------------------------------------------------------
    
    IOCommandPool *IOCommandPool::
    withWorkLoop(IOWorkLoop *inWorkLoop)
    {
        IOCommandPool * me = new IOCommandPool;
        
        if (me && !me->initWithWorkLoop(inWorkLoop)) {
            me->release();
            return 0;
        }
        
        return me;
    }
    
    
    bool IOCommandPool::
    initWithWorkLoop(IOWorkLoop *inWorkLoop)
    {
        assert(inWorkLoop);
        
        if (!super::init())
            return false;
        
        queue_init(&fQueueHead);
        
        fSerializer = IOCommandGate::commandGate(this);
        assert(fSerializer);
        if (!fSerializer)
            return false;
        
        if (kIOReturnSuccess != inWorkLoop->addEventSource(fSerializer))
            return false;
        
        return true;
    }
    
    //--------------------------------------------------------------------------
    //      commandPool & init -    obsolete initializer and factory method
    //--------------------------------------------------------------------------
    
    IOCommandPool *IOCommandPool::
    commandPool(IOService * inOwner, IOWorkLoop *inWorkLoop, UInt32 inSize)
    {
        IOCommandPool * me = new IOCommandPool;
       
       if (me && !me->init(inOwner, inWorkLoop, inSize)) {
           me->release();
           return 0;
       }
       
       return me;
   }
   
   bool IOCommandPool::
   init(IOService */* inOwner */, IOWorkLoop *inWorkLoop, UInt32 /* inSize */)
   {
       return initWithWorkLoop(inWorkLoop);
   }
   
   
   //--------------------------------------------------------------------------
   //      free -  free all allocated resources
   //--------------------------------------------------------------------------
   
   void
   IOCommandPool::free(void)
   {
       if (fSerializer) {
           // remove our event source from owner's workloop
           IOWorkLoop *wl = fSerializer->getWorkLoop();
           if (wl)
               wl->removeEventSource(fSerializer);
           
           fSerializer->release();
           fSerializer = 0;
       }
               
       // Tell our superclass to cleanup too
       super::free();
   }
   
   
   //--------------------------------------------------------------------------
   //      getCommand -    Gets a command from the pool. Pass true in
   //                      blockForCommand if you want your thread to sleep
   //                      waiting for resources
   //--------------------------------------------------------------------------
   
   IOCommand *
   IOCommandPool::getCommand(bool blockForCommand)
   {
       IOReturn     result  = kIOReturnSuccess;
       IOCommand *command = 0;
   
       IOCommandGate::Action func = OSMemberFunctionCast(
               IOCommandGate::Action, this, &IOCommandPool::gatedGetCommand);
       result = fSerializer->
           runAction(func, (void *) &command, (void *) blockForCommand);
       if (kIOReturnSuccess == result)
           return command;
       else
           return 0;
   }
   
   
   //--------------------------------------------------------------------------
   //      gatedGetCommand -       Static callthrough function
   //                              (on safe side of command gate)
   //--------------------------------------------------------------------------
   
   IOReturn IOCommandPool::
   gatedGetCommand(IOCommand **command, bool blockForCommand)
   {
       while (queue_empty(&fQueueHead)) {
           if (!blockForCommand)
               return kIOReturnNoResources;
   
           fSleepers++;
           fSerializer->commandSleep(&fSleepers, THREAD_UNINT);
       }
   
       queue_remove_first(&fQueueHead,
                          *command, IOCommand *, fCommandChain);
       return kIOReturnSuccess;
   }
   
   
   //--------------------------------------------------------------------------
   //      returnCommand -         Returns command to the pool.
   //--------------------------------------------------------------------------
   
   void IOCommandPool::
   returnCommand(IOCommand *command)
   {
       IOCommandGate::Action func = OSMemberFunctionCast(
               IOCommandGate::Action, this, &IOCommandPool::gatedReturnCommand);
       (void) fSerializer->runAction(func, (void *) command);
   }
   
   
   //--------------------------------------------------------------------------
   //      gatedReturnCommand -    Callthrough function
   //                              (on safe side of command gate)
   //--------------------------------------------------------------------------
   
   IOReturn IOCommandPool::
   gatedReturnCommand(IOCommand *command)
   {
       queue_enter_first(&fQueueHead, command, IOCommand *, fCommandChain);
       if (fSleepers) {
           fSerializer->commandWakeup(&fSleepers, /* oneThread */ true);
           fSleepers--;
       }
       return kIOReturnSuccess;
   }

Cache object: abfb34b7b4b7a502e676f9cbb70c80fe