1 /* 2 * Copyright (c) 2015, Linaro Limited 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 11 * 2. Redistributions in binary form must reproduce the above copyright notice, 12 * this list of conditions and the following disclaimer in the documentation 13 * and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 19 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 25 * POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include <assert.h> 29 #include <kernel/mutex.h> 30 #include <kernel/panic.h> 31 #include <kernel/thread.h> 32 #include <mm/core_memprot.h> 33 #include <optee_msg_supplicant.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <string_ext.h> 37 #include <string.h> 38 #include <sys/queue.h> 39 #include <tee/fs_dirfile.h> 40 #include <tee/fs_htree.h> 41 #include <tee/tee_cryp_provider.h> 42 #include <tee/tee_fs.h> 43 #include <tee/tee_fs_rpc.h> 44 #include <tee/tee_pobj.h> 45 #include <trace.h> 46 #include <utee_defines.h> 47 #include <util.h> 48 49 #define BLOCK_SHIFT 12 50 51 #define BLOCK_SIZE (1 << BLOCK_SHIFT) 52 53 struct tee_fs_fd { 54 struct tee_fs_htree *ht; 55 int fd; 56 struct tee_fs_dirfile_fileh dfh; 57 const TEE_UUID *uuid; 58 }; 59 60 struct tee_fs_dir { 61 struct tee_fs_dirfile_dirh *dirh; 62 int idx; 63 struct tee_fs_dirent d; 64 const TEE_UUID *uuid; 65 }; 66 67 static int pos_to_block_num(int position) 68 { 69 return position >> BLOCK_SHIFT; 70 } 71 72 static struct mutex ree_fs_mutex = MUTEX_INITIALIZER; 73 74 75 76 static TEE_Result out_of_place_write(struct tee_fs_fd *fdp, size_t pos, 77 const void *buf, size_t len) 78 { 79 TEE_Result res; 80 size_t start_block_num = pos_to_block_num(pos); 81 size_t end_block_num = pos_to_block_num(pos + len - 1); 82 size_t remain_bytes = len; 83 uint8_t *data_ptr = (uint8_t *)buf; 84 uint8_t *block; 85 struct tee_fs_htree_meta *meta = tee_fs_htree_get_meta(fdp->ht); 86 87 block = malloc(BLOCK_SIZE); 88 if (!block) 89 return TEE_ERROR_OUT_OF_MEMORY; 90 91 while (start_block_num <= end_block_num) { 92 size_t offset = pos % BLOCK_SIZE; 93 size_t size_to_write = MIN(remain_bytes, (size_t)BLOCK_SIZE); 94 95 if (size_to_write + offset > BLOCK_SIZE) 96 size_to_write = BLOCK_SIZE - offset; 97 98 if (start_block_num * BLOCK_SIZE < 99 ROUNDUP(meta->length, BLOCK_SIZE)) { 100 res = tee_fs_htree_read_block(&fdp->ht, 101 start_block_num, block); 102 if (res != TEE_SUCCESS) 103 goto exit; 104 } else { 105 memset(block, 0, BLOCK_SIZE); 106 } 107 108 if (data_ptr) 109 memcpy(block + offset, data_ptr, size_to_write); 110 else 111 memset(block + offset, 0, size_to_write); 112 113 res = tee_fs_htree_write_block(&fdp->ht, start_block_num, 114 block); 115 if (res != TEE_SUCCESS) 116 goto exit; 117 118 if (data_ptr) 119 data_ptr += size_to_write; 120 remain_bytes -= size_to_write; 121 start_block_num++; 122 pos += size_to_write; 123 } 124 125 if (pos > meta->length) 126 meta->length = pos; 127 128 exit: 129 free(block); 130 return res; 131 } 132 133 static TEE_Result get_offs_size(enum tee_fs_htree_type type, size_t idx, 134 uint8_t vers, size_t *offs, size_t *size) 135 { 136 const size_t node_size = sizeof(struct tee_fs_htree_node_image); 137 const size_t block_nodes = BLOCK_SIZE / (node_size * 2); 138 size_t pbn; 139 size_t bidx; 140 141 assert(vers == 0 || vers == 1); 142 143 /* 144 * File layout 145 * 146 * phys block 0: 147 * tee_fs_htree_image vers 0 @ offs = 0 148 * tee_fs_htree_image vers 1 @ offs = sizeof(tee_fs_htree_image) 149 * 150 * phys block 1: 151 * tee_fs_htree_node_image 0 vers 0 @ offs = 0 152 * tee_fs_htree_node_image 0 vers 1 @ offs = node_size 153 * tee_fs_htree_node_image 1 vers 0 @ offs = node_size * 2 154 * tee_fs_htree_node_image 1 vers 1 @ offs = node_size * 3 155 * ... 156 * tee_fs_htree_node_image 61 vers 0 @ offs = node_size * 122 157 * tee_fs_htree_node_image 61 vers 1 @ offs = node_size * 123 158 * 159 * phys block 2: 160 * data block 0 vers 0 161 * 162 * phys block 3: 163 * data block 0 vers 1 164 * 165 * ... 166 * phys block 63: 167 * data block 61 vers 0 168 * 169 * phys block 64: 170 * data block 61 vers 1 171 * 172 * phys block 65: 173 * tee_fs_htree_node_image 62 vers 0 @ offs = 0 174 * tee_fs_htree_node_image 62 vers 1 @ offs = node_size 175 * tee_fs_htree_node_image 63 vers 0 @ offs = node_size * 2 176 * tee_fs_htree_node_image 63 vers 1 @ offs = node_size * 3 177 * ... 178 * tee_fs_htree_node_image 121 vers 0 @ offs = node_size * 122 179 * tee_fs_htree_node_image 121 vers 1 @ offs = node_size * 123 180 * 181 * ... 182 */ 183 184 switch (type) { 185 case TEE_FS_HTREE_TYPE_HEAD: 186 *offs = sizeof(struct tee_fs_htree_image) * vers; 187 *size = sizeof(struct tee_fs_htree_image); 188 return TEE_SUCCESS; 189 case TEE_FS_HTREE_TYPE_NODE: 190 pbn = 1 + ((idx / block_nodes) * block_nodes * 2); 191 *offs = pbn * BLOCK_SIZE + 192 2 * node_size * (idx % block_nodes) + 193 node_size * vers; 194 *size = node_size; 195 return TEE_SUCCESS; 196 case TEE_FS_HTREE_TYPE_BLOCK: 197 bidx = 2 * idx + vers; 198 pbn = 2 + bidx + bidx / (block_nodes * 2 - 1); 199 *offs = pbn * BLOCK_SIZE; 200 *size = BLOCK_SIZE; 201 return TEE_SUCCESS; 202 default: 203 return TEE_ERROR_GENERIC; 204 } 205 } 206 207 static TEE_Result ree_fs_rpc_read_init(void *aux, 208 struct tee_fs_rpc_operation *op, 209 enum tee_fs_htree_type type, size_t idx, 210 uint8_t vers, void **data) 211 { 212 struct tee_fs_fd *fdp = aux; 213 TEE_Result res; 214 size_t offs; 215 size_t size; 216 217 res = get_offs_size(type, idx, vers, &offs, &size); 218 if (res != TEE_SUCCESS) 219 return res; 220 221 return tee_fs_rpc_read_init(op, OPTEE_MSG_RPC_CMD_FS, fdp->fd, 222 offs, size, data); 223 } 224 225 static TEE_Result ree_fs_rpc_write_init(void *aux, 226 struct tee_fs_rpc_operation *op, 227 enum tee_fs_htree_type type, size_t idx, 228 uint8_t vers, void **data) 229 { 230 struct tee_fs_fd *fdp = aux; 231 TEE_Result res; 232 size_t offs; 233 size_t size; 234 235 res = get_offs_size(type, idx, vers, &offs, &size); 236 if (res != TEE_SUCCESS) 237 return res; 238 239 return tee_fs_rpc_write_init(op, OPTEE_MSG_RPC_CMD_FS, fdp->fd, 240 offs, size, data); 241 } 242 243 static const struct tee_fs_htree_storage ree_fs_storage_ops = { 244 .block_size = BLOCK_SIZE, 245 .rpc_read_init = ree_fs_rpc_read_init, 246 .rpc_read_final = tee_fs_rpc_read_final, 247 .rpc_write_init = ree_fs_rpc_write_init, 248 .rpc_write_final = tee_fs_rpc_write_final, 249 }; 250 251 static TEE_Result ree_fs_ftruncate_internal(struct tee_fs_fd *fdp, 252 tee_fs_off_t new_file_len) 253 { 254 TEE_Result res; 255 struct tee_fs_htree_meta *meta = tee_fs_htree_get_meta(fdp->ht); 256 257 if ((size_t)new_file_len > meta->length) { 258 size_t ext_len = new_file_len - meta->length; 259 260 res = out_of_place_write(fdp, meta->length, NULL, ext_len); 261 if (res != TEE_SUCCESS) 262 return res; 263 } else { 264 size_t offs; 265 size_t sz; 266 267 res = get_offs_size(TEE_FS_HTREE_TYPE_BLOCK, 268 ROUNDUP(new_file_len, BLOCK_SIZE) / 269 BLOCK_SIZE, 1, &offs, &sz); 270 if (res != TEE_SUCCESS) 271 return res; 272 273 res = tee_fs_htree_truncate(&fdp->ht, 274 new_file_len / BLOCK_SIZE); 275 if (res != TEE_SUCCESS) 276 return res; 277 278 res = tee_fs_rpc_truncate(OPTEE_MSG_RPC_CMD_FS, fdp->fd, 279 offs + sz); 280 if (res != TEE_SUCCESS) 281 return res; 282 283 meta->length = new_file_len; 284 } 285 286 return TEE_SUCCESS; 287 } 288 289 static TEE_Result ree_fs_read_primitive(struct tee_file_handle *fh, size_t pos, 290 void *buf, size_t *len) 291 { 292 TEE_Result res; 293 int start_block_num; 294 int end_block_num; 295 size_t remain_bytes; 296 uint8_t *data_ptr = buf; 297 uint8_t *block = NULL; 298 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 299 struct tee_fs_htree_meta *meta = tee_fs_htree_get_meta(fdp->ht); 300 301 remain_bytes = *len; 302 if ((pos + remain_bytes) < remain_bytes || pos > meta->length) 303 remain_bytes = 0; 304 else if (pos + remain_bytes > meta->length) 305 remain_bytes = meta->length - pos; 306 307 *len = remain_bytes; 308 309 if (!remain_bytes) { 310 res = TEE_SUCCESS; 311 goto exit; 312 } 313 314 start_block_num = pos_to_block_num(pos); 315 end_block_num = pos_to_block_num(pos + remain_bytes - 1); 316 317 block = malloc(BLOCK_SIZE); 318 if (!block) { 319 res = TEE_ERROR_OUT_OF_MEMORY; 320 goto exit; 321 } 322 323 while (start_block_num <= end_block_num) { 324 size_t offset = pos % BLOCK_SIZE; 325 size_t size_to_read = MIN(remain_bytes, (size_t)BLOCK_SIZE); 326 327 if (size_to_read + offset > BLOCK_SIZE) 328 size_to_read = BLOCK_SIZE - offset; 329 330 res = tee_fs_htree_read_block(&fdp->ht, start_block_num, block); 331 if (res != TEE_SUCCESS) 332 goto exit; 333 334 memcpy(data_ptr, block + offset, size_to_read); 335 336 data_ptr += size_to_read; 337 remain_bytes -= size_to_read; 338 pos += size_to_read; 339 340 start_block_num++; 341 } 342 res = TEE_SUCCESS; 343 exit: 344 free(block); 345 return res; 346 } 347 348 static TEE_Result ree_fs_read(struct tee_file_handle *fh, size_t pos, 349 void *buf, size_t *len) 350 { 351 TEE_Result res; 352 353 mutex_lock(&ree_fs_mutex); 354 res = ree_fs_read_primitive(fh, pos, buf, len); 355 mutex_unlock(&ree_fs_mutex); 356 357 return res; 358 } 359 360 static TEE_Result ree_fs_write_primitive(struct tee_file_handle *fh, size_t pos, 361 const void *buf, size_t len) 362 { 363 TEE_Result res; 364 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 365 size_t file_size; 366 367 if (!len) 368 return TEE_SUCCESS; 369 370 file_size = tee_fs_htree_get_meta(fdp->ht)->length; 371 372 if ((pos + len) < len) 373 return TEE_ERROR_BAD_PARAMETERS; 374 375 if (file_size < pos) { 376 res = ree_fs_ftruncate_internal(fdp, pos); 377 if (res != TEE_SUCCESS) 378 return res; 379 } 380 381 return out_of_place_write(fdp, pos, buf, len); 382 } 383 384 static TEE_Result ree_fs_open_primitive(bool create, uint8_t *hash, 385 const TEE_UUID *uuid, 386 struct tee_fs_dirfile_fileh *dfh, 387 struct tee_file_handle **fh) 388 { 389 TEE_Result res; 390 struct tee_fs_fd *fdp; 391 392 fdp = calloc(1, sizeof(struct tee_fs_fd)); 393 if (!fdp) 394 return TEE_ERROR_OUT_OF_MEMORY; 395 fdp->fd = -1; 396 fdp->uuid = uuid; 397 398 if (create) 399 res = tee_fs_rpc_create_dfh(OPTEE_MSG_RPC_CMD_FS, 400 dfh, &fdp->fd); 401 else 402 res = tee_fs_rpc_open_dfh(OPTEE_MSG_RPC_CMD_FS, dfh, &fdp->fd); 403 404 if (res != TEE_SUCCESS) 405 goto out; 406 407 res = tee_fs_htree_open(create, hash, uuid, &ree_fs_storage_ops, 408 fdp, &fdp->ht); 409 out: 410 if (res == TEE_SUCCESS) { 411 if (dfh) 412 fdp->dfh = *dfh; 413 else 414 fdp->dfh.idx = -1; 415 *fh = (struct tee_file_handle *)fdp; 416 } else { 417 if (fdp->fd != -1) 418 tee_fs_rpc_close(OPTEE_MSG_RPC_CMD_FS, fdp->fd); 419 if (create) 420 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, dfh); 421 free(fdp); 422 } 423 424 return res; 425 } 426 427 static void ree_fs_close_primitive(struct tee_file_handle *fh) 428 { 429 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 430 431 if (fdp) { 432 tee_fs_htree_close(&fdp->ht); 433 tee_fs_rpc_close(OPTEE_MSG_RPC_CMD_FS, fdp->fd); 434 free(fdp); 435 } 436 } 437 438 static TEE_Result ree_dirf_commit_writes(struct tee_file_handle *fh, 439 uint8_t *hash) 440 { 441 TEE_Result res; 442 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 443 444 res = tee_fs_htree_sync_to_storage(&fdp->ht, fdp->dfh.hash); 445 446 if (!res && hash) 447 memcpy(hash, fdp->dfh.hash, sizeof(fdp->dfh.hash)); 448 449 return res; 450 } 451 452 static const struct tee_fs_dirfile_operations ree_dirf_ops = { 453 .open = ree_fs_open_primitive, 454 .close = ree_fs_close_primitive, 455 .read = ree_fs_read_primitive, 456 .write = ree_fs_write_primitive, 457 .commit_writes = ree_dirf_commit_writes, 458 }; 459 460 static struct tee_fs_dirfile_dirh *ree_fs_dirh; 461 static size_t ree_fs_dirh_refcount; 462 463 static TEE_Result open_dirh(struct tee_fs_dirfile_dirh **dirh) 464 { 465 if (!tee_fs_dirfile_open(false, NULL, &ree_dirf_ops, dirh)) 466 return TEE_SUCCESS; 467 return tee_fs_dirfile_open(true, NULL, &ree_dirf_ops, dirh); 468 } 469 470 static TEE_Result commit_dirh_writes(struct tee_fs_dirfile_dirh *dirh) 471 { 472 return tee_fs_dirfile_commit_writes(dirh, NULL); 473 } 474 475 static void close_dirh(struct tee_fs_dirfile_dirh **dirh) 476 { 477 tee_fs_dirfile_close(*dirh); 478 *dirh = NULL; 479 } 480 481 static TEE_Result get_dirh(struct tee_fs_dirfile_dirh **dirh) 482 { 483 if (!ree_fs_dirh) { 484 TEE_Result res = open_dirh(&ree_fs_dirh); 485 486 if (res) { 487 *dirh = NULL; 488 return res; 489 } 490 } 491 ree_fs_dirh_refcount++; 492 assert(ree_fs_dirh); 493 assert(ree_fs_dirh_refcount); 494 *dirh = ree_fs_dirh; 495 return TEE_SUCCESS; 496 } 497 498 static void put_dirh_primitive(bool close) 499 { 500 assert(ree_fs_dirh_refcount); 501 assert(ree_fs_dirh); 502 503 ree_fs_dirh_refcount--; 504 if (!ree_fs_dirh_refcount || close) 505 close_dirh(&ree_fs_dirh); 506 } 507 508 static void put_dirh(struct tee_fs_dirfile_dirh *dirh, bool close) 509 { 510 if (dirh) { 511 assert(dirh == ree_fs_dirh); 512 put_dirh_primitive(close); 513 } 514 } 515 516 static TEE_Result ree_fs_open(struct tee_pobj *po, size_t *size, 517 struct tee_file_handle **fh) 518 { 519 TEE_Result res; 520 struct tee_fs_dirfile_dirh *dirh = NULL; 521 struct tee_fs_dirfile_fileh dfh; 522 523 mutex_lock(&ree_fs_mutex); 524 525 res = get_dirh(&dirh); 526 if (res != TEE_SUCCESS) 527 goto out; 528 529 res = tee_fs_dirfile_find(dirh, &po->uuid, po->obj_id, po->obj_id_len, 530 &dfh); 531 if (res != TEE_SUCCESS) 532 goto out; 533 534 res = ree_fs_open_primitive(false, dfh.hash, &po->uuid, &dfh, fh); 535 if (res == TEE_ERROR_ITEM_NOT_FOUND) { 536 /* 537 * If the object isn't found someone has tampered with it, 538 * treat it as corrupt. 539 */ 540 res = TEE_ERROR_CORRUPT_OBJECT; 541 } else if (!res && size) { 542 struct tee_fs_fd *fdp = (struct tee_fs_fd *)*fh; 543 544 *size = tee_fs_htree_get_meta(fdp->ht)->length; 545 } 546 547 out: 548 if (res) 549 put_dirh(dirh, false); 550 mutex_unlock(&ree_fs_mutex); 551 552 return res; 553 } 554 555 static TEE_Result set_name(struct tee_fs_dirfile_dirh *dirh, 556 struct tee_fs_fd *fdp, struct tee_pobj *po, 557 bool overwrite) 558 { 559 TEE_Result res; 560 bool have_old_dfh = false; 561 struct tee_fs_dirfile_fileh old_dfh = { .idx = -1 }; 562 563 res = tee_fs_dirfile_find(dirh, &po->uuid, po->obj_id, po->obj_id_len, 564 &old_dfh); 565 if (!overwrite && !res) 566 return TEE_ERROR_ACCESS_CONFLICT; 567 568 if (!res) 569 have_old_dfh = true; 570 571 /* 572 * If old_dfh wasn't found, the idx will be -1 and 573 * tee_fs_dirfile_rename() will allocate a new index. 574 */ 575 fdp->dfh.idx = old_dfh.idx; 576 old_dfh.idx = -1; 577 res = tee_fs_dirfile_rename(dirh, &po->uuid, &fdp->dfh, 578 po->obj_id, po->obj_id_len); 579 if (res) 580 return res; 581 582 res = commit_dirh_writes(dirh); 583 if (res) 584 return res; 585 586 if (have_old_dfh) 587 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &old_dfh); 588 589 return TEE_SUCCESS; 590 } 591 592 static void ree_fs_close(struct tee_file_handle **fh) 593 { 594 if (*fh) { 595 mutex_lock(&ree_fs_mutex); 596 put_dirh_primitive(false); 597 mutex_unlock(&ree_fs_mutex); 598 599 ree_fs_close_primitive(*fh); 600 *fh = NULL; 601 } 602 } 603 604 static TEE_Result ree_fs_create(struct tee_pobj *po, bool overwrite, 605 const void *head, size_t head_size, 606 const void *attr, size_t attr_size, 607 const void *data, size_t data_size, 608 struct tee_file_handle **fh) 609 { 610 struct tee_fs_fd *fdp; 611 struct tee_fs_dirfile_dirh *dirh = NULL; 612 struct tee_fs_dirfile_fileh dfh; 613 TEE_Result res; 614 size_t pos = 0; 615 616 *fh = NULL; 617 mutex_lock(&ree_fs_mutex); 618 619 res = get_dirh(&dirh); 620 if (res) 621 goto out; 622 623 res = tee_fs_dirfile_get_tmp(dirh, &dfh); 624 if (res) 625 goto out; 626 627 res = ree_fs_open_primitive(true, dfh.hash, &po->uuid, &dfh, fh); 628 if (res) 629 goto out; 630 631 if (head && head_size) { 632 res = ree_fs_write_primitive(*fh, pos, head, head_size); 633 if (res) 634 goto out; 635 pos += head_size; 636 } 637 638 if (attr && attr_size) { 639 res = ree_fs_write_primitive(*fh, pos, attr, attr_size); 640 if (res) 641 goto out; 642 pos += attr_size; 643 } 644 645 if (data && data_size) { 646 res = ree_fs_write_primitive(*fh, pos, data, data_size); 647 if (res) 648 goto out; 649 } 650 651 fdp = (struct tee_fs_fd *)*fh; 652 res = tee_fs_htree_sync_to_storage(&fdp->ht, fdp->dfh.hash); 653 if (res) 654 goto out; 655 656 res = set_name(dirh, fdp, po, overwrite); 657 out: 658 if (res) { 659 put_dirh(dirh, true); 660 if (*fh) { 661 ree_fs_close_primitive(*fh); 662 *fh = NULL; 663 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &dfh); 664 } 665 } 666 mutex_unlock(&ree_fs_mutex); 667 668 return res; 669 } 670 671 static TEE_Result ree_fs_write(struct tee_file_handle *fh, size_t pos, 672 const void *buf, size_t len) 673 { 674 TEE_Result res; 675 struct tee_fs_dirfile_dirh *dirh = NULL; 676 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 677 678 mutex_lock(&ree_fs_mutex); 679 680 res = get_dirh(&dirh); 681 if (res) 682 goto out; 683 684 res = ree_fs_write_primitive(fh, pos, buf, len); 685 if (res) 686 goto out; 687 688 res = tee_fs_htree_sync_to_storage(&fdp->ht, fdp->dfh.hash); 689 if (res) 690 goto out; 691 692 res = tee_fs_dirfile_update_hash(dirh, &fdp->dfh); 693 if (res) 694 goto out; 695 res = commit_dirh_writes(dirh); 696 out: 697 put_dirh(dirh, res); 698 mutex_unlock(&ree_fs_mutex); 699 700 return res; 701 } 702 703 static TEE_Result ree_fs_rename(struct tee_pobj *old, struct tee_pobj *new, 704 bool overwrite) 705 { 706 TEE_Result res; 707 struct tee_fs_dirfile_dirh *dirh = NULL; 708 struct tee_fs_dirfile_fileh dfh; 709 struct tee_fs_dirfile_fileh remove_dfh = { .idx = -1 }; 710 711 if (!new) 712 return TEE_ERROR_BAD_PARAMETERS; 713 714 mutex_lock(&ree_fs_mutex); 715 res = get_dirh(&dirh); 716 if (res) 717 goto out; 718 719 res = tee_fs_dirfile_find(dirh, &new->uuid, new->obj_id, 720 new->obj_id_len, &remove_dfh); 721 if (!res && !overwrite) { 722 res = TEE_ERROR_ACCESS_CONFLICT; 723 goto out; 724 } 725 726 res = tee_fs_dirfile_find(dirh, &old->uuid, old->obj_id, 727 old->obj_id_len, &dfh); 728 if (res) 729 goto out; 730 731 res = tee_fs_dirfile_rename(dirh, &new->uuid, &dfh, new->obj_id, 732 new->obj_id_len); 733 if (res) 734 goto out; 735 736 if (remove_dfh.idx != -1) { 737 res = tee_fs_dirfile_remove(dirh, &remove_dfh); 738 if (res) 739 goto out; 740 } 741 742 res = commit_dirh_writes(dirh); 743 if (res) 744 goto out; 745 746 if (remove_dfh.idx != -1) 747 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &remove_dfh); 748 749 out: 750 put_dirh(dirh, res); 751 mutex_unlock(&ree_fs_mutex); 752 753 return res; 754 755 } 756 757 static TEE_Result ree_fs_remove(struct tee_pobj *po) 758 { 759 TEE_Result res; 760 struct tee_fs_dirfile_dirh *dirh = NULL; 761 struct tee_fs_dirfile_fileh dfh; 762 763 mutex_lock(&ree_fs_mutex); 764 res = get_dirh(&dirh); 765 if (res) 766 goto out; 767 768 res = tee_fs_dirfile_find(dirh, &po->uuid, po->obj_id, po->obj_id_len, 769 &dfh); 770 if (res) 771 goto out; 772 773 res = tee_fs_dirfile_remove(dirh, &dfh); 774 if (res) 775 goto out; 776 777 res = commit_dirh_writes(dirh); 778 if (res) 779 goto out; 780 781 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &dfh); 782 783 assert(tee_fs_dirfile_find(dirh, &po->uuid, po->obj_id, po->obj_id_len, 784 &dfh)); 785 out: 786 put_dirh(dirh, res); 787 mutex_unlock(&ree_fs_mutex); 788 789 return res; 790 } 791 792 static TEE_Result ree_fs_truncate(struct tee_file_handle *fh, size_t len) 793 { 794 TEE_Result res; 795 struct tee_fs_dirfile_dirh *dirh = NULL; 796 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 797 798 mutex_lock(&ree_fs_mutex); 799 800 res = get_dirh(&dirh); 801 if (res != TEE_SUCCESS) 802 goto out; 803 804 res = ree_fs_ftruncate_internal(fdp, len); 805 if (!res) 806 goto out; 807 808 res = tee_fs_htree_sync_to_storage(&fdp->ht, fdp->dfh.hash); 809 if (!res) 810 goto out; 811 812 res = tee_fs_dirfile_update_hash(dirh, &fdp->dfh); 813 814 out: 815 put_dirh(dirh, res); 816 mutex_unlock(&ree_fs_mutex); 817 818 return res; 819 } 820 821 static TEE_Result ree_fs_opendir_rpc(const TEE_UUID *uuid, 822 struct tee_fs_dir **dir) 823 824 { 825 TEE_Result res; 826 struct tee_fs_dir *d = calloc(1, sizeof(*d)); 827 828 if (!d) 829 return TEE_ERROR_OUT_OF_MEMORY; 830 831 d->uuid = uuid; 832 833 mutex_lock(&ree_fs_mutex); 834 835 res = get_dirh(&d->dirh); 836 if (res) 837 goto out; 838 839 /* See that there's at least one file */ 840 d->idx = -1; 841 d->d.oidlen = sizeof(d->d.oid); 842 res = tee_fs_dirfile_get_next(d->dirh, d->uuid, &d->idx, d->d.oid, 843 &d->d.oidlen); 844 d->idx = -1; 845 846 out: 847 if (!res) { 848 *dir = d; 849 } else { 850 if (d) 851 put_dirh(d->dirh, false); 852 free(d); 853 } 854 mutex_unlock(&ree_fs_mutex); 855 856 return res; 857 } 858 859 static void ree_fs_closedir_rpc(struct tee_fs_dir *d) 860 { 861 if (d) { 862 mutex_lock(&ree_fs_mutex); 863 864 put_dirh(d->dirh, false); 865 free(d); 866 867 mutex_unlock(&ree_fs_mutex); 868 } 869 } 870 871 static TEE_Result ree_fs_readdir_rpc(struct tee_fs_dir *d, 872 struct tee_fs_dirent **ent) 873 { 874 TEE_Result res; 875 876 mutex_lock(&ree_fs_mutex); 877 878 d->d.oidlen = sizeof(d->d.oid); 879 res = tee_fs_dirfile_get_next(d->dirh, d->uuid, &d->idx, d->d.oid, 880 &d->d.oidlen); 881 if (res == TEE_SUCCESS) 882 *ent = &d->d; 883 884 mutex_unlock(&ree_fs_mutex); 885 886 return res; 887 } 888 889 const struct tee_file_operations ree_fs_ops = { 890 .open = ree_fs_open, 891 .create = ree_fs_create, 892 .close = ree_fs_close, 893 .read = ree_fs_read, 894 .write = ree_fs_write, 895 .truncate = ree_fs_truncate, 896 .rename = ree_fs_rename, 897 .remove = ree_fs_remove, 898 .opendir = ree_fs_opendir_rpc, 899 .closedir = ree_fs_closedir_rpc, 900 .readdir = ree_fs_readdir_rpc, 901 }; 902