ProcFs.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include "ProcFs.h"
#include "pedigree/kernel/BootstrapInfo.h"
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/Version.h"
#include "pedigree/kernel/machine/Device.h"
#include "pedigree/kernel/process/Scheduler.h"
#include "pedigree/kernel/processor/PhysicalMemoryManager.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/StaticString.h"
 
#include "PosixProcess.h"
#include "file-syscalls.h"
#include "modules/system/users/Group.h"
#include "modules/system/users/User.h"
 
namespace {
Mutex procRegistryLock;
ProcFs* procRegistry = nullptr;
}  // namespace
 
extern size_t g_FreePages;
extern size_t g_AllocedPages;
 
MeminfoFile::MeminfoFile(size_t inode, Filesystem* pParentFS, File* pParent)
    : File(String("meminfo"), 0, 0, 0, inode, pParentFS, 0, pParent), m_Contents(), m_Lock() {
  setPermissionsOnly(FILE_UR | FILE_GR | FILE_OR);
  setUidOnly(0);
  setGidOnly(0);
 
  updateContents();
}
 
MeminfoFile::~MeminfoFile() = default;
 
size_t MeminfoFile::getSize() {
  updateContents();
  LockGuard<Mutex> guard(m_Lock);
  return m_Contents.length();
}
 
void MeminfoFile::updateContents() {
  const auto memory = PhysicalMemoryManager::instance().memorySnapshot();
  const uint64_t totalPages = memory.available ? memory.totalPages : g_FreePages + g_AllocedPages;
  const uint64_t freePages = memory.available ? memory.freePages : g_FreePages;
  const uint64_t totalKb = (totalPages * PhysicalMemoryManager::getPageSize()) / 1024;
  const uint64_t freeKb = (freePages * PhysicalMemoryManager::getPageSize()) / 1024;
  String contents;
  contents.Format(
      "MemTotal:       %lu kB\n"
      "MemFree:        %lu kB\n"
      "MemAvailable:   %lu kB\n"
      "Buffers:        0 kB\n"
      "Cached:         0 kB\n"
      "SwapCached:     0 kB\n"
      "SwapTotal:      0 kB\n"
      "SwapFree:       0 kB\n",
      totalKb, freeKb, freeKb);
  LockGuard<Mutex> guard(m_Lock);
  m_Contents = contents;
}
 
uint64_t MeminfoFile::readBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                   bool bCanBlock) {
  updateContents();
  LockGuard<Mutex> guard(m_Lock);
 
  if (location >= m_Contents.length()) {
    return 0;  // EOF
  } else if (size > m_Contents.length() - location) {
    size = m_Contents.length() - location;
  }
 
  char* destination = reinterpret_cast<char*>(buffer);
  const char* source = static_cast<const char*>(m_Contents);
 
  MemoryCopy(destination, source + location, size);
 
  return size;
}
 
uint64_t MeminfoFile::writeBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                    bool bCanBlock) {
  return 0;
}
 
PciDevicesFile::PciDevicesFile(size_t inode, Filesystem* pParentFS, File* pParent)
    : File(String("devices"), 0, 0, 0, inode, pParentFS, 0, pParent), m_Contents() {
  setPermissionsOnly(FILE_UR | FILE_UW | FILE_GR | FILE_GW | FILE_OR);
  setUidOnly(0);
  setGidOnly(0);
 
  resync();
}
 
PciDevicesFile::~PciDevicesFile() {}
 
size_t PciDevicesFile::getSize() {
  return m_Contents.length();
}
 
uint64_t PciDevicesFile::readBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                      bool bCanBlock) {
  resync();
 
  if (location >= m_Contents.length()) {
    return 0;  // EOF
  } else if ((location + size) > m_Contents.length()) {
    size = m_Contents.length() - location;
  }
 
  char* destination = reinterpret_cast<char*>(buffer);
  const char* source = static_cast<const char*>(m_Contents);
 
  StringCopy(destination, source);
 
  return size;
}
 
uint64_t PciDevicesFile::writeBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                       bool bCanBlock) {
  return 0;
}
 
void PciDevicesFile::resync() {
  m_Contents = String();
 
  auto printer = [this](Device* p) -> Device* {
    String initial;
    initial.Format("%02x%02x\t%04x%04x\t%x", p->getPciBusPosition(),
                   (p->getPciDevicePosition() << 4) | p->getPciFunctionNumber(),
                   p->getPciVendorId(), p->getPciDeviceId(), p->getInterruptNumber());
 
    String resStart;
    String resLength;
    for (size_t i = 0; i < 7; ++i) {
      String thisResStart;
      String thisResLength;
 
      if (i < p->addresses().count()) {
        size_t length = p->addresses()[i]->m_Size;
 
        uintptr_t address = p->addresses()[i]->m_Address;
        uintptr_t flags = 0;
        if (p->addresses()[i]->m_IsIoSpace) {
          flags = 1;
        }
 
        thisResStart.Format("\t%16lx", address | flags);
        thisResLength.Format("\t%16lx", length ? length + 1 : 0);
      } else {
        thisResStart.Format("\t%16lx", 0);
        thisResLength.Format("\t%16lx", 0);
      }
 
      resStart += thisResStart;
      resLength += thisResLength;
    }
 
    m_Contents += initial;
    m_Contents += resStart;
    m_Contents += resLength;
    m_Contents += "\t";  
    m_Contents += "\n";
 
    return p;
  };
 
  auto callback = pedigree_std::make_callable(printer);
  Device::foreach (callback, nullptr);
}
 
MountFile::MountFile(size_t inode, Filesystem* pParentFS, File* pParent)
    : File(String("mounts"), 0, 0, 0, inode, pParentFS, 0, pParent) {
  setPermissionsOnly(FILE_UR | FILE_GR | FILE_OR);
  setUidOnly(0);
  setGidOnly(0);
}
 
MountFile::~MountFile() = default;
 
uint64_t MountFile::readBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                 bool bCanBlock) {
  String mounts;
  generate_mtab(mounts);
 
  if (location >= mounts.length()) {
    // "EOF"
    return 0;
  }
 
  if ((location + size) >= mounts.length()) {
    size = mounts.length() - location;
  }
 
  char* destination = reinterpret_cast<char*>(buffer);
  StringCopyN(destination, static_cast<const char*>(mounts) + location, size);
 
  return size;
}
 
uint64_t MountFile::writeBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                  bool bCanBlock) {
  return 0;
}
 
size_t MountFile::getSize() {
  String mounts;
  generate_mtab(mounts);
  return mounts.length();
}
 
UptimeFile::UptimeFile(size_t inode, Filesystem* pParentFS, File* pParent)
    : File(String("uptime"), 0, 0, 0, inode, pParentFS, 0, pParent) {
  setPermissionsOnly(FILE_UR | FILE_GR | FILE_OR);
  setUidOnly(0);
  setGidOnly(0);
}
 
UptimeFile::~UptimeFile() = default;
 
uint64_t UptimeFile::readBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                  bool bCanBlock) {
  String f = generateString();
 
  if (location >= f.length()) {
    // "EOF"
    return 0;
  }
 
  if ((location + size) >= f.length()) {
    size = f.length() - location;
  }
 
  char* destination = reinterpret_cast<char*>(buffer);
  StringCopyN(destination, static_cast<const char*>(f) + location, size);
 
  return size;
}
 
uint64_t UptimeFile::writeBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                   bool bCanBlock) {
  return 0;
}
 
size_t UptimeFile::getSize() {
  String f = generateString();
  return f.length();
}
 
String UptimeFile::generateString() {
  const uint64_t uptime = Time::getTicks();
  const uint64_t idle = Scheduler::instance().systemActivity().idleNanoseconds;
 
  String f;
  f.Format("%lu.%02lu %lu.%02lu\n", uptime / Time::Multiplier::Second,
           (uptime % Time::Multiplier::Second) / (Time::Multiplier::Second / 100),
           idle / Time::Multiplier::Second,
           (idle % Time::Multiplier::Second) / (Time::Multiplier::Second / 100));
 
  return f;
}
 
ConstantFile::ConstantFile(String name, const char* value, size_t size, size_t inode,
                           Filesystem* pParentFS, File* pParent)
    : File(name, 0, 0, 0, inode, pParentFS, 0, pParent), m_Contents() {
  setPermissionsOnly(FILE_UR | FILE_UW | FILE_GR | FILE_GW | FILE_OR);
  setUidOnly(0);
  setGidOnly(0);
 
  m_Contents = new char[size];
  m_Size = size;
  MemoryCopy(m_Contents, value, size);
}
 
ConstantFile::~ConstantFile() {
  delete[] m_Contents;
}
 
uint64_t ConstantFile::readBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                    bool bCanBlock) {
  if (location >= m_Size) {
    return 0;  // EOF
  } else if ((location + size) > m_Size) {
    size = m_Size - location;
  }
 
  char* destination = reinterpret_cast<char*>(buffer);
  const char* source = m_Contents + location;
 
  MemoryCopy(destination, source, size);
 
  return size;
}
 
uint64_t ConstantFile::writeBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                     bool bCanBlock) {
  return 0;
}
 
size_t ConstantFile::getSize() {
  return m_Size;
}
 
ProcFsDirectory::~ProcFsDirectory() = default;
 
ProcFs::~ProcFs() {
  {
    LockGuard<Mutex> guard(procRegistryLock);
    ProcFs** link = &procRegistry;
    while (*link && *link != this) {
      link = &(*link)->m_RegistryNext;
    }
    if (*link) {
      *link = m_RegistryNext;
    }
  }
  delete m_pRoot;
}
 
bool ProcFs::initialise(Disk* pDisk) {
 
  // Deterministic inode assignment to each ProcFs node
  m_NextInode = 0;
 
  if (m_pRoot) {
    delete m_pRoot;
  }
 
  m_pRoot = new ProcFsDirectory(String(""), 0, 0, 0, getNextInode(), this, 0, 0);
  // Allow user/group to read and write, but disallow all others anything
  // other than the ability to list and access files.
  m_pRoot->setPermissions(FILE_UR | FILE_UW | FILE_UX | FILE_GR | FILE_GW | FILE_GX | FILE_OR |
                          FILE_OX);
 
  // dot entry
  Directory* dot = new ProcFsDirectory(String("."), 0, 0, 0, m_pRoot->getInode(), this, 0, 0);
  dot->setPermissions(m_pRoot->getPermissions());
  m_pRoot->addEntry(dot->getName(), dot);
 
  MeminfoFile* meminfo = new MeminfoFile(getNextInode(), this, m_pRoot);
  m_pRoot->addEntry(meminfo->getName(), meminfo);
 
  MountFile* mounts = new MountFile(getNextInode(), this, m_pRoot);
  m_pRoot->addEntry(mounts->getName(), mounts);
 
  initialiseResolverFile();
  initialiseNetworkFile();
 
  auto* sys = new ProcFsDirectory(String("sys"), 0, 0, 0, getNextInode(), this, 0, m_pRoot);
  auto* kernel = new ProcFsDirectory(String("kernel"), 0, 0, 0, getNextInode(), this, 0, sys);
  constexpr uint32_t directoryMode = FILE_UR | FILE_UX | FILE_GR | FILE_GX | FILE_OR | FILE_OX;
  sys->setPermissions(directoryMode);
  kernel->setPermissions(directoryMode);
  m_pRoot->addEntry(sys->getName(), sys);
  sys->addEntry(kernel->getName(), kernel);
  const char* overflowNames[] = {"overflowuid", "overflowgid"};
  for (const char* name : overflowNames) {
    auto* value = new ConstantFile(String(name), "65534\n", 6, getNextInode(), this, kernel);
    value->setPermissions(FILE_UR | FILE_GR | FILE_OR);
    kernel->addEntry(value->getName(), value);
  }
 
  UptimeFile* uptime = new UptimeFile(getNextInode(), this, m_pRoot);
  m_pRoot->addEntry(uptime->getName(), uptime);
 
  if (!procfsAddSystemStatusFiles(*this, *m_pRoot))
    return false;
 
  static String fs("\text2\nnodev\tproc\nnodev\tsysfs\nnodev\ttmpfs\n");
  ConstantFile* pFilesystems = new ConstantFile(String("filesystems"), fs.cstr(), fs.length(),
                                                getNextInode(), this, m_pRoot);
  m_pRoot->addEntry(pFilesystems->getName(), pFilesystems);
 
  // Kernel command line
  static String cmdline("noswap quiet boot=live\n", 25);  //(g_pBootstrapInfo->getCommandLine());
  NOTICE("cmdline is '" << cmdline << "'");
  ConstantFile* pCmdline = new ConstantFile(String("cmdline"), cmdline.cstr(), cmdline.length(),
                                            getNextInode(), this, m_pRoot);
  m_pRoot->addEntry(pCmdline->getName(), pCmdline);
 
  // /proc/version contains some extra version info (not same as uname)
  static String version;
  version.Format("Pedigree version %s (%s@%s) %s", g_pBuildRevision, g_pBuildUser, g_pBuildMachine,
                 g_pBuildTime);
  ConstantFile* pVersion = new ConstantFile(String("version"), version.cstr(), version.length(),
                                            getNextInode(), this, m_pRoot);
  m_pRoot->addEntry(pVersion->getName(), pVersion);
 
  ProcFsDirectory* pBusDir =
      new ProcFsDirectory(String("bus"), 0, 0, 0, getNextInode(), this, 0, m_pRoot);
  ProcFsDirectory* pPciDir =
      new ProcFsDirectory(String("pci"), 0, 0, 0, getNextInode(), this, 0, pBusDir);
 
  pBusDir->setPermissions(FILE_UR | FILE_UX | FILE_GR | FILE_GX | FILE_OR | FILE_OX);
  pPciDir->setPermissions(FILE_UR | FILE_UX | FILE_GR | FILE_GX | FILE_OR | FILE_OX);
 
  m_pRoot->addEntry(pBusDir->getName(), pBusDir);
  pBusDir->addEntry(pPciDir->getName(), pPciDir);
 
  // Load PCI devices into bus/pci/devices file
  auto printer = [pPciDir, this](Device* p) -> Device* {
    String bus;
    bus.Format("%02x", p->getPciBusPosition());
 
    // create config space file for this
    File* d = VFS::instance().find(bus, pPciDir);
    if (!d) {
      ProcFsDirectory* dir = new ProcFsDirectory(bus, 0, 0, 0, getNextInode(), this, 0, pPciDir);
      pPciDir->addEntry(dir->getName(), dir);
 
      d = dir;
    }
 
    ProcFsDirectory* dir = static_cast<ProcFsDirectory*>(Directory::fromFile(d));
 
    String fn;
    fn.Format("%02x.%01x", p->getPciDevicePosition(), p->getPciFunctionNumber());
 
    // Sometimes the device file already exists, avoid creating duplicate
    // files
    File* e = VFS::instance().find(fn, dir);
    if (!e) {
      PciBus::ConfigSpace space = p->getPciConfigHeader();
 
      ConstantFile* cf = new ConstantFile(fn, reinterpret_cast<const char*>(&space), sizeof(space),
                                          getNextInode(), this, dir);
      dir->addEntry(cf->getName(), cf);
    }
 
    String initial;
    initial.Format("%02x%02x\t%04x%04x\t%x", p->getPciBusPosition(),
                   (p->getPciDevicePosition() << 4) | p->getPciFunctionNumber(),
                   p->getPciVendorId(), p->getPciDeviceId(), p->getInterruptNumber());
 
    String resStart;
    String resLength;
    for (size_t i = 0; i < 7; ++i) {
      String thisResStart;
      String thisResLength;
 
      if (i < p->addresses().count()) {
        size_t length = p->addresses()[i]->m_Size;
 
        uintptr_t address = p->addresses()[i]->m_Address;
        uintptr_t flags = 0;
        if (p->addresses()[i]->m_IsIoSpace) {
          flags = 1;
        }
 
        thisResStart.Format("\t%16lx", address | flags);
        thisResLength.Format("\t%16lx", length ? length + 1 : 0);
      } else {
        thisResStart.Format("\t%16lx", 0);
        thisResLength.Format("\t%16lx", 0);
      }
 
      resStart += thisResStart;
      resLength += thisResLength;
    }
 
    m_PciDevices += initial;
    m_PciDevices += resStart;
    m_PciDevices += resLength;
    m_PciDevices += "\t";  
    m_PciDevices += "\n";
 
    return p;
  };
 
  auto callback = pedigree_std::make_callable(printer);
  Device::foreach (callback, nullptr);
 
  ConstantFile* pPciDevices = new ConstantFile(
      String("devices"), m_PciDevices.cstr(), m_PciDevices.length(), getNextInode(), this, pPciDir);
  pPciDir->addEntry(pPciDevices->getName(), pPciDevices);
 
  if (!initialiseNamespaceLinks()) {
    return false;
  }
  LockGuard<Mutex> guard(procRegistryLock);
  if (!m_Registered) {
    m_RegistryNext = procRegistry;
    procRegistry = this;
    m_Registered = true;
  }
  size_t after = 0;
  Scheduler::ProcessLease process;
  while (Scheduler::instance().acquireNextProcess(process, after)) {
    after = process->getId();
    if (process->getType() == Process::Posix) {
      addProcess(static_cast<PosixProcess*>(process.get()));
    }
  }
  return true;
}
 
size_t ProcFs::getNextInode() {
  return (m_NextInode += 1) - 1;
}
 
void ProcFs::revertInode() {
  // Concurrent allocations may already have published later inode numbers.
  // A failed creation leaves a gap rather than reusing a live inode.
}
 
void ProcFs::addProcess(PosixProcess* proc) {
  size_t pid = proc->getUserspaceId(m_PidNamespace.get());
  if (!pid) {
    return;
  }
 
  NormalStaticString name;
  name.append(pid);
  Directory::ChildLease existing;
  if (m_pRoot->lookupChild(HashedStringView(name), existing) == Directory::LookupStatus::Found) {
    return;
  }
  auto procDir = createProcessDirectory(proc);
  if (!procDir) {
    WARNING("ProcFs: could not prepare process directory for " << Dec << pid);
    return;
  }
  procDir->setPermissions(FILE_UR | FILE_UX | FILE_GR | FILE_GX | FILE_OR | FILE_OX);
 
  if (proc->getUser()) {
    procDir->setUid(proc->getUser()->getId());
  }
  if (proc->getGroup()) {
    procDir->setGid(proc->getGroup()->getId());
  }
 
  // Directory owns publication and lifetime, including concurrent exit and lookup.
  m_pRoot->addEntry(procDir->getName(), procDir);
 
}
 
void ProcFs::removeProcess(PosixProcess* proc) {
  size_t pid = proc->getUserspaceId(m_PidNamespace.get());
  if (!pid) {
    return;
  }
 
  String s;
  s.Format("%d", pid);
 
  m_pRoot->remove(s);
}
 
void ProcFs::publishProcess(PosixProcess* process) {
  LockGuard<Mutex> guard(procRegistryLock);
  for (auto* filesystem = procRegistry; filesystem; filesystem = filesystem->m_RegistryNext) {
    filesystem->addProcess(process);
  }
}
 
void ProcFs::unpublishProcess(PosixProcess* process) {
  LockGuard<Mutex> guard(procRegistryLock);
  for (auto* filesystem = procRegistry; filesystem; filesystem = filesystem->m_RegistryNext) {
    filesystem->removeProcess(process);
  }
}