status_t
device_node::_RemoveChildren()
{
NodeList::Iterator iterator = fChildren.GetIterator();
while (iterator.HasNext()) {
device_node* child = iterator.Next();
child->Release();
}
return fChildren.IsEmpty() ? B_OK : B_BUSY;
}
status_t
device_node::_Probe()
{
device_node* previous = NULL;
if (IsProbed() && !fChildren.IsEmpty()
&& (fFlags & (B_FIND_CHILD_ON_DEMAND | B_FIND_MULTIPLE_CHILDREN))
== B_FIND_CHILD_ON_DEMAND) {
// We already have a driver that claims this node; remove all
// (unused) nodes, and evaluate it again
_RemoveChildren();
previous = _FindCurrentChild();
if (previous != NULL) {
// This driver is still active - give it back the reference
// that was stolen by _RemoveChildren() - _RegisterDynamic()
// will release it, if it really isn't needed anymore
previous->Acquire();
}
}
return _RegisterDynamic(previous);
}
status_t
mount_file_systems(stage2_args *args)
{
// mount other partitions on boot device (if any)
NodeIterator iterator = gPartitions.GetIterator();
Partition *partition = NULL;
while ((partition = (Partition *)iterator.Next()) != NULL) {
// don't scan known partitions again
if (partition->IsFileSystem())
continue;
// remove the partition if it doesn't contain a (known) file system
if (partition->Scan(true) != B_OK && !partition->IsFileSystem()) {
gPartitions.Remove(partition);
delete partition;
}
}
// add all block devices the platform has for us
status_t status = platform_add_block_devices(args, &gBootDevices);
if (status < B_OK)
return status;
iterator = gBootDevices.GetIterator();
Node *device = NULL, *last = NULL;
while ((device = iterator.Next()) != NULL) {
// don't scan former boot device again
if (device == sBootDevice)
continue;
if (add_partitions_for(device, true) == B_OK) {
// ToDo: we can't delete the object here, because it must
// be removed from the list before we know that it was
// deleted.
/* // if the Release() deletes the object, we need to skip it
if (device->Release() > 0) {
list_remove_item(&gBootDevices, device);
device = last;
}
*/
(void)last;
}
last = device;
}
if (gPartitions.IsEmpty())
return B_ENTRY_NOT_FOUND;
#if 0
void *cookie;
if (gRoot->Open(&cookie, O_RDONLY) == B_OK) {
Directory *directory;
while (gRoot->GetNextNode(cookie, (Node **)&directory) == B_OK) {
char name[256];
if (directory->GetName(name, sizeof(name)) == B_OK)
printf(":: %s (%p)\n", name, directory);
void *subCookie;
if (directory->Open(&subCookie, O_RDONLY) == B_OK) {
while (directory->GetNextEntry(subCookie, name, sizeof(name)) == B_OK) {
printf("\t%s\n", name);
}
directory->Close(subCookie);
}
}
gRoot->Close(cookie);
}
#endif
return B_OK;
}
/*! Registers this node, and all of its children that have to be registered.
Also initializes the driver and keeps it that way on return in case
it returns successfully.
*/
status_t
device_node::Register(device_node* parent)
{
// make it public
if (parent != NULL)
parent->AddChild(this);
else
sRootNode = this;
status_t status = InitDriver();
if (status != B_OK)
return status;
if ((fFlags & B_KEEP_DRIVER_LOADED) != 0) {
// We keep this driver loaded by having it always initialized
InitDriver();
}
fFlags |= NODE_FLAG_REGISTER_INITIALIZED;
// We don't uninitialize the driver - this is done by the caller
// in order to save reinitializing during driver loading.
uint32 registeredFixedCount;
status = _RegisterFixed(registeredFixedCount);
if (status != B_OK) {
UninitUnusedDriver();
return status;
}
// Register the children the driver wants
if (DriverModule()->register_child_devices != NULL) {
status = DriverModule()->register_child_devices(DriverData());
if (status != B_OK) {
UninitUnusedDriver();
return status;
}
if (!fChildren.IsEmpty()) {
fRegistered = true;
return B_OK;
}
}
if (registeredFixedCount > 0) {
// Nodes with fixed children cannot have any dynamic children, so bail
// out here
fRegistered = true;
return B_OK;
}
// Register all possible child device nodes
status = _RegisterDynamic();
if (status == B_OK)
fRegistered = true;
else
UninitUnusedDriver();
return status;
}