1 /******************************************************************************
3 * Copyright (c) 2019 Intel.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
17 *******************************************************************************/
22 #include <sys/types.h>
41 #define WLS_PHY_SHM_FILE_NAME "/tmp/phyappshm"
43 #define HUGE_PAGE_FILE_NAME "/mnt/huge/page"
45 #define DIV_ROUND_OFFSET(X,Y) ( X/Y + ((X%Y)?1:0) )
47 #define WLS_LIB_USER_SPACE_CTX_SIZE DMA_MAP_MAX_BLOCK_SIZE
49 #define PLIB_ERR(x, args...) printf("wls_lib: "x, ## args);
50 #define PLIB_INFO(x, args...) printf("wls_lib: "x, ## args);
53 #define PLIB_DEBUG(x, args...) printf("wls_lib debug: "x, ## args);
55 #define PLIB_DEBUG(x, args...) do { } while(0)
59 #define WLS_LIB_MMAP mmap
61 #define WLS_LIB_MMAP mmap64
64 extern int gethugepagesizes(long pagesizes[], int n_elem);
65 extern int hugetlbfs_unlinked_fd(void);
68 static pthread_mutex_t wls_put_lock;
69 static pthread_mutex_t wls_get_lock;
71 static int wls_dev_fd = 0;
72 static wls_us_ctx_t* wls_us_ctx = NULL;
74 static uint64_t wls_kernel_va_to_user_va(void *pWls_us, uint64_t ptr);
78 static int wls_VirtToPhys(void* virtAddr, uint64_t* physAddr)
82 unsigned int pageSize;
83 unsigned long virtualPageNumber;
85 mapFd = open ("/proc/self/pagemap" , O_RDONLY );
88 PLIB_ERR("Could't open pagemap file\n");
92 /*get standard page size*/
93 pageSize = getpagesize();
95 virtualPageNumber = (unsigned long) virtAddr / pageSize ;
97 lseek(mapFd , virtualPageNumber * sizeof(uint64_t) , SEEK_SET );
99 if(read(mapFd ,&page , sizeof(uint64_t)) < 0 )
102 PLIB_ERR("Could't read pagemap file\n");
106 *physAddr = (( page & 0x007fffffffffffffULL ) * pageSize );
113 static void wls_mutex_destroy(pthread_mutex_t* pMutex)
115 pthread_mutex_destroy(pMutex);
118 static void wls_mutex_init(pthread_mutex_t* pMutex)
120 pthread_mutexattr_t prior;
121 pthread_mutexattr_init(&prior);
122 pthread_mutexattr_setprotocol(&prior, PTHREAD_PRIO_INHERIT);
123 pthread_mutex_init(pMutex, &prior);
124 pthread_mutexattr_destroy(&prior);
127 static void wls_mutex_lock(pthread_mutex_t* pMutex)
129 pthread_mutex_lock(pMutex);
132 static void wls_mutex_unlock(pthread_mutex_t* pMutex)
134 pthread_mutex_unlock(pMutex);
137 static uint64_t wls_kernel_va_to_user_va(void *pWls_us, uint64_t ptr)
139 unsigned long ret = 0;
140 wls_us_ctx_t* pUs = (wls_us_ctx_t*)pWls_us;
142 uint64_t kva = (uint64_t) pUs->wls_us_kernel_va;
143 uint64_t uva = (uint64_t) pUs->wls_us_user_space_va;
145 ret = (uva + (ptr - kva));
147 PLIB_DEBUG("kva %lx to uva %lx [offset %d]\n",kva, ret, (kva - ret));
151 static uint64_t wls_kernel_va_to_user_va_dest(void *pWls_us, uint64_t ptr)
153 unsigned long ret = 0;
154 wls_us_ctx_t* pUs = (wls_us_ctx_t*)pWls_us;
156 uint64_t kva = (uint64_t) pUs->dst_kernel_va;
157 uint64_t uva = (uint64_t) pUs->dst_user_va;
159 ret = (uva + (ptr - kva));
161 PLIB_DEBUG("kva %lx to uva %lx [offset %d]\n",kva, ret, (kva - ret));
166 void* WLS_Open(const char *ifacename, unsigned int mode, unsigned long long nWlsMemorySize)
168 wls_us_ctx_t* pWls_us = NULL;
169 unsigned int ret = 0;
170 wls_open_req_t params;
172 char temp[WLS_DEV_SHM_NAME_LEN];
181 params.size = WLS_LIB_USER_SPACE_CTX_SIZE;
183 if(sizeof(wls_us_ctx_t) >= 64*1024){
184 PLIB_ERR("WLS_Open %ld \n", sizeof(wls_us_ctx_t));
189 PLIB_INFO("Open %s 0x%08lx\n", ifacename, WLS_IOC_OPEN);
191 if ((wls_dev_fd = open(ifacename, O_RDWR | O_SYNC)) < 0){
192 PLIB_ERR("Open filed [%d]\n", wls_dev_fd);
195 /* allocate block in shared space */
196 if((ret = ioctl(wls_dev_fd, WLS_IOC_OPEN, ¶ms)) < 0) {
197 PLIB_ERR("Open filed [%d]\n", ret);
201 PLIB_DEBUG("params: kernel va 0x%016llx pa 0x%016llx size %ld\n",
202 params.ctx, params.ctx_pa, params.size);
205 /* remap to user space the same block */
206 pWls_us = (wls_us_ctx_t*) WLS_LIB_MMAP(NULL,
208 PROT_READ|PROT_WRITE ,
213 if( pWls_us == MAP_FAILED ){
214 PLIB_ERR("mmap has failed (%d:%s) 0x%016lx [size %d]\n", errno, strerror(errno),params.ctx_pa, params.size);
218 PLIB_DEBUG("Local: pWls_us 0x%016p\n", pWls_us);
220 PLIB_DEBUG("size wls_us_ctx_t %d\n", sizeof(wls_us_ctx_t));
221 PLIB_DEBUG(" ul free : off 0x%016lx\n",((unsigned long) &pWls_us->ul_free_block_pq -(unsigned long)pWls_us));
222 PLIB_DEBUG(" get_queue: off 0x%016lx\n",((unsigned long) &pWls_us->get_queue -(unsigned long)pWls_us));
223 PLIB_DEBUG(" put_queue: off 0x%016lx\n",((unsigned long) &pWls_us->put_queue -(unsigned long)pWls_us));
225 //memset(pWls_us, 0, params.size);
227 pWls_us->padding_wls_us_user_space_va = 0LL;
229 pWls_us->wls_us_user_space_va = pWls_us;
231 pWls_us->wls_us_kernel_va = (uint64_t) params.ctx;
232 pWls_us->wls_us_pa = (uint64_t) params.ctx_pa;
233 pWls_us->wls_us_ctx_size = params.size;
235 PLIB_INFO("User Space Lib Context: us va 0x%016lx kernel va 0x%016lx pa 0x%016lx size %d \n",
236 (uintptr_t)pWls_us->wls_us_user_space_va,
237 pWls_us->wls_us_kernel_va,
239 pWls_us->wls_us_ctx_size);
241 wls_mutex_init(&wls_put_lock);
242 wls_mutex_init(&wls_get_lock);
244 pWls_us->mode = mode;
245 PLIB_INFO("\nMode %d\n", pWls_us->mode);
247 PLIB_INFO("\nWLS device %s [%d]\n", ifacename, (int)strlen(ifacename));
248 strncpy(temp, ifacename, WLS_DEV_SHM_NAME_LEN - 1);
249 len = strlen(ifacename);
250 if (len < WLS_DEV_SHM_NAME_LEN - 1)
251 strncpy(pWls_us->wls_dev_name, temp, len);
253 strncpy(pWls_us->wls_dev_name, temp, WLS_DEV_SHM_NAME_LEN - 1);
254 for(i = 0; i < MIN(strlen(pWls_us->wls_dev_name),WLS_DEV_SHM_NAME_LEN); i++)
255 if(pWls_us->wls_dev_name[i] != '/')
256 pWls_us->wls_shm_name[i] = pWls_us->wls_dev_name[i];
258 pWls_us->wls_shm_name[i] = '_';
260 wls_us_ctx = pWls_us;
263 PLIB_ERR("Open filed: incorrect allocation \n");
271 int WLS_Ready(void* h)
274 wls_event_req_t params;
276 if (!wls_us_ctx || !wls_dev_fd){
277 PLIB_ERR("Library was not opened\n");
281 params.event_to_wls = WLS_EVENT_IA_READY;
282 params.event_param = 0;
284 /* free block in shared space */
285 if((ret = ioctl(wls_dev_fd, WLS_IOC_EVENT, ¶ms)) < 0) {
286 PLIB_ERR("Event filed [%d]\n", ret);
293 int WLS_Close(void* h)
295 wls_us_ctx_t* pWls_us = (wls_us_ctx_t*)h;
296 wls_close_req_t params;
299 if (!wls_us_ctx || !wls_dev_fd){
300 PLIB_ERR("Library was not opened\n");
304 if ((unsigned long)pWls_us != (unsigned long )wls_us_ctx){
305 PLIB_ERR("Incorret handle %lx [expected %lx]\n", (unsigned long)pWls_us, (unsigned long )wls_us_ctx);
309 params.ctx = pWls_us->wls_us_kernel_va;
310 params.ctx_pa = pWls_us->wls_us_pa;
311 params.size = pWls_us->wls_us_ctx_size;
313 /* free block in shared space */
314 if((ret = ioctl(wls_dev_fd, WLS_IOC_CLOSE, ¶ms)) < 0) {
315 PLIB_ERR("Close filed [%d]\n", ret);
319 /* unmap to user space */
320 munmap(pWls_us, pWls_us->wls_us_ctx_size);
322 wls_mutex_destroy(&wls_put_lock);
323 wls_mutex_destroy(&wls_get_lock);
334 void* WLS_Alloc(void* h, unsigned int size)
336 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
342 hugepage_tabl_t* pHugePageTlb = &pWls_us->hugepageTbl[0];
344 void* pvirtAddr = NULL;
348 char shm_file_name[256];
350 fd = hugetlbfs_unlinked_fd();
353 PLIB_ERR("Unable to open temp file in hugetlbfs (%s)", strerror(errno));
355 gethugepagesizes(pageSize,1);
356 hugePageSize = pageSize[0];
358 PLIB_INFO("hugePageSize on the system is %ld\n", hugePageSize);
360 /* calculate total number of hugepages */
361 nHugePage = DIV_ROUND_OFFSET(size, hugePageSize);
363 if (nHugePage >= MAX_N_HUGE_PAGES){
364 PLIB_INFO("not enough hugepages: need %ld system has %d\n", nHugePage, MAX_N_HUGE_PAGES);
368 if(pHugePageTlb == NULL )
370 PLIB_INFO("Table memory allocation failed\n");
376 snprintf(shm_file_name, WLS_DEV_SHM_NAME_LEN, "%s_%s", WLS_PHY_SHM_FILE_NAME, pWls_us->wls_shm_name);
377 PLIB_INFO("shm open %s\n", shm_file_name);
378 ipc_file = open(shm_file_name, O_CREAT); // | O_EXCL maybe sometimes in future.. ;-)
380 PLIB_ERR("open failed (%s)\n", strerror(errno) );
384 key_t key = ftok(shm_file_name, '4');
385 int shm_handle = shmget(key, size, SHM_HUGETLB|SHM_R|SHM_W);
386 if(shm_handle == -1){
387 PLIB_INFO("Create shared memory\n");
388 shm_handle = shmget(key, size, SHM_HUGETLB | IPC_CREAT | SHM_R | SHM_W);
391 PLIB_INFO("Attach to shared memory\n");
393 if(shm_handle == -1){
394 PLIB_ERR("shmget has failed (%s) [size %ld]\n", strerror(errno), nHugePage * hugePageSize);
398 pvirtAddr = shmat(shm_handle, 0, /*SHM_RND*/0);
401 /* Allocate required number of pages */
402 pvirtAddr = mmap(0,(nHugePage * hugePageSize), (PROT_READ|PROT_WRITE), MAP_SHARED, fd,0);
404 if(pvirtAddr == MAP_FAILED )
406 PLIB_ERR("mmap has failed (%s) [size %ld]\n", strerror(errno), nHugePage * hugePageSize);
410 PLIB_INFO("pvirtAddr 0x%016lx\n", (unsigned long)pvirtAddr);
412 for(count = 0 ; count < nHugePage ; count++ )
414 /*Incremented virtual address to next hugepage to create table*/
415 pHugePageTlb[count].pageVa = ((unsigned char*)pvirtAddr + \
416 ( count * hugePageSize ));
417 /*Creating dummy page fault in process for each page
418 inorder to get pagemap*/
419 *(unsigned char*)pHugePageTlb[count].pageVa = 1;
421 if(wls_VirtToPhys((uint64_t*) pHugePageTlb[count].pageVa,
422 &pHugePageTlb[count].pagePa ) == -1)
424 munmap(pvirtAddr, (nHugePage * hugePageSize));
425 PLIB_ERR("Virtual to physical conversion failed\n");
429 //PLIB_INFO("id %d va 0x%016p pa 0x%016llx [%ld]\n", count, (uintptr_t)pHugePageTlb[count].pageVa, (uint64_t) pHugePageTlb[count].pagePa, hugePageSize);
432 PLIB_INFO("WLS_Alloc: 0x%016lx [%d]\n", (unsigned long)pvirtAddr, size);
436 pWls_us->HugePageSize = (uint32_t)hugePageSize;
437 pWls_us->alloc_buffer = pvirtAddr;
438 pWls_us->alloc_size = (uint32_t)(nHugePage * hugePageSize);
440 if (pWls_us->mode == WLS_MASTER_CLIENT){
441 wls_us_ctx_t* pWls_usRem = NULL;
442 PLIB_INFO("Connecting to remote peer ...\n");
443 while (pWls_us->dst_pa == 0) // wait for slave
446 /* remap to user space the same block */
447 pWls_usRem = (wls_us_ctx_t*) WLS_LIB_MMAP(NULL,
448 sizeof(wls_us_ctx_t),
449 PROT_READ|PROT_WRITE ,
454 if( pWls_us == MAP_FAILED ){
455 PLIB_ERR("mmap has failed (%d:%s) 0x%016lx \n", errno, strerror(errno),pWls_us->dst_pa);
459 PLIB_INFO("Remote: pWls_us 0x%p\n", pWls_usRem);
461 PLIB_INFO("size wls_us_ctx_t %ld\n", sizeof(wls_us_ctx_t));
462 PLIB_INFO(" ul free : off 0x%016lx\n",((unsigned long) &pWls_usRem->ul_free_block_pq -(unsigned long)pWls_usRem));
463 PLIB_INFO(" get_queue: off 0x%016lx\n",((unsigned long) &pWls_usRem->get_queue -(unsigned long)pWls_usRem));
464 PLIB_INFO(" put_queue: off 0x%016lx\n",((unsigned long) &pWls_usRem->put_queue -(unsigned long)pWls_usRem));
466 pWls_us->dst_user_va = (uint64_t) pWls_usRem ;
473 int WLS_Free(void* h, PVOID pMsg)
475 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
477 if ((unsigned long)pMsg != (unsigned long)pWls_us->alloc_buffer) {
478 PLIB_ERR("incorrect pMsg %lx [expected %lx]\n", (unsigned long)pMsg ,(unsigned long)pWls_us->alloc_buffer);
482 if (pWls_us->mode == WLS_MASTER_CLIENT){
483 if(pWls_us->dst_user_va){
484 munmap((void*)pWls_us->dst_user_va, sizeof(wls_us_ctx_t));
485 pWls_us->dst_user_va = 0;
489 PLIB_DEBUG("WLS_Free 0x%016lx", (unsigned long)pMsg);
494 munmap(pMsg, pWls_us->alloc_size);
502 int WLS_Put(void* h, unsigned long long pMsg, unsigned int MsgSize, unsigned short MsgTypeID, unsigned short Flags)
504 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
507 if ((unsigned long)h != (unsigned long)wls_us_ctx) {
508 PLIB_ERR("Incorrect user space context %lx [%lx]\n", (unsigned long)h, (unsigned long)wls_us_ctx);
512 if(!WLS_IS_ONE_HUGE_PAGE(pMsg, MsgSize, WLS_HUGE_DEF_PAGE_SIZE)) {
513 PLIB_ERR("WLS_Put input error: buffer is crossing 2MB page boundary 0x%016llx size %ld\n", pMsg, (unsigned long)MsgSize);
516 wls_mutex_lock(&wls_put_lock);
518 if ((WLS_FLAGS_MASK & Flags)){ // multi block transaction
519 if (Flags & WLS_TF_SYN){
520 PLIB_DEBUG("WLS_SG_FIRST\n");
521 if (WLS_MsgEnqueue(&pWls_us->put_queue, pMsg, MsgSize, MsgTypeID, Flags, wls_kernel_va_to_user_va, (void*)pWls_us))
523 PLIB_DEBUG("WLS_Get %lx %d type %d\n",(U64) pMsg, MsgSize, MsgTypeID);
525 } else if ((Flags & WLS_TF_SCATTER_GATHER) && !(Flags & WLS_TF_SYN) && !(Flags & WLS_TF_FIN)){
526 PLIB_DEBUG("WLS_SG_NEXT\n");
527 if (WLS_MsgEnqueue(&pWls_us->put_queue, pMsg, MsgSize, MsgTypeID, Flags, wls_kernel_va_to_user_va, (void*)pWls_us))
529 PLIB_DEBUG("WLS_Put %lx %d type %d\n",(U64) pMsg, MsgSize, MsgTypeID);
531 } else if (Flags & WLS_TF_FIN) {
532 wls_put_req_t params;
533 PLIB_DEBUG("WLS_SG_LAST\n");
534 params.wls_us_kernel_va = pWls_us->wls_us_kernel_va;
535 if (WLS_MsgEnqueue(&pWls_us->put_queue, pMsg, MsgSize, MsgTypeID, Flags, wls_kernel_va_to_user_va, (void*)pWls_us))
537 PLIB_DEBUG("WLS_Put %lx %d type %d\n",(U64) pMsg, MsgSize, MsgTypeID);
540 PLIB_DEBUG("List: call WLS_IOC_PUT\n");
541 if((ret = ioctl(wls_dev_fd, WLS_IOC_PUT, ¶ms)) < 0) {
542 PLIB_ERR("Put filed [%d]\n", ret);
543 wls_mutex_unlock(&wls_put_lock);
547 PLIB_ERR("unsaported flags %x\n", WLS_FLAGS_MASK & Flags);
548 } else { // one block transaction
549 wls_put_req_t params;
550 params.wls_us_kernel_va = pWls_us->wls_us_kernel_va;
551 if (WLS_MsgEnqueue(&pWls_us->put_queue, pMsg, MsgSize, MsgTypeID, Flags, wls_kernel_va_to_user_va, (void*)pWls_us))
553 PLIB_DEBUG("WLS_Put %lx %d type %d\n",(U64) pMsg, MsgSize, MsgTypeID);
556 PLIB_DEBUG("One block: call WLS_IOC_PUT\n");
557 if((ret = ioctl(wls_dev_fd, WLS_IOC_PUT, ¶ms)) < 0) {
558 PLIB_ERR("Put filed [%d]\n", ret);
559 wls_mutex_unlock(&wls_put_lock);
563 wls_mutex_unlock(&wls_put_lock);
568 int WLS_Check(void* h)
570 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
572 if ((unsigned long)h != (unsigned long)wls_us_ctx) {
573 PLIB_ERR("Incorrect user space context %lx [%lx]\n", (unsigned long)h, (unsigned long)wls_us_ctx);
577 PLIB_DEBUG("offset get_queue %lx\n",(U64)&pWls_us->get_queue - (U64)pWls_us);
579 return WLS_GetNumItemsInTheQueue(&pWls_us->get_queue);
583 unsigned long long WLS_Get(void* h, unsigned int *MsgSize, unsigned short *MsgTypeID, unsigned short *Flags)
585 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
587 uint64_t pMsg = NULL;
589 if ((unsigned long)h != (unsigned long)wls_us_ctx) {
590 PLIB_ERR("Incorrect user space context %lx [%lx]\n", (unsigned long)h, (unsigned long)wls_us_ctx);
594 PLIB_DEBUG("offset get_queue %lx\n",(U64)&pWls_us->get_queue - (U64)pWls_us);
595 wls_mutex_lock(&wls_get_lock);
597 if (WLS_MsgDequeue(&pWls_us->get_queue, &hMsg, wls_kernel_va_to_user_va, (void*)pWls_us))
599 PLIB_DEBUG("WLS_Get %lx %d type %d\n",(U64) hMsg.pIaPaMsg, hMsg.MsgSize, hMsg.TypeID);
600 pMsg = hMsg.pIaPaMsg;
601 *MsgSize = hMsg.MsgSize;
602 *MsgTypeID = hMsg.TypeID;
606 wls_mutex_unlock(&wls_get_lock);
611 int WLS_WakeUp(void* h)
614 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
615 wls_wake_up_req_t params;
617 if (!wls_us_ctx || !wls_dev_fd){
618 PLIB_ERR("Library was not opened\n");
622 params.ctx = (uint64_t)pWls_us;
623 params.wls_us_kernel_va = (uint64_t)pWls_us->wls_us_kernel_va;
625 PLIB_DEBUG("WLS_WakeUp\n");
627 if((ret = ioctl(wls_dev_fd, WLS_IOC_WAKE_UP, ¶ms)) < 0) {
628 PLIB_ERR("Wake Up filed [%d]\n", ret);
635 int WLS_Wait(void* h)
638 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
639 wls_wait_req_t params;
641 if (!wls_us_ctx || !wls_dev_fd){
642 PLIB_ERR("Library was not opened\n");
646 params.ctx = (uint64_t)pWls_us;
647 params.wls_us_kernel_va = (uint64_t)pWls_us->wls_us_kernel_va;
651 PLIB_DEBUG("WLS_Wait\n");
653 if((ret = ioctl(wls_dev_fd, WLS_IOC_WAIT, ¶ms)) < 0) {
654 PLIB_ERR("Wait filed [%d]\n", ret);
661 unsigned long long WLS_WGet(void* h, unsigned int *MsgSize, unsigned short *MsgTypeID, unsigned short *Flags)
663 uint64_t pRxMsg = WLS_Get(h, MsgSize, MsgTypeID, Flags);
669 return WLS_Get(h, MsgSize, MsgTypeID, Flags);
672 unsigned long long WLS_VA2PA(void* h, PVOID pMsg)
675 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
677 unsigned long alloc_base;
678 hugepage_tabl_t* pHugePageTlb;
679 uint64_t hugePageBase;
680 uint64_t hugePageOffet;
681 unsigned int count = 0;
683 uint64_t HugePageMask = ((unsigned long)pWls_us->HugePageSize - 1);
685 if(pWls_us->alloc_buffer == NULL){
686 PLIB_ERR("WLS_VA2PA: nothing was allocated [%ld]\n", ret);
687 return (uint64_t)ret;
690 alloc_base = (unsigned long)pWls_us->alloc_buffer;
692 pHugePageTlb = &pWls_us->hugepageTbl[0];
694 hugePageBase = (uint64_t)pMsg & ~HugePageMask;
695 hugePageOffet = (uint64_t)pMsg & HugePageMask;
697 count = (hugePageBase - alloc_base) / pWls_us->HugePageSize;
699 PLIB_DEBUG("WLS_VA2PA %lx base %llx off %llx count %d\n", (unsigned long)pMsg,
700 (uint64_t)hugePageBase, (uint64_t)hugePageOffet, count);
702 ret = pHugePageTlb[count].pagePa + hugePageOffet;
704 return (uint64_t) ret;
707 void* WLS_PA2VA(void* h, unsigned long long pMsg)
709 unsigned long ret = NULL;
710 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
712 hugepage_tabl_t* pHugePageTlb;
713 uint64_t hugePageBase;
714 uint64_t hugePageOffet;
717 uint64_t HugePageMask = ((uint64_t)pWls_us->HugePageSize - 1);
719 if(pWls_us->alloc_buffer == NULL){
720 PLIB_ERR("WLS_PA2VA: nothing was allocated [%ld]\n", ret);
724 pHugePageTlb = &pWls_us->hugepageTbl[0];
726 hugePageBase = (uint64_t)pMsg & ~HugePageMask;
727 hugePageOffet = (uint64_t)pMsg & HugePageMask;
729 count = pWls_us->alloc_size / pWls_us->HugePageSize;
731 PLIB_DEBUG("WLS_PA2VA %llx base %llx off %llx count %d\n", (uint64_t)pMsg,
732 (uint64_t)hugePageBase, (uint64_t)hugePageOffet, count);
734 for (i = 0; i < count; i++) {
735 if (pHugePageTlb[i].pagePa == hugePageBase)
737 ret = (unsigned long)pHugePageTlb[i].pageVa;
738 ret += hugePageOffet;
743 return (void*) (ret);
746 int WLS_EnqueueBlock(void* h, unsigned long long pMsg)
749 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
751 if (!wls_us_ctx || !wls_dev_fd){
752 PLIB_ERR("Library was not opened\n");
756 if(pWls_us->mode == WLS_SLAVE_CLIENT){
757 PLIB_ERR("Slave doesn't support memory allocation\n");
762 PLIB_ERR("WLS_EnqueueBlock: Null\n");
766 if(pWls_us->dst_kernel_va){
767 if (pWls_us->dst_user_va)
769 wls_us_ctx_t* pDstWls_us = (wls_us_ctx_t* )pWls_us->dst_user_va;
770 ret = SFL_WlsEnqueue(&pDstWls_us->ul_free_block_pq, pMsg, wls_kernel_va_to_user_va_dest, pWls_us);
772 unsigned long* ptr = (unsigned long*)WLS_PA2VA(pWls_us, pMsg);
774 *ptr = 0xFFFFFFFFFFFFFFFF;
784 PLIB_DEBUG("SFL_WlsEnqueue %d\n", ret);
788 unsigned long long WLS_DequeueBlock(void* h)
790 unsigned long long retval = NULL;
791 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
793 if(pWls_us->mode == WLS_SLAVE_CLIENT){
795 retval = SFL_WlsDequeue(&pWls_us->ul_free_block_pq, wls_kernel_va_to_user_va, h );
796 } else if(pWls_us->dst_kernel_va) {
798 if (pWls_us->dst_user_va)
800 wls_us_ctx_t* pDstWls_us = (wls_us_ctx_t* )pWls_us->dst_user_va;
801 retval = SFL_WlsDequeue(&pDstWls_us->ul_free_block_pq, wls_kernel_va_to_user_va_dest, pWls_us);
803 unsigned long* ptr = (unsigned long*)WLS_PA2VA(pWls_us, retval);
805 if(*ptr != 0xFFFFFFFFFFFFFFFF){
806 PLIB_ERR("WLS_EnqueueBlock: incorrect content pa: 0x%016lx: 0x%016lx\n", (unsigned long)retval, *ptr);
816 int WLS_NumBlocks(void* h)
818 wls_us_ctx_t* pWls_us = (wls_us_ctx_t* )h;
821 if(pWls_us->mode == WLS_SLAVE_CLIENT){
823 n = SFL_GetNumItemsInTheQueue(&pWls_us->ul_free_block_pq);
824 } else if(pWls_us->dst_kernel_va) {
826 if (pWls_us->dst_user_va)
828 wls_us_ctx_t* pDstWls_us = (wls_us_ctx_t* )pWls_us->dst_user_va;
829 n = SFL_GetNumItemsInTheQueue(&pDstWls_us->ul_free_block_pq);