include/library/filesystem.hpp

   1 #ifndef _library__filesystem__hpp__included
   2 #define _library__filesystem__hpp__included
   3
   4 #include <cstdint>
   5 #include <map>
   6 #include <string>
   7 #include <fstream>
   8 #include "threads.hpp"
   9
  10 #define CLUSTER_SIZE 8192
  11 #define CLUSTERS_PER_SUPER (CLUSTER_SIZE / 4)
  12 #define SUPERCLUSTER_SIZE (static_cast<uint64_t>(CLUSTER_SIZE) * CLUSTERS_PER_SUPER)
  13 #define FILESYSTEM_SUPERBLOCK 1
  14 #define FILESYSTEM_ROOTDIR 2
  15
  16 /**
  17  * A filesystem.
  18  */
  19 class filesystem
  20 {
  21 public:
  22 /**
  23  * Create a new filesystem or open existing one, backed by specified file.
  24  *
  25  * Parameters backingfile: The backing file name.
  26  */
  27         filesystem(const std::string& backingfile);
  28 /**
  29  * Allocate a new file.
  30  *
  31  * Returns: The initial cluster for the new file.
  32  */
  33         uint32_t allocate_cluster();
  34 /**
  35  * Delete a file.
  36  *
  37  * Parameter cluster: The initial cluster of file to delete.
  38  */
  39         void free_cluster_chain(uint32_t cluster);
  40 /**
  41  * Read and discard specified amount of data.
  42  *
  43  * Parameter cluster: Cluster to start the read from. Updated to be cluster for following data.
  44  * Parameter ptr: The offset in cluster. Updated to be offset for following data.
  45  * Parameter length: The length to read.
  46  * Returns: The actual amount read. Can only be smaller than length if EOF was seen first.
  47  *
  48  * Note: If this runs off the end of file, cluster will be left pointing to last cluster in file and ptr will be
  49  *      left at CLUSTER_SIZE.
  50  */
  51         size_t skip_data(uint32_t& cluster, uint32_t& ptr, uint32_t length);
  52 /**
  53  * Read specified amount of data.
  54  *
  55  * Parameter cluster: Cluster to start the read from. Updated to be cluster for following data.
  56  * Parameter ptr: The offset in cluster. Updated to be offset for following data.
  57  * Parameter data: The buffer to store the read data to.
  58  * Parameter length: The length to read.
  59  * Returns: The actual amount read. Can only be smaller than length if EOF was seen first.
  60  *
  61  * Note: If this runs off the end of file, cluster will be left pointing to last cluster in file and ptr will be
  62  *      left at CLUSTER_SIZE.
  63  */
  64         size_t read_data(uint32_t& cluster, uint32_t& ptr, void* data, uint32_t length);
  65 /**
  66  * Write specified amount of data.
  67  *
  68  * Parameter cluster: Cluster to start the write from. Update to be cluster for following data.
  69  * Parameter ptr: The offset in cluster. Updated to be offset for following data.
  70  * Parameter data: The buffer to read the data to write.
  71  * Parameter length: The length to write.
  72  * Parameter real_cluster: The real cluster the write started from is stored here.
  73  * Parameter real_ptr: The real offset the write started from is stored here.
  74  *
  75  * Note: If the write exactly fills the last cluster, ptr will be left as CLUSTER_SIZE.
  76  */
  77         void write_data(uint32_t& cluster, uint32_t& ptr, const void* data, uint32_t length,
  78                 uint32_t& real_cluster, uint32_t& real_ptr);
  79 /**
  80  * A reference-counted refernece to a filesystem.
  81  */
  82         class ref
  83         {
  84         public:
  85 /**
  86  * Create a reference to NULL filesystem.
  87  */
  88                 ref()
  89                 {
  90                         refcnt = NULL;
  91                         mlock = NULL;
  92                         fs = NULL;
  93                 }
  94 /**
  95  * Create/Open a new filesystem and take reference to that.
  96  *
  97  * Parameters backingfile: The backing file.
  98  */
  99                 ref(const std::string& backingfile)
 100                 {
 101                         refcnt = NULL;
 102                         mlock = NULL;
 103                         try {
 104                                 refcnt = new unsigned;
 105                                 mlock = new threads::lock;
 106                                 fs = new filesystem(backingfile);
 107                         } catch(...) {
 108                                 delete refcnt;
 109                                 delete mlock;
 110                                 throw;
 111                         }
 112                         *refcnt = 1;
 113                 }
 114 /**
 115  * Destructor.
 116  */
 117                 ~ref()
 118                 {
 119                         threads::lock* mtodelete = NULL;
 120                         if(!mlock)
 121                                 return;
 122                         {
 123                                 threads::alock m(*mlock);
 124                                 --*refcnt;
 125                                 if(!*refcnt) {
 126                                         delete fs;
 127                                         delete refcnt;
 128                                         mtodelete = mlock;
 129                                 }
 130                         }
 131                         if(mtodelete)
 132                                 delete mtodelete;
 133                 }
 134 /**
 135  * Copy constructor.
 136  */
 137                 ref(const ref& r)
 138                 {
 139                         threads::alock m(*r.mlock);
 140                         ++*(r.refcnt);
 141                         refcnt = r.refcnt;
 142                         mlock = r.mlock;
 143                         fs = r.fs;
 144                 }
 145 /**
 146  * Assignment operator.
 147  */
 148                 ref& operator=(const ref& r);
 149 /**
 150  * Call allocate_cluster() on underlying filesystem.
 151  *
 152  * Note: See filesystem::allocate_cluster() for description.
 153  */
 154                 uint32_t allocate_cluster()
 155                 {
 156                         threads::alock m(*mlock);
 157                         return fs->allocate_cluster();
 158                 }
 159 /**
 160  * Call free_cluster_chain() on underlying filesystem.
 161  *
 162  * Note: See filesystem::free_cluster_chain() for description.
 163  */
 164                 void free_cluster_chain(uint32_t cluster)
 165                 {
 166                         threads::alock m(*mlock);
 167                         fs->free_cluster_chain(cluster);
 168                 }
 169 /**
 170  * Call skip_data() on underlying filesystem.
 171  *
 172  * Note: See filesystem::skip_data() for description.
 173  */
 174                 size_t skip_data(uint32_t& cluster, uint32_t& ptr, uint32_t length)
 175                 {
 176                         threads::alock m(*mlock);
 177                         return fs->skip_data(cluster, ptr, length);
 178                 }
 179 /**
 180  * Call read_data() on underlying filesystem.
 181  *
 182  * Note: See filesystem::read_data() for description.
 183  */
 184                 size_t read_data(uint32_t& cluster, uint32_t& ptr, void* data, uint32_t length)
 185                 {
 186                         threads::alock m(*mlock);
 187                         return fs->read_data(cluster, ptr, data, length);
 188                 }
 189 /**
 190  * Call write_data() on underlying filesystem.
 191  *
 192  * Note: See filesystem::write_data() for description.
 193  */
 194                 void write_data(uint32_t& cluster, uint32_t& ptr, const void* data, uint32_t length,
 195                         uint32_t& real_cluster, uint32_t& real_ptr)
 196                 {
 197                         threads::alock m(*mlock);
 198                         fs->write_data(cluster, ptr, data, length, real_cluster, real_ptr);
 199                 }
 200         private:
 201                 filesystem* fs;
 202                 unsigned* refcnt;
 203                 threads::lock* mlock;
 204         };
 205 private:
 206         filesystem(const filesystem&);
 207         filesystem& operator=(const filesystem&);
 208         void link_cluster(uint32_t cluster, uint32_t linkto);
 209         struct supercluster
 210         {
 211                 unsigned free_clusters;
 212                 uint32_t clusters[CLUSTERS_PER_SUPER];
 213                 void load(std::fstream& s, uint32_t index);
 214                 void save(std::fstream& s, uint32_t index);
 215         };
 216         uint32_t supercluster_count;
 217         std::map<uint32_t, supercluster> superclusters;
 218         std::fstream backing;
 219 };
 220
 221
 222 #endif