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 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 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 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 *)malloc(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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 *)malloc(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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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; 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