status_t packagefs_read_index_dir(fs_volume* fsVolume, void* cookie, struct dirent* buffer, size_t bufferSize, uint32* _num) { Volume* volume = (Volume*)fsVolume->private_volume; FUNCTION("volume: %p, cookie: %p, buffer: %p, bufferSize: %zu, num: %" B_PRIu32 "\n", volume, cookie, buffer, bufferSize, *_num); IndexDirIterator* iterator = (IndexDirIterator*)cookie; if (*_num == 0) return B_BAD_VALUE; IndexDirIterator previousIterator = *iterator; // get the next index Index* index = iterator->Next(); if (index == NULL) { *_num = 0; return B_OK; } // fill in the entry if (!set_dirent_name(buffer, bufferSize, index->Name())) { *iterator = previousIterator; return B_BUFFER_OVERFLOW; } buffer->d_dev = volume->ID(); buffer->d_ino = 0; *_num = 1; return B_OK; }
static status_t packagefs_get_vnode(fs_volume* fsVolume, ino_t vnid, fs_vnode* fsNode, int* _type, uint32* _flags, bool reenter) { Volume* volume = (Volume*)fsVolume->private_volume; FUNCTION("volume: %p, vnid: %" B_PRId64 "\n", volume, vnid); VolumeReadLocker volumeLocker(volume); Node* node = volume->FindNode(vnid); if (node == NULL) return B_ENTRY_NOT_FOUND; BReference<Node> nodeReference(node); volumeLocker.Unlock(); NodeWriteLocker nodeLocker(node); status_t error = node->VFSInit(volume->ID()); if (error != B_OK) RETURN_ERROR(error); nodeLocker.Unlock(); fsNode->private_node = nodeReference.Detach(); fsNode->ops = &gPackageFSVnodeOps; *_type = node->Mode() & S_IFMT; *_flags = 0; return B_OK; }
static status_t packagefs_mount(fs_volume* fsVolume, const char* device, uint32 flags, const char* parameters, ino_t* _rootID) { FUNCTION("fsVolume: %p, device: \"%s\", flags: %#" B_PRIx32 ", parameters: " "\"%s\"\n", fsVolume, device, flags, parameters); // create a Volume object Volume* volume = new(std::nothrow) Volume(fsVolume); if (volume == NULL) RETURN_ERROR(B_NO_MEMORY); ObjectDeleter<Volume> volumeDeleter(volume); // Initialize the fs_volume now already, so it is mostly usable in during // mounting. fsVolume->private_volume = volumeDeleter.Detach(); fsVolume->ops = &gPackageFSVolumeOps; status_t error = volume->Mount(parameters); if (error != B_OK) return error; // set return values *_rootID = volume->RootDirectory()->ID(); return B_OK; }
void SkeletonDrawable::adjustVolume(Volume & volume) { Inherited::adjustVolume(volume); //Extend the volume by all the Root Joints of Skeleton if(getSkeleton() == NULL) { FWARNING(("SkeletonDrawable::drawPrimitives:: no skeleton!\n"));; } else { Pnt3f JointLocation(0.0,0.0,0.0); for(UInt32 i(0) ; i<getSkeleton()->getNumJoints() ; ++i) { JointLocation.setValues(0.0,0.0,0.0); if(getDrawPose()) { getSkeleton()->getAbsoluteTransformation(i).mult(Pnt3f(0.0f,0.0f,0.0f),JointLocation); volume.extendBy(JointLocation); } if(getDrawBindPose()) { getSkeleton()->getAbsoluteBindTransformation(i).mult(Pnt3f(0.0f,0.0f,0.0f),JointLocation); volume.extendBy(JointLocation); } } } }
void Geometry::adjustVolume(Volume & volume) { if(!_volumeCache.isEmpty()) { // use cached volume. volume.setValid(); volume.extendBy(_volumeCache); return; } GeoVectorProperty *pos = getPositions(); if(pos == NULL) return; // Node has no points, no volume _volumeCache.setValid(); PrimitiveIterator it = this->beginPrimitives(); PrimitiveIterator end = this->endPrimitives (); for(; it != end; ++it) { for(UInt32 v = 0; v < it.getLength(); ++v) { _volumeCache.extendBy(it.getPosition(v)); } } volume.extendBy(_volumeCache); }
// reiserfs_open static status_t reiserfs_open(fs_volume *fs, fs_vnode *_node, int openMode, void **cookie) { // FUNCTION_START(); Volume *volume = (Volume*)fs->private_volume; VNode *node = (VNode*)_node->private_node; FUNCTION(("node: (%Ld: %lu, %lu)\n", node->GetID(), node->GetDirID(), node->GetObjectID())); status_t error = B_OK; // check the open mode if ((openMode & O_RWMASK) == O_WRONLY || (openMode & O_RWMASK) == O_RDWR || (openMode & (O_TRUNC | O_CREAT))) { error = B_READ_ONLY_DEVICE; } // create a StreamReader if (error == B_OK) { StreamReader *reader = new(nothrow) StreamReader(volume->GetTree(), node->GetDirID(), node->GetObjectID()); if (reader) { error = reader->Suspend(); if (error == B_OK) *cookie = reader; else delete reader; } else error = B_NO_MEMORY; } RETURN_ERROR(error); }
// HandleEvent void ServerVolume::HandleEvent(VolumeEvent* event) { if (event->GetType() == CONNECTION_BROKEN_EVENT) { // tell all share volumes that they have been disconnected // init a directory iterator fLock.Lock(); VirtualDirIterator iterator; iterator.SetDirectory(fRootNode, true); // iterate through the directory const char* name; Node* node; while (iterator.GetCurrentEntry(&name, &node)) { iterator.NextEntry(); Volume* volume = fVolumeManager->GetVolume(node->GetID()); fLock.Unlock(); if (ShareVolume* shareVolume = dynamic_cast<ShareVolume*>(volume)) shareVolume->ConnectionClosed(); if (volume) volume->PutVolume(); fLock.Lock(); } // uninit the directory iterator iterator.SetDirectory(NULL); // mark ourselves unmounting SetUnmounting(true); fLock.Unlock(); } }
static status_t ext2_get_vnode(fs_volume* _volume, ino_t id, fs_vnode* _node, int* _type, uint32* _flags, bool reenter) { Volume* volume = (Volume*)_volume->private_volume; if (id < 2 || id > volume->NumInodes()) { ERROR("invalid inode id %" B_PRIdINO " requested!\n", id); return B_BAD_VALUE; } Inode* inode = new(std::nothrow) Inode(volume, id); if (inode == NULL) return B_NO_MEMORY; status_t status = inode->InitCheck(); if (status != B_OK) delete inode; if (status == B_OK) { _node->private_node = inode; _node->ops = &gExt2VnodeOps; *_type = inode->Mode(); *_flags = 0; } else ERROR("get_vnode: InitCheck() failed. Error: %s\n", strerror(status)); return status; }
//////////////////////////////////////////////////////////////////////// // GetNeighbours - sreiter void GetNeighbours(std::vector<Volume*>& vVolsOut, Grid& grid, Volume* v, int side, bool clearContainer) { if(clearContainer) vVolsOut.clear(); // if VOLOPT_AUTOGENERATE_FACES and FACEOPT_STORE_ASSOCIATED_VOLUMES are // activated, we may use them to find the connected volume quite fast. if(grid.option_is_enabled(VOLOPT_AUTOGENERATE_FACES | FACEOPT_STORE_ASSOCIATED_VOLUMES)) { Face* f = grid.get_face(v, side); Grid::AssociatedVolumeIterator iterEnd = grid.associated_volumes_end(f); for(Grid::AssociatedVolumeIterator iter = grid.associated_volumes_begin(f); iter != iterEnd; ++iter) { if(*iter != v) vVolsOut.push_back(*iter); } return; } // we can't assume that associated faces exist. // we have to find the neighbour by hand. // mark all vertices of the side grid.begin_marking(); FaceDescriptor fd; v->face_desc(side, fd); uint numFaceVrts = fd.num_vertices(); for(uint i = 0; i < numFaceVrts; ++ i) grid.mark(fd.vertex(i)); // iterate over associated volumes of the first vertex and count // the number of marked vertices it contains. Vertex* vrt = fd.vertex(0); Grid::AssociatedVolumeIterator iterEnd = grid.associated_volumes_end(vrt); for(Grid::AssociatedVolumeIterator iter = grid.associated_volumes_begin(vrt); iter != iterEnd; ++iter) { Volume* vol = *iter; if(vol != v){ size_t count = 0; uint numVrts = vol->num_vertices(); for(uint i = 0; i < numVrts; ++i){ if(grid.is_marked(vol->vertex(i))) ++count; } // if the number of marked vertices in vol matches the // number of vertices of the specified side, we consider // the volume to be a neighbout of that side. if(count == numFaceVrts) vVolsOut.push_back(vol); } } grid.end_marking(); }
static status_t checksumfs_read_fs_info(fs_volume* fsVolume, struct fs_info* info) { Volume* volume = (Volume*)fsVolume->private_volume; volume->GetInfo(*info); return B_OK; }
// NOTE: We only set the volume in DiskInfo if 'containerPath' is set. // If volume mode is not specified, Volume::RW will be used (assuming // 'containerPath' is set). inline Resource::DiskInfo createDiskInfo( const Option<std::string>& persistenceId, const Option<std::string>& containerPath, const Option<Volume::Mode>& mode = None(), const Option<std::string>& hostPath = None(), const Option<Resource::DiskInfo::Source>& source = None()) { Resource::DiskInfo info; if (persistenceId.isSome()) { info.mutable_persistence()->set_id(persistenceId.get()); } if (containerPath.isSome()) { Volume volume; volume.set_container_path(containerPath.get()); volume.set_mode(mode.isSome() ? mode.get() : Volume::RW); if (hostPath.isSome()) { volume.set_host_path(hostPath.get()); } info.mutable_volume()->CopyFrom(volume); } if (source.isSome()) { info.mutable_source()->CopyFrom(source.get()); } return info; }
//! set the bounding volume of the node void DVRVolume::adjustVolume(Volume &volume) { volume.setValid(); volume.setEmpty(); DVRVolumeTexturePtr tex = DVRVOLUME_PARAMETER(this, DVRVolumeTexture); if (tex != NullFC) { const Vec3f & res = tex->getResolution (); const Vec3f & slice = tex->getSliceThickness(); Vec3f minBB(-0.5f * res[0] * slice[0], -0.5f * res[1] * slice[1], -0.5f * res[2] * slice[2]); Vec3f maxBB(-minBB); volume.extendBy(minBB); volume.extendBy(maxBB); } else { // something wrong with initialization - show boundingbox either Vec3f minBB(-0.5, -0.5, -0.5); Vec3f maxBB( 0.5, 0.5, 0.5); volume.extendBy(minBB); volume.extendBy(maxBB); } }
static status_t ext2_io(fs_volume* _volume, fs_vnode* _node, void* _cookie, io_request* request) { Volume* volume = (Volume*)_volume->private_volume; Inode* inode = (Inode*)_node->private_node; #ifndef EXT2_SHELL if (io_request_is_write(request) && volume->IsReadOnly()) { notify_io_request(request, B_READ_ONLY_DEVICE); return B_READ_ONLY_DEVICE; } #endif if (inode->FileCache() == NULL) { #ifndef EXT2_SHELL notify_io_request(request, B_BAD_VALUE); #endif return B_BAD_VALUE; } // We lock the node here and will unlock it in the "finished" hook. rw_lock_read_lock(inode->Lock()); return do_iterative_fd_io(volume->Device(), request, iterative_io_get_vecs_hook, iterative_io_finished_hook, inode); }
bool ExportSystemData(const Volume& volume, const Partition& partition, const std::string& export_folder) { bool success = true; File::CreateFullPath(export_folder + "/sys/"); success &= ExportHeader(volume, partition, export_folder + "/sys/boot.bin"); success &= ExportBI2Data(volume, partition, export_folder + "/sys/bi2.bin"); success &= ExportApploader(volume, partition, export_folder + "/sys/apploader.img"); success &= ExportDOL(volume, partition, export_folder + "/sys/main.dol"); success &= ExportFST(volume, partition, export_folder + "/sys/fst.bin"); if (volume.GetVolumeType() == Platform::WiiDisc) { File::CreateFullPath(export_folder + "/disc/"); success &= ExportWiiUnencryptedHeader(volume, export_folder + "/disc/header.bin"); success &= ExportWiiRegionData(volume, export_folder + "/disc/region.bin"); success &= ExportTicket(volume, partition, export_folder + "/ticket.bin"); success &= ExportTMD(volume, partition, export_folder + "/tmd.bin"); success &= ExportCertificateChain(volume, partition, export_folder + "/cert.bin"); if (volume.IsEncryptedAndHashed()) success &= ExportH3Hashes(volume, partition, export_folder + "/h3.bin"); } return success; }
Model loadModelSTL_binary(const char* filename) { Model m; FILE* f = fopen(filename, "rb"); if (f == NULL) { ostringstream oss; oss << "Can't open file " << filename << " for reading"; throw oss.str(); } char buffer[80]; uint32_t faceCount; //Skip the header if (fread(buffer, 80, 1, f) != 1) { fclose(f); return m; } //Read the face count if (fread(&faceCount, sizeof(uint32_t), 1, f) != 1) { fclose(f); return m; } //For each face read: //float(x,y,z) = normal, float(X,Y,Z)*3 = vertexes, uint16_t = flags m.volumes.push_back(Volume()); Volume* vol = &m.volumes[0]; if(vol == NULL) { fclose(f); return m; } for(unsigned int i=0;i<faceCount;i++) { if (fread(buffer, sizeof(float) * 3, 1, f) != 1) { fclose(f); return m; } float v[9]; if (fread(v, sizeof(float) * 9, 1, f) != 1) { fclose(f); return m; } Point3 v0 = Point3(v[0]*1000, v[1]*1000, v[2]*1000); Point3 v1 = Point3(v[3]*1000, v[4]*1000, v[5]*1000); Point3 v2 = Point3(v[6]*1000, v[7]*1000, v[8]*1000); vol->addFace(Face(v0, v1, v2)); if (fread(buffer, sizeof(uint16_t), 1, f) != 1) { fclose(f); return m; } } fclose(f); return m; }
static status_t ext2_get_file_map(fs_volume* _volume, fs_vnode* _node, off_t offset, size_t size, struct file_io_vec* vecs, size_t* _count) { TRACE("ext2_get_file_map()\n"); Volume* volume = (Volume*)_volume->private_volume; Inode* inode = (Inode*)_node->private_node; size_t index = 0, max = *_count; while (true) { fsblock_t block; uint32 count = 1; status_t status = inode->FindBlock(offset, block, &count); if (status != B_OK) return status; if (block > volume->NumBlocks()) { panic("ext2_get_file_map() found block %" B_PRIu64 " for offset %" B_PRIdOFF "\n", block, offset); } off_t blockOffset = block << volume->BlockShift(); uint32 blockLength = volume->BlockSize() * count; if (index > 0 && (vecs[index - 1].offset == blockOffset - vecs[index - 1].length || (vecs[index - 1].offset == -1 && block == 0))) { vecs[index - 1].length += blockLength; } else { if (index >= max) { // we're out of file_io_vecs; let's bail out *_count = index; return B_BUFFER_OVERFLOW; } // 'block' is 0 for sparse blocks if (block != 0) vecs[index].offset = blockOffset; else vecs[index].offset = -1; vecs[index].length = blockLength; index++; } offset += blockLength; if (offset >= inode->Size() || size <= blockLength) { // We're done! *_count = index; TRACE("ext2_get_file_map for inode %" B_PRIdINO "\n", inode->ID()); return B_OK; } size -= blockLength; } // can never get here return B_ERROR; }
static status_t ext2_read_attr_dir(fs_volume* _volume, fs_vnode* _node, void* _cookie, struct dirent* dirent, size_t bufferSize, uint32* _num) { Inode* inode = (Inode*)_node->private_node; int32 index = *(int32 *)_cookie; Attribute attribute(inode); TRACE("%s()\n", __FUNCTION__); size_t length = bufferSize; status_t status = attribute.Find(index); if (status == B_ENTRY_NOT_FOUND) { *_num = 0; return B_OK; } else if (status != B_OK) return status; status = attribute.GetName(dirent->d_name, &length); if (status != B_OK) return B_OK; Volume* volume = (Volume*)_volume->private_volume; dirent->d_dev = volume->ID(); dirent->d_ino = inode->ID(); dirent->d_reclen = sizeof(struct dirent) + length; *_num = 1; *(int32*)_cookie = index + 1; return B_OK; }
// reiserfs_mount static status_t reiserfs_mount(fs_volume *_volume, const char *device, uint32 flags, const char *parameters, ino_t *rootID) { TOUCH(flags); TOUCH(parameters); FUNCTION_START(); // parameters are ignored for now status_t error = B_OK; // allocate and init the volume Volume *volume = new(nothrow) Volume; if (!volume) error = B_NO_MEMORY; if (error == B_OK) error = volume->Mount(_volume, device); // set the results if (error == B_OK) { *rootID = volume->GetRootVNode()->GetID(); _volume->private_volume = volume; _volume->ops = &gReiserFSVolumeOps; } // cleanup on failure if (error != B_OK && volume) delete volume; RETURN_ERROR(error); }
static status_t ext2_mount(fs_volume* _volume, const char* device, uint32 flags, const char* args, ino_t* _rootID) { Volume* volume = new(std::nothrow) Volume(_volume); if (volume == NULL) return B_NO_MEMORY; // TODO: this is a bit hacky: we can't use publish_vnode() to publish // the root node, or else its file cache cannot be created (we could // create it later, though). Therefore we're using get_vnode() in Mount(), // but that requires us to export our volume data before calling it. _volume->private_volume = volume; _volume->ops = &gExt2VolumeOps; status_t status = volume->Mount(device, flags); if (status != B_OK) { ERROR("Failed mounting the volume. Error: %s\n", strerror(status)); delete volume; return status; } *_rootID = volume->RootNode()->ID(); return B_OK; }
//------------------------------------------------------------------------------ // serialize() -- print the value of this object to the output stream sout. //------------------------------------------------------------------------------ std::ostream& FlowRate::serialize(std::ostream& sout, const int i, const bool slotsOnly) const { using namespace std; int j = 0; if (!slotsOnly) { sout << "( " << getFormName() << endl; // tab here j = 4; } indent(sout, i+j); sout << "value: " << flowRate << endl; if (myVolume != 0) { indent(sout, i+j); sout << "volume: "; Volume* mv = (Volume*) myVolume; mv->serialize(sout, i+j); } if (myTime != 0) { indent(sout, i+j); sout << "time: "; Time* mt = (Time*) myTime; mt->serialize(sout, i+j); } sout << ")" << endl; return sout; }
static status_t checksumfs_unmount(fs_volume* fsVolume) { Volume* volume = (Volume*)fsVolume->private_volume; volume->Unmount(); return B_OK; }
static status_t ext2_lookup(fs_volume* _volume, fs_vnode* _directory, const char* name, ino_t* _vnodeID) { TRACE("ext2_lookup: name address: %p\n", name); TRACE("ext2_lookup: name: %s\n", name); Volume* volume = (Volume*)_volume->private_volume; Inode* directory = (Inode*)_directory->private_node; // check access permissions status_t status = directory->CheckPermissions(X_OK); if (status < B_OK) return status; HTree htree(volume, directory); DirectoryIterator* iterator; status = htree.Lookup(name, &iterator); if (status != B_OK) return status; ObjectDeleter<DirectoryIterator> iteratorDeleter(iterator); status = iterator->FindEntry(name, _vnodeID); if (status != B_OK) return status; return get_vnode(volume->FSVolume(), *_vnodeID, NULL); }
static status_t ext2_open(fs_volume* _volume, fs_vnode* _node, int openMode, void** _cookie) { Volume* volume = (Volume*)_volume->private_volume; Inode* inode = (Inode*)_node->private_node; // opening a directory read-only is allowed, although you can't read // any data from it. if (inode->IsDirectory() && (openMode & O_RWMASK) != 0) return B_IS_A_DIRECTORY; status_t status = inode->CheckPermissions(open_mode_to_access(openMode) | (openMode & O_TRUNC ? W_OK : 0)); if (status != B_OK) return status; // Prepare the cookie file_cookie* cookie = new(std::nothrow) file_cookie; if (cookie == NULL) return B_NO_MEMORY; ObjectDeleter<file_cookie> cookieDeleter(cookie); cookie->open_mode = openMode & EXT2_OPEN_MODE_USER_MASK; cookie->last_size = inode->Size(); cookie->last_notification = system_time(); MethodDeleter<Inode, status_t> fileCacheEnabler(&Inode::EnableFileCache); if ((openMode & O_NOCACHE) != 0) { status = inode->DisableFileCache(); if (status != B_OK) return status; fileCacheEnabler.SetTo(inode); } // Should we truncate the file? if ((openMode & O_TRUNC) != 0) { if ((openMode & O_RWMASK) == O_RDONLY) return B_NOT_ALLOWED; Transaction transaction(volume->GetJournal()); inode->WriteLockInTransaction(transaction); status_t status = inode->Resize(transaction, 0); if (status == B_OK) status = inode->WriteBack(transaction); if (status == B_OK) status = transaction.Done(); if (status != B_OK) return status; // TODO: No need to notify file size changed? } fileCacheEnabler.Detach(); cookieDeleter.Detach(); *_cookie = cookie; return B_OK; }
std::optional<u64> GetFSTSize(const Volume& volume, const Partition& partition) { const Platform volume_type = volume.GetVolumeType(); if (!IsDisc(volume_type)) return {}; return volume.ReadSwappedAndShifted(0x428, partition); }
void ISPCDevice::sampleVolume(float **results, OSPVolume _volume, const vec3f *worldCoordinates, const size_t &count) { Volume *volume = (Volume *)_volume; volume->computeSamples(results, worldCoordinates, count); }
// PutVolume // // The VolumeManager must not be locked, when this method is invoked. void VolumeManager::PutVolume(Volume* volume) { if (!volume) return; // If the volume is marked unmounting and is not yet marked removed, we // initiate the removal process. { AutoLocker<Locker> locker(this); //PRINT(("VolumeManager::PutVolume(%p): reference count before: %ld\n", //volume, volume->CountReferences())); if (volume->IsUnmounting() && !volume->IsRemoved()) { //PRINT(("VolumeManager::PutVolume(%p): Volume connection broken, marking " //"removed and removing all nodes.\n", volume)); // mark removed volume->MarkRemoved(); // get parent volume Volume* parentVolume = volume->GetParentVolume(); if (parentVolume && !GetVolume(parentVolume)) parentVolume = NULL; locker.Unlock(); // prepare to unmount volume->PrepareToUnmount(); // remove from parent volume if (parentVolume) { parentVolume->RemoveChildVolume(volume); PutVolume(parentVolume); } } } // If the volume is marked removed and it's reference count drops to 0, // we unmount and delete it. { AutoLocker<Locker> locker(this); if (volume->ReleaseReference() && volume->IsRemoved()) { PRINT(("VolumeManager::PutVolume(%p): Removed volume unreferenced. " "Unmounting...\n", volume)); // remove from volume set -- now noone can get a reference to it // anymore fVolumes->Remove(volume); locker.Unlock(); // unmount and delete the volume // TODO: At some point all the volume's node IDs have to be removed from // fNodeIDs2Volumes. For the time being we expect the volume to do that itself // in Unmount(). volume->Unmount(); delete volume; } } }
static status_t ext2_unlink(fs_volume* _volume, fs_vnode* _directory, const char* name) { TRACE("ext2_unlink()\n"); if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) return B_NOT_ALLOWED; Volume* volume = (Volume*)_volume->private_volume; Inode* directory = (Inode*)_directory->private_node; status_t status = directory->CheckPermissions(W_OK); if (status != B_OK) return status; TRACE("ext2_unlink(): Starting transaction\n"); Transaction transaction(volume->GetJournal()); directory->WriteLockInTransaction(transaction); TRACE("ext2_unlink(): Looking up for directory entry\n"); HTree htree(volume, directory); DirectoryIterator* directoryIterator; status = htree.Lookup(name, &directoryIterator); if (status != B_OK) return status; ino_t id; status = directoryIterator->FindEntry(name, &id); if (status != B_OK) return status; Vnode vnode(volume, id); Inode* inode; status = vnode.Get(&inode); if (status != B_OK) return status; inode->WriteLockInTransaction(transaction); status = inode->Unlink(transaction); if (status != B_OK) return status; status = directoryIterator->RemoveEntry(transaction); if (status != B_OK) return status; entry_cache_remove(volume->ID(), directory->ID(), name); status = transaction.Done(); if (status != B_OK) entry_cache_add(volume->ID(), directory->ID(), name, id); else notify_entry_removed(volume->ID(), directory->ID(), name, id); return status; }
// OpenQuery status_t VirtualVolume::OpenQuery(const char* queryString, uint32 flags, port_id port, int32 token, QueryIterator** _iterator) { QueryManager* queryManager = fVolumeManager->GetQueryManager(); // allocate a hierarchical iterator HierarchicalQueryIterator* iterator = new(std::nothrow) HierarchicalQueryIterator(this); if (!iterator) return B_NO_MEMORY; // add it to the query manager status_t error = queryManager->AddIterator(iterator); if (error != B_OK) { delete iterator; return error; } QueryIteratorPutter iteratorPutter(queryManager, iterator); // iterate through the child volumes and open subqueries for them // init a directory iterator fLock.Lock(); VirtualDirIterator dirIterator; dirIterator.SetDirectory(fRootNode, true); // iterate through the directory const char* name; Node* node; while (dirIterator.GetCurrentEntry(&name, &node)) { dirIterator.NextEntry(); Volume* volume = fVolumeManager->GetVolume(node->GetID()); fLock.Unlock(); // open the subquery QueryIterator* subIterator; if (volume->OpenQuery(queryString, flags, port, token, &subIterator) == B_OK) { // add the subiterator if (queryManager->AddSubIterator(iterator, subIterator) != B_OK) queryManager->PutIterator(subIterator); } volume->PutVolume(); fLock.Lock(); } // uninit the directory iterator dirIterator.SetDirectory(NULL); fLock.Unlock(); // return the result *_iterator = iterator; iteratorPutter.Detach(); return B_OK; }
voreen::VolumeCollection* VolumeCollection::selectOrigin(const VolumeURL& origin) const { VolumeCollection* collection = new VolumeCollection(); for (size_t i=0; i<volumeHandles_.size(); ++i) { Volume* vh = dynamic_cast<Volume*>(volumeHandles_[i]); if (vh && vh->getOrigin() == origin) collection->add(volumeHandles_[i]); } return collection; }
void khResourceManager::CleanVolumeReservation(const std::string &volume, const std::string &path) { Volume *vol = GetVolume(volume); if (vol) { vol->CleanReservation(path); } }