/*
 * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#include "precompiled.hpp"
#include "gc/z/zArray.inline.hpp"
#include "gc/z/zBackingPath_linux_x86.hpp"
#include "gc/z/zErrno.hpp"
#include "logging/log.hpp"

#include <stdio.h>
#include <unistd.h>

// Mount information, see proc(5) for more details.
#define PROC_SELF_MOUNTINFO        "/proc/self/mountinfo"

ZBackingPath::ZBackingPath(const char* filesystem, const char** preferred_mountpoints) {
  if (ZPath != NULL) {
    // Use specified path
    _path = strdup(ZPath);
  } else {
    // Find suitable path
    _path = find_mountpoint(filesystem, preferred_mountpoints);
  }
}

ZBackingPath::~ZBackingPath() {
  free(_path);
  _path = NULL;
}

char* ZBackingPath::get_mountpoint(const char* line, const char* filesystem) const {
  char* line_mountpoint = NULL;
  char* line_filesystem = NULL;

  // Parse line and return a newly allocated string containing the mount point if
  // the line contains a matching filesystem and the mount point is accessible by
  // the current user.
  if (sscanf(line, "%*u %*u %*u:%*u %*s %ms %*[^-]- %ms", &line_mountpoint, &line_filesystem) != 2 ||
      strcmp(line_filesystem, filesystem) != 0 ||
      access(line_mountpoint, R_OK|W_OK|X_OK) != 0) {
    // Not a matching or accessible filesystem
    free(line_mountpoint);
    line_mountpoint = NULL;
  }

  free(line_filesystem);

  return line_mountpoint;
}

void ZBackingPath::get_mountpoints(const char* filesystem, ZArray<char*>* mountpoints) const {
  FILE* fd = fopen(PROC_SELF_MOUNTINFO, "r");
  if (fd == NULL) {
    ZErrno err;
    log_error(gc, init)("Failed to open %s: %s", PROC_SELF_MOUNTINFO, err.to_string());
    return;
  }

  char* line = NULL;
  size_t length = 0;

  while (getline(&line, &length, fd) != -1) {
    char* const mountpoint = get_mountpoint(line, filesystem);
    if (mountpoint != NULL) {
      mountpoints->add(mountpoint);
    }
  }

  free(line);
  fclose(fd);
}

void ZBackingPath::free_mountpoints(ZArray<char*>* mountpoints) const {
  ZArrayIterator<char*> iter(mountpoints);
  for (char* mountpoint; iter.next(&mountpoint);) {
    free(mountpoint);
  }
  mountpoints->clear();
}

char* ZBackingPath::find_preferred_mountpoint(const char* filesystem,
                                              ZArray<char*>* mountpoints,
                                              const char** preferred_mountpoints) const {
  // Find preferred mount point
  ZArrayIterator<char*> iter1(mountpoints);
  for (char* mountpoint; iter1.next(&mountpoint);) {
    for (const char** preferred = preferred_mountpoints; *preferred != NULL; preferred++) {
      if (!strcmp(mountpoint, *preferred)) {
        // Preferred mount point found
        return strdup(mountpoint);
      }
    }
  }

  // Preferred mount point not found
  log_error(gc, init)("More than one %s filesystem found:", filesystem);
  ZArrayIterator<char*> iter2(mountpoints);
  for (char* mountpoint; iter2.next(&mountpoint);) {
    log_error(gc, init)("  %s", mountpoint);
  }

  return NULL;
}

char* ZBackingPath::find_mountpoint(const char* filesystem, const char** preferred_mountpoints) const {
  char* path = NULL;
  ZArray<char*> mountpoints;

  get_mountpoints(filesystem, &mountpoints);

  if (mountpoints.size() == 0) {
    // No mount point found
    log_error(gc, init)("Failed to find an accessible %s filesystem", filesystem);
  } else if (mountpoints.size() == 1) {
    // One mount point found
    path = strdup(mountpoints.at(0));
  } else {
    // More than one mount point found
    path = find_preferred_mountpoint(filesystem, &mountpoints, preferred_mountpoints);
  }

  free_mountpoints(&mountpoints);

  return path;
}

const char* ZBackingPath::get() const {
  return _path;
}
