DiskLoc ExtentManager::createExtent( int size, int maxFileNoForQuota ) { size = quantizeExtentSize( size ); if ( size > Extent::maxSize() ) size = Extent::maxSize(); verify( size < DataFile::maxSize() ); for ( int i = numFiles() - 1; i >= 0; i-- ) { DataFile* f = getFile( i ); if ( f->getHeader()->unusedLength >= size ) { return _createExtentInFile( i, f, size, maxFileNoForQuota ); } } if ( maxFileNoForQuota > 0 && static_cast<int>( numFiles() ) >= maxFileNoForQuota && !cc().hasWrittenThisPass() ) { _quotaExceeded(); } // no space in an existing file // allocate files until we either get one big enough or hit maxSize for ( int i = 0; i < 8; i++ ) { DataFile* f = addAFile( size, false ); if ( f->getHeader()->unusedLength >= size ) { return _createExtentInFile( numFiles() - 1, f, size, maxFileNoForQuota ); } } // callers don't check for null return code, so assert msgasserted(14810, "couldn't allocate space for a new extent" ); }
MongoDataFile* Database::suitableFile( const char *ns, int sizeNeeded, bool preallocate, bool enforceQuota ) { // check existing files for ( int i=numFiles()-1; i>=0; i-- ) { MongoDataFile* f = getFile( i ); if ( f->getHeader()->unusedLength >= sizeNeeded ) { if ( fileIndexExceedsQuota( ns, i-1, enforceQuota ) ) // NOTE i-1 is the value used historically for this check. ; else return f; } } if ( fileIndexExceedsQuota( ns, numFiles(), enforceQuota ) ) { if ( cc().hasWrittenThisPass() ) { warning() << "quota exceeded, but can't assert, probably going over quota for: " << ns << endl; } else { uasserted(12501, "quota exceeded"); } } // allocate files until we either get one big enough or hit maxSize for ( int i = 0; i < 8; i++ ) { MongoDataFile* f = addAFile( sizeNeeded, preallocate ); if ( f->getHeader()->unusedLength >= sizeNeeded ) return f; if ( f->getHeader()->fileLength >= MongoDataFile::maxSize() ) // this is as big as they get so might as well stop return f; } uasserted(14810, "couldn't allocate space (suitableFile)"); // callers don't check for null return code return 0; }
Marker* distribute(File* hw, Marker* markers) { double sumRatio; int numHWs; int numHWsParRatio; int numMarkHWs; Marker* it; Marker* tmp; Marker* result; int i; int r; sumRatio = 0; for (it = markers; it; it = it->next) { sumRatio += it->ratio; } numHWs = numFiles(hw); numHWsParRatio = (int)(numHWs / sumRatio + EPSILON); for (it = markers; it; it = it->next) { numMarkHWs = (int)(numHWsParRatio * it->ratio + EPSILON); for (int i = 0; i < numMarkHWs; ++i) { it->files = insertFile(it->files, removeFrontFile(&hw)); } } result = NULL; for (i = numMarkers(markers); hw; --i) { r = rand() % i; tmp = removeMarker(&markers, r); tmp->files = insertFile(tmp->files, removeFrontFile(&hw)); result = insertMarker(result, tmp); } while (markers) { result = insertMarker(result, removeMarker(&markers, 0)); } return result; }
int main(int argv, char** argc) { File* hw; Marker* markers; Marker* it; const char* markersPath; const char* hwPath; FILE* outFile; if (argv != 3) { printf("Usage: %s markers homeworks\n", argc[0]); printf("markers: Markers file path.\n"); printf("files: HW files path.\n"); exit(EXIT_FAILURE); } markersPath = argc[1]; hwPath = argc[2]; markers = readMarkers(markersPath); srand(time(NULL)); rand(); rand(); hw = makeFileList(hwPath); markers = distribute(hw, markers); markers = sortMarkers(markers, numMarkers(markers)); for (it = markers; it; it = it->next) { it->files = sortFiles(it->files, numFiles(it->files)); } printMarkers(markers); for (it = markers; it; it = it->next) { free((void*)it->name); } freeMarkers(markers); freeFiles(hw); return 0; }
void clIndexerRequest::fromBinary(char* data) { UNPACK_INT(m_cmd, data); UNPACK_STD_STRING(m_ctagOptions, data); UNPACK_STD_STRING(m_databaseFileName, data); // read the number of files size_t numFiles(0); UNPACK_INT(numFiles, data); m_files.clear(); for (size_t i=0; i<numFiles; i++) { std::string file_name; UNPACK_STD_STRING(file_name, data); m_files.push_back(file_name); } }
MongoDataFile* Database::suitableFile( int sizeNeeded, bool preallocate ) { // check existing files for ( int i=numFiles()-1; i>=0; i-- ) { MongoDataFile* f = getFile( i ); if ( f->getHeader()->unusedLength >= sizeNeeded ) return f; } // allocate files until we either get one big enough or hit maxSize for ( int i = 0; i < 8; i++ ) { MongoDataFile* f = addAFile( sizeNeeded, preallocate ); if ( f->getHeader()->unusedLength >= sizeNeeded ) return f; if ( f->getHeader()->fileLength >= MongoDataFile::maxSize() ) // this is as big as they get so might as well stop return f; } return 0; }
MongoDataFile* Database::newestFile() { int n = numFiles(); if ( n == 0 ) return 0; return getFile(n-1); }
// Deserialize //------------------------------------------------------------------------------ void ToolManifest::Deserialize( IOStream & ms ) { ms.Read( m_ToolId ); ASSERT( m_Files.IsEmpty() ); uint32_t numFiles( 0 ); ms.Read( numFiles ); m_Files.SetCapacity( numFiles ); for ( size_t i=0; i<(size_t)numFiles; ++i ) { AStackString<> name; uint64_t timeStamp( 0 ); uint32_t hash( 0 ); uint32_t contentSize( 0 ); ms.Read( name ); ms.Read( timeStamp ); ms.Read( hash ); ms.Read( contentSize ); m_Files.Append( File( name, timeStamp, hash, nullptr, contentSize ) ); } // determine if any files are remaining from a previous run size_t numFilesAlreadySynchronized = 0; for ( size_t i=0; i<(size_t)numFiles; ++i ) { AStackString<> localFile; GetRemoteFilePath( (uint32_t)i, localFile ); // is this file already present? AutoPtr< FileStream > fileStream( FNEW( FileStream ) ); FileStream & f = *( fileStream.Get() ); if ( f.Open( localFile.Get() ) == false ) { continue; // file not found } if ( f.GetFileSize() != m_Files[ i ].m_ContentSize ) { continue; // file is not complete } AutoPtr< char > mem( (char *)ALLOC( (size_t)f.GetFileSize() ) ); if ( f.Read( mem.Get(), (size_t)f.GetFileSize() ) != f.GetFileSize() ) { continue; // problem reading file } if( Murmur3::Calc32( mem.Get(), (size_t)f.GetFileSize() ) != m_Files[ i ].m_Hash ) { continue; // file contents unexpected } // file present and ok m_Files[ i ].m_FileLock = fileStream.Release(); // NOTE: keep file open to prevent deletions m_Files[ i ].m_SyncState = File::SYNCHRONIZED; numFilesAlreadySynchronized++; } // Generate Environment ASSERT( m_RemoteEnvironmentString == nullptr ); // PATH= AStackString<> basePath; GetRemotePath( basePath ); AStackString<> paths; paths.Format( "PATH=%s", basePath.Get() ); // TMP= AStackString<> normalTmp; Env::GetEnvVariable( "TMP", normalTmp ); AStackString<> tmp; tmp.Format( "TMP=%s", normalTmp.Get() ); // SystemRoot= AStackString<> sysRoot( "SystemRoot=C:\\Windows" ); char * mem = (char *)ALLOC( paths.GetLength() + 1 + tmp.GetLength() + 1 + sysRoot.GetLength() + 1 + 1 ); m_RemoteEnvironmentString = mem; AString::Copy( paths.Get(), mem, paths.GetLength() + 1 ); // including null mem += ( paths.GetLength() + 1 ); // including null AString::Copy( tmp.Get(), mem, tmp.GetLength() + 1 ); // including null mem += ( tmp.GetLength() + 1 ); // including null AString::Copy( sysRoot.Get(), mem, sysRoot.GetLength() + 1 ); // including null mem += ( sysRoot.GetLength() + 1 ); // including null *mem = 0; ++mem; // double null // are all files already present? if ( numFilesAlreadySynchronized == m_Files.GetSize() ) { m_Synchronized = true; } }
void CTestUtilSessionSwi::ServiceL(const RMessage2& aMessage) { switch (aMessage.Function()) { case ECopy: { HBufC* source = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); HBufC* destination = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,1); TInt err = Server().FileMan().Copy(*source, *destination, CFileMan::ERecurse | CFileMan::EOverWrite); if (err == KErrNone) { // Turn off the read only attributes TTime time(0); // must specify 0, or a valid time, otherwise sets time to a random value and causes -6/-21 errors err = Server().FileMan().Attribs(*destination, 0, KEntryAttReadOnly, time, CFileMan::ERecurse); } CleanupStack::PopAndDestroy(destination); CleanupStack::PopAndDestroy(source); aMessage.Complete(err); break; } case EMove: { HBufC* source = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); HBufC* destination = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,1); TInt err = Server().FS().Rename(*source,*destination); if (err == KErrNone) { // Turn off the read only attributes TTime time(0); // must specify 0, or a valid time, otherwise sets time to a random value and causes -6/-21 errors err = Server().FileMan().Attribs(*destination, 0, KEntryAttReadOnly, time, CFileMan::ERecurse); } CleanupStack::PopAndDestroy(destination); CleanupStack::PopAndDestroy(source); aMessage.Complete(err); break; } case EDelete: { HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); TEntry entry; TInt err = Server().FS().Entry(*fileName, entry); if (err == KErrNone) { if (entry.IsDir()) { TPath pathName(*fileName); if (pathName[pathName.Length() - 1] != KPathDelimiter) { pathName.Append(KPathDelimiter); } err = Server().FileMan().RmDir(pathName); } else { err = Server().FS().Delete(*fileName); } } CleanupStack::PopAndDestroy(fileName); aMessage.Complete(err); break; } case ERmDir: { HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); TParsePtrC parsePtr(*fileName); if(parsePtr.IsRoot()) { User::Leave(KErrAccessDenied); } TInt err = Server().FileMan().RmDir(*fileName); CleanupStack::PopAndDestroy(fileName); aMessage.Complete(err); break; } case EMkDirAll: { HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); TInt err = Server().FS().MkDirAll(*fileName); CleanupStack::PopAndDestroy(fileName); aMessage.Complete(err); break; } case EFileExists: { delete iDetector; iDetector=CTestFileDetector::NewL(aMessage, Server().FS()); iDetector->DetectFile(); break; } case ELock: { HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); RFile lockFile; TInt err = lockFile.Open(Server().FS(), *fileName, EFileWrite); if (err == KErrNone) iLockedFileHandles.Append(lockFile); CleanupStack::PopAndDestroy(fileName); aMessage.Complete(err); break; } case EUnlock: { HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); TInt err = KErrNotFound; TFileName lockedFileName; for (TInt i = 0; i < iLockedFileHandles.Count() && err;i++) { TInt err2 = iLockedFileHandles[i].FullName(lockedFileName); User::LeaveIfError(err2); if (lockedFileName.MatchF(*fileName) != KErrNotFound) { iLockedFileHandles[i].Close(); iLockedFileHandles.Remove(i); err = KErrNone; } } CleanupStack::PopAndDestroy(fileName); aMessage.Complete(err); break; } case EFormat: { TInt drive = aMessage.Int0(); TBool formatFatOnly = aMessage.Int1(); TChar aDriveChar; User::LeaveIfError(Server().FS().DriveToChar(drive, aDriveChar)); TBuf<3> bfDrv; bfDrv.Append(aDriveChar); bfDrv.Append(KBP); RFormat format; TInt count; User::LeaveIfError(format.Open(Server().FS(), bfDrv, EHighDensity, count)); CleanupClosePushL(format); if (formatFatOnly) { User::LeaveIfError(format.Next(count)); } else { while (count > 0) { User::LeaveIfError(format.Next(count)); } } CleanupStack::PopAndDestroy(&format); aMessage.Complete(KErrNone); break; } case EMount: { TInt drive = aMessage.Int0(); User::LeaveIfError(Server().FS().Connect()); //Mount the drive synchronizely to make sure the drive is ready for the next operation User::LeaveIfError(Server().FS().MountFileSystem(KFAT, drive, ETrue)); aMessage.Complete(KErrNone); break; } case EUnMount: { TInt drive = aMessage.Int0(); TFileName fsName; User::LeaveIfError(Server().FS().FileSystemName(fsName, drive)); User::LeaveIfError(Server().FS().DismountFileSystem(fsName, drive)); aMessage.Complete(KErrNone); break; } case ESetReadOnly: { HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); TInt setReadOnly = aMessage.Int1(); TUint setmask; TUint clearmask; if (setReadOnly) { // Setting read only attribute setmask = KEntryAttReadOnly; clearmask = 0; } else { // Clearing read only attribute setmask = 0; clearmask = KEntryAttReadOnly; } // Turn off the read only attributes TTime time(0); TInt err = Server().FileMan().Attribs(*fileName, setmask, clearmask, time); CleanupStack::PopAndDestroy(fileName); aMessage.Complete(err); break; } case EGetFileHandle: { HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); RFile file; CleanupClosePushL(file); User::LeaveIfError(file.Open(Server().FS(), *fileName, EFileRead | EFileShareReadersOnly)); User::LeaveIfError(file.TransferToClient(aMessage, 1)); CleanupStack::PopAndDestroy(2, fileName); // file break; } case EWatchFile: { if (iFileWatcher) { if (iFileWatcher->IsActive()) { aMessage.Complete(KErrServerBusy); break; } else { delete iFileWatcher; iFileWatcher = NULL; } } // Create a new file watcher for this session iFileWatcher = CFileWatcher::NewL(Server().FS(), aMessage); break; } case EWatchFileCancel: { if (iFileWatcher) { iFileWatcher->Cancel(); aMessage.Complete(KErrNone); } else { // No file watch request to cancel! aMessage.Complete(KErrNotReady); } break; } case EGetNumFiles: { HBufC* dirPath = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); CDir* dirContents = NULL; User::LeaveIfError(Server().FS().GetDir(*dirPath, KEntryAttNormal, ESortNone, dirContents)); TPckg<TInt> numFiles(dirContents->Count()); delete dirContents; aMessage.WriteL(1, numFiles); aMessage.Complete(KErrNone); CleanupStack::PopAndDestroy(dirPath); break; } case ERegenerateCache: { #ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK Swi::RSisRegistryWritableSession session; User::LeaveIfError(session.Connect()); CleanupClosePushL(session); session.RegenerateCacheL(); CleanupStack::PopAndDestroy(&session); aMessage.Complete(KErrNone); #else aMessage.Complete(KErrNotSupported); #endif break; } case EGetFileHash: { HBufC* fileNameA = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); CMessageDigest* digest = CalculateFileHashLC(*fileNameA); aMessage.WriteL(1, digest->Final()); aMessage.Complete(KErrNone); CleanupStack::PopAndDestroy(2, fileNameA); break; } default: { PanicClient(aMessage,EPanicIllegalFunction); break; } } }