Line data    Source code

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