Console.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 "Console.h"
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/process/Thread.h"
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/ProcessorInformation.h"
 
#include "modules/Module.h"
 
class RequestQueue;
 
ConsoleManager ConsoleManager::m_Instance;
 
void ConsoleManager::newConsole(char c, size_t i) {
  newConsole(c, i, true);
}
 
void ConsoleManager::newConsole(char c, size_t i, bool lock) {
  char a = 'a' + (i % 10);
  if (i <= 9)
    a = '0' + i;
 
  char master[] = {'p', 't', 'y', c, a, 0};
  char slave[] = {'t', 't', 'y', c, a, 0};
 
  String masterName(master), slaveName(slave);
 
  ConsoleMasterFile* pMaster = new ConsoleMasterFile(i, masterName, this);
  ConsoleSlaveFile* pSlave = new ConsoleSlaveFile(i, slaveName, this);
 
  pMaster->setOther(pSlave);
  pSlave->setOther(pMaster);
 
  {
    LockGuard<Spinlock> guard(m_Lock, lock);
    m_Consoles.pushBack(pMaster);
    m_Consoles.pushBack(pSlave);
  }
}
 
ConsoleManager::ConsoleManager() : m_Consoles(), m_Lock() {
  // Create all consoles, so we can look them up easily.
  for (size_t i = 0; i < 16; ++i) {
    for (char c = 'p'; c <= 'z'; ++c) {
      newConsole(c, i, false);
    }
    for (char c = 'a'; c <= 'e'; ++c) {
      newConsole(c, i, false);
    }
  }
}
 
ConsoleManager::~ConsoleManager() {
  for (auto it : m_Consoles) {
    delete it;
  }
}
 
ConsoleManager& ConsoleManager::instance() {
  return m_Instance;
}
 
File* ConsoleManager::getConsole(String consoleName) {
  LockGuard<Spinlock> guard(m_Lock);
  for (size_t i = 0; i < m_Consoles.count(); i++) {
    ConsoleFile* pC = m_Consoles[i];
    if (pC->m_ConsoleName == consoleName) {
      return pC;
    }
  }
  // Error - not found.
  return 0;
}
 
ConsoleFile* ConsoleManager::getConsoleFile(RequestQueue* pBackend) {
  return 0;
}
 
bool ConsoleManager::lockConsole(File* file) {
  LockGuard<Spinlock> guard(m_Lock);
  if (!isConsole(file))
    return false;
 
  ConsoleMasterFile* pConsole = static_cast<ConsoleMasterFile*>(file);
  if (!pConsole->isMaster())
    return false;
 
  if (pConsole->bLocked)
    return false;
 
  Process* pProcess = Processor::information().getCurrentThread()->getParent();
  pConsole->bLocked = true;
  pConsole->pLocker = pProcess;
 
  return true;
}
 
void ConsoleManager::unlockConsole(File* file) {
  LockGuard<Spinlock> guard(m_Lock);
  if (!isConsole(file))
    return;
 
  ConsoleMasterFile* pConsole = static_cast<ConsoleMasterFile*>(file);
  if (!pConsole->isMaster())
    return;
 
  // Make sure we are the owner of the master.
  // Forked children shouldn't be able to close() and steal a master pty.
  Process* pProcess = Processor::information().getCurrentThread()->getParent();
  if (pConsole->pLocker != pProcess)
    return;
  pConsole->bLocked = false;
}
 
bool ConsoleManager::setPtyLock(File* file, bool locked) {
  LockGuard<Spinlock> guard(m_Lock);
  if (!isConsole(file) || !isMasterConsole(file) || !static_cast<ConsoleFile*>(file)->isPtyMaster())
    return false;
 
  ConsoleMasterFile* pConsole = static_cast<ConsoleMasterFile*>(file);
  pConsole->bSlaveLocked = locked;
  return true;
}
 
bool ConsoleManager::isPtySlaveLocked(File* file) {
  LockGuard<Spinlock> guard(m_Lock);
  if (!isConsole(file) || !static_cast<ConsoleFile*>(file)->isPtySlave())
    return false;
 
  ConsoleFile* other = static_cast<ConsoleFile*>(file)->m_pOther;
  if (!other || !other->isMaster())
    return false;
  return static_cast<ConsoleMasterFile*>(other)->bSlaveLocked;
}
 
bool ConsoleManager::isConsole(File* file) {
  if (!file)
    return false;
  return (file->getInode() == 0xdeadbeef);
}
 
bool ConsoleManager::isMasterConsole(File* file) {
  if (!isConsole(file))
    return false;
 
  ConsoleFile* pFile = reinterpret_cast<ConsoleFile*>(file);
  return pFile->isMaster();
}
 
void ConsoleManager::setAttributes(File* file, size_t flags) {
  // \todo Sanity checking of the flags.
  if (!file)
    return;
  ConsoleFile* pFile = reinterpret_cast<ConsoleFile*>(file);
  pFile->m_Flags = flags;
}
 
void ConsoleManager::getAttributes(File* file, size_t* flags) {
  if (!file || !flags)
    return;
  ConsoleFile* pFile = reinterpret_cast<ConsoleFile*>(file);
  *flags = pFile->m_Flags;
}
 
void ConsoleManager::setControlChars(File* file, void* p) {
  if (!file || !p)
    return;
  ConsoleFile* pFile = reinterpret_cast<ConsoleFile*>(file);
  MemoryCopy(pFile->m_ControlChars, p, MAX_CONTROL_CHAR);
}
 
void ConsoleManager::getControlChars(File* file, void* p) {
  if (!file || !p)
    return;
  ConsoleFile* pFile = reinterpret_cast<ConsoleFile*>(file);
  MemoryCopy(p, pFile->m_ControlChars, MAX_CONTROL_CHAR);
}
 
int ConsoleManager::getWindowSize(File* file, unsigned short* rows, unsigned short* cols) {
  if (!file)
    return -1;
  ConsoleFile* pFile = reinterpret_cast<ConsoleFile*>(file);
  if (!pFile->isMaster()) {
    if (pFile->m_pOther) {
      pFile = pFile->m_pOther;
    }
  }
 
  *rows = pFile->m_Rows;
  *cols = pFile->m_Cols;
  return 0;
}
 
int ConsoleManager::setWindowSize(File* file, unsigned short rows, unsigned short cols) {
  if (!file)
    return false;
  ConsoleFile* pFile = reinterpret_cast<ConsoleFile*>(file);
  if ((!pFile->isMaster()) && pFile->m_pOther) {
    // Ignore. Slave cannot change window size.
    return 0;
  }
  pFile->m_Rows = rows;
  pFile->m_Cols = cols;
  return 0;
}
 
bool ConsoleManager::hasDataAvailable(File* file) {
  if (!file)
    return false;
  ConsoleFile* pFile = reinterpret_cast<ConsoleFile*>(file);
  return pFile->select(false, 0);
}
 
void ConsoleManager::flush(File* file) {}
 
File* ConsoleManager::getOther(File* file) {
  if (!file)
    return 0;
  ConsoleFile* pFile = reinterpret_cast<ConsoleFile*>(file);
  if (!pFile->m_pOther) {
    return file;  // some consoles (e.g. physical) don't have others
  }
  return pFile->m_pOther;
}
 
static bool initConsole() {
  return true;
}
 
static void destroyConsole() {}
 
MODULE_INFO("console", &initConsole, &destroyConsole, "vfs");