ConsoleMaster.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/processor/types.h"
#include "pedigree/kernel/utilities/Buffer.h"
#include "pedigree/kernel/utilities/String.h"
 
#include "Console.h"
 
class Filesystem;
 
ConsoleMasterFile::ConsoleMasterFile(size_t consoleNumber, String consoleName, Filesystem* pFs)
    : ConsoleFile(consoleNumber, consoleName, pFs),
      bLocked(false),
      pLocker(0),
      bSlaveLocked(false) {}
 
uint64_t ConsoleMasterFile::readIo(ConsoleIoState& state, uint64_t size, uintptr_t buffer,
                                   bool bCanBlock) {
  // Check for NL->CRNL conversion which requires special logic.
  size_t slaveFlags = m_pOther->m_Flags;
  if (!(slaveFlags & ConsoleManager::OPostProcess) ||
      !(slaveFlags & ConsoleManager::OMapNLToCRNL)) {
    // Easy read/write - output line discipline will not need to do any
    // conversions that involve expansion.
    uint64_t nBytes = state.output.read(reinterpret_cast<char*>(buffer), size, bCanBlock);
    if (!nBytes) {
      return 0;
    }
 
    dataChanged();
    if (m_pOther) {
      m_pOther->dataChanged();
    }
 
    return outputLineDiscipline(reinterpret_cast<char*>(buffer), nBytes, size, m_pOther->m_Flags);
  }
 
  uint64_t totalBytes = 0;
  while (totalBytes < size) {
    // We assume that the worst-case buffer might be read, which contains
    // 100% newlines that would expand to carriage return + newline.
    // Once one byte remains, consume it directly; the line discipline keeps
    // the result bounded by the caller's buffer in that case.
    const uint64_t readSize = size > 1 ? size / 2 : 1;
    uint64_t nBytes =
        state.output.read(reinterpret_cast<char*>(buffer + totalBytes), readSize, bCanBlock);
    if (!nBytes) {
      break;
    }
 
    // Perform line discipline using the full, unhalved size so we can
    // expand all available newlines.
    size_t disciplineSize = outputLineDiscipline(reinterpret_cast<char*>(buffer + totalBytes),
                                                 nBytes, size, m_pOther->m_Flags);
    totalBytes += disciplineSize;
    size -= disciplineSize;
 
    // After the first iteration, disallow any further blocking so we read
    // the remainder of the buffer then terminate quickly.
    bCanBlock = false;
  }
 
  if (totalBytes) {
    dataChanged();
    if (m_pOther) {
      m_pOther->dataChanged();
    }
  }
 
  return totalBytes;
}
 
uint64_t ConsoleMasterFile::writeIo(ConsoleIoState& state, uint64_t size, uintptr_t buffer,
                                    bool bCanBlock) {
  if (!state.input.canWrite(bCanBlock)) {
    return 0;
  }
 
  // Pass on to the input discipline, which will write to the slave.
  size_t amount = inputLineDiscipline(state, reinterpret_cast<char*>(buffer), size, bCanBlock);
 
  return state.revoked() ? 0 : amount;
}
 
uint64_t ConsoleMasterFile::readBytewise(uint64_t, uint64_t size, uintptr_t buffer, bool canBlock) {
  return readEpoch(captureOpenEpoch(), size, buffer, canBlock);
}
 
uint64_t ConsoleMasterFile::writeBytewise(uint64_t, uint64_t size, uintptr_t buffer,
                                          bool canBlock) {
  return writeEpoch(captureOpenEpoch(), size, buffer, canBlock);
}