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
33static 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
45static 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
57void SetOwnerIdForHeapFlags(DmabufHeapBuffer *buffer, enum DmaHeapFlagOwnerId ownerId)
58{
59    if (buffer) {
60        set_owner_id_for_heap_flags(&buffer->heapFlags, ownerId);
61    }
62}
63
64int 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    long newFd = fd;
78    memtrace((void *)newFd, HEAP_NAME_MAX_LEN, "DmabufHeap", true);
79    return fd;
80}
81
82int DmabufHeapClose(unsigned int fd)
83{
84    long newFd = fd;
85    memtrace((void *)newFd, HEAP_NAME_MAX_LEN, "DmabufHeap", false);
86    return close(fd);
87}
88
89int DmabufHeapBufferAlloc(unsigned int heapFd, DmabufHeapBuffer *buffer)
90{
91    if (buffer == NULL) {
92        HILOG_ERROR(LOG_CORE, "%{public}s: buffer is NULL!", __func__);
93        return -EINVAL;
94    }
95    if (buffer->size == 0) {
96        HILOG_ERROR(LOG_CORE, "alloc buffer size is wrong.");
97        return -EINVAL;
98    }
99
100    struct dma_heap_allocation_data data = {
101        .len = buffer->size,
102        .fd_flags = O_RDWR | O_CLOEXEC,
103        .heap_flags = buffer->heapFlags,
104    };
105    int ret = ioctl(heapFd, DMA_HEAP_IOCTL_ALLOC, &data);
106    if (ret < 0) {
107        HILOG_ERROR(LOG_CORE, "alloc buffer failed, size = %zu, ret = %d.", buffer->size, ret);
108        return ret;
109    }
110    memtrace((void *)buffer, buffer->size, "DmabufHeap", true);
111    buffer->fd = data.fd;
112    return ret;
113}
114
115int DmabufHeapBufferFree(DmabufHeapBuffer *buffer)
116{
117    if (buffer == NULL) {
118        HILOG_ERROR(LOG_CORE, "%{public}s: buffer is NULL!", __func__);
119        return -EINVAL;
120    }
121    memtrace((void *)buffer, buffer->size, "DmabufHeap", false);
122    return close(buffer->fd);
123}
124
125int DmabufHeapBufferSyncStart(unsigned int fd, DmabufHeapBufferSyncType syncType)
126{
127    if (!IsSyncTypeValid(syncType)) {
128        HILOG_ERROR(LOG_CORE, "buffer start syncType is wrong, syncType = %u.", syncType);
129        return -EINVAL;
130    }
131
132    struct dma_buf_sync sync = {0};
133    sync.flags = DMA_BUF_SYNC_START | syncType;
134    return ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync);
135}
136
137int DmabufHeapBufferSyncEnd(unsigned int fd, DmabufHeapBufferSyncType syncType)
138{
139    if (!IsSyncTypeValid(syncType)) {
140        HILOG_ERROR(LOG_CORE, "buffer end syncType is wrong, syncType = %u.", syncType);
141        return -EINVAL;
142    }
143
144    struct dma_buf_sync sync = {0};
145    sync.flags = DMA_BUF_SYNC_END | syncType;
146    return ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync);
147}