1 /*
2 * Copyright 2020, Rockchip Electronics Co., Ltd
3 * hisping lin, <hisping.lin@rock-chips.com>
4 *
5 * SPDX-License-Identifier: GPL-2.0+
6 */
7
8 #include <common.h>
9 #include <stdlib.h>
10 #include <command.h>
11 #include <boot_rkimg.h>
12 #include <part.h>
13 #include <optee_include/OpteeClientRkFs.h>
14
15 //#define DEBUG_RKSS
16 //#define DEBUG_CLEAN_RKSS
17
18 /*
19 * RK Secure Storage Version 2
20 * Area0 Backup 0 Size : 256 kb <----> Area0 Backup 1 Size : 256 kb
21 * Area1 Backup 0 Size : 256 kb <----> Area1 Backup 1 Size : 256 kb
22 *
23 * ------ 1 section is 512 bytes -----
24 * ------ Area0 Backup0 section from 0 to 511 --------
25 * 1 section for file header [0]
26 * 1 section for used flags [1]
27 * - 1 byte = 2 flag
28 * 62 section for file tables [2-63]
29 * - size of table 128 bytes
30 * 447 section for data [64-510]
31 * 1 section for file footer [511]
32 *
33 * ------ Area0 Backup1 section from 512 to 1023 --------
34 * 1 section for file header [512]
35 * 1 section for used flags [513]
36 * - 1 byte = 2 flag
37 * 62 section for file tables [514-575]
38 * - size of table 128 bytes
39 * 447 section for data [576-1022]
40 * 1 section for file footer [1023]
41 *
42 * ------ Area1 Backup0 section from 1024 to 1535 --------
43 * 1 section for file header [1024]
44 * 1 section for used flags [1025]
45 * - 1 byte = 2 flag
46 * 62 section for file tables [1026-1087]
47 * - size of table 128 bytes
48 * 447 section for data [1088-1534]
49 * 1 section for file footer [1535]
50 *
51 * ------ Area1 Backup1 section from 1536 to 2047 --------
52 * 1 section for file header [1536]
53 * 1 section for used flags [1537]
54 * - 1 byte = 2 flag
55 * 62 section for file tables [1538-1599]
56 * - size of table 128 bytes
57 * 447 section for data [1600-2046]
58 * 1 section for file footer [2047]
59 */
60
61 /* define for backup */
62 #define RKSS_HEADER_INDEX 0
63 #define RKSS_HEADER_COUNT 1
64 #define RKSS_USEDFLAGS_INDEX 1
65 #define RKSS_USEDFLAGS_COUNT 1
66 #define RKSS_TABLE_INDEX 2
67 #define RKSS_TABLE_COUNT 62
68 #define RKSS_DATA_INDEX 64
69 #define RKSS_DATA_COUNT 447
70 #define RKSS_FOOTER_INDEX 511
71 #define RKSS_FOOTER_COUNT 1
72 #define RKSS_SECTION_COUNT 512
73
74 #define RKSS_MAX_AREA_NUM 8
75 #define RKSS_ACTIVE_AREA_NUM 2
76 #define RKSS_DATA_LEN 512
77 #define RKSS_EACH_FILEFOLDER_COUNT 4
78 #define RKSS_TABLE_SIZE 128
79 #define RKSS_NAME_MAX_LENGTH 112
80 #define RKSS_BACKUP_NUM 2
81 #define RKSS_TAG 0x524B5353
82
83 struct rkss_file_header {
84 uint32_t tag;
85 uint32_t version;
86 uint32_t backup_count;
87 uint16_t backup_index;
88 uint16_t backup_dirty;
89 uint8_t reserve[496];
90 };
91 struct rkss_file_table {
92 uint32_t size;
93 uint16_t index;
94 uint8_t flags;
95 uint8_t used;
96 char name[RKSS_NAME_MAX_LENGTH];
97 uint8_t reserve[8];
98 };
99 struct rkss_file_footer {
100 uint8_t reserve[508];
101 uint32_t backup_count;
102 };
103 struct rkss_file {
104 struct rkss_file_header *header;
105 uint8_t *flags;
106 struct rkss_file_table *table;
107 uint8_t *data;
108 struct rkss_file_footer *footer;
109 };
110
111 /* RK Secure Storage Calls */
112 static int file_seek;
113 static char dir_cache[RKSS_NAME_MAX_LENGTH][12];
114 static int dir_num;
115 static int dir_seek;
116 static uint8_t *rkss_buffer[RKSS_MAX_AREA_NUM];
117 static struct rkss_file rkss_info[RKSS_MAX_AREA_NUM];
118
119 static struct blk_desc *dev_desc;
120 static disk_partition_t part_info;
121
check_security_exist(int print_flag)122 static int check_security_exist(int print_flag)
123 {
124 if (!dev_desc) {
125 dev_desc = rockchip_get_bootdev();
126 if (!dev_desc) {
127 printf("TEEC: %s: Could not find device\n", __func__);
128 return -1;
129 }
130
131 if (part_get_info_by_name(dev_desc,
132 "security", &part_info) < 0) {
133 dev_desc = NULL;
134 if (print_flag != 0)
135 printf("TEEC: Could not find security partition\n");
136 return -1;
137 }
138 }
139 return 0;
140 }
141
rkss_verify_usedflags(unsigned int area_index)142 static int rkss_verify_usedflags(unsigned int area_index)
143 {
144 uint8_t *flags;
145 int i, duel, flag, n, value;
146 uint8_t *flagw;
147 int used_count;
148
149 if (area_index >= RKSS_MAX_AREA_NUM) {
150 printf("TEEC: Not support area_index 0x%x\n", area_index);
151 return -1;
152 }
153
154 flags = rkss_info[area_index].flags;
155 if (flags == NULL) {
156 printf("TEEC: %s flags is null\n", __func__);
157 return -1;
158 }
159
160 used_count = RKSS_HEADER_COUNT +
161 RKSS_USEDFLAGS_COUNT +
162 RKSS_TABLE_COUNT;
163
164 for (i = 0; i < used_count; i++) {
165 duel = *(flags + (int)i/2);
166 flag = i & 0x1 ? duel & 0x0F : (duel & 0xF0) >> 4;
167 if (flag != 0x1)
168 goto init;
169 }
170
171 for (i = RKSS_FOOTER_INDEX; i < RKSS_USEDFLAGS_COUNT * RKSS_DATA_LEN * 2; i++) {
172 duel = *(flags + (int)i/2);
173 flag = i & 0x1 ? duel & 0x0F : (duel & 0xF0) >> 4;
174 if (flag != 0x1)
175 goto init;
176 }
177
178 debug("TEEC: %s: success.\n", __func__);
179 return 0;
180
181 init:
182 debug("TEEC: init usedflags section ...\n");
183 memset(flags, 0, RKSS_USEDFLAGS_COUNT * RKSS_DATA_LEN);
184 for (n = 0; n < used_count; n++) {
185 flagw = flags + (int)n/2;
186 value = 0x1;
187 *flagw = n & 0x1 ? (*flagw & 0xF0) | (value & 0x0F) :
188 (*flagw & 0x0F) | (value << 4);
189 }
190
191 for (n = RKSS_FOOTER_INDEX; n < RKSS_USEDFLAGS_COUNT * RKSS_DATA_LEN * 2; n++) {
192 flagw = flags + (int)n/2;
193 value = 0x1;
194 *flagw = n & 0x1 ? (*flagw & 0xF0) | (value & 0x0F) :
195 (*flagw & 0x0F) | (value << 4);
196 }
197 return 0;
198 }
199
200 #ifdef DEBUG_CLEAN_RKSS
rkss_storage_delete(uint32_t area_index)201 static int rkss_storage_delete(uint32_t area_index)
202 {
203 int ret;
204 uint32_t size;
205 uint8_t *delete_buff;
206
207 if (area_index >= RKSS_MAX_AREA_NUM) {
208 printf("TEEC: Not support area_index 0x%x\n", area_index);
209 return -1;
210 }
211
212 printf("TEEC: delete area index 0x%x!\n", area_index);
213 size = RKSS_SECTION_COUNT * RKSS_BACKUP_NUM * RKSS_DATA_LEN;
214 delete_buff = (uint8_t *)memalign(CONFIG_SYS_CACHELINE_SIZE, size);
215 if (!delete_buff) {
216 printf("TEEC: Malloc failed!\n");
217 return -1;
218 }
219 memset(delete_buff, 0, size);
220 ret = blk_dwrite(dev_desc,
221 part_info.start + area_index * RKSS_SECTION_COUNT * RKSS_BACKUP_NUM,
222 RKSS_SECTION_COUNT * RKSS_BACKUP_NUM, delete_buff);
223 if (ret != RKSS_SECTION_COUNT * RKSS_BACKUP_NUM) {
224 free(delete_buff);
225 printf("TEEC: blk_dwrite fail\n");
226 return -1;
227 }
228
229 if (delete_buff)
230 free(delete_buff);
231 printf("TEEC: delete area success!\n");
232 return 0;
233 }
234
rkss_storage_reset(void)235 static int rkss_storage_reset(void)
236 {
237 if (rkss_storage_delete(0) < 0)
238 return -1;
239 if (rkss_storage_delete(1) < 0)
240 return -1;
241 return 0;
242 }
243 #endif
244
245 #ifdef DEBUG_RKSS
rkss_dump(void * data,unsigned int len)246 static void rkss_dump(void *data, unsigned int len)
247 {
248 char *p = (char *)data;
249 unsigned int i = 0;
250
251 printf("-------------- DUMP %d --------------\n", len);
252 for (i = 0; i < len; i++) {
253 if (i % 32 == 0)
254 printf("\n");
255 printf("%02x ", *(p + i));
256 }
257 printf("\n------------- DUMP END -------------\n");
258 }
259
rkss_dump_ptable(void)260 static void rkss_dump_ptable(void)
261 {
262 int i, j, n;
263 struct rkss_file_table *ptable;
264
265 printf("-------------- DUMP ptable --------------\n");
266
267 for (i = 0; i < RKSS_MAX_AREA_NUM; i++) {
268 ptable = rkss_info[i].table;
269 if (rkss_info[i].table == NULL)
270 continue;
271 printf("--------------- area[%d] tables ------------\n", i);
272 for (j = 0; j < RKSS_TABLE_COUNT; j++) {
273 for (n = 0; n < RKSS_EACH_FILEFOLDER_COUNT; n++) {
274 printf("[%02d][%c] %s , inx:%d, size:%d\n",
275 j * RKSS_EACH_FILEFOLDER_COUNT + n,
276 ptable->used == 0 ? 'F':'T', ptable->name,
277 ptable->index, ptable->size);
278
279 ptable++;
280 }
281 }
282 }
283 printf("-------------- DUMP END --------------\n");
284 }
285
rkss_dump_usedflags(void)286 static void rkss_dump_usedflags(void)
287 {
288 int i;
289
290 for (i = 0; i < RKSS_MAX_AREA_NUM; i++) {
291 if (rkss_info[i].flags == NULL)
292 continue;
293 printf("--------------- area[%d] flags ------------\n", i);
294 rkss_dump(rkss_info[i].flags, RKSS_USEDFLAGS_COUNT * RKSS_DATA_LEN);
295 }
296 }
297 #endif
298
rkss_read_multi_sections(unsigned int area_index,unsigned char * data,unsigned long index,unsigned int num)299 static int rkss_read_multi_sections(unsigned int area_index,
300 unsigned char *data, unsigned long index, unsigned int num)
301 {
302 if (area_index >= RKSS_MAX_AREA_NUM) {
303 printf("TEEC: %s area_index invalid\n", __func__);
304 return -1;
305 }
306 if (index >= RKSS_SECTION_COUNT || num > RKSS_SECTION_COUNT ||
307 (index + num) > RKSS_SECTION_COUNT) {
308 printf("TEEC: %s index num invalid\n", __func__);
309 return -1;
310 }
311 if (rkss_buffer[area_index] == NULL) {
312 printf("TEEC: %s rkss_buffer is null\n", __func__);
313 return -1;
314 }
315 memcpy(data, rkss_buffer[area_index] + index * RKSS_DATA_LEN, num * RKSS_DATA_LEN);
316 return 0;
317 }
318
rkss_write_multi_sections(unsigned int area_index,unsigned char * data,unsigned long index,unsigned int num)319 static int rkss_write_multi_sections(unsigned int area_index,
320 unsigned char *data, unsigned long index, unsigned int num)
321 {
322 if (num == 0)
323 return 0;
324
325 if (area_index >= RKSS_MAX_AREA_NUM) {
326 printf("TEEC: %s area_index invalid\n", __func__);
327 return -1;
328 }
329
330 if (index >= RKSS_SECTION_COUNT || num > RKSS_SECTION_COUNT ||
331 (index + num) > RKSS_SECTION_COUNT) {
332 printf("TEEC: %s index num invalid\n", __func__);
333 return -1;
334 }
335
336 if (rkss_buffer[area_index] == NULL) {
337 printf("TEEC: %s rkss_buffer is null\n", __func__);
338 return -1;
339 }
340
341 memcpy(rkss_buffer[area_index] + index * RKSS_DATA_LEN, data, num * RKSS_DATA_LEN);
342 rkss_info[area_index].header->backup_dirty = 1;
343 return 0;
344 }
345
rkss_get_fileinfo_by_index(int fd,struct rkss_file_table * ptable,unsigned int * out_area_index)346 static int rkss_get_fileinfo_by_index(int fd,
347 struct rkss_file_table *ptable, unsigned int *out_area_index)
348 {
349 struct rkss_file_table *p;
350 unsigned int area_index;
351
352 area_index = fd / (RKSS_TABLE_COUNT * RKSS_EACH_FILEFOLDER_COUNT);
353 if (area_index >= RKSS_MAX_AREA_NUM) {
354 printf("TEEC: %s area_index invalid\n", __func__);
355 return -1;
356 }
357
358 p = rkss_info[area_index].table;
359 if (p == NULL) {
360 printf("TEEC: %s table is null\n", __func__);
361 return -1;
362 }
363
364 p += fd % (RKSS_TABLE_COUNT * RKSS_EACH_FILEFOLDER_COUNT);
365 if (p->used != 1) {
366 debug("TEEC: %s unused table!\n", __func__);
367 return -1;
368 }
369 debug("TEEC: %s p->used = %d p->name=%s p->index=%d p->size=%d\n",
370 __func__, p->used, p->name, p->index, p->size);
371 memcpy(ptable, p, sizeof(struct rkss_file_table));
372 *out_area_index = area_index;
373 return 0;
374 }
375
rkss_get_fileinfo_by_name(char * filename,struct rkss_file_table * ptable,unsigned int * out_area_index)376 static int rkss_get_fileinfo_by_name(char *filename,
377 struct rkss_file_table *ptable, unsigned int *out_area_index)
378 {
379 int ret;
380 unsigned int i, j, n, len;
381 struct rkss_file_table *p;
382
383 len = strlen(filename);
384 if (len > RKSS_NAME_MAX_LENGTH - 1) {
385 printf("TEEC: filename is too long. length:%u\n", len);
386 return -1;
387 }
388
389 for (i = 0; i < RKSS_MAX_AREA_NUM; i++) {
390 if (rkss_info[i].table == NULL)
391 continue;
392 for (j = 0; j < RKSS_TABLE_COUNT; j++) {
393 for (n = 0; n < RKSS_EACH_FILEFOLDER_COUNT; n++) {
394 p = rkss_info[i].table + j * RKSS_EACH_FILEFOLDER_COUNT + n;
395
396 if (p->used == 0)
397 continue;
398
399 if (!strcmp(p->name, filename)) {
400 debug("TEEC: %s: area%d hit table[%d/%d], index[%d/%d]\n",
401 __func__, i, j, RKSS_TABLE_COUNT, n, RKSS_EACH_FILEFOLDER_COUNT);
402 memcpy(ptable, p, sizeof(struct rkss_file_table));
403 *out_area_index = i;
404 ret = i * RKSS_TABLE_COUNT * RKSS_EACH_FILEFOLDER_COUNT +
405 j * RKSS_EACH_FILEFOLDER_COUNT + n;
406 return ret;
407 }
408
409 // Folder Matching
410 const char *split = "/";
411 char *last_inpos = filename;
412 char *last_svpos = p->name;
413 char *cur_inpos = NULL;
414 char *cur_svpos = NULL;
415
416 do {
417 cur_inpos = strstr(last_inpos, split);
418 cur_svpos = strstr(last_svpos, split);
419 int size_in = cur_inpos == NULL ?
420 (int)strlen(last_inpos) : cur_inpos - last_inpos;
421 int size_sv = cur_svpos == NULL ?
422 (int)strlen(last_svpos) : cur_svpos - last_svpos;
423
424 ret = memcmp(last_inpos, last_svpos, size_in);
425
426 last_inpos = cur_inpos + 1;
427 last_svpos = cur_svpos + 1;
428
429 if (size_in != size_sv || ret)
430 goto UNMATCHFOLDER;
431
432 } while (cur_inpos && cur_svpos);
433
434 debug("TEEC: Matched folder: %s\n", p->name);
435 return -100;
436 UNMATCHFOLDER:
437 debug("TEEC: Unmatched ...");
438 }
439 }
440 }
441 debug("TEEC: %s: file or dir no found!\n", __func__);
442 return -1;
443 }
444
rkss_get_dirs_by_name(char * filename)445 static int rkss_get_dirs_by_name(char *filename)
446 {
447 int ret;
448 unsigned int i, j, n, len;
449 struct rkss_file_table *p;
450
451 len = strlen(filename);
452 if (len > RKSS_NAME_MAX_LENGTH - 1) {
453 printf("TEEC: filename is too long. length:%u\n", len);
454 return -1;
455 }
456
457 dir_num = 0;
458 for (i = 0; i < RKSS_MAX_AREA_NUM; i++) {
459 if (rkss_info[i].table == NULL)
460 continue;
461 for (j = 0; j < RKSS_TABLE_COUNT; j++) {
462 for (n = 0; n < RKSS_EACH_FILEFOLDER_COUNT; n++) {
463 p = rkss_info[i].table + j * RKSS_EACH_FILEFOLDER_COUNT + n;
464
465 if (p->used == 0)
466 continue;
467
468 // Full Matching
469 ret = memcmp(p->name, filename, strlen(filename));
470 debug("TEEC: comparing [fd:%d] : %s ?= %s, ret: %d\n",
471 (i * RKSS_TABLE_COUNT + j) * RKSS_EACH_FILEFOLDER_COUNT + n,
472 p->name, filename, ret);
473 if (!ret && strlen(p->name) > strlen(filename)) {
474 char *chk = p->name + strlen(filename);
475 if (*chk == '/') {
476 char *file = p->name + strlen(filename) + 1;
477 char *subdir = strtok(file, "/");
478 debug("TEEC: found: %s\n", subdir);
479 strcpy(dir_cache[dir_num], subdir);
480 ++dir_num;
481 }
482 }
483 }
484 }
485 }
486 return dir_num;
487 }
488
rkss_get_empty_section_from_usedflags(unsigned int area_index,int section_size)489 static int rkss_get_empty_section_from_usedflags(
490 unsigned int area_index, int section_size)
491 {
492 int i = 0;
493 int count0 = 0;
494
495 if (area_index >= RKSS_MAX_AREA_NUM) {
496 printf("TEEC: %s area_index invalid\n", __func__);
497 return -1;
498 }
499 if (rkss_info[area_index].flags == NULL) {
500 printf("TEEC: %s flags is null\n", __func__);
501 return -1;
502 }
503 for (i = 0; i < RKSS_SECTION_COUNT; i++) {
504 uint8_t *flag = rkss_info[area_index].flags + (int)i/2;
505 uint8_t value = i & 0x1 ? *flag & 0x0F : (*flag & 0xF0) >> 4;
506
507 if (value == 0x0) {
508 if (++count0 == section_size)
509 return (i + 1 - section_size);
510 } else {
511 count0 = 0;
512 }
513 }
514
515 printf("TEEC: Not enough space available in secure storage !\n");
516 return -10;
517 }
518
rkss_incref_multi_usedflags_sections(unsigned int area_index,unsigned int index,unsigned int num)519 static int rkss_incref_multi_usedflags_sections(
520 unsigned int area_index, unsigned int index, unsigned int num)
521 {
522 int value, i;
523 uint8_t *flag;
524
525 if (area_index >= RKSS_MAX_AREA_NUM) {
526 printf("TEEC: %s area_index invalid\n", __func__);
527 return -1;
528 }
529
530 if (index >= RKSS_SECTION_COUNT || num > RKSS_SECTION_COUNT ||
531 (index + num) > RKSS_SECTION_COUNT) {
532 printf("TEEC: index[%d] out of range.\n", index);
533 return -1;
534 }
535 if (rkss_info[area_index].flags == NULL) {
536 printf("TEEC: %s flags is null\n", __func__);
537 return -1;
538 }
539
540 for (i = 0; i < num; i++, index++) {
541 flag = rkss_info[area_index].flags + (int)index / 2;
542 value = index & 0x1 ? *flag & 0x0F : (*flag & 0xF0) >> 4;
543 if (++value > 0xF) {
544 printf("TEEC: reference out of data: %d\n", value);
545 value = 0xF;
546 }
547 *flag = index & 0x1 ? (*flag & 0xF0) | (value & 0x0F) :
548 (*flag & 0x0F) | (value << 4);
549 }
550 rkss_info[area_index].header->backup_dirty = 1;
551 return 0;
552 }
553
rkss_decref_multi_usedflags_sections(unsigned int area_index,unsigned int index,unsigned int num)554 static int rkss_decref_multi_usedflags_sections(
555 unsigned int area_index, unsigned int index, unsigned int num)
556 {
557 int value, i;
558 uint8_t *flag;
559
560 if (area_index >= RKSS_MAX_AREA_NUM) {
561 printf("TEEC: %s area_index invalid\n", __func__);
562 return -1;
563 }
564
565 if (index >= RKSS_SECTION_COUNT || num > RKSS_SECTION_COUNT ||
566 (index + num) > RKSS_SECTION_COUNT) {
567 printf("TEEC: index[%d] out of range.\n", index);
568 return -1;
569 }
570 if (rkss_info[area_index].flags == NULL) {
571 printf("TEEC: %s flags is null\n", __func__);
572 return -1;
573 }
574
575 for (i = 0; i < num; i++, index++) {
576 flag = rkss_info[area_index].flags + (int)index / 2;
577 value = index & 0x1 ? *flag & 0x0F : (*flag & 0xF0) >> 4;
578 if (--value < 0) {
579 printf("TEEC: reference out of data: %d\n", value);
580 value = 0x0;
581 }
582 *flag = index & 0x1 ? (*flag & 0xF0) | (value & 0x0F) :
583 (*flag & 0x0F) | (value << 4);
584 }
585 rkss_info[area_index].header->backup_dirty = 1;
586 return 0;
587 }
588
rkss_get_remain_tables(struct rkss_file_table * p)589 static int rkss_get_remain_tables(struct rkss_file_table *p)
590 {
591 unsigned int i, n;
592 int count = 0;
593
594 if (p == NULL)
595 return -1;
596
597 for (i = 0; i < RKSS_TABLE_COUNT; i++) {
598 for (n = 0; n < RKSS_EACH_FILEFOLDER_COUNT; n++) {
599 if (p->used == 0)
600 count++;
601 p++;
602 }
603 }
604 return count;
605 }
606
rkss_get_remain_flags(uint8_t * flags)607 static int rkss_get_remain_flags(uint8_t *flags)
608 {
609 unsigned int i, value;
610 uint8_t *flag;
611 int count = 0;
612
613 if (flags == NULL)
614 return -1;
615
616 for (i = 0; i < RKSS_SECTION_COUNT; i++) {
617 flag = flags + (int)i / 2;
618 value = i & 0x1 ? *flag & 0x0F : (*flag & 0xF0) >> 4;
619 if (value == 0)
620 count++;
621 }
622 return count;
623 }
624
rkss_get_larger_area(void)625 static int rkss_get_larger_area(void)
626 {
627 int i, tables, flags, max_flags = 0;
628 int area_index = -1;
629
630 for (i = 0; i < RKSS_MAX_AREA_NUM; i++) {
631 if (rkss_info[i].table == NULL ||
632 rkss_info[i].flags == NULL)
633 continue;
634 tables = rkss_get_remain_tables(rkss_info[i].table);
635 flags = rkss_get_remain_flags(rkss_info[i].flags);
636 if (tables > 0 && flags > 0 && flags > max_flags) {
637 max_flags = flags;
638 area_index = i;
639 }
640 }
641 return area_index;
642 }
643
rkss_write_area_empty_ptable(unsigned int area_index,struct rkss_file_table * pfile_table)644 static int rkss_write_area_empty_ptable(
645 unsigned int area_index, struct rkss_file_table *pfile_table)
646 {
647 int i, n, ret;
648 struct rkss_file_table *p;
649
650 if (rkss_info[area_index].table == NULL) {
651 printf("TEEC: %s table is null\n", __func__);
652 return -1;
653 }
654 for (i = 0; i < RKSS_TABLE_COUNT; i++) {
655 for (n = 0; n < RKSS_EACH_FILEFOLDER_COUNT; n++) {
656 p = rkss_info[area_index].table + i * RKSS_EACH_FILEFOLDER_COUNT + n;
657 if (p->used == 0) {
658 memcpy(p, pfile_table, sizeof(struct rkss_file_table));
659 p->used = 1;
660 debug("TEEC: write emt ptable : [%d,%d] name:%s, index:%d, size:%d, used:%d\n",
661 i, n, p->name, p->index, p->size, p->used);
662 rkss_info[area_index].header->backup_dirty = 1;
663 ret = area_index * RKSS_TABLE_COUNT * RKSS_EACH_FILEFOLDER_COUNT +
664 i * RKSS_EACH_FILEFOLDER_COUNT + n;
665 return ret;
666 }
667 }
668 }
669 printf("TEEC: No enough ptable space available in secure storage.\n");
670 return -1;
671 }
672
rkss_write_empty_ptable(struct rkss_file_table * pfile_table)673 static int rkss_write_empty_ptable(struct rkss_file_table *pfile_table)
674 {
675 int area_index;
676
677 area_index = rkss_get_larger_area();
678 if (area_index < 0) {
679 printf("TEEC: get area index fail\n");
680 return -1;
681 }
682
683 return rkss_write_area_empty_ptable(area_index, pfile_table);
684 }
685
rkss_write_back_ptable(int fd,struct rkss_file_table * pfile_table)686 static int rkss_write_back_ptable(
687 int fd, struct rkss_file_table *pfile_table)
688 {
689 struct rkss_file_table *p;
690 unsigned int area_index;
691
692 area_index = fd / (RKSS_TABLE_COUNT * RKSS_EACH_FILEFOLDER_COUNT);
693 if (area_index >= RKSS_MAX_AREA_NUM) {
694 printf("TEEC: %s area_index invalid\n", __func__);
695 return -1;
696 }
697
698 p = rkss_info[area_index].table;
699 if (p == NULL) {
700 printf("TEEC: %s table is null\n", __func__);
701 return -1;
702 }
703
704 p += fd % (RKSS_TABLE_COUNT * RKSS_EACH_FILEFOLDER_COUNT);
705
706 memcpy(p, pfile_table, sizeof(struct rkss_file_table));
707 debug("TEEC: write ptable : name:%s, index:%d, size:%d, used:%d\n",
708 p->name, p->index, p->size, p->used);
709
710 rkss_info[area_index].header->backup_dirty = 1;
711 return 0;
712 }
713
rkss_storage_write(void)714 static int rkss_storage_write(void)
715 {
716 int ret, i;
717
718 for (i = 0; i < RKSS_MAX_AREA_NUM; i++) {
719 if (rkss_info[i].header != NULL && rkss_info[i].header->backup_dirty == 1) {
720 rkss_info[i].header->backup_count++;
721 rkss_info[i].footer->backup_count = rkss_info[i].header->backup_count;
722 rkss_info[i].header->backup_index++;
723 if (rkss_info[i].header->backup_index >= RKSS_BACKUP_NUM)
724 rkss_info[i].header->backup_index = 0;
725 rkss_info[i].header->backup_dirty = 0;
726
727 if (rkss_info[i].header->backup_count == 0xffffffff) {
728 rkss_info[i].header->backup_count = 1;
729 rkss_info[i].footer->backup_count = 1;
730 ret = blk_dwrite(dev_desc,
731 part_info.start + i * RKSS_SECTION_COUNT * RKSS_BACKUP_NUM +
732 rkss_info[i].header->backup_index * RKSS_SECTION_COUNT,
733 RKSS_SECTION_COUNT, rkss_buffer[i]);
734 if (ret != RKSS_SECTION_COUNT) {
735 printf("TEEC: blk_dwrite fail\n");
736 return -1;
737 }
738
739 rkss_info[i].header->backup_count = 2;
740 rkss_info[i].footer->backup_count = 2;
741 rkss_info[i].header->backup_index++;
742 if (rkss_info[i].header->backup_index >= RKSS_BACKUP_NUM)
743 rkss_info[i].header->backup_index = 0;
744 ret = blk_dwrite(dev_desc,
745 part_info.start + i * RKSS_SECTION_COUNT * RKSS_BACKUP_NUM +
746 rkss_info[i].header->backup_index * RKSS_SECTION_COUNT,
747 RKSS_SECTION_COUNT, rkss_buffer[i]);
748 if (ret != RKSS_SECTION_COUNT) {
749 printf("TEEC: blk_dwrite fail\n");
750 return -1;
751 }
752 } else {
753 ret = blk_dwrite(dev_desc,
754 part_info.start + i * RKSS_SECTION_COUNT * RKSS_BACKUP_NUM +
755 rkss_info[i].header->backup_index * RKSS_SECTION_COUNT,
756 RKSS_SECTION_COUNT, rkss_buffer[i]);
757 if (ret != RKSS_SECTION_COUNT) {
758 printf("TEEC: blk_dwrite fail\n");
759 return -1;
760 }
761 }
762 }
763 }
764 return 0;
765 }
766
rkss_storage_init(uint32_t area_index)767 static int rkss_storage_init(uint32_t area_index)
768 {
769 unsigned long ret = 0;
770 uint32_t size, i;
771 uint32_t max_ver = 0;
772 uint32_t max_index = 0;
773 uint32_t flags_offset, table_offset, data_offset, footer_offset;
774
775 if (area_index >= RKSS_MAX_AREA_NUM) {
776 printf("TEEC: Not support index=0x%x\n", area_index);
777 return -1;
778 }
779
780 size = RKSS_SECTION_COUNT * RKSS_DATA_LEN;
781 flags_offset = RKSS_USEDFLAGS_INDEX * RKSS_DATA_LEN;
782 table_offset = RKSS_TABLE_INDEX * RKSS_DATA_LEN;
783 data_offset = RKSS_DATA_INDEX * RKSS_DATA_LEN;
784 footer_offset = RKSS_FOOTER_INDEX * RKSS_DATA_LEN;
785
786 if (rkss_buffer[area_index] == NULL) {
787 /* Always use, no need to release */
788 rkss_buffer[area_index] = (uint8_t *)memalign(CONFIG_SYS_CACHELINE_SIZE, size);
789 if (!(rkss_buffer[area_index])) {
790 printf("TEEC: Malloc failed!\n");
791 return -1;
792 }
793
794 /* Pointer initialization */
795 rkss_info[area_index].header = (struct rkss_file_header *)(rkss_buffer[area_index]);
796 rkss_info[area_index].flags = (uint8_t *)(rkss_buffer[area_index] + flags_offset);
797 rkss_info[area_index].table = (struct rkss_file_table *)(rkss_buffer[area_index] + table_offset);
798 rkss_info[area_index].data = (uint8_t *)(rkss_buffer[area_index] + data_offset);
799 rkss_info[area_index].footer = (struct rkss_file_footer *)(rkss_buffer[area_index] + footer_offset);
800
801 /* Find valid from (backup0 - backup1) */
802 for (i = 0; i < RKSS_BACKUP_NUM; i++) {
803 ret = blk_dread(dev_desc,
804 part_info.start +
805 area_index * RKSS_SECTION_COUNT * RKSS_BACKUP_NUM +
806 i * RKSS_SECTION_COUNT,
807 RKSS_SECTION_COUNT, rkss_buffer[area_index]);
808 if (ret != RKSS_SECTION_COUNT) {
809 printf("TEEC: blk_dread fail\n");
810 return -1;
811 }
812
813 if ((rkss_info[area_index].header->tag == RKSS_TAG) &&
814 (rkss_info[area_index].footer->backup_count == rkss_info[area_index].header->backup_count)) {
815 if (max_ver < rkss_info[area_index].header->backup_count) {
816 max_index = i;
817 max_ver = rkss_info[area_index].header->backup_count;
818 }
819 }
820 }
821
822 if (max_ver) {
823 debug("TEEC: max_ver=%d, max_index=%d.\n",
824 max_ver, max_index);
825
826 if (max_index != (RKSS_BACKUP_NUM - 1)) {
827 ret = blk_dread(dev_desc,
828 part_info.start +
829 area_index * RKSS_SECTION_COUNT * RKSS_BACKUP_NUM +
830 max_index * RKSS_SECTION_COUNT,
831 RKSS_SECTION_COUNT, rkss_buffer[area_index]);
832 if (ret != RKSS_SECTION_COUNT) {
833 printf("TEEC: blk_dread fail\n");
834 return -1;
835 }
836 }
837
838 if (rkss_info[area_index].header->version == RKSS_VERSION_V2) {
839 debug("TEEC: data version equal to image version, do nothing!\n");
840 } else if (rkss_info[area_index].header->version < RKSS_VERSION_V2) {
841 printf("TEEC: data version lower than image version!\n");
842 /* convert rkss version 2 to higher rkss version */
843 free(rkss_buffer[area_index]);
844 rkss_buffer[area_index] = NULL;
845 return -1;
846 } else {
847 printf("TEEC: data version higher than image version!\n");
848 printf("TEEC: please update image!\n");
849 free(rkss_buffer[area_index]);
850 rkss_buffer[area_index] = NULL;
851 return -1;
852 }
853 } else {
854 printf("TEEC: Reset area[%d] info...\n", area_index);
855 memset(rkss_buffer[area_index], 0, size);
856 rkss_info[area_index].header->tag = RKSS_TAG;
857 rkss_info[area_index].header->version = RKSS_VERSION_V2;
858 rkss_info[area_index].header->backup_count = 1;
859 rkss_info[area_index].footer->backup_count = 1;
860 /* Verify Usedflags Section */
861 if (rkss_verify_usedflags(area_index) < 0) {
862 printf("TEEC: rkss_verify_usedflags fail !\n");
863 return -1;
864 }
865 }
866 }
867 return 0;
868 }
869
tee_fs_open(struct tee_fs_rpc * fsrpc)870 static int tee_fs_open(struct tee_fs_rpc *fsrpc)
871 {
872 int make_newfile = 0;
873 char *filename = (char *)(fsrpc + 1);
874 struct rkss_file_table p = {0};
875 int ret;
876 unsigned int area_index;
877
878 if (strlen(filename) > RKSS_NAME_MAX_LENGTH) {
879 debug("TEEC: %s: file name too long. %s\n", __func__, filename);
880 return -1;
881 }
882
883 debug("TEEC: %s open file: %s, len: %zu\n",
884 __func__, filename, strlen(filename));
885
886 ret = rkss_get_fileinfo_by_name(filename, &p, &area_index);
887 if (ret < 0) {
888 debug("TEEC: %s : no such file. %s\n", __func__, filename);
889 make_newfile = 1;
890 } else {
891 fsrpc->fd = ret;
892 file_seek = 0;
893 if (CHECKFLAG(fsrpc->flags, TEE_FS_O_APPEND))
894 file_seek = p.size;
895 }
896
897 if (make_newfile) {
898 if (CHECKFLAG(fsrpc->flags, TEE_FS_O_CREAT)) {
899 debug("TEEC: %s create new file: %s\n",
900 __func__, filename);
901 strcpy(p.name, filename);
902 p.index = 0;
903 p.size = 0;
904 p.used = 1;
905 p.flags = RK_FS_R | RK_FS_W;
906 ret = rkss_write_empty_ptable(&p);
907 if (ret < 0) {
908 printf("TEEC: %s : error. %s\n",
909 __func__, filename);
910 return -1;
911 }
912 fsrpc->fd = ret;
913 file_seek = 0;
914 } else {
915 debug("TEEC: and no create flag found.\n");
916 return -1;
917 }
918 }
919
920 debug("TEEC: %s ! %s , fd:%d, flag: %x, len: %d\n",
921 __func__, filename, fsrpc->fd, fsrpc->flags, fsrpc->len);
922
923 return fsrpc->fd;
924 }
925
tee_fs_close(struct tee_fs_rpc * fsrpc)926 static int tee_fs_close(struct tee_fs_rpc *fsrpc)
927 {
928 debug("TEEC: %s !\n", __func__);
929
930 UNREFERENCED_PARAMETER(fsrpc);
931 return 0;
932 }
933
tee_fs_read(struct tee_fs_rpc * fsrpc)934 static int tee_fs_read(struct tee_fs_rpc *fsrpc)
935 {
936 void *data = (void *)(fsrpc + 1);
937 struct rkss_file_table p = {0};
938 int ret, num, di;
939 uint8_t *temp_file_data;
940 unsigned int area_index;
941
942 debug("TEEC: %s! fd:%d, len:%d\n", __func__, fsrpc->fd, fsrpc->len);
943
944 ret = rkss_get_fileinfo_by_index(fsrpc->fd, &p, &area_index);
945 if (ret < 0) {
946 printf("TEEC: unavailable fd !\n");
947 return -1;
948 }
949
950 if (file_seek != 0)
951 printf("TEEC: warning !!! file_seek != 0. unsupported now.\n");
952
953 num = fsrpc->len / RKSS_DATA_LEN + 1;
954 di = 0;
955 debug("TEEC: reading section[%d], fd:%d, len:%d, filesize:%d\n",
956 p.index, fsrpc->fd, fsrpc->len, p.size);
957
958 temp_file_data = malloc(num * RKSS_DATA_LEN);
959 ret = rkss_read_multi_sections(area_index, temp_file_data, p.index, num);
960 if (ret < 0) {
961 printf("TEEC: unavailable file index\n");
962 free(temp_file_data);
963 return -1;
964 }
965 di = fsrpc->len > p.size ? p.size : fsrpc->len;
966 memcpy(data, temp_file_data, di);
967 free(temp_file_data);
968 temp_file_data = 0;
969 return di;
970 }
971
tee_fs_write(struct tee_fs_rpc * fsrpc)972 static int tee_fs_write(struct tee_fs_rpc *fsrpc)
973 {
974 void *data = (void *)(fsrpc + 1);
975 struct rkss_file_table p = {0};
976 int ret, num;
977 uint8_t *temp_file_data;
978 unsigned int area_index;
979
980 debug("TEEC: %s ! fd:%d, lenth:%d\n", __func__, fsrpc->fd, fsrpc->len);
981
982 if (fsrpc->fd < 0) {
983 printf("TEEC: %s error ! wrong fd : %d\n", __func__, fsrpc->fd);
984 return -1;
985 }
986
987 if (file_seek != 0)
988 printf("TEEC: warning !!! file_seek != 0. unsupported now.\n");
989
990 ret = rkss_get_fileinfo_by_index(fsrpc->fd, &p, &area_index);
991 if (ret < 0) {
992 printf("TEEC: %s: fd unvailable!\n", __func__);
993 return -1;
994 }
995
996 if (p.size != 0) {
997 num = p.size / RKSS_DATA_LEN + 1;
998 ret = rkss_decref_multi_usedflags_sections(area_index, p.index, num);
999 if (ret < 0) {
1000 printf("TEEC: rkss decref usedflags error !\n");
1001 return -1;
1002 }
1003 }
1004
1005 p.size = fsrpc->len;
1006 num = fsrpc->len / RKSS_DATA_LEN + 1;
1007 p.index = rkss_get_empty_section_from_usedflags(area_index, num);
1008 debug("TEEC: Get Empty section in %d\n", p.index);
1009 p.used = 1;
1010
1011 ret = rkss_incref_multi_usedflags_sections(area_index, p.index, num);
1012 if (ret < 0) {
1013 printf("TEEC: rkss_incref_multi_usedflags_sections error !\n");
1014 ret = -1;
1015 }
1016
1017 ret = rkss_write_back_ptable(fsrpc->fd, &p);
1018 if (ret < 0) {
1019 printf("TEEC: %s: write ptable error!\n", __func__);
1020 return -1;
1021 }
1022
1023 temp_file_data = malloc(num * RKSS_DATA_LEN);
1024 if (temp_file_data == NULL) {
1025 printf("TEEC: Malloc failed!\n");
1026 return -1;
1027 }
1028 memset(temp_file_data, 0, num * RKSS_DATA_LEN);
1029 memcpy(temp_file_data, data, p.size);
1030 rkss_write_multi_sections(area_index, temp_file_data, p.index, num);
1031 free(temp_file_data);
1032 temp_file_data = 0;
1033
1034 return fsrpc->len;
1035 }
1036
tee_fs_seek(struct tee_fs_rpc * fsrpc)1037 static int tee_fs_seek(struct tee_fs_rpc *fsrpc)
1038 {
1039 struct rkss_file_table p = {0};
1040 int ret;
1041 unsigned int area_index;
1042
1043 debug("TEEC: %s ! fd:%d, seek:%d, flag:%x\n",
1044 __func__, fsrpc->fd, fsrpc->arg, fsrpc->flags);
1045
1046 if (fsrpc->flags == TEE_FS_SEEK_CUR) {
1047 fsrpc->res = file_seek + fsrpc->arg;
1048 } else if (fsrpc->flags == TEE_FS_SEEK_SET) {
1049 file_seek = fsrpc->arg;
1050 fsrpc->res = file_seek;
1051 } else if (fsrpc->flags == TEE_FS_SEEK_END) {
1052 ret = rkss_get_fileinfo_by_index(fsrpc->fd, &p, &area_index);
1053 if (ret < 0) {
1054 printf("TEEC: unavilable fd.\n");
1055 return -1;
1056 }
1057 file_seek = p.size + fsrpc->arg;
1058 fsrpc->res = file_seek;
1059 } else {
1060 printf("TEEC: %s: unsupport seed mode.\n", __func__);
1061 return -1;
1062 }
1063
1064 return fsrpc->res;
1065 }
1066
tee_fs_unlink(struct tee_fs_rpc * fsrpc)1067 static int tee_fs_unlink(struct tee_fs_rpc *fsrpc)
1068 {
1069 char *filename = (char *)(fsrpc + 1);
1070 struct rkss_file_table p = {0};
1071 int ret, fd, num;
1072 unsigned int area_index;
1073
1074 fd = rkss_get_fileinfo_by_name(filename, &p, &area_index);
1075 if (fd < 0) {
1076 printf("TEEC: %s : no such file. %s\n", __func__, filename);
1077 return 0;
1078 }
1079
1080 debug("TEEC: %s ! %s fd:%d index:%d size:%d\n",
1081 __func__, filename, fd, p.index, p.size);
1082
1083 /* decrease ref from usedflags */
1084 num = p.size / RKSS_DATA_LEN + 1;
1085 ret = rkss_decref_multi_usedflags_sections(area_index, p.index, num);
1086 if (ret < 0) {
1087 printf("TEEC: rkss_decref_multi_usedflags_sections error !\n");
1088 return -1;
1089 }
1090
1091 /* rm from ptable */
1092 memset(&p, 0, sizeof(struct rkss_file_table));
1093 ret = rkss_write_back_ptable(fd, &p);
1094 if (ret < 0) {
1095 printf("TEEC: %s : write back error %d\n", __func__, ret);
1096 return -1;
1097 }
1098
1099 return 0;
1100 }
1101
tee_fs_link(struct tee_fs_rpc * fsrpc)1102 static int tee_fs_link(struct tee_fs_rpc *fsrpc)
1103 {
1104 char *filename = (char *)(fsrpc + 1);
1105 size_t offset_new_fn = strlen(filename) + 1;
1106 char *newfilename = filename + offset_new_fn;
1107 struct rkss_file_table p_old = {0};
1108 struct rkss_file_table p_check = {0};
1109 struct rkss_file_table p_new = {0};
1110 int ret, num;
1111 unsigned int old_area, new_area;
1112
1113 debug("TEEC: %s ! %s -> %s\n", __func__, filename, newfilename);
1114
1115 ret = rkss_get_fileinfo_by_name(filename, &p_old, &old_area);
1116 if (ret < 0) {
1117 printf("TEEC: cannot find src file %s.\n", filename);
1118 return -1;
1119 }
1120
1121 ret = rkss_get_fileinfo_by_name(newfilename, &p_check, &new_area);
1122 if (ret >= 0) {
1123 printf("TEEC: file exist ! %s.\n", newfilename);
1124 return -1;
1125 }
1126
1127 memcpy(&p_new, &p_old, sizeof(struct rkss_file_table));
1128 strcpy(p_new.name, newfilename);
1129 ret = rkss_write_area_empty_ptable(old_area, &p_new);
1130 if (ret < 0) {
1131 printf("TEEC: tee_fs_open : error. %s\n", filename);
1132 return -1;
1133 }
1134
1135 num = p_new.size / RKSS_DATA_LEN + 1;
1136 ret = rkss_incref_multi_usedflags_sections(old_area, p_new.index, num);
1137 if (ret < 0) {
1138 printf("TEEC: rkss_incref_multi_usedflags_sections error !\n");
1139 return -1;
1140 }
1141
1142 return 0;
1143 }
1144
tee_fs_rename(struct tee_fs_rpc * fsrpc)1145 static int tee_fs_rename(struct tee_fs_rpc *fsrpc)
1146 {
1147 char *filenames = (char *)(fsrpc + 1);
1148 char *newnames = filenames + strlen(filenames) + 1;
1149 struct rkss_file_table p = {0};
1150 int ret;
1151 unsigned int area_index;
1152
1153 debug("TEEC: rename: %s -> %s\n", filenames, newnames);
1154
1155 ret = rkss_get_fileinfo_by_name(filenames, &p, &area_index);
1156 if (ret < 0) {
1157 printf("TEEC: filename no found .\n");
1158 return -1;
1159 }
1160
1161 strcpy(p.name, newnames);
1162
1163 ret = rkss_write_back_ptable(ret, &p);
1164 if (ret < 0) {
1165 printf("TEEC: write ptable error!\n");
1166 return -1;
1167 }
1168
1169 return 0;
1170 }
1171
tee_fs_truncate(struct tee_fs_rpc * fsrpc)1172 static int tee_fs_truncate(struct tee_fs_rpc *fsrpc)
1173 {
1174 int section_num, new_section_num, free_section_num;
1175 uint16_t free_index;
1176 struct rkss_file_table p = {0};
1177 int ret;
1178 unsigned int area_index;
1179
1180 debug("TEEC: %s: fd:%d, lenth:%d\n",
1181 __func__, fsrpc->fd, fsrpc->arg);
1182 if (fsrpc->fd < 0) {
1183 printf("TEEC: %s: fd unavilable !\n", __func__);
1184 return -1;
1185 }
1186
1187 ret = rkss_get_fileinfo_by_index(fsrpc->fd, &p, &area_index);
1188 if (ret < 0) {
1189 printf("TEEC: fd unvailable!\n");
1190 return -1;
1191 }
1192
1193 if (p.size < fsrpc->arg) {
1194 printf("TEEC: truncate size not support!\n ");
1195 return -1;
1196 } else {
1197 section_num = p.size / RKSS_DATA_LEN + 1;
1198 new_section_num = fsrpc->arg / RKSS_DATA_LEN + 1;
1199 free_section_num = section_num - new_section_num;
1200 free_index = p.index + new_section_num;
1201 ret = rkss_decref_multi_usedflags_sections(area_index, free_index, free_section_num);
1202 if (ret < 0) {
1203 printf("TEEC: rkss decref usedflags error!\n");
1204 return -1;
1205 }
1206 p.size = fsrpc->arg;
1207 ret = rkss_write_back_ptable(fsrpc->fd, &p);
1208 if (ret < 0) {
1209 printf("TEEC: rkss_write_back_ptable error!\n");
1210 return -1;
1211 }
1212 }
1213
1214 return 0;
1215 }
1216
tee_fs_mkdir(struct tee_fs_rpc * fsrpc)1217 static int tee_fs_mkdir(struct tee_fs_rpc *fsrpc)
1218 {
1219 char *dirname = (char *)(fsrpc + 1);
1220
1221 UNREFERENCED_PARAMETER(dirname);
1222 debug("TEEC: %s: %s\n", __func__, dirname);
1223 return 0;
1224 }
1225
tee_fs_opendir(struct tee_fs_rpc * fsrpc)1226 static int tee_fs_opendir(struct tee_fs_rpc *fsrpc)
1227 {
1228 char *dirname = (char *)(fsrpc + 1);
1229 int ret;
1230
1231 dir_seek = 0;
1232 ret = rkss_get_dirs_by_name(dirname);
1233 if (ret < 0)
1234 printf("TEEC: %s: error\n", __func__);
1235
1236 debug("TEEC: %s: %s, seek/num:%d/%d\n", __func__,
1237 dirname, dir_seek, dir_num);
1238 return 0;
1239 }
1240
tee_fs_closedir(struct tee_fs_rpc * fsrpc)1241 static int tee_fs_closedir(struct tee_fs_rpc *fsrpc)
1242 {
1243 char *dirname = (char *)(fsrpc + 1);
1244
1245 UNREFERENCED_PARAMETER(dirname);
1246 debug("TEEC: %s: %s\n", __func__, dirname);
1247 dir_seek = 0;
1248 dir_num = 0;
1249 return 0;
1250 }
1251
tee_fs_readdir(struct tee_fs_rpc * fsrpc)1252 static int tee_fs_readdir(struct tee_fs_rpc *fsrpc)
1253 {
1254 char *dirname = (char *)(fsrpc + 1);
1255
1256 debug("TEEC: seek/num:%d/%d\n", dir_seek, dir_num);
1257 if (dir_seek == dir_num) {
1258 dirname = NULL;
1259 fsrpc->len = 0;
1260 debug("TEEC: %s: END\n", __func__);
1261 return -1;
1262 }
1263
1264 strcpy(dirname, dir_cache[dir_seek]);
1265 fsrpc->len = strlen(dir_cache[dir_seek]) + 1;
1266 ++dir_seek;
1267
1268 debug("TEEC: %s: %s\n", __func__, dirname);
1269 return 0;
1270 }
1271
tee_fs_rmdir(struct tee_fs_rpc * fsrpc)1272 static int tee_fs_rmdir(struct tee_fs_rpc *fsrpc)
1273 {
1274 char *dirname = (char *)(fsrpc + 1);
1275 struct rkss_file_table p = {0};
1276 int ret;
1277 unsigned int area_index;
1278
1279 debug("TEEC: %s: %s\n", __func__, dirname);
1280
1281 ret = rkss_get_fileinfo_by_name(dirname, &p, &area_index);
1282 if (ret == -100) {
1283 printf("TEEC: dir is not empty.\n");
1284 return -1;
1285 } else if (ret >= 0) {
1286 printf("TEEC: %s is not a dir.\n", p.name);
1287 return -1;
1288 }
1289 debug("TEEC: rmdir success.\n");
1290 return 0;
1291 }
1292
tee_fs_access(struct tee_fs_rpc * fsrpc)1293 static int tee_fs_access(struct tee_fs_rpc *fsrpc)
1294 {
1295 char *filename = (char *)(fsrpc + 1);
1296 struct rkss_file_table p = {0};
1297 int ret;
1298 unsigned int area_index;
1299
1300 debug("TEEC: %s: name:%s,flag:%x\n",
1301 __func__, filename, fsrpc->flags);
1302
1303 ret = rkss_get_fileinfo_by_name(filename, &p, &area_index);
1304 if (ret < 0 && ret != -100) {
1305 debug("TEEC: %s: %s no such file or directory.\n",
1306 __func__, filename);
1307 return -1;
1308 }
1309
1310 if (CHECKFLAG(fsrpc->flags, TEE_FS_R_OK)) {
1311 if (!CHECKFLAG(p.flags, RK_FS_R)) {
1312 printf("TEEC: %s: no permission FS_R_OK in %x.\n",
1313 __func__, p.flags);
1314 return -1;
1315 }
1316 }
1317
1318 if (CHECKFLAG(fsrpc->flags, TEE_FS_W_OK)) {
1319 if (!CHECKFLAG(p.flags, RK_FS_W)) {
1320 printf("TEEC: %s: no permission FS_W_OK in %x.\n",
1321 __func__, p.flags);
1322 return -1;
1323 }
1324 }
1325 return 0;
1326 }
1327
tee_supp_rk_fs_init_v2(void)1328 int tee_supp_rk_fs_init_v2(void)
1329 {
1330 assert(sizeof(struct rkss_file_table) == RKSS_TABLE_SIZE);
1331 assert(RKSS_DATA_LEN / sizeof(struct rkss_file_table) ==
1332 RKSS_EACH_FILEFOLDER_COUNT);
1333
1334 if (check_security_exist(0) < 0)
1335 return 0;
1336
1337 /* clean secure storage */
1338 #ifdef DEBUG_CLEAN_RKSS
1339 if (rkss_storage_reset() < 0)
1340 return -1;
1341 #endif
1342
1343 for (uint32_t i = 0; i < RKSS_ACTIVE_AREA_NUM; i++) {
1344 if (rkss_storage_init(i) < 0)
1345 return -1;
1346 }
1347
1348 #ifdef DEBUG_RKSS
1349 rkss_dump_ptable();
1350 rkss_dump_usedflags();
1351 #endif
1352
1353 return 0;
1354 }
1355
1356 static int rkss_step;
tee_supp_rk_fs_process_v2(void * cmd,size_t cmd_size)1357 int tee_supp_rk_fs_process_v2(void *cmd, size_t cmd_size)
1358 {
1359 struct tee_fs_rpc *fsrpc = cmd;
1360 int ret = -1;
1361
1362 if (check_security_exist(0) < 0) {
1363 printf("TEEC: security partition not exist! unable to use RK FS!\n");
1364 return ret;
1365 }
1366
1367 if (cmd_size < sizeof(struct tee_fs_rpc)) {
1368 printf(">>>cmd_size < sizeof(struct tee_fs_rpc) !\n");
1369 return ret;
1370 }
1371
1372 if (cmd == NULL) {
1373 printf(">>>cmd == NULL !\n");
1374 return ret;
1375 }
1376
1377 switch (fsrpc->op) {
1378 case TEE_FS_OPEN:
1379 debug(">>>>>>> [%d] TEE_FS_OPEN !\n", rkss_step++);
1380 ret = tee_fs_open(fsrpc);
1381 break;
1382 case TEE_FS_CLOSE:
1383 debug(">>>>>>> [%d] TEE_FS_CLOSE !\n", rkss_step++);
1384 ret = tee_fs_close(fsrpc);
1385 rkss_storage_write();
1386 break;
1387 case TEE_FS_READ:
1388 debug(">>>>>>> [%d] TEE_FS_READ !\n", rkss_step++);
1389 ret = tee_fs_read(fsrpc);
1390 break;
1391 case TEE_FS_WRITE:
1392 debug(">>>>>>> [%d] TEE_FS_WRITE !\n", rkss_step++);
1393 ret = tee_fs_write(fsrpc);
1394 break;
1395 case TEE_FS_SEEK:
1396 debug(">>>>>>> [%d] TEE_FS_SEEK !\n", rkss_step++);
1397 ret = tee_fs_seek(fsrpc);
1398 break;
1399 case TEE_FS_UNLINK:
1400 debug(">>>>>>> [%d] TEE_FS_UNLINK !\n", rkss_step++);
1401 ret = tee_fs_unlink(fsrpc);
1402 rkss_storage_write();
1403 break;
1404 case TEE_FS_RENAME:
1405 debug(">>>>>>> [%d] TEE_FS_RENAME !\n", rkss_step++);
1406 ret = tee_fs_rename(fsrpc);
1407 rkss_storage_write();
1408 break;
1409 case TEE_FS_TRUNC:
1410 debug(">>>>>>> [%d] TEE_FS_TRUNC !\n", rkss_step++);
1411 ret = tee_fs_truncate(fsrpc);
1412 break;
1413 case TEE_FS_MKDIR:
1414 debug(">>>>>>> [%d] TEE_FS_MKDIR !\n", rkss_step++);
1415 ret = tee_fs_mkdir(fsrpc);
1416 break;
1417 case TEE_FS_OPENDIR:
1418 debug(">>>>>>> [%d] TEE_FS_OPENDIR !\n", rkss_step++);
1419 ret = tee_fs_opendir(fsrpc);
1420 break;
1421 case TEE_FS_CLOSEDIR:
1422 debug(">>>>>>> [%d] TEE_FS_CLOSEDIR !\n", rkss_step++);
1423 ret = tee_fs_closedir(fsrpc);
1424 break;
1425 case TEE_FS_READDIR:
1426 debug(">>>>>>> [%d] TEE_FS_READDIR !\n", rkss_step++);
1427 ret = tee_fs_readdir(fsrpc);
1428 break;
1429 case TEE_FS_RMDIR:
1430 debug(">>>>>>> [%d] TEE_FS_RMDIR !\n", rkss_step++);
1431 ret = tee_fs_rmdir(fsrpc);
1432 break;
1433 case TEE_FS_ACCESS:
1434 debug(">>>>>>> [%d] TEE_FS_ACCESS !\n", rkss_step++);
1435 ret = tee_fs_access(fsrpc);
1436 break;
1437 case TEE_FS_LINK:
1438 debug(">>>>>>> [%d] TEE_FS_LINK !\n", rkss_step++);
1439 ret = tee_fs_link(fsrpc);
1440 rkss_storage_write();
1441 break;
1442 default:
1443 printf(">>>>> DEFAULT !! %d\n", fsrpc->op);
1444 break;
1445 }
1446
1447 fsrpc->res = ret;
1448 debug(">>>>>>> fsrpc->res = [%d] !\n", fsrpc->res);
1449
1450 return ret;
1451 }
1452