/*********************************************************************
* Initialize the IOCatalog object.
*********************************************************************/
bool IOCatalogue::init(OSArray * initArray)
{
OSDictionary * dict;
OSObject * obj;
if ( !super::init() )
return false;
generation = 1;
personalities = OSDictionary::withCapacity(32);
personalities->setOptions(OSCollection::kSort, OSCollection::kSort);
for (unsigned int idx = 0; (obj = initArray->getObject(idx)); idx++)
{
dict = OSDynamicCast(OSDictionary, obj);
if (!dict) continue;
OSKext::uniquePersonalityProperties(dict);
if( 0 == dict->getObject( gIOClassKey ))
{
IOLog("Missing or bad \"%s\" key\n",
gIOClassKey->getCStringNoCopy());
continue;
}
dict->setObject("KernelConfigTable", kOSBooleanTrue);
addPersonality(dict);
}
gIOCatalogLock = IORWLockAlloc();
lock = gIOCatalogLock;
return true;
}
bool DldIOShadowFile::initWithFileName( __in char* name, __in size_t nameLength )
{
assert( preemption_enabled() );
if( nameLength > (MAXPATHLEN + sizeof( L'\0' )) ){
DBG_PRINT_ERROR(("length > (MAXPATHLEN + sizeof( L'\\0' ))\n"));
return false;
}
if( !super::init() ){
DBG_PRINT_ERROR(("super::init() failed\n"));
return false;
}
this->rwLock = IORWLockAlloc();
assert( this->rwLock );
if( !this->rwLock ){
DBG_PRINT_ERROR(("this->rwLock = IORWLockAlloc() failed\n" ));
return false;
}
//
// set a maximum file size to infinity
//
this->maxSize = DLD_IGNR_FSIZE;
//
// set switch size to 512 MB
//
this->switchSize = 0x20000000ll;
this->path = (char*)IOMalloc( nameLength );
assert( this->path );
if( !this->path ){
DBG_PRINT_ERROR(("this->path = IOMalloc( %u ) failed\n", (int)nameLength ));
return false;
}
this->pathLength = nameLength;
memcpy( this->path, name, nameLength );
assert( L'\0' == this->path[ this->pathLength - 0x1 ] );
//
// open or create the file
//
errno_t error;
vfs_context_t vfs_context;
vfs_context = vfs_context_create( NULL );
assert( vfs_context );
if( !vfs_context )
return false;
//
// open or create a file, truncate if the file exists
//
error = vnode_open( this->path,
O_EXLOCK | O_RDWR | O_CREAT | O_TRUNC | O_SYNC, // fmode
0644,// cmode
0x0,// flags
&this->vnode,
vfs_context );
vfs_context_rele( vfs_context );
if( error ){
DBG_PRINT_ERROR(("vnode_open() failed with the %u error\n", error));
return false;
}
//
// vn_open returns with both a use_count
// and an io_count on the found vnode
//
//
// mark as an internal non shadowed vnode, use the CreateAndAddIOVnodByBSDVnode
// as the kauth callback might have not been registered so the vnode open
// was not seen by the DL driver
//
DldIOVnode* dldVnode;
dldVnode = DldVnodeHashTable::sVnodesHashTable->CreateAndAddIOVnodByBSDVnode( this->vnode );
assert( dldVnode );
if( !dldVnode ){
//
// we can't use this vnode as will be unable to distinguish
// the DL internal writes from the user writes this will result
// in an endless loop
//
DBG_PRINT_ERROR(("RetrieveReferencedIOVnodByBSDVnode() failed\n"));
this->release();
return NULL;
}
//
// mark as skipped for log, shadowing and any other operations
//
dldVnode->flags.internal = 0x1;
dldVnode->release();
DLD_DBG_MAKE_POINTER_INVALID( dldVnode );
this->expandFile();
//
// mark as noncached vnode, writes must be sector aligned!
//
//vnode_setnocache( this->vnode );
return true;
}
