void LLTextureCache::purgeCache(ELLPath location)
{
if (!mReadOnly)
{
setDirNames(location);
ll_apr_file_remove(mHeaderEntriesFileName, NULL);
ll_apr_file_remove(mHeaderDataFileName, NULL);
}
purgeAllTextures(true);
}
bool LLCrashLogger::init()
{
// We assume that all the logs we're looking for reside on the current drive
gDirUtilp->initAppDirs("SecondLife");
// Default to the product name "Second Life" (this is overridden by the -name argument)
mProductName = "Second Life";
mCrashSettings.declareS32(CRASH_BEHAVIOR_SETTING, CRASH_BEHAVIOR_ASK, "Controls behavior when viewer crashes "
"(0 = ask before sending crash report, 1 = always send crash report, 2 = never send crash report)");
llinfos << "Loading crash behavior setting" << llendl;
mCrashBehavior = loadCrashBehaviorSetting();
// If user doesn't want to send, bail out
if (mCrashBehavior == CRASH_BEHAVIOR_NEVER_SEND)
{
llinfos << "Crash behavior is never_send, quitting" << llendl;
return false;
}
gServicePump = new LLPumpIO(gAPRPoolp);
gServicePump->prime(gAPRPoolp);
LLHTTPClient::setPump(*gServicePump);
//If we've opened the crash logger, assume we can delete the marker file if it exists
if( gDirUtilp )
{
std::string marker_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"SecondLife.exec_marker");
ll_apr_file_remove( marker_file );
}
return true;
}
void LLTextureCache::removeFromCache(const LLUUID& id)
{
//llwarns << "Removing texture from cache: " << id << llendl;
if (!mReadOnly)
{
removeHeaderCacheEntry(id);
ll_apr_file_remove(getTextureFileName(id), NULL);
}
}
void LLTextureCache::purgeTextureFilesTimeSliced(BOOL force_all)
{
LLMutexLock lock(&mHeaderMutex);
F32 delay_between_passes = 1.0f; // seconds
F32 max_time_per_pass = 0.1f; // seconds
if (!force_all && mTimeLastFileDelete.getElapsedTimeF32() <= delay_between_passes)
{
return;
}
LLTimer timer;
S32 howmany = 0;
if (mFilesToDelete.size() > 0)
{
llinfos << "TEXTURE CACHE: " << mFilesToDelete.size() << " files scheduled for deletion" << llendl;
}
for (LLTextureCache::filename_list_t::iterator iter = mFilesToDelete.begin(); iter!=mFilesToDelete.end(); )
{
LLTextureCache::filename_list_t::iterator iter2 = iter++;
ll_apr_file_remove(*iter2, NULL);
mFilesToDelete.erase(iter2);
howmany++;
if (!force_all && timer.getElapsedTimeF32() > max_time_per_pass)
{
break;
}
}
if (!mFilesToDelete.empty())
{
llinfos << "TEXTURE CACHE: "<< howmany << " files deleted ("
<< mFilesToDelete.size() << " files left for next pass)"
<< llendl;
}
mTimeLastFileDelete.reset();
}
void LLTextureCache::purgeAllTextures(bool purge_directories)
{
if (!mReadOnly)
{
const char* subdirs = "0123456789abcdef";
std::string delem = gDirUtilp->getDirDelimiter();
std::string mask = delem + "*";
for (S32 i=0; i<16; i++)
{
std::string dirname = mTexturesDirName + delem + subdirs[i];
gDirUtilp->deleteFilesInDir(dirname,mask);
if (purge_directories)
{
LLFile::rmdir(dirname);
}
}
ll_apr_file_remove(mTexturesDirEntriesFileName, NULL);
if (purge_directories)
{
LLFile::rmdir(mTexturesDirName);
}
}
mTexturesSizeMap.clear();
}
void LLTextureCache::purgeTextures(bool validate)
{
if (mReadOnly)
{
return;
}
// *FIX:Mani - watchdog off.
LLAppViewer::instance()->pauseMainloopTimeout();
LLMutexLock lock(&mHeaderMutex);
S32 filesize = ll_apr_file_size(mTexturesDirEntriesFileName, NULL);
S32 num_entries = filesize / sizeof(Entry);
if (num_entries * (S32)sizeof(Entry) != filesize)
{
LL_WARNS("TextureCache") << "Bad cache file: " << mTexturesDirEntriesFileName << " Purging." << LL_ENDL;
purgeAllTextures(false);
return;
}
if (num_entries == 0)
{
return; // nothing to do
}
Entry* entries = new Entry[num_entries];
S32 bytes_read = ll_apr_file_read_ex(mTexturesDirEntriesFileName, NULL,
(U8*)entries, 0, num_entries*sizeof(Entry));
if (bytes_read != filesize)
{
LL_WARNS("TextureCache") << "Bad cache file (2): " << mTexturesDirEntriesFileName << " Purging." << LL_ENDL;
purgeAllTextures(false);
return;
}
LL_DEBUGS("TextureCache") << "TEXTURE CACHE: Reading " << num_entries << " Entries from " << mTexturesDirEntriesFileName << LL_ENDL;
std::map<LLUUID, S32> entry_idx_map;
S64 total_size = 0;
for (S32 idx=0; idx<num_entries; idx++)
{
const LLUUID& id = entries[idx].mID;
LL_DEBUGS("TextureCache") << "Entry: " << id << " Size: " << entries[idx].mSize << " Time: " << entries[idx].mTime << LL_ENDL;
std::map<LLUUID, S32>::iterator iter = entry_idx_map.find(id);
if (iter != entry_idx_map.end())
{
// Newer entry replacing older entry
S32 pidx = iter->second;
total_size -= entries[pidx].mSize;
entries[pidx].mSize = 0; // flag: skip older entry
}
entry_idx_map[id] = idx;
total_size += entries[idx].mSize;
}
U32 validate_idx = 0;
if (validate)
{
validate_idx = gSavedSettings.getU32("CacheValidateCounter");
U32 next_idx = (++validate_idx) % 256;
gSavedSettings.setU32("CacheValidateCounter", next_idx);
LL_DEBUGS("TextureCache") << "TEXTURE CACHE: Validating: " << validate_idx << LL_ENDL;
}
S64 min_cache_size = sCacheMaxTexturesSize / 100 * 95;
S32 purge_count = 0;
S32 next_idx = 0;
for (S32 idx=0; idx<num_entries; idx++)
{
if (entries[idx].mSize == 0)
{
continue;
}
bool purge_entry = false;
std::string filename = getTextureFileName(entries[idx].mID);
if (total_size >= min_cache_size)
{
purge_entry = true;
}
else if (validate)
{
// make sure file exists and is the correct size
S32 uuididx = entries[idx].mID.mData[0];
if (uuididx == validate_idx)
{
LL_DEBUGS("TextureCache") << "Validating: " << filename << "Size: " << entries[idx].mSize << LL_ENDL;
S32 bodysize = ll_apr_file_size(filename, NULL);
if (bodysize != entries[idx].mSize)
{
LL_WARNS("TextureCache") << "TEXTURE CACHE BODY HAS BAD SIZE: " << bodysize << " != " << entries[idx].mSize
<< filename << LL_ENDL;
purge_entry = true;
}
}
}
if (purge_entry)
{
purge_count++;
LL_DEBUGS("TextureCache") << "PURGING: " << filename << LL_ENDL;
mFilesToDelete.push_back(filename);
total_size -= entries[idx].mSize;
entries[idx].mSize = 0;
}
else
{
if (next_idx != idx)
{
entries[next_idx] = entries[idx];
}
++next_idx;
}
}
num_entries = next_idx;
mTimeLastFileDelete.reset();
LL_DEBUGS("TextureCache") << "TEXTURE CACHE: Writing Entries: "
<< num_entries << " (" << num_entries*sizeof(Entry)/1024 << "KB)"
<< LL_ENDL;
ll_apr_file_remove(mTexturesDirEntriesFileName, NULL);
ll_apr_file_write_ex(mTexturesDirEntriesFileName, NULL,
(U8*)&entries[0], 0, num_entries*sizeof(Entry));
mTexturesSizeTotal = 0;
mTexturesSizeMap.clear();
for (S32 idx=0; idx<num_entries; idx++)
{
mTexturesSizeMap[entries[idx].mID] = entries[idx].mSize;
mTexturesSizeTotal += entries[idx].mSize;
}
llassert(mTexturesSizeTotal == total_size);
delete[] entries;
// *FIX:Mani - watchdog back on.
LLAppViewer::instance()->resumeMainloopTimeout();
LL_INFOS("TextureCache") << "TEXTURE CACHE:"
<< " PURGED: " << purge_count
<< " ENTRIES: " << num_entries
<< " CACHE SIZE: " << total_size/1024/1024 << " MB"
<< llendl;
}
