src/plugins/file_system/s4u_FileSystem.cpp

   1 /* Copyright (c) 2015-2020. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "simgrid/plugins/file_system.h"
   7 #include "simgrid/s4u/Actor.hpp"
   8 #include "simgrid/s4u/Engine.hpp"
   9 #include "src/surf/HostImpl.hpp"
  10 #include "src/surf/xml/platf_private.hpp"
  11 #include "xbt/config.hpp"
  12
  13 #include <algorithm>
  14 #include <boost/algorithm/string.hpp>
  15 #include <boost/algorithm/string/join.hpp>
  16 #include <boost/algorithm/string/split.hpp>
  17 #include <fstream>
  18 #include <numeric>
  19
  20 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_file, s4u, "S4U files");
  21 int sg_storage_max_file_descriptors = 1024;
  22
  23 /** @defgroup plugin_filesystem Plugin FileSystem
  24  *
  25  * This adds the notion of Files on top of the storage notion that provided by the core of SimGrid.
  26  * Activate this plugin at will.
  27  */
  28
  29 namespace simgrid {
  30
  31 template class xbt::Extendable<s4u::File>;
  32
  33 namespace s4u {
  34 simgrid::xbt::Extension<Disk, FileSystemDiskExt> FileSystemDiskExt::EXTENSION_ID;
  35 simgrid::xbt::Extension<Storage, FileSystemStorageExt> FileSystemStorageExt::EXTENSION_ID;
  36 simgrid::xbt::Extension<Host, FileDescriptorHostExt> FileDescriptorHostExt::EXTENSION_ID;
  37
  38 Storage* File::find_local_storage_on(Host* host)
  39 {
  40   Storage* st                  = nullptr;
  41   size_t longest_prefix_length = 0;
  42   XBT_DEBUG("Search for storage name for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
  43
  44   for (auto const& mnt : host->get_mounted_storages()) {
  45     XBT_DEBUG("See '%s'", mnt.first.c_str());
  46     mount_point_ = fullpath_.substr(0, mnt.first.length());
  47
  48     if (mount_point_ == mnt.first && mnt.first.length() > longest_prefix_length) {
  49       /* The current mount name is found in the full path and is bigger than the previous*/
  50       longest_prefix_length = mnt.first.length();
  51       st                    = mnt.second;
  52     }
  53   }
  54   if (longest_prefix_length > 0) { /* Mount point found, split fullpath_ into mount_name and path+filename*/
  55     mount_point_ = fullpath_.substr(0, longest_prefix_length);
  56     path_        = fullpath_.substr(longest_prefix_length, fullpath_.length());
  57   } else
  58     xbt_die("Can't find mount point for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
  59
  60   return st;
  61 }
  62
  63 Disk* File::find_local_disk_on(const Host* host)
  64 {
  65   Disk* d                      = nullptr;
  66   size_t longest_prefix_length = 0;
  67   for (auto const& disk : host->get_disks()) {
  68     std::string current_mount;
  69     if (disk->get_host() != host)
  70       current_mount = disk->extension<FileSystemDiskExt>()->get_mount_point(disk->get_host());
  71     else
  72       current_mount = disk->extension<FileSystemDiskExt>()->get_mount_point();
  73     mount_point_ = fullpath_.substr(0, current_mount.length());
  74     if (mount_point_ == current_mount && current_mount.length() > longest_prefix_length) {
  75       /* The current mount name is found in the full path and is bigger than the previous*/
  76       longest_prefix_length = current_mount.length();
  77       d                     = disk;
  78     }
  79     if (longest_prefix_length > 0) { /* Mount point found, split fullpath_ into mount_name and path+filename*/
  80       mount_point_ = fullpath_.substr(0, longest_prefix_length);
  81       if (mount_point_ == std::string("/"))
  82         path_ = fullpath_;
  83       else
  84         path_ = fullpath_.substr(longest_prefix_length, fullpath_.length());
  85       XBT_DEBUG("%s + %s", mount_point_.c_str(), path_.c_str());
  86     } else
  87       xbt_die("Can't find mount point for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
  88   }
  89   return d;
  90 }
  91
  92 File::File(const std::string& fullpath, void* userdata) : File(fullpath, Host::current(), userdata) {}
  93
  94 File::File(const std::string& fullpath, sg_host_t host, void* userdata) : fullpath_(fullpath)
  95 {
  96   this->set_data(userdata);
  97   // this cannot fail because we get a xbt_die if the mountpoint does not exist
  98   if (not host->get_mounted_storages().empty()) {
  99     local_storage_ = find_local_storage_on(host);
 100   }
 101   if (not host->get_disks().empty()) {
 102     local_disk_ = find_local_disk_on(host);
 103   }
 104
 105   // assign a file descriptor id to the newly opened File
 106   FileDescriptorHostExt* ext = host->extension<simgrid::s4u::FileDescriptorHostExt>();
 107   if (ext->file_descriptor_table == nullptr) {
 108     ext->file_descriptor_table.reset(new std::vector<int>(sg_storage_max_file_descriptors));
 109     std::iota(ext->file_descriptor_table->rbegin(), ext->file_descriptor_table->rend(), 0); // Fill with ..., 1, 0.
 110   }
 111   xbt_assert(not ext->file_descriptor_table->empty(), "Too much files are opened! Some have to be closed.");
 112   desc_id = ext->file_descriptor_table->back();
 113   ext->file_descriptor_table->pop_back();
 114
 115   XBT_DEBUG("\tOpen file '%s'", path_.c_str());
 116   std::map<std::string, sg_size_t>* content = nullptr;
 117   if (local_storage_)
 118     content = local_storage_->extension<FileSystemStorageExt>()->get_content();
 119
 120   if (local_disk_)
 121     content = local_disk_->extension<FileSystemDiskExt>()->get_content();
 122
 123   // if file does not exist create an empty file
 124   if (content) {
 125     auto sz = content->find(path_);
 126     if (sz != content->end()) {
 127       size_ = sz->second;
 128     } else {
 129       size_ = 0;
 130       content->insert({path_, size_});
 131       XBT_DEBUG("File '%s' was not found, file created.", path_.c_str());
 132     }
 133   }
 134 }
 135
 136 File::~File()
 137 {
 138   Host::current()->extension<simgrid::s4u::FileDescriptorHostExt>()->file_descriptor_table->push_back(desc_id);
 139 }
 140
 141 void File::dump()
 142 {
 143   if (local_storage_)
 144     XBT_INFO("File Descriptor information:\n"
 145              "\t\tFull path: '%s'\n"
 146              "\t\tSize: %llu\n"
 147              "\t\tMount point: '%s'\n"
 148              "\t\tStorage Id: '%s'\n"
 149              "\t\tStorage Type: '%s'\n"
 150              "\t\tFile Descriptor Id: %d",
 151              get_path(), size_, mount_point_.c_str(), local_storage_->get_cname(), local_storage_->get_type(), desc_id);
 152   if (local_disk_)
 153     XBT_INFO("File Descriptor information:\n"
 154              "\t\tFull path: '%s'\n"
 155              "\t\tSize: %llu\n"
 156              "\t\tMount point: '%s'\n"
 157              "\t\tDisk Id: '%s'\n"
 158              "\t\tHost Id: '%s'\n"
 159              "\t\tFile Descriptor Id: %d",
 160              get_path(), size_, mount_point_.c_str(), local_disk_->get_cname(), local_disk_->get_host()->get_cname(),
 161              desc_id);
 162 }
 163
 164 sg_size_t File::read(sg_size_t size)
 165 {
 166   if (size_ == 0) /* Nothing to read, return */
 167     return 0;
 168   sg_size_t read_size = 0;
 169   Host* host          = nullptr;
 170   if (local_storage_) {
 171     /* Find the host where the file is physically located and read it */
 172     host = local_storage_->get_host();
 173     XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
 174     // if the current position is close to the end of the file, we may not be able to read the requested size
 175     read_size = local_storage_->read(std::min(size, size_ - current_position_));
 176     current_position_ += read_size;
 177   }
 178
 179   if (local_disk_) {
 180     /* Find the host where the file is physically located and read it */
 181     host = local_disk_->get_host();
 182     XBT_DEBUG("READ %s on disk '%s'", get_path(), local_disk_->get_cname());
 183     // if the current position is close to the end of the file, we may not be able to read the requested size
 184     read_size = local_disk_->read(std::min(size, size_ - current_position_));
 185     current_position_ += read_size;
 186   }
 187
 188   if (host && host->get_name() != Host::current()->get_name() && read_size > 0) {
 189     /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
 190     XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), read_size);
 191     host->sendto(Host::current(), read_size);
 192   }
 193
 194   return read_size;
 195 }
 196
 197 /** @brief Write into a file (local or remote)
 198  * @ingroup plugin_filesystem
 199  *
 200  * @param size of the file to write
 201  * @return the number of bytes successfully write or -1 if an error occurred
 202  */
 203 sg_size_t File::write_on_disk(sg_size_t size, bool write_inside)
 204 {
 205   sg_size_t write_size = 0;
 206   /* Find the host where the file is physically located (remote or local)*/
 207   Host* host = local_disk_->get_host();
 208
 209   if (host && host->get_name() != Host::current()->get_name()) {
 210     /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
 211     XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), size);
 212     Host::current()->sendto(host, size);
 213   }
 214   XBT_DEBUG("WRITE %s on disk '%s'. size '%llu/%llu' '%llu:%llu'", get_path(), local_disk_->get_cname(), size, size_,
 215             sg_disk_get_size_used(local_disk_), sg_disk_get_size(local_disk_));
 216   // If the storage is full before even starting to write
 217   if (sg_disk_get_size_used(local_disk_) >= sg_disk_get_size(local_disk_))
 218     return 0;
 219   if (not write_inside) {
 220     /* Subtract the part of the file that might disappear from the used sized on the storage element */
 221     local_disk_->extension<FileSystemDiskExt>()->decr_used_size(size_ - current_position_);
 222     write_size = local_disk_->write(size);
 223     local_disk_->extension<FileSystemDiskExt>()->incr_used_size(write_size);
 224     current_position_ += write_size;
 225     size_ = current_position_;
 226   } else {
 227     write_size = local_disk_->write(size);
 228     current_position_ += write_size;
 229     if (current_position_ > size_)
 230       size_ = current_position_;
 231   }
 232   std::map<std::string, sg_size_t>* content = local_disk_->extension<FileSystemDiskExt>()->get_content();
 233
 234   content->erase(path_);
 235   content->insert({path_, size_});
 236
 237   return write_size;
 238 }
 239
 240 sg_size_t File::write_on_storage(sg_size_t size, bool write_inside)
 241 {
 242   sg_size_t write_size = 0;
 243   /* Find the host where the file is physically located (remote or local)*/
 244   Host* host = local_storage_->get_host();
 245
 246   if (host && host->get_name() != Host::current()->get_name()) {
 247     /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
 248     XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), size);
 249     Host::current()->sendto(host, size);
 250   }
 251
 252   XBT_DEBUG("WRITE %s on disk '%s'. size '%llu/%llu' '%llu:%llu'", get_path(), local_storage_->get_cname(), size, size_,
 253             sg_storage_get_size_used(local_storage_), sg_storage_get_size(local_storage_));
 254   // If the storage is full before even starting to write
 255   if (sg_storage_get_size_used(local_storage_) >= sg_storage_get_size(local_storage_))
 256     return 0;
 257   if (not write_inside) {
 258     /* Subtract the part of the file that might disappear from the used sized on the storage element */
 259     local_storage_->extension<FileSystemStorageExt>()->decr_used_size(size_ - current_position_);
 260     write_size = local_storage_->write(size);
 261     local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
 262     current_position_ += write_size;
 263     size_ = current_position_;
 264   } else {
 265     write_size = local_storage_->write(size);
 266     current_position_ += write_size;
 267     if (current_position_ > size_)
 268       size_ = current_position_;
 269   }
 270   std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
 271
 272   content->erase(path_);
 273   content->insert({path_, size_});
 274
 275   return write_size;
 276 }
 277
 278 sg_size_t File::write(sg_size_t size, bool write_inside)
 279 {
 280   if (size == 0) /* Nothing to write, return */
 281     return 0;
 282
 283   if (local_disk_)
 284     return write_on_disk(size, write_inside);
 285   if (local_storage_)
 286     return write_on_storage(size, write_inside);
 287
 288   return 0;
 289 }
 290
 291 sg_size_t File::size()
 292 {
 293   return size_;
 294 }
 295
 296 void File::seek(sg_offset_t offset)
 297 {
 298   current_position_ = offset;
 299 }
 300
 301 void File::seek(sg_offset_t offset, int origin)
 302 {
 303   switch (origin) {
 304     case SEEK_SET:
 305       current_position_ = offset;
 306       break;
 307     case SEEK_CUR:
 308       current_position_ += offset;
 309       break;
 310     case SEEK_END:
 311       current_position_ = size_ + offset;
 312       break;
 313     default:
 314       break;
 315   }
 316 }
 317
 318 sg_size_t File::tell()
 319 {
 320   return current_position_;
 321 }
 322
 323 void File::move(const std::string& fullpath)
 324 {
 325   /* Check if the new full path is on the same mount point */
 326   if (fullpath.compare(0, mount_point_.length(), mount_point_) == 0) {
 327     std::map<std::string, sg_size_t>* content = nullptr;
 328     if (local_storage_)
 329       content = local_storage_->extension<FileSystemStorageExt>()->get_content();
 330     if (local_disk_)
 331       content = local_disk_->extension<FileSystemDiskExt>()->get_content();
 332     if (content) {
 333       auto sz = content->find(path_);
 334       if (sz != content->end()) { // src file exists
 335         sg_size_t new_size = sz->second;
 336         content->erase(path_);
 337         std::string path = fullpath.substr(mount_point_.length(), fullpath.length());
 338         content->insert({path.c_str(), new_size});
 339         XBT_DEBUG("Move file from %s to %s, size '%llu'", path_.c_str(), fullpath.c_str(), new_size);
 340       } else {
 341         XBT_WARN("File %s doesn't exist", path_.c_str());
 342       }
 343     }
 344   } else {
 345     XBT_WARN("New full path %s is not on the same mount point: %s.", fullpath.c_str(), mount_point_.c_str());
 346   }
 347 }
 348
 349 int File::unlink()
 350 {
 351   /* Check if the file is on local storage */
 352   std::map<std::string, sg_size_t>* content = nullptr;
 353   const char* name = "";
 354   if (local_storage_) {
 355     content = local_storage_->extension<FileSystemStorageExt>()->get_content();
 356     name    = local_storage_->get_cname();
 357   }
 358   if (local_disk_) {
 359     content = local_disk_->extension<FileSystemDiskExt>()->get_content();
 360     name    = local_disk_->get_cname();
 361   }
 362
 363   if (not content || content->find(path_) == content->end()) {
 364     XBT_WARN("File %s is not on disk %s. Impossible to unlink", path_.c_str(), name);
 365     return -1;
 366   } else {
 367     XBT_DEBUG("UNLINK %s on disk '%s'", path_.c_str(), name);
 368
 369     if (local_storage_)
 370       local_storage_->extension<FileSystemStorageExt>()->decr_used_size(size_);
 371
 372     if (local_disk_)
 373       local_disk_->extension<FileSystemDiskExt>()->decr_used_size(size_);
 374
 375     // Remove the file from storage
 376     content->erase(path_);
 377
 378     return 0;
 379   }
 380 }
 381
 382 int File::remote_copy(sg_host_t host, const char* fullpath)
 383 {
 384   /* Find the host where the file is physically located and read it */
 385   Host* src_host = nullptr;
 386   if (local_storage_) {
 387     src_host = local_storage_->get_host();
 388     XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
 389   }
 390
 391   if (local_disk_) {
 392     src_host = local_disk_->get_host();
 393     XBT_DEBUG("READ %s on disk '%s'", get_path(), local_disk_->get_cname());
 394   }
 395
 396   seek(0, SEEK_SET);
 397   // if the current position is close to the end of the file, we may not be able to read the requested size
 398   sg_size_t read_size = 0;
 399   if (local_storage_)
 400     read_size = local_storage_->read(size_);
 401   if (local_disk_)
 402     read_size = local_disk_->read(size_);
 403
 404   current_position_ += read_size;
 405
 406   Host* dst_host = host;
 407   size_t longest_prefix_length = 0;
 408   if (local_storage_) {
 409     /* Find the host that owns the storage where the file has to be copied */
 410     const Storage* storage_dest = nullptr;
 411
 412     for (auto const& elm : host->get_mounted_storages()) {
 413       std::string mount_point = std::string(fullpath).substr(0, elm.first.size());
 414       if (mount_point == elm.first && elm.first.length() > longest_prefix_length) {
 415         /* The current mount name is found in the full path and is bigger than the previous*/
 416         longest_prefix_length = elm.first.length();
 417         storage_dest          = elm.second;
 418       }
 419     }
 420
 421     if (storage_dest != nullptr) {
 422       /* Mount point found, retrieve the host the storage is attached to */
 423       dst_host = storage_dest->get_host();
 424     } else {
 425       XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host->get_cname());
 426       return -1;
 427     }
 428   }
 429
 430   if (local_disk_) {
 431     const Disk* dst_disk = nullptr;
 432
 433     for (auto const& disk : host->get_disks()) {
 434       std::string current_mount = disk->extension<FileSystemDiskExt>()->get_mount_point();
 435       std::string mount_point   = std::string(fullpath).substr(0, current_mount.length());
 436       if (mount_point == current_mount && current_mount.length() > longest_prefix_length) {
 437         /* The current mount name is found in the full path and is bigger than the previous*/
 438         longest_prefix_length = current_mount.length();
 439         dst_disk              = disk;
 440       }
 441     }
 442
 443     if (dst_disk == nullptr) {
 444       XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host->get_cname());
 445       return -1;
 446     }
 447   }
 448
 449   if (src_host) {
 450     XBT_DEBUG("Initiate data transfer of %llu bytes between %s and %s.", read_size, src_host->get_cname(),
 451               dst_host->get_cname());
 452     src_host->sendto(dst_host, read_size);
 453   }
 454
 455   /* Create file on remote host, write it and close it */
 456   File* fd = new File(fullpath, dst_host, nullptr);
 457   if (local_storage_) {
 458     sg_size_t write_size = fd->local_storage_->write(read_size);
 459     fd->local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
 460     (*(fd->local_storage_->extension<FileSystemStorageExt>()->get_content()))[path_] = size_;
 461   }
 462   if (local_disk_)
 463     fd->write(read_size);
 464   delete fd;
 465   return 0;
 466 }
 467
 468 int File::remote_move(sg_host_t host, const char* fullpath)
 469 {
 470   int res = remote_copy(host, fullpath);
 471   unlink();
 472   return res;
 473 }
 474
 475 FileSystemDiskExt::FileSystemDiskExt(const Disk* ptr)
 476 {
 477   const char* size_str    = ptr->get_property("size");
 478   if (size_str)
 479     size_ = surf_parse_get_size(size_str, "disk size", ptr->get_name());
 480
 481   const char* current_mount_str = ptr->get_property("mount");
 482   if (current_mount_str)
 483     mount_point_ = std::string(current_mount_str);
 484   else
 485     mount_point_ = std::string("/");
 486
 487   const char* content_str = ptr->get_property("content");
 488   if (content_str)
 489     content_.reset(parse_content(content_str));
 490 }
 491
 492 FileSystemStorageExt::FileSystemStorageExt(const Storage* ptr) : size_(ptr->get_impl()->size_)
 493 {
 494   content_.reset(parse_content(ptr->get_impl()->content_name_));
 495 }
 496
 497 std::map<std::string, sg_size_t>* FileSystemDiskExt::parse_content(const std::string& filename)
 498 {
 499   if (filename.empty())
 500     return nullptr;
 501
 502   std::map<std::string, sg_size_t>* parse_content = new std::map<std::string, sg_size_t>();
 503
 504   std::ifstream* fs = surf_ifsopen(filename);
 505   xbt_assert(not fs->fail(), "Cannot open file '%s' (path=%s)", filename.c_str(),
 506              (boost::join(surf_path, ":")).c_str());
 507
 508   std::string line;
 509   std::vector<std::string> tokens;
 510   do {
 511     std::getline(*fs, line);
 512     boost::trim(line);
 513     if (line.length() > 0) {
 514       boost::split(tokens, line, boost::is_any_of(" \t"), boost::token_compress_on);
 515       xbt_assert(tokens.size() == 2, "Parse error in %s: %s", filename.c_str(), line.c_str());
 516       sg_size_t size = std::stoull(tokens.at(1));
 517
 518       used_size_ += size;
 519       parse_content->insert({tokens.front(), size});
 520     }
 521   } while (not fs->eof());
 522   delete fs;
 523   return parse_content;
 524 }
 525
 526 std::map<std::string, sg_size_t>* FileSystemStorageExt::parse_content(const std::string& filename)
 527 {
 528   if (filename.empty())
 529     return nullptr;
 530
 531   std::map<std::string, sg_size_t>* parse_content = new std::map<std::string, sg_size_t>();
 532
 533   std::ifstream* fs = surf_ifsopen(filename);
 534   xbt_assert(not fs->fail(), "Cannot open file '%s' (path=%s)", filename.c_str(),
 535              (boost::join(surf_path, ":")).c_str());
 536
 537   std::string line;
 538   std::vector<std::string> tokens;
 539   do {
 540     std::getline(*fs, line);
 541     boost::trim(line);
 542     if (line.length() > 0) {
 543       boost::split(tokens, line, boost::is_any_of(" \t"), boost::token_compress_on);
 544       xbt_assert(tokens.size() == 2, "Parse error in %s: %s", filename.c_str(), line.c_str());
 545       sg_size_t size = std::stoull(tokens.at(1));
 546
 547       used_size_ += size;
 548       parse_content->insert({tokens.front(), size});
 549     }
 550   } while (not fs->eof());
 551   delete fs;
 552   return parse_content;
 553 }
 554
 555 void FileSystemStorageExt::decr_used_size(sg_size_t size)
 556 {
 557   simgrid::kernel::actor::simcall([this, size] { used_size_ -= size; });
 558 }
 559
 560 void FileSystemStorageExt::incr_used_size(sg_size_t size)
 561 {
 562   simgrid::kernel::actor::simcall([this, size] { used_size_ += size; });
 563 }
 564
 565 void FileSystemDiskExt::decr_used_size(sg_size_t size)
 566 {
 567   simgrid::kernel::actor::simcall([this, size] { used_size_ -= size; });
 568 }
 569
 570 void FileSystemDiskExt::incr_used_size(sg_size_t size)
 571 {
 572   simgrid::kernel::actor::simcall([this, size] { used_size_ += size; });
 573 }
 574 }
 575 }
 576
 577 using simgrid::s4u::FileDescriptorHostExt;
 578 using simgrid::s4u::FileSystemDiskExt;
 579 using simgrid::s4u::FileSystemStorageExt;
 580
 581 static void on_disk_creation(simgrid::s4u::Disk& d)
 582 {
 583   d.extension_set(new FileSystemDiskExt(&d));
 584 }
 585 static void on_storage_creation(simgrid::s4u::Storage& st)
 586 {
 587   st.extension_set(new FileSystemStorageExt(&st));
 588 }
 589
 590 static void on_host_creation(simgrid::s4u::Host& host)
 591 {
 592   host.extension_set<FileDescriptorHostExt>(new FileDescriptorHostExt());
 593 }
 594
 595 static void on_platform_created()
 596 {
 597   for (auto const& host : simgrid::s4u::Engine::get_instance()->get_all_hosts()) {
 598     const char* remote_disk_str = host->get_property("remote_disk");
 599     if (remote_disk_str) {
 600       std::vector<std::string> tokens;
 601       boost::split(tokens, remote_disk_str, boost::is_any_of(":"));
 602       std::string mount_point         = tokens[0];
 603       simgrid::s4u::Host* remote_host = simgrid::s4u::Host::by_name_or_null(tokens[2]);
 604       xbt_assert(remote_host, "You're trying to access a host that does not exist. Please check your platform file");
 605
 606       simgrid::s4u::Disk* disk = nullptr;
 607       for (auto const& d : remote_host->get_disks())
 608         if (d->get_name() == tokens[1]) {
 609           disk = d;
 610           break;
 611         }
 612
 613       xbt_assert(disk, "You're trying to mount a disk that does not exist. Please check your platform file");
 614       disk->extension<FileSystemDiskExt>()->add_remote_mount(remote_host, mount_point);
 615       host->add_disk(disk);
 616
 617       XBT_DEBUG("Host '%s' wants to mount a remote disk: %s of %s mounted on %s", host->get_cname(), disk->get_cname(),
 618                 remote_host->get_cname(), mount_point.c_str());
 619       XBT_DEBUG("Host '%s' now has %zu disks", host->get_cname(), host->get_disks().size());
 620     }
 621   }
 622 }
 623
 624 static void on_simulation_end()
 625 {
 626   XBT_DEBUG("Simulation is over, time to unregister remote disks if any");
 627   for (auto const& host : simgrid::s4u::Engine::get_instance()->get_all_hosts()) {
 628     const char* remote_disk_str = host->get_property("remote_disk");
 629     if (remote_disk_str) {
 630       std::vector<std::string> tokens;
 631       boost::split(tokens, remote_disk_str, boost::is_any_of(":"));
 632       XBT_DEBUG("Host '%s' wants to unmount a remote disk: %s of %s mounted on %s", host->get_cname(),
 633                 tokens[1].c_str(), tokens[2].c_str(), tokens[0].c_str());
 634       host->remove_disk(tokens[1]);
 635       XBT_DEBUG("Host '%s' now has %zu disks", host->get_cname(), host->get_disks().size());
 636     }
 637   }
 638 }
 639
 640 /* **************************** Public interface *************************** */
 641 /** @brief Initialize the file system plugin.
 642     @ingroup plugin_filesystem
 643
 644     @beginrst
 645     See the examples in :ref:`s4u_ex_disk_io`.
 646     @endrst
 647  */
 648 void sg_storage_file_system_init()
 649 {
 650   sg_storage_max_file_descriptors = 1024;
 651   simgrid::config::bind_flag(sg_storage_max_file_descriptors, "storage/max_file_descriptors",
 652                              "Maximum number of concurrently opened files per host. Default is 1024");
 653
 654   if (not FileSystemStorageExt::EXTENSION_ID.valid()) {
 655     FileSystemStorageExt::EXTENSION_ID = simgrid::s4u::Storage::extension_create<FileSystemStorageExt>();
 656     simgrid::s4u::Storage::on_creation.connect(&on_storage_creation);
 657   }
 658
 659   if (not FileSystemDiskExt::EXTENSION_ID.valid()) {
 660     FileSystemDiskExt::EXTENSION_ID = simgrid::s4u::Disk::extension_create<FileSystemDiskExt>();
 661     simgrid::s4u::Disk::on_creation.connect(&on_disk_creation);
 662   }
 663
 664   if (not FileDescriptorHostExt::EXTENSION_ID.valid()) {
 665     FileDescriptorHostExt::EXTENSION_ID = simgrid::s4u::Host::extension_create<FileDescriptorHostExt>();
 666     simgrid::s4u::Host::on_creation.connect(&on_host_creation);
 667   }
 668   simgrid::s4u::Engine::on_platform_created.connect(&on_platform_created);
 669   simgrid::s4u::Engine::on_simulation_end.connect(&on_simulation_end);
 670 }
 671
 672 sg_file_t sg_file_open(const char* fullpath, void* data)
 673 {
 674   return new simgrid::s4u::File(fullpath, data);
 675 }
 676
 677 sg_size_t sg_file_read(sg_file_t fd, sg_size_t size)
 678 {
 679   return fd->read(size);
 680 }
 681
 682 sg_size_t sg_file_write(sg_file_t fd, sg_size_t size)
 683 {
 684   return fd->write(size);
 685 }
 686
 687 void sg_file_close(const_sg_file_t fd)
 688 {
 689   delete fd;
 690 }
 691
 692 /** Retrieves the path to the file
 693  * @ingroup plugin_filesystem
 694  */
 695 const char* sg_file_get_name(sg_file_t fd)
 696 {
 697   xbt_assert((fd != nullptr), "Invalid file descriptor");
 698   return fd->get_path();
 699 }
 700
 701 /** Retrieves the size of the file
 702  * @ingroup plugin_filesystem
 703  */
 704 sg_size_t sg_file_get_size(sg_file_t fd)
 705 {
 706   return fd->size();
 707 }
 708
 709 void sg_file_dump(sg_file_t fd)
 710 {
 711   fd->dump();
 712 }
 713
 714 /** Retrieves the user data associated with the file
 715  * @ingroup plugin_filesystem
 716  */
 717 void* sg_file_get_data(const_sg_file_t fd)
 718 {
 719   return fd->get_data();
 720 }
 721
 722 /** Changes the user data associated with the file
 723  * @ingroup plugin_filesystem
 724  */
 725 void sg_file_set_data(sg_file_t fd, void* data)
 726 {
 727   fd->set_data(data);
 728 }
 729
 730 /**
 731  * @brief Set the file position indicator in the sg_file_t by adding offset bytes to the position specified by origin (either SEEK_SET, SEEK_CUR, or SEEK_END).
 732  * @ingroup plugin_filesystem
 733  *
 734  * @param fd : file object that identifies the stream
 735  * @param offset : number of bytes to offset from origin
 736  * @param origin : Position used as reference for the offset. It is specified by one of the following constants defined
 737  *                 in \<stdio.h\> exclusively to be used as arguments for this function (SEEK_SET = beginning of file,
 738  *                 SEEK_CUR = current position of the file pointer, SEEK_END = end of file)
 739  */
 740 void sg_file_seek(sg_file_t fd, sg_offset_t offset, int origin)
 741 {
 742   fd->seek(offset, origin);
 743 }
 744
 745 sg_size_t sg_file_tell(sg_file_t fd)
 746 {
 747   return fd->tell();
 748 }
 749
 750 void sg_file_move(sg_file_t fd, const char* fullpath)
 751 {
 752   fd->move(fullpath);
 753 }
 754
 755 void sg_file_unlink(sg_file_t fd)
 756 {
 757   fd->unlink();
 758   delete fd;
 759 }
 760
 761 /**
 762  * @brief Copy a file to another location on a remote host.
 763  * @ingroup plugin_filesystem
 764  *
 765  * @param file : the file to move
 766  * @param host : the remote host where the file has to be copied
 767  * @param fullpath : the complete path destination on the remote host
 768  * @return If successful, the function returns 0. Otherwise, it returns -1.
 769  */
 770 int sg_file_rcopy(sg_file_t file, sg_host_t host, const char* fullpath)
 771 {
 772   return file->remote_copy(host, fullpath);
 773 }
 774
 775 /**
 776  * @brief Move a file to another location on a remote host.
 777  * @ingroup plugin_filesystem
 778  *
 779  * @param file : the file to move
 780  * @param host : the remote host where the file has to be moved
 781  * @param fullpath : the complete path destination on the remote host
 782  * @return If successful, the function returns 0. Otherwise, it returns -1.
 783  */
 784 int sg_file_rmove(sg_file_t file, sg_host_t host, const char* fullpath)
 785 {
 786   return file->remote_move(host, fullpath);
 787 }
 788
 789 sg_size_t sg_disk_get_size_free(const_sg_disk_t d)
 790 {
 791   return d->extension<FileSystemDiskExt>()->get_size() - d->extension<FileSystemDiskExt>()->get_used_size();
 792 }
 793
 794 sg_size_t sg_disk_get_size_used(const_sg_disk_t d)
 795 {
 796   return d->extension<FileSystemDiskExt>()->get_used_size();
 797 }
 798
 799 sg_size_t sg_disk_get_size(const_sg_disk_t d)
 800 {
 801   return d->extension<FileSystemDiskExt>()->get_size();
 802 }
 803
 804 const char* sg_disk_get_mount_point(const_sg_disk_t d)
 805 {
 806   return d->extension<FileSystemDiskExt>()->get_mount_point();
 807 }
 808
 809 sg_size_t sg_storage_get_size_free(const_sg_storage_t st)
 810 {
 811   return st->extension<FileSystemStorageExt>()->get_size() - st->extension<FileSystemStorageExt>()->get_used_size();
 812 }
 813
 814 sg_size_t sg_storage_get_size_used(const_sg_storage_t st)
 815 {
 816   return st->extension<FileSystemStorageExt>()->get_used_size();
 817 }
 818
 819 sg_size_t sg_storage_get_size(const_sg_storage_t st)
 820 {
 821   return st->extension<FileSystemStorageExt>()->get_size();
 822 }
 823
 824 xbt_dict_t sg_storage_get_content(const_sg_storage_t storage)
 825 {
 826   const std::map<std::string, sg_size_t>* content =
 827       storage->extension<simgrid::s4u::FileSystemStorageExt>()->get_content();
 828   // Note: ::operator delete is ok here (no destructor called) since the dict elements are of POD type sg_size_t.
 829   xbt_dict_t content_as_dict = xbt_dict_new_homogeneous(::operator delete);
 830
 831   for (auto const& entry : *content) {
 832     sg_size_t* psize = new sg_size_t;
 833     *psize           = entry.second;
 834     xbt_dict_set(content_as_dict, entry.first.c_str(), psize);
 835   }
 836   return content_as_dict;
 837 }
 838
 839 xbt_dict_t sg_host_get_storage_content(sg_host_t host)
 840 {
 841   xbt_assert((host != nullptr), "Invalid parameters");
 842   xbt_dict_t contents = xbt_dict_new_homogeneous(nullptr);
 843   for (auto const& elm : host->get_mounted_storages())
 844     xbt_dict_set(contents, elm.first.c_str(), sg_storage_get_content(elm.second));
 845
 846   return contents;
 847 }