Add internal mmap/munmap functions with DSP address tracking

Introduce fastrpc_mmap_internal() and fastrpc_munmap_internal() to handle
buffer mapping with DSP virtual address management. These functions maintain
mappings in the static map list and enable lookup by DSP virtual address.

Extract common mmap logic into fastrpc_mmap_helper() to eliminate code
duplication between fastrpc_mmap() and fastrpc_mmap_internal().

Simplify apps_mem_request_map64() by removing conditional allocation logic
and always allocating in userspace, then using fastrpc_mmap_internal() for
mapping. Update apps_mem_request_unmap64() to route to appropriate unmap
function based on mapping type:
- FASTRPC_ALLOC_HLOS_FD: use fastrpc_munmap()
- ADSP_MMAP_HEAP_ADDR/ADSP_MMAP_REMOTE_HEAP_ADDR: use remote_munmap64()
- Other allocations: use fastrpc_munmap_internal()

Signed-off-by: Vinayak Katoch <[email protected]>

Author: quic-vkatoch

inc/fastrpc_mem.h

@@ -73,4 +73,33 @@ int fastrpc_buffer_ref(int domain, int fd, int ref, void **va, size_t *size);
  */
 void remote_register_buf(void *buf, int size, int fd);
 
+/*
+ * Internal function to map a buffer and return the DSP virtual address.
+ * Creates a mapping on the DSP and stores the mapping information in the static map list.
+ *
+ * @param domain The DSP domain ID (-1 for current domain)
+ * @param fd File descriptor of the buffer
+ * @param vaddr Virtual address of the buffer on CPU side
+ * @param offset Offset from the beginning of the buffer (must be 0)
+ * @param length Size of buffer in bytes
+ * @param flags Mapping flags (uint32_t)
+ * @param raddr Output: DSP virtual address of the mapped buffer
+ *
+ * @return 0 on success, error code on failure
+ */
+int fastrpc_mmap_internal(int domain, int fd, void *vaddr, int offset, size_t length, uint32_t flags, uint64_t *raddr);
+
+/*
+ * Internal function to unmap a buffer using the DSP virtual address.
+ * Looks up the mapping in the static map list using the DSP virtual address,
+ * then performs the unmap operation and removes the mapping from the list.
+ *
+ * @param domain The DSP domain ID (-1 for current domain)
+ * @param raddr DSP virtual address of the mapped buffer
+ * @param length Size of buffer in bytes to unmap
+ *
+ * @return 0 on success, error code on failure
+ */
+int fastrpc_munmap_internal(int domain, uint64_t raddr, size_t length);
+
 #endif //FASTRPC_MEM_H

src/apps_mem_imp.c

@@ -163,23 +163,13 @@ __QAIC_IMPL(apps_mem_request_map64)(int heapid, uint32_t lflags, uint32_t rflags
      */
     *vadsp = (uint64_t)fd;
   } else {
-    /* Memory for unsignedPD's user-heap will be allocated in userspace for
-     * security reasons. Memory for signedPD's user-heap will be allocated in
-     * kernel.
-     */
-    if (((rflags != ADSP_MMAP_ADD_PAGES) &&
-         (rflags != ADSP_MMAP_ADD_PAGES_LLC)) ||
-        (((rflags == ADSP_MMAP_ADD_PAGES) ||
-          (rflags == ADSP_MMAP_ADD_PAGES_LLC)) &&
-         (unsigned_module && ualloc_support))) {
-      VERIFYC(NULL != (buf = rpcmem_alloc_internal(heapid, lflags, len)),
-              AEE_ENORPCMEMORY);
-      fd = rpcmem_to_fd_internal(buf);
-      VERIFYC(fd > 0, AEE_EBADPARM);
-    }
+    VERIFYC(NULL != (buf = rpcmem_alloc_internal(heapid, lflags, len)),
+            AEE_ENORPCMEMORY);
+    fd = rpcmem_to_fd_internal(buf);
+    VERIFYC(fd > 0, AEE_EBADPARM);
     VERIFY(AEE_SUCCESS ==
-           (nErr = remote_mmap64_internal(fd, rflags, (uint64_t)buf, len,
-                                          (uint64_t *)vadsp)));
+           (nErr = fastrpc_mmap_internal(domain, fd, buf, 0, len,
+                                         rflags, vadsp)));
     pbuf = (uint64_t)buf;
     *vapps = pbuf;
     minfo->vapps = *vapps;
@@ -250,17 +240,27 @@ __QAIC_IMPL(apps_mem_request_unmap64)(uint64_t vadsp,
   pthread_mutex_unlock(&me->mem_mut);
 
   /* If apps_mem_request_map64 was called with flag FASTRPC_ALLOC_HLOS_FD,
-   * use fastrpc_munmap else use remote_munmap64 to unmap.
+   * use fastrpc_munmap. For ADSP_MMAP_HEAP_ADDR and ADSP_MMAP_REMOTE_HEAP_ADDR,
+   * use remote_munmap64. For other cases, use fastrpc_munmap_with_raddr.
    */
    if(mfree && mfree->rflags == FASTRPC_ALLOC_HLOS_FD) {
       fd = (int)vadsp;
       VERIFY(AEE_SUCCESS == (nErr = fastrpc_munmap(domain, fd, 0, len)));
+   } else if (mfree && (mfree->rflags == ADSP_MMAP_HEAP_ADDR ||
+                        mfree->rflags == ADSP_MMAP_REMOTE_HEAP_ADDR)) {
+      /* These cases use remote_mmap64_internal, so use remote_munmap64 */
+      VERIFY(AEE_SUCCESS == (nErr = remote_munmap64((uint64_t)vadsp, len)));
    } else if (mfree || fastrpc_get_pd_type(domain) == AUDIO_STATICPD){
       /*
        * Map info not available for Audio static PD after daemon reconnect,
        * So continue to unmap to avoid driver global maps leak.
+       * For other cases, use fastrpc_munmap_with_raddr as they were mapped with fastrpc_mmap_with_raddr.
        */
-      VERIFY(AEE_SUCCESS == (nErr = remote_munmap64((uint64_t)vadsp, len)));
+      if (mfree) {
+         VERIFY(AEE_SUCCESS == (nErr = fastrpc_munmap_internal(domain, (uint64_t)vadsp, len)));
+      } else {
+         VERIFY(AEE_SUCCESS == (nErr = remote_munmap64((uint64_t)vadsp, len)));
+      }
       if (!mfree)
          goto bail;
    }