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