src/plugins/file_system/s4u_FileSystem.cpp

   1 /* Copyright (c) 2015-2019. 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 "src/surf/HostImpl.hpp"
   9 #include "src/surf/xml/platf_private.hpp"
  10 #include "xbt/config.hpp"
  11
  12 #include <algorithm>
  13 #include <boost/algorithm/string.hpp>
  14 #include <boost/algorithm/string/join.hpp>
  15 #include <boost/algorithm/string/split.hpp>
  16 #include <fstream>
  17 #include <numeric>
  18
  19 XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_file, "S4U files");
  20 int sg_storage_max_file_descriptors = 1024;
  21
  22 namespace simgrid {
  23 namespace s4u {
  24 simgrid::xbt::Extension<Disk, FileSystemDiskExt> FileSystemDiskExt::EXTENSION_ID;
  25 simgrid::xbt::Extension<Storage, FileSystemStorageExt> FileSystemStorageExt::EXTENSION_ID;
  26 simgrid::xbt::Extension<Host, FileDescriptorHostExt> FileDescriptorHostExt::EXTENSION_ID;
  27
  28 File::File(const std::string& fullpath, void* userdata) : File(fullpath, Host::current(), userdata){};
  29
  30 File::File(const std::string& fullpath, sg_host_t host, void* userdata) : fullpath_(fullpath), userdata_(userdata)
  31 {
  32   // this cannot fail because we get a xbt_die if the mountpoint does not exist
  33   if (not host->get_mounted_storages().empty()) {
  34     Storage* st                  = nullptr;
  35     size_t longest_prefix_length = 0;
  36     XBT_DEBUG("Search for storage name for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
  37
  38     for (auto const& mnt : host->get_mounted_storages()) {
  39       XBT_DEBUG("See '%s'", mnt.first.c_str());
  40       mount_point_ = fullpath_.substr(0, mnt.first.length());
  41
  42       if (mount_point_ == mnt.first && mnt.first.length() > longest_prefix_length) {
  43         /* The current mount name is found in the full path and is bigger than the previous*/
  44         longest_prefix_length = mnt.first.length();
  45         st                    = mnt.second;
  46       }
  47     }
  48     if (longest_prefix_length > 0) { /* Mount point found, split fullpath_ into mount_name and path+filename*/
  49       mount_point_ = fullpath_.substr(0, longest_prefix_length);
  50       path_        = fullpath_.substr(longest_prefix_length, fullpath_.length());
  51     } else
  52       xbt_die("Can't find mount point for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
  53
  54     local_storage_ = st;
  55   }
  56   if (not host->get_disks().empty()) {
  57     Disk* d                      = nullptr;
  58     size_t longest_prefix_length = 0;
  59     for (auto const& disk : host->get_disks()) {
  60       const char* current_mount_str = disk->get_property("mount");
  61       if (current_mount_str) {
  62         std::string current_mount = std::string(current_mount_str);
  63         mount_point_              = fullpath_.substr(0, current_mount.length());
  64         if (mount_point_ == current_mount && current_mount.length() > longest_prefix_length) {
  65           /* The current mount name is found in the full path and is bigger than the previous*/
  66           longest_prefix_length = current_mount.length();
  67           d                     = disk;
  68         }
  69         if (longest_prefix_length > 0) { /* Mount point found, split fullpath_ into mount_name and path+filename*/
  70           mount_point_ = fullpath_.substr(0, longest_prefix_length);
  71           path_        = fullpath_.substr(longest_prefix_length, fullpath_.length());
  72         } else
  73           xbt_die("Can't find mount point for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
  74       }
  75     }
  76     local_disk_ = d;
  77   }
  78
  79   // assign a file descriptor id to the newly opened File
  80   FileDescriptorHostExt* ext = host->extension<simgrid::s4u::FileDescriptorHostExt>();
  81   if (ext->file_descriptor_table == nullptr) {
  82     ext->file_descriptor_table.reset(new std::vector<int>(sg_storage_max_file_descriptors));
  83     std::iota(ext->file_descriptor_table->rbegin(), ext->file_descriptor_table->rend(), 0); // Fill with ..., 1, 0.
  84   }
  85   xbt_assert(not ext->file_descriptor_table->empty(), "Too much files are opened! Some have to be closed.");
  86   desc_id = ext->file_descriptor_table->back();
  87   ext->file_descriptor_table->pop_back();
  88
  89   XBT_DEBUG("\tOpen file '%s'", path_.c_str());
  90   std::map<std::string, sg_size_t>* content;
  91   if (local_storage_)
  92     content = local_storage_->extension<FileSystemStorageExt>()->get_content();
  93
  94   if (local_disk_)
  95     content = local_disk_->extension<FileSystemDiskExt>()->get_content();
  96
  97   // if file does not exist create an empty file
  98   auto sz = content->find(path_);
  99   if (sz != content->end()) {
 100     size_ = sz->second;
 101   } else {
 102     size_ = 0;
 103     content->insert({path_, size_});
 104     XBT_DEBUG("File '%s' was not found, file created.", path_.c_str());
 105   }
 106 }
 107
 108 File::~File()
 109 {
 110   Host::current()->extension<simgrid::s4u::FileDescriptorHostExt>()->file_descriptor_table->push_back(desc_id);
 111 }
 112
 113 void File::dump()
 114 {
 115   if (local_storage_)
 116     XBT_INFO("File Descriptor information:\n"
 117              "\t\tFull path: '%s'\n"
 118              "\t\tSize: %llu\n"
 119              "\t\tMount point: '%s'\n"
 120              "\t\tStorage Id: '%s'\n"
 121              "\t\tStorage Type: '%s'\n"
 122              "\t\tFile Descriptor Id: %d",
 123              get_path(), size_, mount_point_.c_str(), local_storage_->get_cname(), local_storage_->get_type(), desc_id);
 124   if (local_disk_)
 125     XBT_INFO("File Descriptor information:\n"
 126              "\t\tFull path: '%s'\n"
 127              "\t\tSize: %llu\n"
 128              "\t\tMount point: '%s'\n"
 129              "\t\tDisk Id: '%s'\n"
 130              "\t\tHost Id: '%s'\n"
 131              "\t\tFile Descriptor Id: %d",
 132              get_path(), size_, mount_point_.c_str(), local_disk_->get_cname(), local_disk_->get_host()->get_cname(),
 133              desc_id);
 134 }
 135
 136 sg_size_t File::read(sg_size_t size)
 137 {
 138   if (size_ == 0) /* Nothing to read, return */
 139     return 0;
 140   sg_size_t read_size = 0;
 141
 142   if (local_storage_) {
 143     /* Find the host where the file is physically located and read it */
 144     Host* host = local_storage_->get_host();
 145     XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
 146     // if the current position is close to the end of the file, we may not be able to read the requested size
 147     read_size = local_storage_->read(std::min(size, size_ - current_position_));
 148     current_position_ += read_size;
 149
 150     if (host->get_name() != Host::current()->get_name() && read_size > 0) {
 151       /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
 152       XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), read_size);
 153       host->send_to(Host::current(), read_size);
 154     }
 155   }
 156
 157   if (local_disk_) {
 158     /* Find the host where the file is physically located and read it */
 159     XBT_DEBUG("READ %s on disk '%s'", get_path(), local_disk_->get_cname());
 160     // if the current position is close to the end of the file, we may not be able to read the requested size
 161     read_size = local_disk_->read(std::min(size, size_ - current_position_));
 162     current_position_ += read_size;
 163   }
 164
 165   return read_size;
 166 }
 167
 168 /** @brief Write into a file (local or remote)
 169  *
 170  * @param size of the file to write
 171  * @return the number of bytes successfully write or -1 if an error occurred
 172  */
 173 sg_size_t File::write(sg_size_t size, int write_inside)
 174 {
 175   if (size == 0) /* Nothing to write, return */
 176     return 0;
 177   sg_size_t write_size = 0;
 178
 179   if (local_storage_) {
 180     /* Find the host where the file is physically located (remote or local)*/
 181     Host* host = local_storage_->get_host();
 182
 183     if (host->get_name() != Host::current()->get_name()) {
 184       /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
 185       XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), size);
 186       Host::current()->send_to(host, size);
 187     }
 188
 189     XBT_DEBUG("WRITE %s on disk '%s'. size '%llu/%llu' '%llu:%llu'", get_path(), local_storage_->get_cname(), size,
 190               size_, sg_storage_get_size_used(local_storage_), sg_storage_get_size(local_storage_));
 191     // If the storage is full before even starting to write
 192     if (sg_storage_get_size_used(local_storage_) >= sg_storage_get_size(local_storage_))
 193       return 0;
 194     if (write_inside == 0) {
 195       /* Substract the part of the file that might disappear from the used sized on the storage element */
 196       local_storage_->extension<FileSystemStorageExt>()->decr_used_size(size_ - current_position_);
 197       write_size = local_storage_->write(size);
 198       local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
 199       current_position_ += write_size;
 200       size_ = current_position_;
 201     } else {
 202       write_size = local_storage_->write(size);
 203       current_position_ += write_size;
 204       if (current_position_ > size_)
 205         size_ = current_position_;
 206     }
 207     std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
 208
 209     content->erase(path_);
 210     content->insert({path_, size_});
 211   }
 212
 213   if (local_disk_) {
 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 (write_inside == 0) {
 220       /* Substract 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::size()
 241 {
 242   return size_;
 243 }
 244
 245 void File::seek(sg_offset_t offset)
 246 {
 247   current_position_ = offset;
 248 }
 249
 250 void File::seek(sg_offset_t offset, int origin)
 251 {
 252   switch (origin) {
 253     case SEEK_SET:
 254       current_position_ = offset;
 255       break;
 256     case SEEK_CUR:
 257       current_position_ += offset;
 258       break;
 259     case SEEK_END:
 260       current_position_ = size_ + offset;
 261       break;
 262     default:
 263       break;
 264   }
 265 }
 266
 267 sg_size_t File::tell()
 268 {
 269   return current_position_;
 270 }
 271
 272 void File::move(const std::string& fullpath)
 273 {
 274   /* Check if the new full path is on the same mount point */
 275   if (fullpath.compare(0, mount_point_.length(), mount_point_) == 0) {
 276     std::map<std::string, sg_size_t>* content;
 277     if (local_storage_)
 278       content = local_storage_->extension<FileSystemStorageExt>()->get_content();
 279     if (local_disk_)
 280       content = local_disk_->extension<FileSystemDiskExt>()->get_content();
 281     auto sz = content->find(path_);
 282     if (sz != content->end()) { // src file exists
 283       sg_size_t new_size = sz->second;
 284       content->erase(path_);
 285       std::string path = fullpath.substr(mount_point_.length(), fullpath.length());
 286       content->insert({path.c_str(), new_size});
 287       XBT_DEBUG("Move file from %s to %s, size '%llu'", path_.c_str(), fullpath.c_str(), new_size);
 288     } else {
 289       XBT_WARN("File %s doesn't exist", path_.c_str());
 290     }
 291   } else {
 292     XBT_WARN("New full path %s is not on the same mount point: %s.", fullpath.c_str(), mount_point_.c_str());
 293   }
 294 }
 295
 296 int File::unlink()
 297 {
 298   /* Check if the file is on local storage */
 299   std::map<std::string, sg_size_t>* content;
 300   const char* name = nullptr;
 301   if (local_storage_) {
 302     content = local_storage_->extension<FileSystemStorageExt>()->get_content();
 303     name    = local_storage_->get_cname();
 304   }
 305   if (local_disk_) {
 306     content = local_disk_->extension<FileSystemDiskExt>()->get_content();
 307     name    = local_disk_->get_cname();
 308   }
 309
 310   if (content->find(path_) == content->end()) {
 311     XBT_WARN("File %s is not on disk %s. Impossible to unlink", path_.c_str(), name);
 312     return -1;
 313   } else {
 314     XBT_DEBUG("UNLINK %s on disk '%s'", path_.c_str(), name);
 315
 316     if (local_storage_)
 317       local_storage_->extension<FileSystemStorageExt>()->decr_used_size(size_);
 318
 319     if (local_disk_)
 320       local_disk_->extension<FileSystemDiskExt>()->decr_used_size(size_);
 321
 322     // Remove the file from storage
 323     content->erase(fullpath_);
 324
 325     return 0;
 326   }
 327 }
 328
 329 int File::remote_copy(sg_host_t host, const char* fullpath)
 330 {
 331   /* Find the host where the file is physically located and read it */
 332   Host* src_host;
 333   if (local_storage_) {
 334     src_host = local_storage_->get_host();
 335     XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
 336   }
 337
 338   if (local_disk_) {
 339     src_host = local_disk_->get_host();
 340     XBT_DEBUG("READ %s on disk '%s'", get_path(), local_disk_->get_cname());
 341   }
 342
 343   seek(0, SEEK_SET);
 344   // if the current position is close to the end of the file, we may not be able to read the requested size
 345   sg_size_t read_size = 0;
 346   if (local_storage_)
 347     read_size = local_storage_->read(size_);
 348   if (local_disk_)
 349     read_size = local_disk_->read(size_);
 350
 351   current_position_ += read_size;
 352
 353   Host* dst_host = host;
 354   if (local_storage_) {
 355     /* Find the host that owns the storage where the file has to be copied */
 356     Storage* storage_dest        = nullptr;
 357     size_t longest_prefix_length = 0;
 358
 359     for (auto const& elm : host->get_mounted_storages()) {
 360       std::string mount_point = std::string(fullpath).substr(0, elm.first.size());
 361       if (mount_point == elm.first && elm.first.length() > longest_prefix_length) {
 362         /* The current mount name is found in the full path and is bigger than the previous*/
 363         longest_prefix_length = elm.first.length();
 364         storage_dest          = elm.second;
 365       }
 366     }
 367
 368     if (storage_dest != nullptr) {
 369       /* Mount point found, retrieve the host the storage is attached to */
 370       dst_host = storage_dest->get_host();
 371     } else {
 372       XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host->get_cname());
 373       return -1;
 374     }
 375   }
 376
 377   if (local_disk_) {
 378     size_t longest_prefix_length = 0;
 379     Disk* dst_disk               = nullptr;
 380
 381     for (auto const& disk : host->get_disks()) {
 382       const char* current_mount_str = disk->get_property("mount");
 383       if (current_mount_str) {
 384         std::string current_mount = std::string(current_mount_str);
 385         std::string mount_point   = std::string(fullpath).substr(0, current_mount.length());
 386         if (mount_point == current_mount && current_mount.length() > longest_prefix_length) {
 387           /* The current mount name is found in the full path and is bigger than the previous*/
 388           longest_prefix_length = current_mount.length();
 389           dst_disk              = disk;
 390         }
 391       }
 392     }
 393
 394     if (dst_disk == nullptr) {
 395       XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host->get_cname());
 396       return -1;
 397     }
 398   }
 399
 400   XBT_DEBUG("Initiate data transfer of %llu bytes between %s and %s.", read_size, src_host->get_cname(),
 401             dst_host->get_cname());
 402   src_host->send_to(dst_host, read_size);
 403
 404   /* Create file on remote host, write it and close it */
 405   File* fd = new File(fullpath, dst_host, nullptr);
 406   if (local_storage_) {
 407     sg_size_t write_size = fd->local_storage_->write(read_size);
 408     fd->local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
 409     (*(fd->local_storage_->extension<FileSystemStorageExt>()->get_content()))[path_] = size_;
 410   }
 411   if (local_disk_)
 412     fd->write(read_size);
 413   delete fd;
 414   return 0;
 415 }
 416
 417 int File::remote_move(sg_host_t host, const char* fullpath)
 418 {
 419   int res = remote_copy(host, fullpath);
 420   unlink();
 421   return res;
 422 }
 423
 424 FileSystemDiskExt::FileSystemDiskExt(simgrid::s4u::Disk* ptr)
 425 {
 426   const char* size_str    = ptr->get_property("size");
 427   const char* content_str = ptr->get_property("content");
 428   size_                   = size_str ? surf_parse_get_size(size_str, "disk size", ptr->get_name()) : 0;
 429   if (content_str)
 430     content_.reset(parse_content(content_str));
 431 }
 432
 433 FileSystemStorageExt::FileSystemStorageExt(simgrid::s4u::Storage* ptr)
 434 {
 435   content_.reset(parse_content(ptr->get_impl()->content_name_));
 436   size_    = ptr->get_impl()->size_;
 437 }
 438
 439 std::map<std::string, sg_size_t>* FileSystemDiskExt::parse_content(const std::string& filename)
 440 {
 441   if (filename.empty())
 442     return nullptr;
 443
 444   std::map<std::string, sg_size_t>* parse_content = new std::map<std::string, sg_size_t>();
 445
 446   std::ifstream* fs = surf_ifsopen(filename);
 447
 448   std::string line;
 449   std::vector<std::string> tokens;
 450   do {
 451     std::getline(*fs, line);
 452     boost::trim(line);
 453     if (line.length() > 0) {
 454       boost::split(tokens, line, boost::is_any_of(" \t"), boost::token_compress_on);
 455       xbt_assert(tokens.size() == 2, "Parse error in %s: %s", filename.c_str(), line.c_str());
 456       sg_size_t size = std::stoull(tokens.at(1));
 457
 458       used_size_ += size;
 459       parse_content->insert({tokens.front(), size});
 460     }
 461   } while (not fs->eof());
 462   delete fs;
 463   return parse_content;
 464 }
 465
 466 std::map<std::string, sg_size_t>* FileSystemStorageExt::parse_content(const std::string& filename)
 467 {
 468   if (filename.empty())
 469     return nullptr;
 470
 471   std::map<std::string, sg_size_t>* parse_content = new std::map<std::string, sg_size_t>();
 472
 473   std::ifstream* fs = surf_ifsopen(filename);
 474
 475   std::string line;
 476   std::vector<std::string> tokens;
 477   do {
 478     std::getline(*fs, line);
 479     boost::trim(line);
 480     if (line.length() > 0) {
 481       boost::split(tokens, line, boost::is_any_of(" \t"), boost::token_compress_on);
 482       xbt_assert(tokens.size() == 2, "Parse error in %s: %s", filename.c_str(), line.c_str());
 483       sg_size_t size = std::stoull(tokens.at(1));
 484
 485       used_size_ += size;
 486       parse_content->insert({tokens.front(), size});
 487     }
 488   } while (not fs->eof());
 489   delete fs;
 490   return parse_content;
 491 }
 492 }
 493 }
 494
 495 using simgrid::s4u::FileDescriptorHostExt;
 496 using simgrid::s4u::FileSystemDiskExt;
 497 using simgrid::s4u::FileSystemStorageExt;
 498
 499 static void on_disk_creation(simgrid::s4u::Disk& d)
 500 {
 501   d.extension_set(new FileSystemDiskExt(&d));
 502 }
 503 static void on_storage_creation(simgrid::s4u::Storage& st)
 504 {
 505   st.extension_set(new FileSystemStorageExt(&st));
 506 }
 507
 508 static void on_host_creation(simgrid::s4u::Host& host)
 509 {
 510   host.extension_set<FileDescriptorHostExt>(new FileDescriptorHostExt());
 511 }
 512
 513 /* **************************** Public interface *************************** */
 514 void sg_storage_file_system_init()
 515 {
 516   sg_storage_max_file_descriptors = 1024;
 517   simgrid::config::bind_flag(sg_storage_max_file_descriptors, "storage/max_file_descriptors",
 518                              "Maximum number of concurrently opened files per host. Default is 1024");
 519
 520   if (not FileSystemStorageExt::EXTENSION_ID.valid()) {
 521     FileSystemStorageExt::EXTENSION_ID = simgrid::s4u::Storage::extension_create<FileSystemStorageExt>();
 522     simgrid::s4u::Storage::on_creation.connect(&on_storage_creation);
 523   }
 524
 525   if (not FileSystemDiskExt::EXTENSION_ID.valid()) {
 526     FileSystemDiskExt::EXTENSION_ID = simgrid::s4u::Disk::extension_create<FileSystemDiskExt>();
 527     simgrid::s4u::Disk::on_creation.connect(&on_disk_creation);
 528   }
 529
 530   if (not FileDescriptorHostExt::EXTENSION_ID.valid()) {
 531     FileDescriptorHostExt::EXTENSION_ID = simgrid::s4u::Host::extension_create<FileDescriptorHostExt>();
 532     simgrid::s4u::Host::on_creation.connect(&on_host_creation);
 533   }
 534 }
 535
 536 sg_file_t sg_file_open(const char* fullpath, void* data)
 537 {
 538   return new simgrid::s4u::File(fullpath, data);
 539 }
 540
 541 sg_size_t sg_file_read(sg_file_t fd, sg_size_t size)
 542 {
 543   return fd->read(size);
 544 }
 545
 546 sg_size_t sg_file_write(sg_file_t fd, sg_size_t size)
 547 {
 548   return fd->write(size);
 549 }
 550
 551 void sg_file_close(sg_file_t fd)
 552 {
 553   delete fd;
 554 }
 555
 556 const char* sg_file_get_name(sg_file_t fd)
 557 {
 558   xbt_assert((fd != nullptr), "Invalid file descriptor");
 559   return fd->get_path();
 560 }
 561
 562 sg_size_t sg_file_get_size(sg_file_t fd)
 563 {
 564   return fd->size();
 565 }
 566
 567 void sg_file_dump(sg_file_t fd)
 568 {
 569   fd->dump();
 570 }
 571
 572 void* sg_file_get_data(sg_file_t fd)
 573 {
 574   return fd->get_userdata();
 575 }
 576
 577 void sg_file_set_data(sg_file_t fd, void* data)
 578 {
 579   fd->set_userdata(data);
 580 }
 581
 582 /**
 583  * @brief Set the file position indicator in the sg_file_t by adding offset bytes
 584  * to the position specified by origin (either SEEK_SET, SEEK_CUR, or SEEK_END).
 585  *
 586  * @param fd : file object that identifies the stream
 587  * @param offset : number of bytes to offset from origin
 588  * @param origin : Position used as reference for the offset. It is specified by one of the following constants defined
 589  *                 in \<stdio.h\> exclusively to be used as arguments for this function (SEEK_SET = beginning of file,
 590  *                 SEEK_CUR = current position of the file pointer, SEEK_END = end of file)
 591  */
 592 void sg_file_seek(sg_file_t fd, sg_offset_t offset, int origin)
 593 {
 594   fd->seek(offset, origin);
 595 }
 596
 597 sg_size_t sg_file_tell(sg_file_t fd)
 598 {
 599   return fd->tell();
 600 }
 601
 602 void sg_file_move(sg_file_t fd, const char* fullpath)
 603 {
 604   fd->move(fullpath);
 605 }
 606
 607 void sg_file_unlink(sg_file_t fd)
 608 {
 609   fd->unlink();
 610   delete fd;
 611 }
 612
 613 /**
 614  * @brief Copy a file to another location on a remote host.
 615  * @param file : the file to move
 616  * @param host : the remote host where the file has to be copied
 617  * @param fullpath : the complete path destination on the remote host
 618  * @return If successful, the function returns 0. Otherwise, it returns -1.
 619  */
 620 int sg_file_rcopy(sg_file_t file, sg_host_t host, const char* fullpath)
 621 {
 622   return file->remote_copy(host, fullpath);
 623 }
 624
 625 /**
 626  * @brief Move a file to another location on a remote host.
 627  * @param file : the file to move
 628  * @param host : the remote host where the file has to be moved
 629  * @param fullpath : the complete path destination on the remote host
 630  * @return If successful, the function returns 0. Otherwise, it returns -1.
 631  */
 632 int sg_file_rmove(sg_file_t file, sg_host_t host, const char* fullpath)
 633 {
 634   return file->remote_move(host, fullpath);
 635 }
 636
 637 sg_size_t sg_disk_get_size_free(sg_disk_t d)
 638 {
 639   return d->extension<FileSystemDiskExt>()->get_size() - d->extension<FileSystemDiskExt>()->get_used_size();
 640 }
 641
 642 sg_size_t sg_disk_get_size_used(sg_disk_t d)
 643 {
 644   return d->extension<FileSystemDiskExt>()->get_used_size();
 645 }
 646
 647 sg_size_t sg_disk_get_size(sg_disk_t d)
 648 {
 649   return d->extension<FileSystemDiskExt>()->get_size();
 650 }
 651
 652 sg_size_t sg_storage_get_size_free(sg_storage_t st)
 653 {
 654   return st->extension<FileSystemStorageExt>()->get_size() - st->extension<FileSystemStorageExt>()->get_used_size();
 655 }
 656
 657 sg_size_t sg_storage_get_size_used(sg_storage_t st)
 658 {
 659   return st->extension<FileSystemStorageExt>()->get_used_size();
 660 }
 661
 662 sg_size_t sg_storage_get_size(sg_storage_t st)
 663 {
 664   return st->extension<FileSystemStorageExt>()->get_size();
 665 }
 666
 667 xbt_dict_t sg_storage_get_content(sg_storage_t storage)
 668 {
 669   std::map<std::string, sg_size_t>* content = storage->extension<simgrid::s4u::FileSystemStorageExt>()->get_content();
 670   // Note: ::operator delete is ok here (no destructor called) since the dict elements are of POD type sg_size_t.
 671   xbt_dict_t content_as_dict = xbt_dict_new_homogeneous(::operator delete);
 672
 673   for (auto const& entry : *content) {
 674     sg_size_t* psize = new sg_size_t;
 675     *psize           = entry.second;
 676     xbt_dict_set(content_as_dict, entry.first.c_str(), psize, nullptr);
 677   }
 678   return content_as_dict;
 679 }
 680
 681 xbt_dict_t sg_host_get_storage_content(sg_host_t host)
 682 {
 683   xbt_assert((host != nullptr), "Invalid parameters");
 684   xbt_dict_t contents = xbt_dict_new_homogeneous(nullptr);
 685   for (auto const& elm : host->get_mounted_storages())
 686     xbt_dict_set(contents, elm.first.c_str(), sg_storage_get_content(elm.second), nullptr);
 687
 688   return contents;
 689 }