1 /*
2 * Copyright (c) 2022, Google Inc. All rights reserved
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining
5 * a copy of this software and associated documentation files
6 * (the "Software"), to deal in the Software without restriction,
7 * including without limitation the rights to use, copy, modify, merge,
8 * publish, distribute, sublicense, and/or sell copies of the Software,
9 * and to permit persons to whom the Software is furnished to do so,
10 * subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
19 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
20 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
21 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 */
23
24 /* Guards uses of trusty/kernel/lib/shared/binder_discover */
25 #define ENABLE_KERNEL_BINDER (0)
26
27 #include <err.h>
28 #include <kernel/vm.h>
29 #include <lib/dtb_service/dtb_service.h>
30 #include <lib/ktipc/ktipc.h>
31 #if ENABLE_KERNEL_BINDER
32 #include <lib/shared/binder_discover/binder_discover.h>
33 #include <lib/shared/device_tree/service/device_tree_service.h>
34 #endif
35 #include <lib/trusty/ipc.h>
36 #include <lib/vmm_obj_service/vmm_obj_service.h>
37 #include <libfdt.h>
38 #include <lk/trace.h>
39 #include <string.h>
40
41 #define LOCAL_TRACE (0)
42
43 /* UUID: 185b4dbc-8935-4a1e-89ee-df027b89bc7a */
44 const static struct uuid device_tree_service_uuid = {
45 0x185b4dbc,
46 0x8935,
47 0x4a1e,
48 {0x89, 0xee, 0xdf, 0x02, 0x7b, 0x89, 0xbc, 0x7a},
49 };
50
51 const static struct uuid* dtb_service_uuids[] = {
52 &device_tree_service_uuid,
53 };
54
55 const static struct ktipc_port_acl dtb_service_port_acl = {
56 .flags = IPC_PORT_ALLOW_TA_CONNECT,
57 .uuid_num = countof(dtb_service_uuids),
58 .uuids = dtb_service_uuids,
59 .extra_data = NULL,
60 };
61
dtb_service_add_user(const void * dtb,size_t dtb_size,const char * dtb_port,struct ktipc_server * server)62 static int dtb_service_add_user(const void* dtb,
63 size_t dtb_size,
64 const char* dtb_port,
65 struct ktipc_server* server) {
66 int rc;
67 vmm_aspace_t* kas = vmm_get_kernel_aspace();
68 struct vmm_obj_slice slice = VMM_OBJ_SLICE_INITIAL_VALUE(slice);
69
70 uint64_t aligned_size = round_up(dtb_size, PAGE_SIZE);
71 void* dtb_copy;
72 rc = vmm_alloc(kas, "dtb copy", aligned_size, &dtb_copy, PAGE_SIZE_SHIFT, 0,
73 ARCH_MMU_FLAG_PERM_NO_EXECUTE);
74 if (rc != NO_ERROR) {
75 TRACEF("error allocating memory (%d)\n", rc);
76 goto err_alloc;
77 }
78
79 /*
80 * We need to make a copy because calling memref_create_from_aspace
81 * directly on dtb returns ERR_OUT_OF_RANGE because there is no backing
82 * vmm_obj for the kernel image
83 */
84 rc = fdt_move(dtb, dtb_copy, aligned_size);
85 if (rc) {
86 TRACEF("failed (%d) to move fdt\n", rc);
87 goto err_fdt_move;
88 }
89
90 rc = vmm_get_obj(kas, (vaddr_t)dtb_copy, aligned_size, &slice);
91 if (rc < 0) {
92 TRACEF("failed (%d) to get vmm_obj\n", rc);
93 goto err_get_obj;
94 }
95
96 struct vmm_obj_service* srv;
97 rc = vmm_obj_service_create_ro(dtb_port, &dtb_service_port_acl, slice.obj,
98 slice.offset, slice.size, &srv);
99 if (rc < 0) {
100 TRACEF("failed (%d) to create vmm_obj_service\n", rc);
101 goto err_create_service;
102 }
103
104 rc = vmm_obj_service_add(srv, server);
105 if (rc < 0) {
106 TRACEF("error (%d) adding new service\n", rc);
107 goto err_add_service;
108 }
109
110 /* vmm_obj_service_create_ro incremented the reference count of slice.obj */
111 vmm_obj_slice_release(&slice);
112 /* We can free the allocation now that we have the slice */
113 vmm_free_region(kas, (vaddr_t)dtb_copy);
114 return NO_ERROR;
115
116 err_add_service:
117 vmm_obj_service_destroy(&srv);
118 err_create_service:
119 vmm_obj_slice_release(&slice);
120 err_get_obj:
121 err_fdt_move:
122 vmm_free_region(kas, (vaddr_t)dtb_copy);
123 err_alloc:
124 return rc;
125 }
126
dtb_service_add(const void * dtb,size_t dtb_size,const char * dt_port,const char * dtb_port,struct ktipc_server * server)127 int dtb_service_add(const void* dtb,
128 size_t dtb_size,
129 const char* dt_port,
130 const char* dtb_port,
131 struct ktipc_server* server) {
132 if (!dtb) {
133 TRACEF("invalid dtb pointer\n");
134 return ERR_INVALID_ARGS;
135 }
136 if (!dtb_size) {
137 TRACEF("invalid dtb size\n");
138 return ERR_INVALID_ARGS;
139 }
140 if (fdt_check_full(dtb, dtb_size)) {
141 TRACEF("invalid dtb contents");
142 return ERR_INVALID_ARGS;
143 }
144 if (!dt_port) {
145 TRACEF("invalid kernel port name\n");
146 return ERR_INVALID_ARGS;
147 }
148 if (!dtb_port) {
149 TRACEF("invalid user port name\n");
150 return ERR_INVALID_ARGS;
151 }
152 if (!server) {
153 TRACEF("invalid server pointer\n");
154 return ERR_INVALID_ARGS;
155 }
156
157 #if ENABLE_KERNEL_BINDER
158 auto dt = android::sp<com::android::trusty::device_tree::DeviceTree>::make(
159 static_cast<const unsigned char*>(dtb), dtb_size);
160 int err = binder_discover_add_service(dt_port, dt);
161 if (err != android::OK) {
162 TRACEF("error adding service (%d)\n", err);
163 return ERR_GENERIC;
164 }
165 #endif
166
167 int rc = dtb_service_add_user(dtb, dtb_size, dtb_port, server);
168 if (rc < 0) {
169 #if ENABLE_KERNEL_BINDER
170 binder_discover_remove_service(dt_port);
171 #endif
172 return rc;
173 }
174
175 return NO_ERROR;
176 }
177