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, const TEE_UUID *uuid, 385 struct tee_fs_dirfile_fileh *dfh, 386 struct tee_file_handle **fh) 387 { 388 TEE_Result res; 389 struct tee_fs_fd *fdp; 390 uint8_t *hash = NULL; 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 if (dfh) 408 hash = dfh->hash; 409 res = tee_fs_htree_open(create, hash, uuid, &ree_fs_storage_ops, 410 fdp, &fdp->ht); 411 out: 412 if (res == TEE_SUCCESS) { 413 if (dfh) 414 fdp->dfh = *dfh; 415 else 416 fdp->dfh.idx = -1; 417 *fh = (struct tee_file_handle *)fdp; 418 } else { 419 if (fdp->fd != -1) 420 tee_fs_rpc_close(OPTEE_MSG_RPC_CMD_FS, fdp->fd); 421 if (create) 422 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, dfh); 423 free(fdp); 424 } 425 426 return res; 427 } 428 429 static void ree_fs_close_primitive(struct tee_file_handle *fh) 430 { 431 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 432 433 if (fdp) { 434 tee_fs_htree_close(&fdp->ht); 435 tee_fs_rpc_close(OPTEE_MSG_RPC_CMD_FS, fdp->fd); 436 free(fdp); 437 } 438 } 439 440 static TEE_Result ree_dirf_commit_writes(struct tee_file_handle *fh, 441 uint8_t *hash) 442 { 443 TEE_Result res; 444 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 445 446 res = tee_fs_htree_sync_to_storage(&fdp->ht, fdp->dfh.hash); 447 448 if (!res && hash) 449 memcpy(hash, fdp->dfh.hash, sizeof(fdp->dfh.hash)); 450 451 return res; 452 } 453 454 static const struct tee_fs_dirfile_operations ree_dirf_ops = { 455 .open = ree_fs_open_primitive, 456 .close = ree_fs_close_primitive, 457 .read = ree_fs_read_primitive, 458 .write = ree_fs_write_primitive, 459 .commit_writes = ree_dirf_commit_writes, 460 }; 461 462 static struct tee_fs_dirfile_dirh *ree_fs_dirh; 463 static size_t ree_fs_dirh_refcount; 464 465 static TEE_Result get_dirh(struct tee_fs_dirfile_dirh **dirh) 466 { 467 if (!ree_fs_dirh_refcount) { 468 TEE_Result res; 469 470 assert(!ree_fs_dirh); 471 res = tee_fs_dirfile_open(&ree_dirf_ops, &ree_fs_dirh); 472 if (res) 473 return res; 474 } 475 assert(ree_fs_dirh); 476 ree_fs_dirh_refcount++; 477 *dirh = ree_fs_dirh; 478 return TEE_SUCCESS; 479 } 480 481 static void put_dirh_primitive(void) 482 { 483 assert(ree_fs_dirh_refcount); 484 assert(ree_fs_dirh); 485 486 ree_fs_dirh_refcount--; 487 if (!ree_fs_dirh_refcount) { 488 tee_fs_dirfile_close(ree_fs_dirh); 489 ree_fs_dirh = NULL; 490 } 491 } 492 493 static void put_dirh(struct tee_fs_dirfile_dirh *dirh) 494 { 495 if (dirh) { 496 assert(dirh == ree_fs_dirh); 497 put_dirh_primitive(); 498 } 499 } 500 501 static TEE_Result ree_fs_open(struct tee_pobj *po, size_t *size, 502 struct tee_file_handle **fh) 503 { 504 TEE_Result res; 505 struct tee_fs_dirfile_dirh *dirh = NULL; 506 struct tee_fs_dirfile_fileh dfh; 507 508 mutex_lock(&ree_fs_mutex); 509 510 res = get_dirh(&dirh); 511 if (res != TEE_SUCCESS) 512 goto out; 513 514 res = tee_fs_dirfile_find(dirh, &po->uuid, po->obj_id, po->obj_id_len, 515 &dfh); 516 if (res != TEE_SUCCESS) 517 goto out; 518 519 res = ree_fs_open_primitive(false, &po->uuid, &dfh, fh); 520 if (res == TEE_ERROR_ITEM_NOT_FOUND) { 521 /* 522 * If the object isn't found someone has tampered with it, 523 * treat it as corrupt. 524 */ 525 res = TEE_ERROR_CORRUPT_OBJECT; 526 } else if (!res && size) { 527 struct tee_fs_fd *fdp = (struct tee_fs_fd *)*fh; 528 529 *size = tee_fs_htree_get_meta(fdp->ht)->length; 530 } 531 532 out: 533 if (res) 534 put_dirh(dirh); 535 mutex_unlock(&ree_fs_mutex); 536 537 return res; 538 } 539 540 static TEE_Result set_name(struct tee_fs_dirfile_dirh *dirh, 541 struct tee_fs_fd *fdp, struct tee_pobj *po, 542 bool overwrite) 543 { 544 TEE_Result res; 545 bool have_old_dfh = false; 546 struct tee_fs_dirfile_fileh old_dfh = { .idx = -1 }; 547 548 res = tee_fs_dirfile_find(dirh, &po->uuid, po->obj_id, po->obj_id_len, 549 &old_dfh); 550 if (!overwrite && !res) 551 return TEE_ERROR_ACCESS_CONFLICT; 552 553 if (!res) 554 have_old_dfh = true; 555 556 /* 557 * If old_dfh wasn't found, the idx will be -1 and 558 * tee_fs_dirfile_rename() will allocate a new index. 559 */ 560 fdp->dfh.idx = old_dfh.idx; 561 old_dfh.idx = -1; 562 res = tee_fs_dirfile_rename(dirh, &po->uuid, &fdp->dfh, 563 po->obj_id, po->obj_id_len); 564 if (res) 565 return res; 566 567 res = tee_fs_dirfile_commit_writes(dirh); 568 if (res) 569 return res; 570 571 if (have_old_dfh) 572 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &old_dfh); 573 574 return TEE_SUCCESS; 575 } 576 577 static void ree_fs_close(struct tee_file_handle **fh) 578 { 579 if (*fh) { 580 mutex_lock(&ree_fs_mutex); 581 put_dirh_primitive(); 582 mutex_unlock(&ree_fs_mutex); 583 584 ree_fs_close_primitive(*fh); 585 *fh = NULL; 586 } 587 } 588 589 static TEE_Result ree_fs_create(struct tee_pobj *po, bool overwrite, 590 const void *head, size_t head_size, 591 const void *attr, size_t attr_size, 592 const void *data, size_t data_size, 593 struct tee_file_handle **fh) 594 { 595 struct tee_fs_fd *fdp; 596 struct tee_fs_dirfile_dirh *dirh = NULL; 597 struct tee_fs_dirfile_fileh dfh; 598 TEE_Result res; 599 size_t pos = 0; 600 601 *fh = NULL; 602 mutex_lock(&ree_fs_mutex); 603 604 res = get_dirh(&dirh); 605 if (res) 606 goto out; 607 608 res = tee_fs_dirfile_get_tmp(dirh, &dfh); 609 if (res) 610 goto out; 611 612 res = ree_fs_open_primitive(true, &po->uuid, &dfh, fh); 613 if (res) 614 goto out; 615 616 if (head && head_size) { 617 res = ree_fs_write_primitive(*fh, pos, head, head_size); 618 if (res) 619 goto out; 620 pos += head_size; 621 } 622 623 if (attr && attr_size) { 624 res = ree_fs_write_primitive(*fh, pos, attr, attr_size); 625 if (res) 626 goto out; 627 pos += attr_size; 628 } 629 630 if (data && data_size) { 631 res = ree_fs_write_primitive(*fh, pos, data, data_size); 632 if (res) 633 goto out; 634 } 635 636 fdp = (struct tee_fs_fd *)*fh; 637 res = tee_fs_htree_sync_to_storage(&fdp->ht, fdp->dfh.hash); 638 if (res) 639 goto out; 640 641 res = set_name(dirh, fdp, po, overwrite); 642 out: 643 if (res) { 644 put_dirh(dirh); 645 if (*fh) { 646 ree_fs_close(fh); 647 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &dfh); 648 } 649 } 650 mutex_unlock(&ree_fs_mutex); 651 652 return res; 653 } 654 655 static TEE_Result ree_fs_write(struct tee_file_handle *fh, size_t pos, 656 const void *buf, size_t len) 657 { 658 TEE_Result res; 659 struct tee_fs_dirfile_dirh *dirh = NULL; 660 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 661 662 mutex_lock(&ree_fs_mutex); 663 664 res = get_dirh(&dirh); 665 if (res) 666 goto out; 667 668 res = ree_fs_write_primitive(fh, pos, buf, len); 669 if (res) 670 goto out; 671 672 res = tee_fs_htree_sync_to_storage(&fdp->ht, fdp->dfh.hash); 673 if (res) 674 goto out; 675 676 res = tee_fs_dirfile_update_hash(dirh, &fdp->dfh); 677 if (res) 678 goto out; 679 res = tee_fs_dirfile_commit_writes(dirh); 680 out: 681 put_dirh(dirh); 682 mutex_unlock(&ree_fs_mutex); 683 684 return res; 685 } 686 687 static TEE_Result ree_fs_rename(struct tee_pobj *old, struct tee_pobj *new, 688 bool overwrite) 689 { 690 TEE_Result res; 691 struct tee_fs_dirfile_dirh *dirh = NULL; 692 struct tee_fs_dirfile_fileh dfh; 693 struct tee_fs_dirfile_fileh remove_dfh = { .idx = -1 }; 694 695 if (!new) 696 return TEE_ERROR_BAD_PARAMETERS; 697 698 mutex_lock(&ree_fs_mutex); 699 res = get_dirh(&dirh); 700 if (res) 701 goto out; 702 703 res = tee_fs_dirfile_find(dirh, &new->uuid, new->obj_id, 704 new->obj_id_len, &remove_dfh); 705 if (!res && !overwrite) { 706 res = TEE_ERROR_ACCESS_CONFLICT; 707 goto out; 708 } 709 710 res = tee_fs_dirfile_find(dirh, &old->uuid, old->obj_id, 711 old->obj_id_len, &dfh); 712 if (res) 713 goto out; 714 715 res = tee_fs_dirfile_rename(dirh, &new->uuid, &dfh, new->obj_id, 716 new->obj_id_len); 717 if (res) 718 goto out; 719 720 if (remove_dfh.idx != -1) { 721 res = tee_fs_dirfile_remove(dirh, &remove_dfh); 722 if (res) 723 goto out; 724 } 725 726 res = tee_fs_dirfile_commit_writes(dirh); 727 if (res) 728 goto out; 729 730 if (remove_dfh.idx != -1) 731 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &remove_dfh); 732 733 out: 734 put_dirh(dirh); 735 mutex_unlock(&ree_fs_mutex); 736 737 return res; 738 739 } 740 741 static TEE_Result ree_fs_remove(struct tee_pobj *po) 742 { 743 TEE_Result res; 744 struct tee_fs_dirfile_dirh *dirh = NULL; 745 struct tee_fs_dirfile_fileh dfh; 746 747 mutex_lock(&ree_fs_mutex); 748 res = get_dirh(&dirh); 749 if (res) 750 goto out; 751 752 res = tee_fs_dirfile_find(dirh, &po->uuid, po->obj_id, po->obj_id_len, 753 &dfh); 754 if (res) 755 goto out; 756 757 res = tee_fs_dirfile_remove(dirh, &dfh); 758 if (res) 759 goto out; 760 761 res = tee_fs_dirfile_commit_writes(dirh); 762 if (res) 763 goto out; 764 765 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &dfh); 766 767 assert(tee_fs_dirfile_find(dirh, &po->uuid, po->obj_id, po->obj_id_len, 768 &dfh)); 769 out: 770 put_dirh(dirh); 771 mutex_unlock(&ree_fs_mutex); 772 773 return res; 774 } 775 776 static TEE_Result ree_fs_truncate(struct tee_file_handle *fh, size_t len) 777 { 778 TEE_Result res; 779 struct tee_fs_dirfile_dirh *dirh = NULL; 780 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 781 782 mutex_lock(&ree_fs_mutex); 783 784 res = get_dirh(&dirh); 785 if (res != TEE_SUCCESS) 786 goto out; 787 788 res = ree_fs_ftruncate_internal(fdp, len); 789 if (!res) 790 goto out; 791 792 res = tee_fs_htree_sync_to_storage(&fdp->ht, fdp->dfh.hash); 793 if (!res) 794 goto out; 795 796 res = tee_fs_dirfile_update_hash(dirh, &fdp->dfh); 797 798 out: 799 put_dirh(dirh); 800 mutex_unlock(&ree_fs_mutex); 801 802 return res; 803 } 804 805 static TEE_Result ree_fs_opendir_rpc(const TEE_UUID *uuid, 806 struct tee_fs_dir **dir) 807 808 { 809 TEE_Result res; 810 struct tee_fs_dir *d = calloc(1, sizeof(*d)); 811 812 if (!d) 813 return TEE_ERROR_OUT_OF_MEMORY; 814 815 d->uuid = uuid; 816 817 mutex_lock(&ree_fs_mutex); 818 819 res = get_dirh(&d->dirh); 820 if (res) 821 goto out; 822 823 /* See that there's at least one file */ 824 d->idx = -1; 825 d->d.oidlen = sizeof(d->d.oid); 826 res = tee_fs_dirfile_get_next(d->dirh, d->uuid, &d->idx, d->d.oid, 827 &d->d.oidlen); 828 d->idx = -1; 829 830 out: 831 if (!res) { 832 *dir = d; 833 } else { 834 if (d) 835 put_dirh(d->dirh); 836 free(d); 837 } 838 mutex_unlock(&ree_fs_mutex); 839 840 return res; 841 } 842 843 static void ree_fs_closedir_rpc(struct tee_fs_dir *d) 844 { 845 if (d) { 846 mutex_lock(&ree_fs_mutex); 847 848 put_dirh(d->dirh); 849 free(d); 850 851 mutex_unlock(&ree_fs_mutex); 852 } 853 } 854 855 static TEE_Result ree_fs_readdir_rpc(struct tee_fs_dir *d, 856 struct tee_fs_dirent **ent) 857 { 858 TEE_Result res; 859 860 mutex_lock(&ree_fs_mutex); 861 862 d->d.oidlen = sizeof(d->d.oid); 863 res = tee_fs_dirfile_get_next(d->dirh, d->uuid, &d->idx, d->d.oid, 864 &d->d.oidlen); 865 if (res == TEE_SUCCESS) 866 *ent = &d->d; 867 868 mutex_unlock(&ree_fs_mutex); 869 870 return res; 871 } 872 873 const struct tee_file_operations ree_fs_ops = { 874 .open = ree_fs_open, 875 .create = ree_fs_create, 876 .close = ree_fs_close, 877 .read = ree_fs_read, 878 .write = ree_fs_write, 879 .truncate = ree_fs_truncate, 880 .rename = ree_fs_rename, 881 .remove = ree_fs_remove, 882 .opendir = ree_fs_opendir_rpc, 883 .closedir = ree_fs_closedir_rpc, 884 .readdir = ree_fs_readdir_rpc, 885 }; 886