#include <IOKit/storage/IOMedia.h>

#include <IOKit/storage/IOStorage.h>

class com_MySoftwareCompany_driver_MyFilterScheme : public IOStorage {

    OSDeclareDefaultStructors(com_MySoftwareCompany_driver_MyFilterScheme)

protected:

    IOMedia*    _childMedia;

    // Free all of this object's outstanding resources.

    virtual void free(void);

    // The handleOpen method grants or denies permission to access this

    // object to an interested client.

    virtual bool handleOpen(IOService*   client,

                            IOOptionBits options,

                            void*        access);

    // The handleIsOpen method determines whether the specified client,

    // or any client if none is specified, presently has an open

    // on this object.

    virtual bool handleIsOpen(const IOService* client) const;

     // The handleClose method closes the client's access to this object.

    virtual void handleClose(IOService* client, IOOptionBits options);

    // Attach the passed-in media object to the device tree plane.

    // This is necessary if you want to stack this filter scheme on top

    // of the boot volume. You do not need to include this method if you

    // do not need to filter the boot volume.

    virtual bool attachMediaObjectToDeviceTree(IOMedia* media);

    // Detach the passed-in media object from the device tree plane.

    // This is necessary if you want to stack this filter scheme on top

    // of the boot volume. You do not need to include this method if you

    // do not need to filter the boot volume.

    virtual void detachMediaObjectFromDeviceTree(IOMedia* media);

public:

     // Initialize this object's minimal state.

    virtual bool init(OSDictionary* properties = 0);

     // Publish the new IOMedia object that represents the filtered content.

    virtual bool start(IOService* provider);

    // Clean up after the published media object before terminating.

    virtual void stop(IOService* provider);

    // Read data from the storage object at the specified byte offset into

    // the specified buffer, asynchronously.   When the read completes,

    // the caller will be notified via the specified completion action.

    // The buffer will be retained for the duration of the read.

    virtual void read(IOService*           client,

                      UInt64               byteStart,

                      IOMemoryDescriptor*  buffer,

                      IOStorageCompletion  completion);

    // Write data into the storage object at the specified byte offset from

    // the specified buffer, asynchronously.   When the write completes, the

    // caller will be notified via the specified completion action.

    // The buffer will be retained for the duration of the write.

    virtual void write(IOService*           client,

                       UInt64               byteStart,

                       IOMemoryDescriptor*  buffer,

                       IOStorageCompletion  completion);

    // Flush the cached data in the storage object, if any, synchronously.

    // The I/O Kit provides for data caches at the driver level, but

    // Apple discourages this because it is rarely needed. In the majority

    // of cases, a pass-through implementation is sufficient.

    virtual IOReturn synchronizeCache(IOService* client);

    // Obtain this object's provider.  This method returns IOMedia,

    // rather than the less-specific OSObject, as a convenience.

    virtual IOMedia* getProvider() const;

};

#include <IOKit/assert.h>   // For debugging purposes.

#include <IOKit/IOLib.h>

#include "MyFilterScheme.h"

// This definition allows you to use the more convenient "super" in

// place of "IOStorage", where appropriate.

#define super IOStorage

// This macro must appear before you define any of your class's methods.

// Note that you must use the literal name of the superclass here,

// not "super" as defined above.

OSDefineMetaClassAndStructors(com_MySoftwareCompany_driver_MyFilterScheme,

                                IOStorage)

// Define the methods to implement.

bool com_MySoftwareCompany_driver_MyFilterScheme::init(OSDictionary*

                                            properties = 0)

{

    //

    // Initialize this object's minimal state.

    //

    // Call superclass's init.

    if (super::init(properties) == false)  return false;

    // Initialize state.

    _childMedia = 0;

    return true;

}

void com_MySoftwareCompany_driver_MyFilterScheme::free(void)

{

    //

    // Free all of this object's outstanding resources.

    //

    if ( _childMedia )  _childMedia->release();

    // Call superclass's free.

    super::free();

}

IOMedia* com_MySoftwareCompany_driver_MyFilterScheme::getProvider(void)

    const

{

    return (IOMedia*) IOService::getProvider();

}

bool com_MySoftwareCompany_driver_MyFilterScheme::start(IOService* provider)

{

    //

    // Publish the new media object that represents the filtered content.

    //

    IOMedia* media = OSDynamicCast (IOMedia, provider);

    // State assumptions.

    assert(media);

    // Call superclass's start.

    if ( super::start(provider) == false )

        return false;

    // Attach and register the new media object.

    IOMedia* childMedia = new IOMedia;

    if ( childMedia )

    {

        if ( childMedia->init(

                /* base               */ 0,

                /* size               */ media->getSize(),

                /* preferredBlockSize */ media->getPreferredBlockSize(),

                /* isEjectable        */ media->isEjectable(),

                /* isWhole            */ false,

                /* isWritable         */ media->isWritable(),

                /* contentHint        */ "Apple_HFS" ) )

        {

            // Set a name for this partition.

            UInt32 partitionID = 1;

            char name[24];

            sprintf(name, "MySoftwareCompany_Filtered %ld", partitionID);

            childMedia->setName(name);

            // Set a location value (partition number) for this partition.

            char location[12];

            sprintf(location, "%ld", partitionID);

            childMedia->setLocation(location);

            // Attach the new media to this driver

            _childMedia = childMedia;

            childMedia->attach(this);

            // Move parent node to child node.

            (void) attachMediaObjectToDeviceTree(childMedia);

            // Publish the new media object.

            childMedia->registerService();

            return true;

        }

        else

        {

            childMedia->release();

            childMedia = 0;

        }

    }

    return false;

}

void com_MySoftwareCompany_driver_MyFilterScheme::stop(IOService* provider)

{

    // Clean up after the media object before terminating.

    // State assumptions.

    assert(_childMedia);

    // Detach the media object previously attached in start().

    if (_childMedia)

        detachMediaObjectFromDeviceTree(_childMedia);

    super::stop(provider);

}

bool com_MySoftwareCompany_driver_MyFilterScheme::handleOpen(IOService*

                                            client,

                                            IOOptionBits options,

                                            void* argument)

{

    return getProvider()->open(this, options, (IOStorageAccess) argument);

}

bool com_MySoftwareCompany_driver_MyFilterScheme::handleIsOpen(const

                                            IOService* client) const

{

    return getProvider()->isOpen(this);

}

void com_MySoftwareCompany_driver_MyFilterScheme::handleClose(IOService*

                                        client, IOOptionBits options)

{

    getProvider()->close(this, options);

}

bool com_MySoftwareCompany_driver_MyFilterScheme::attachMediaObjectToDeviceTree(

                                            IOMedia* media)

{

    //

    // Attach the given media object to the device tree plane.

    //

    IORegistryEntry* child;

    if ((child = getParentEntry(gIOServicePlane))) {

        IORegistryEntry* parent;

        if ((parent = child->getParentEntry(gIODTPlane))) {

            const char* location = child->getLocation(gIODTPlane);

            const char* name     = child->getName(gIODTPlane);

            if (media->attachToParent(parent, gIODTPlane)) {

                media->setLocation(location, gIODTPlane);

                media->setName(name, gIODTPlane);

                child->detachFromParent(parent, gIODTPlane);

                return true;

            }

        }

    }

    return false;

}

void com_MySoftwareCompany_driver_MyFilterScheme::detachMediaObjectFromDeviceTree

                                            (IOMedia* media)

{

    //

    // Detach the given media object from the device tree plane.

    //

    IORegistryEntry* child;

    if ((child = getParentEntry(gIOServicePlane))) {

        IORegistryEntry * parent;

        if ((parent = media->getParentEntry(gIODTPlane))) {

            const char* location = media->getLocation(gIODTPlane);

            const char* name     = media->getName(gIODTPlane);

            if (child->attachToParent(parent, gIODTPlane)) {

                child->setLocation(location, gIODTPlane);

                child->setName(name, gIODTPlane);

            }

            media->detachFromParent(parent, gIODTPlane);

        }

    }

}

void com_MySoftwareCompany_driver_MyFilterScheme::read(IOService* __attribute__ ((unused)) client,

                                        UInt64 byteStart,

                                        IOMemoryDescriptor* buffer,

                                        IOStorageCompletion completion)

{

    // Add filtering code here.

       getProvider()->read(this, byteStart, buffer, completion);

}

void com_MySoftwareCompany_driver_MyFilterScheme::write(IOService* __attribute__ ((unused)) client,

                                        UInt64 byteStart,

                                        IOMemoryDescriptor* buffer,

                                        IOStorageCompletion completion)

{

   // Add filtering code here.

    getProvider()->write(this, byteStart, buffer, completion);

}

IOReturn com_MySoftwareCompany_driver_MyFilterScheme::synchronizeCache(

                                                    IOService* client)

{

    return getProvider()->synchronizeCache(this);

}