llvfs.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:6k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llvfs.h
  3.  * @brief Definition of virtual file system
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #ifndef LL_LLVFS_H
  33. #define LL_LLVFS_H
  34. #include <deque>
  35. #include "lluuid.h"
  36. #include "linked_lists.h"
  37. #include "llassettype.h"
  38. #include "llthread.h"
  39. enum EVFSValid 
  40. {
  41. VFSVALID_UNKNOWN = 0, 
  42. VFSVALID_OK = 1,
  43. VFSVALID_BAD_CORRUPT = 2,
  44. VFSVALID_BAD_CANNOT_OPEN_READONLY = 3,
  45. VFSVALID_BAD_CANNOT_CREATE = 4
  46. };
  47. // Lock types for open vfiles, pending async reads, and pending async appends
  48. // (There are no async normal writes, currently)
  49. enum EVFSLock
  50. {
  51. VFSLOCK_OPEN = 0,
  52. VFSLOCK_READ = 1,
  53. VFSLOCK_APPEND = 2,
  54. VFSLOCK_COUNT = 3
  55. };
  56. // internal classes
  57. class LLVFSBlock;
  58. class LLVFSFileBlock;
  59. class LLVFSFileSpecifier
  60. {
  61. public:
  62. LLVFSFileSpecifier();
  63. LLVFSFileSpecifier(const LLUUID &file_id, const LLAssetType::EType file_type);
  64. bool operator<(const LLVFSFileSpecifier &rhs) const;
  65. bool operator==(const LLVFSFileSpecifier &rhs) const;
  66. public:
  67. LLUUID mFileID;
  68. LLAssetType::EType mFileType;
  69. };
  70. class LLVFS
  71. {
  72. private:
  73. // Use createLLVFS() to open a VFS file
  74. // Pass 0 to not presize
  75. LLVFS(const std::string& index_filename, 
  76. const std::string& data_filename, 
  77. const BOOL read_only, 
  78. const U32 presize, 
  79. const BOOL remove_after_crash);
  80. public:
  81. ~LLVFS();
  82. // Use this function normally to create LLVFS files
  83. // Pass 0 to not presize
  84. static LLVFS * createLLVFS(const std::string& index_filename, 
  85. const std::string& data_filename, 
  86. const BOOL read_only, 
  87. const U32 presize, 
  88. const BOOL remove_after_crash);
  89. BOOL isValid() const { return (VFSVALID_OK == mValid); }
  90. EVFSValid getValidState() const { return mValid; }
  91. // ---------- The following fucntions lock/unlock mDataMutex ----------
  92. BOOL getExists(const LLUUID &file_id, const LLAssetType::EType file_type);
  93. S32  getSize(const LLUUID &file_id, const LLAssetType::EType file_type);
  94. BOOL checkAvailable(S32 max_size);
  95. S32  getMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type);
  96. BOOL setMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type, S32 max_size);
  97. void renameFile(const LLUUID &file_id, const LLAssetType::EType file_type,
  98. const LLUUID &new_id, const LLAssetType::EType &new_type);
  99. void removeFile(const LLUUID &file_id, const LLAssetType::EType file_type);
  100. S32 getData(const LLUUID &file_id, const LLAssetType::EType file_type, U8 *buffer, S32 location, S32 length);
  101. S32 storeData(const LLUUID &file_id, const LLAssetType::EType file_type, const U8 *buffer, S32 location, S32 length);
  102. void incLock(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock);
  103. void decLock(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock);
  104. BOOL isLocked(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock);
  105. // ----------------------------------------------------------------
  106. // Used to trigger evil WinXP behavior of "preloading" entire file into memory.
  107. void pokeFiles();
  108. // Verify that the index file contents match the in-memory file structure
  109. // Very slow, do not call routinely. JC
  110. void audit();
  111. // Check for uninitialized blocks.  Slow, do not call in release. JC
  112. void checkMem();
  113. // for debugging, prints a map of the vfs
  114. void dumpMap();
  115. void dumpLockCounts();
  116. void dumpStatistics();
  117. void listFiles();
  118. void dumpFiles();
  119. protected:
  120. void removeFileBlock(LLVFSFileBlock *fileblock);
  121. void eraseBlockLength(LLVFSBlock *block);
  122. void eraseBlock(LLVFSBlock *block);
  123. void addFreeBlock(LLVFSBlock *block);
  124. //void mergeFreeBlocks();
  125. void useFreeSpace(LLVFSBlock *free_block, S32 length);
  126. void sync(LLVFSFileBlock *block, BOOL remove = FALSE);
  127. void presizeDataFile(const U32 size);
  128. static LLFILE *openAndLock(const std::string& filename, const char* mode, BOOL read_lock);
  129. static void unlockAndClose(FILE *fp);
  130. // Can initiate LRU-based file removal to make space.
  131. // The immune file block will not be removed.
  132. LLVFSBlock *findFreeBlock(S32 size, LLVFSFileBlock *immune = NULL);
  133. // lock/unlock data mutex (mDataMutex)
  134. void lockData() { mDataMutex->lock(); }
  135. void unlockData() { mDataMutex->unlock(); }
  136. protected:
  137. LLMutex* mDataMutex;
  138. typedef std::map<LLVFSFileSpecifier, LLVFSFileBlock*> fileblock_map;
  139. fileblock_map mFileBlocks;
  140. typedef std::multimap<S32, LLVFSBlock*> blocks_length_map_t;
  141. blocks_length_map_t  mFreeBlocksByLength;
  142. typedef std::multimap<U32, LLVFSBlock*> blocks_location_map_t;
  143. blocks_location_map_t  mFreeBlocksByLocation;
  144. LLFILE *mDataFP;
  145. LLFILE *mIndexFP;
  146. std::deque<S32> mIndexHoles;
  147. std::string mIndexFilename;
  148. std::string mDataFilename;
  149. BOOL mReadOnly;
  150. EVFSValid mValid;
  151. S32 mLockCounts[VFSLOCK_COUNT];
  152. BOOL mRemoveAfterCrash;
  153. };
  154. extern LLVFS *gVFS;
  155. #endif