Subversion Repositories w11

// $Id: Rw11RdmaDisk.cpp 648 2015-02-20 20:16:21Z mueller $

//

// Copyright 2015- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>

//

// This program is free software; you may redistribute and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation, either version 2, or at your option any later version.

//

// This program 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

// for complete details.

// 

// Revision History: 

// Date         Rev Version  Comment

// 2015-01-04   628   1.0    Initial version

// ---------------------------------------------------------------------------

/*!

  \file

  \version $Id: Rw11RdmaDisk.cpp 648 2015-02-20 20:16:21Z mueller $

  \brief   Implemenation of Rw11RdmaDisk.

*/

#include "librtools/RosFill.hpp"

#include "librtools/RosPrintf.hpp"

#include "librtools/Rexception.hpp"

#include "Rw11RdmaDisk.hpp"

using namespace std;

/*!

  \class Retro::Rw11RdmaDisk

  \brief FIXME_docs

*/

// all method definitions in namespace Retro

namespace Retro {

//------------------------------------------+-----------------------------------

//! Constructor

Rw11RdmaDisk::Rw11RdmaDisk(Rw11Cntl* pcntl, const precb_t& precb,

                           const postcb_t& postcb)

  : Rw11Rdma(pcntl, precb, postcb),

    fBuf(),

    fpUnit(nullptr),

    fNWord(0),

    fNBlock(0),

    fLba()

{

  fStats.Define(kStatNWritePadded, "NWritePadded" , "padded disk write");

  fStats.Define(kStatNWChkFail,    "NWChkFail"    , "write check failed");

}

//------------------------------------------+-----------------------------------

//! Destructor

Rw11RdmaDisk::~Rw11RdmaDisk()

{}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void Rw11RdmaDisk::QueueDiskRead(uint32_t addr, size_t size, uint16_t mode,

                                 uint32_t lba, Rw11UnitDisk* punit)

{

  SetupDisk(size, lba, punit, kFuncRead);

  QueueWMem(addr, fBuf.data(), size, mode);

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void Rw11RdmaDisk::QueueDiskWrite(uint32_t addr,size_t size, uint16_t mode,

                                  uint32_t lba, Rw11UnitDisk* punit)

{

  SetupDisk(size, lba, punit, kFuncWrite);

  QueueRMem(addr, fBuf.data(), size, mode);

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void Rw11RdmaDisk::QueueDiskWriteCheck(uint32_t addr, size_t size,

                                       uint16_t mode, uint32_t lba,

                                       Rw11UnitDisk* punit)

{

  SetupDisk(size, lba, punit, kFuncWriteCheck);

  QueueRMem(addr, fBuf.data(), size, mode);

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

size_t Rw11RdmaDisk::WriteCheck(size_t nwdone)

{

  if (nwdone == 0) return 0;

  size_t bszwrd = fpUnit->BlockSize()/2;    // block size in words

  size_t nblk   = (nwdone+bszwrd-1)/bszwrd;

  size_t dsize  = nblk*bszwrd;

  std::vector<uint16_t>  dbuf(dsize);

  RerrMsg emsg;

  bool rc = fpUnit->VirtRead(fLba, nblk,

                             reinterpret_cast<uint8_t*>(dbuf.data()), emsg);

  if (!rc) throw Rexception("Rw11RdmaDisk::WriteCheck()",

                            "VirtRead() failed: ", emsg);

  uint16_t* pdsk = dbuf.data();

  uint16_t* pmem = fBuf.data();

  for (size_t i=0; i<nwdone; i++) {

    if (*pdsk++ != *pmem++) {

      fStats.Inc(kStatNWChkFail);

      return i;

    }

  }

  return nwdone;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void Rw11RdmaDisk::Dump(std::ostream& os, int ind, const char* text) const

{

  RosFill bl(ind);

  os << bl << (text?text:"--") << "Rw11RdmaDisk @ " << this << endl;

  os << bl << "  fBuf.size()      " << RosPrintf(fBuf.size(),"d",5) << endl;

  os << bl << "  fpUnit:          " << fpUnit << endl;

  os << bl << "  fNWord:          " << RosPrintf(fNWord,"d",5) << endl;

  os << bl << "  fNBlock:         " << RosPrintf(fNBlock,"d",5) << endl;

  os << bl << "  fLba:            " << RosPrintf(fLba,"d",8) << endl;

  os << bl << "  fFunc:           " << fFunc << endl;

  Rw11Rdma::Dump(os, ind, " ^");

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void Rw11RdmaDisk::SetupDisk(size_t size, uint32_t lba, Rw11UnitDisk* punit,

                             Rw11RdmaDisk::func func)

{

  fpUnit = punit;

  size_t bszwrd = fpUnit->BlockSize()/2;    // block size in words

  fNWord  = size;

  fNBlock = (fNWord+bszwrd-1)/bszwrd;

  fLba    = lba;

  fFunc   = func;

  size_t tsize = fNBlock*bszwrd;

  if (fBuf.size() < tsize) fBuf.resize(tsize);

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void Rw11RdmaDisk::PreRdmaHook()

{

  if (fFunc != kFuncRead) return;          // quit unless read request

  RerrMsg emsg;

  bool rc = fpUnit->VirtRead(fLba, fNBlock,

                             reinterpret_cast<uint8_t*>(fBuf.data()), emsg);

  if (!rc) throw Rexception("Rw11RdmaDisk::PreRdmaHook()",

                            "VirtRead() failed: ", emsg);

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void Rw11RdmaDisk::PostRdmaHook(size_t nwdone)

{

  if (nwdone == 0) return;                  // quit if rdma failed early

  if (fFunc != kFuncWrite) return;          // quit unless write request

  size_t bszwrd = fpUnit->BlockSize()/2;    // block size in words

  size_t nblock = (nwdone+bszwrd-1)/bszwrd;

  size_t npad   = nblock*bszwrd - nwdone;

  // if an incomplete block was read, pad it with hex dead

  if (npad) {

    fStats.Inc(kStatNWritePadded);

    uint16_t* p = fBuf.data()+nwdone;

    for (size_t i=0; i<npad; i++) *p++ = 0xdead;

  }

  RerrMsg emsg;

  bool rc = fpUnit->VirtWrite(fLba, nblock,

                              reinterpret_cast<uint8_t*>(fBuf.data()), emsg);

  if (!rc) throw Rexception("Rw11RdmaDisk::PostRdmaHook()",

                            "VirtWrite() failed: ", emsg);

  return;

}

} // end namespace Retro