Line data    Source code

       1             : #include <fstream>
       2             : #include <iostream>
       3             : #include <regex>
       4             : #include <cstdlib> // malloc/free
       5             : #include <cstdio>
       6             : 
       7             : #include "cmem_buffer.hpp"
       8             : #include "flxcard/FlxCard.h"
       9             : #include "log.hpp"
      10             : 
      11           0 : CmemBuffer::CmemBuffer(size_t size, const std::string& cmem_name, bool free_previous_cmem): DmaBuffer(size), free_previous_cmem(free_previous_cmem)  {
      12           0 :     int ret;
      13             : 
      14           0 :     ret = CMEM_OpenNopage();
      15           0 :     LOG_DBG("Allocating CMEM buffer %s", cmem_name.c_str());
      16             :     // free previous buffer if any and requested
      17           0 :     if (!ret && free_previous_cmem) {
      18           0 :         ret = CMEM_SegmentUnlockAndFree(const_cast<char*>(cmem_name.c_str()));
      19           0 :         if (!ret) {
      20           0 :             LOG_INFO("Freed previous CMEM buffer: %s", cmem_name.c_str());
      21           0 :         } else if (RCC_ERROR_MINOR(ret) == CMEM_RCC_ILLNAME) {
      22             :             ret = 0;
      23             :         } else {
      24           0 :             rcc_error_print(stdout, ret);
      25             :         }
      26             :     }
      27             : 
      28             :     // allocate new one
      29           0 :     if (!ret) {
      30           0 :         ret = CMEM_GFPBPASegmentAllocate(size, const_cast<char*>(cmem_name.c_str()), &handle);
      31             :     }
      32             : 
      33           0 :     if (!ret) {
      34           0 :         ret = CMEM_SegmentPhysicalAddress(handle, &paddr);
      35             :     }
      36             : 
      37           0 :     if (!ret) {
      38           0 :         ret = CMEM_SegmentVirtualAddress(handle, &vaddr);
      39             :     }
      40             : 
      41           0 :     if (!ret) {
      42           0 :         ret = CMEM_SegmentLock(handle);
      43             :     }
      44             : 
      45           0 :     if (ret) {
      46           0 :         rcc_error_print(stdout, ret);
      47           0 :         exit(1);
      48             :     }
      49           0 : }
      50             : 
      51             : 
      52           0 : CmemBuffer::~CmemBuffer() {
      53           0 :     LOG_DBG("Releasing CMEM buffer with handle %d", handle);
      54           0 :     int ret = CMEM_SegmentUnlock(handle);
      55             : 
      56             :     /* int ret = 0;
      57             : 
      58             :     if(!ret)
      59             :         ret = CMEM_GFPBPASegmentFree(handle);
      60             : 
      61             :     if(!ret) {
      62             :         ret = CMEM_Close();
      63             :     }
      64             :     */
      65             : 
      66           0 :     if (ret) {
      67           0 :         rcc_error_print(stdout, ret);
      68           0 :         exit(1);
      69             :     }
      70           0 : }
      71             : 
      72             : 
      73           0 : bool CmemBuffer::cmem_buffer_exists(const std::string& cmem_name) {
      74             :     //   2771 |      0 |    0x00000002ee800000 | 0x0000000010000000 |    yes |    4 | felix-file2host-0-0
      75             :     // \s?\d+\s+\|\s+\d+\s+\|\s+0x\w+\s+\|\s+0x\w+\s+\|\s+\w+\s+\|\s+\d+\s+\|\s
      76           0 :     std::string regex("^");       // start
      77           0 :     regex += "\\s?\\d+\\s+\\|";   // first number
      78           0 :     regex += "\\s+\\d+\\s+\\|";   // number
      79           0 :     regex += "\\s+0x\\w+\\s+\\|"; // hex-number
      80           0 :     regex += "\\s+0x\\w+\\s+\\|"; // hex-number
      81           0 :     regex += "\\s+\\w+\\s+\\|";   // string
      82           0 :     regex += "\\s+\\d+\\s+\\|";   // number
      83           0 :     regex += "\\s+";              // whitespace
      84           0 :     regex.append(cmem_name);      // cmem_name
      85           0 :     regex += "$";                 // end
      86             : 
      87           0 :     std::ifstream file("/proc/cmem_rcc");
      88           0 :     if (!file.is_open()) {
      89           0 :         fprintf(stderr, "Can't open /proc/cmem_rcc\n" );
      90             :         return false;
      91             :     }
      92             : 
      93           0 :     std::string line;
      94           0 :     while (std::getline(file, line)) {
      95           0 :         if (std::regex_match(line, std::regex(regex))) {
      96             :             return true;
      97             :         }
      98             :     }
      99             : 
     100             :     return false;
     101           0 : }
     102             : 
     103             : 
     104          27 : VmemBuffer::VmemBuffer(size_t size) : DmaBuffer(size) {
     105          27 :     ptr = malloc(size);
     106          27 :     if (!ptr) {
     107           0 :         LOG_ERR("Error vmem memory allocation of %zu failed", size);
     108           0 :         throw std::runtime_error("Cannot allocate vmem buffer");
     109             :     }
     110          27 :     paddr = 0;
     111          27 :     vaddr = (uint64_t)ptr;
     112          27 : }
     113             : 
     114             : 
     115          54 : VmemBuffer::~VmemBuffer() {
     116          27 :     if (vaddr) {
     117          27 :         free(ptr);
     118          27 :         vaddr = 0;
     119          27 :         ptr = 0;
     120             :     }
     121          54 : }
     122             :