1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <stdlib.h>
17 #include <stdbool.h>
18 #include <string.h>
19 #include <errno.h>
20 #include <unistd.h>
21 #include <fcntl.h>
22 #include <sys/ioctl.h>
23 #include "securec.h"
24 #include "hilog/log.h"
25 #include "dmabuf_alloc.h"
26 #include "memory_trace.h"
27
28 #define DMA_BUF_HEAP_ROOT "/dev/dma_heap/"
29 #define HEAP_ROOT_LEN strlen(DMA_BUF_HEAP_ROOT)
30 #define HEAP_NAME_MAX_LEN 128
31 #define HEAP_PATH_LEN (HEAP_ROOT_LEN + HEAP_NAME_MAX_LEN + 1)
32
IsHeapNameValid(const char * heapName)33 static bool IsHeapNameValid(const char *heapName)
34 {
35 if (heapName == NULL) {
36 return false;
37 }
38 size_t len = strlen(heapName);
39 if ((len == 0) || (len > HEAP_NAME_MAX_LEN)) {
40 return false;
41 }
42 return true;
43 }
44
IsSyncTypeValid(DmabufHeapBufferSyncType syncType)45 static bool IsSyncTypeValid(DmabufHeapBufferSyncType syncType)
46 {
47 switch (syncType) {
48 case DMA_BUF_HEAP_BUF_SYNC_RW:
49 case DMA_BUF_HEAP_BUF_SYNC_READ:
50 case DMA_BUF_HEAP_BUF_SYNC_WRITE:
51 return true;
52 default:
53 return false;
54 }
55 }
56
SetOwnerIdForHeapFlags(DmabufHeapBuffer * buffer,enum DmaHeapFlagOwnerId ownerId)57 void SetOwnerIdForHeapFlags(DmabufHeapBuffer *buffer, enum DmaHeapFlagOwnerId ownerId)
58 {
59 if (buffer) {
60 set_owner_id_for_heap_flags(&buffer->heapFlags, ownerId);
61 }
62 }
63
DmabufHeapOpen(const char * heapName)64 int DmabufHeapOpen(const char *heapName)
65 {
66 if (!IsHeapNameValid(heapName)) {
67 HILOG_ERROR(LOG_CORE, "heapName is wrong, name = %s.", (heapName == NULL) ? "NULL" : heapName);
68 return -EINVAL;
69 }
70 char heapPath[HEAP_PATH_LEN] = DMA_BUF_HEAP_ROOT;
71 errno_t ret = strcat_s(heapPath, HEAP_PATH_LEN, heapName);
72 if (ret != EOK) {
73 HILOG_ERROR(LOG_CORE, "strcat_s is wrong, heapName = %s, ret = %d.", heapName, ret);
74 return -EINVAL;
75 }
76 int fd = open(heapPath, O_RDONLY | O_CLOEXEC);
77 if (fd < 0) {
78 HILOG_ERROR(LOG_CORE, "file open faild, heapName = %s, errno = %d.", heapName, errno);
79 return fd;
80 }
81 long newFd = fd;
82 memtrace((void *)newFd, HEAP_NAME_MAX_LEN, "DmabufHeap", true);
83 return fd;
84 }
85
DmabufHeapClose(unsigned int fd)86 int DmabufHeapClose(unsigned int fd)
87 {
88 long newFd = fd;
89 memtrace((void *)newFd, HEAP_NAME_MAX_LEN, "DmabufHeap", false);
90 return close(fd);
91 }
92
DmabufHeapBufferAlloc(unsigned int heapFd,DmabufHeapBuffer * buffer)93 int DmabufHeapBufferAlloc(unsigned int heapFd, DmabufHeapBuffer *buffer)
94 {
95 if (buffer == NULL) {
96 HILOG_ERROR(LOG_CORE, "%{public}s: buffer is NULL!", __func__);
97 return -EINVAL;
98 }
99 if (buffer->size == 0) {
100 HILOG_ERROR(LOG_CORE, "alloc buffer size is wrong.");
101 return -EINVAL;
102 }
103
104 struct dma_heap_allocation_data data = {
105 .len = buffer->size,
106 .fd_flags = O_RDWR | O_CLOEXEC,
107 .heap_flags = buffer->heapFlags,
108 };
109 int ret = ioctl(heapFd, DMA_HEAP_IOCTL_ALLOC, &data);
110 if (ret < 0) {
111 HILOG_ERROR(LOG_CORE, "alloc buffer failed, size = %zu, ret = %d.", buffer->size, ret);
112 return ret;
113 }
114 memtrace((void *)buffer, buffer->size, "DmabufHeap", true);
115 buffer->fd = data.fd;
116 return ret;
117 }
118
DmabufHeapBufferFree(DmabufHeapBuffer * buffer)119 int DmabufHeapBufferFree(DmabufHeapBuffer *buffer)
120 {
121 if (buffer == NULL) {
122 HILOG_ERROR(LOG_CORE, "%{public}s: buffer is NULL!", __func__);
123 return -EINVAL;
124 }
125 memtrace((void *)buffer, buffer->size, "DmabufHeap", false);
126 if (buffer->fd < 0) {
127 HILOG_ERROR(LOG_CORE, "%{public}s: Invalid file descriptor!", __func__);
128 return -EINVAL;
129 }
130 return close(buffer->fd);
131 }
132
DmabufHeapBufferSyncStart(unsigned int fd,DmabufHeapBufferSyncType syncType)133 int DmabufHeapBufferSyncStart(unsigned int fd, DmabufHeapBufferSyncType syncType)
134 {
135 if (!IsSyncTypeValid(syncType)) {
136 HILOG_ERROR(LOG_CORE, "buffer start syncType is wrong, syncType = %u.", syncType);
137 return -EINVAL;
138 }
139
140 struct dma_buf_sync sync = {0};
141 sync.flags = DMA_BUF_SYNC_START | syncType;
142 return ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync);
143 }
144
DmabufHeapBufferSyncEnd(unsigned int fd,DmabufHeapBufferSyncType syncType)145 int DmabufHeapBufferSyncEnd(unsigned int fd, DmabufHeapBufferSyncType syncType)
146 {
147 if (!IsSyncTypeValid(syncType)) {
148 HILOG_ERROR(LOG_CORE, "buffer end syncType is wrong, syncType = %u.", syncType);
149 return -EINVAL;
150 }
151
152 struct dma_buf_sync sync = {0};
153 sync.flags = DMA_BUF_SYNC_END | syncType;
154 return ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync);
155 }