InfoBlock.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 "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/Version.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/Machine.h"
#include "pedigree/kernel/machine/Timer.h"
#include "pedigree/kernel/machine/TimerHandler.h"
#include "pedigree/kernel/process/InfoBlock.h"
#include "pedigree/kernel/processor/PhysicalMemoryManager.h"
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/VirtualAddressSpace.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/utility.h"
 
InfoBlockManager InfoBlockManager::m_Instance;
 
InfoBlockManager::InfoBlockManager()
    : TimerHandler(),
      m_bInitialised(false),
      m_UpdateLock(false, true),
      m_pTimer(nullptr),
      m_pInfoBlock(0) {}
 
InfoBlockManager::~InfoBlockManager() {
  if (!shutdown()) {
    FATAL("InfoBlockManager could not drain its timer callback");
  }
}
 
InfoBlockManager& InfoBlockManager::instance() {
  return m_Instance;
}
 
bool InfoBlockManager::initialise() {
  // Prepare the mapping, if we can.
  VirtualAddressSpace& va = VirtualAddressSpace::getKernelAddressSpace();
  void* infoBlock = reinterpret_cast<void*>(va.getGlobalInfoBlock());
  if (!infoBlock)
    return false;  // Nothing to do here.
 
  NOTICE("InfoBlockManager: Setting up global info block at " << Hex << infoBlock);
 
  // Map for userspace.
  physical_uintptr_t page = PhysicalMemoryManager::instance().allocatePage();
  va.map(page, infoBlock, 0);
 
  // Map for the kernel - trick is, our version is a page ahead.
  m_pInfoBlock =
      reinterpret_cast<InfoBlock*>(adjust_pointer(infoBlock, PhysicalMemoryManager::getPageSize()));
  va.map(page, m_pInfoBlock, VirtualAddressSpace::KernelMode | VirtualAddressSpace::Write);
 
  // Set up basic defaults.
  ByteSet(m_pInfoBlock, 0, sizeof(InfoBlock));
  StringCopy(m_pInfoBlock->sysname, "Pedigree");
  StringCopy(m_pInfoBlock->release, "Foster");
  StringCopy(m_pInfoBlock->version, g_pBuildRevision);
  StringCopy(m_pInfoBlock->machine, g_pBuildTarget);
  m_pInfoBlock->now = Time::getTimeNanoseconds();
  m_pInfoBlock->now_s = Time::getTime();
  m_pInfoBlock->monotonic = Time::getTicks();
 
#if X64 && !HOSTED
  uint32_t maxLeaf, eax, ebx, ecx, edx;
  Processor::cpuid(0x80000000, 0, maxLeaf, ebx, ecx, edx);
  if (maxLeaf >= 0x80000001) {
    Processor::cpuid(0x80000001, 0, eax, ebx, ecx, edx);
    if (edx & (1u << 27)) {
      m_pInfoBlock->vdso_features |= INFO_BLOCK_VDSO_GETCPU_RDTSCP;
    }
  }
#endif
 
  __atomic_store_n(&m_bInitialised, true, __ATOMIC_RELEASE);
#if X64 && !HOSTED
  // The vDSO's time exports sample the kernel clock directly on amd64.
  // Refreshing a shared snapshot would keep an otherwise idle CPU ticking.
  return true;
#else
  Timer* timer = Machine::instance().getTimer();
  if (timer && timer->registerHandler(this)) {
    m_pTimer = timer;
    return true;
  }
  return false;
#endif
}
 
bool InfoBlockManager::shutdown() {
  if (m_pTimer && !m_pTimer->unregisterHandler(this)) {
    return false;
  }
 
  m_pTimer = nullptr;
  __atomic_store_n(&m_bInitialised, false, __ATOMIC_RELEASE);
  return true;
}
 
void InfoBlockManager::timer(uint64_t) {
  refreshTime();
}
 
void InfoBlockManager::refreshTime() {
  if (!__atomic_load_n(&m_bInitialised, __ATOMIC_ACQUIRE)) {
    return;
  }
  // A timer callback must not overwrite a completed clock update with an
  // older sample taken before the setting syscall published its new epoch.
  LockGuard<Spinlock> guard(m_UpdateLock);
  const Time::Timestamp now = Time::getTimeNanoseconds();
  m_pInfoBlock->now = now;
  m_pInfoBlock->now_s = now / Time::Multiplier::Second;
  m_pInfoBlock->monotonic = Time::getTicks();
}
 
void InfoBlockManager::setPid(size_t value) {
  if (LIKELY(__atomic_load_n(&m_bInitialised, __ATOMIC_ACQUIRE)))
    m_pInfoBlock->pid = value;
}