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_primitive(*fh); 647 *fh = NULL; 648 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &dfh); 649 } 650 } 651 mutex_unlock(&ree_fs_mutex); 652 653 return res; 654 } 655 656 static TEE_Result ree_fs_write(struct tee_file_handle *fh, size_t pos, 657 const void *buf, size_t len) 658 { 659 TEE_Result res; 660 struct tee_fs_dirfile_dirh *dirh = NULL; 661 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 662 663 mutex_lock(&ree_fs_mutex); 664 665 res = get_dirh(&dirh); 666 if (res) 667 goto out; 668 669 res = ree_fs_write_primitive(fh, pos, buf, len); 670 if (res) 671 goto out; 672 673 res = tee_fs_htree_sync_to_storage(&fdp->ht, fdp->dfh.hash); 674 if (res) 675 goto out; 676 677 res = tee_fs_dirfile_update_hash(dirh, &fdp->dfh); 678 if (res) 679 goto out; 680 res = tee_fs_dirfile_commit_writes(dirh); 681 out: 682 put_dirh(dirh); 683 mutex_unlock(&ree_fs_mutex); 684 685 return res; 686 } 687 688 static TEE_Result ree_fs_rename(struct tee_pobj *old, struct tee_pobj *new, 689 bool overwrite) 690 { 691 TEE_Result res; 692 struct tee_fs_dirfile_dirh *dirh = NULL; 693 struct tee_fs_dirfile_fileh dfh; 694 struct tee_fs_dirfile_fileh remove_dfh = { .idx = -1 }; 695 696 if (!new) 697 return TEE_ERROR_BAD_PARAMETERS; 698 699 mutex_lock(&ree_fs_mutex); 700 res = get_dirh(&dirh); 701 if (res) 702 goto out; 703 704 res = tee_fs_dirfile_find(dirh, &new->uuid, new->obj_id, 705 new->obj_id_len, &remove_dfh); 706 if (!res && !overwrite) { 707 res = TEE_ERROR_ACCESS_CONFLICT; 708 goto out; 709 } 710 711 res = tee_fs_dirfile_find(dirh, &old->uuid, old->obj_id, 712 old->obj_id_len, &dfh); 713 if (res) 714 goto out; 715 716 res = tee_fs_dirfile_rename(dirh, &new->uuid, &dfh, new->obj_id, 717 new->obj_id_len); 718 if (res) 719 goto out; 720 721 if (remove_dfh.idx != -1) { 722 res = tee_fs_dirfile_remove(dirh, &remove_dfh); 723 if (res) 724 goto out; 725 } 726 727 res = tee_fs_dirfile_commit_writes(dirh); 728 if (res) 729 goto out; 730 731 if (remove_dfh.idx != -1) 732 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &remove_dfh); 733 734 out: 735 put_dirh(dirh); 736 mutex_unlock(&ree_fs_mutex); 737 738 return res; 739 740 } 741 742 static TEE_Result ree_fs_remove(struct tee_pobj *po) 743 { 744 TEE_Result res; 745 struct tee_fs_dirfile_dirh *dirh = NULL; 746 struct tee_fs_dirfile_fileh dfh; 747 748 mutex_lock(&ree_fs_mutex); 749 res = get_dirh(&dirh); 750 if (res) 751 goto out; 752 753 res = tee_fs_dirfile_find(dirh, &po->uuid, po->obj_id, po->obj_id_len, 754 &dfh); 755 if (res) 756 goto out; 757 758 res = tee_fs_dirfile_remove(dirh, &dfh); 759 if (res) 760 goto out; 761 762 res = tee_fs_dirfile_commit_writes(dirh); 763 if (res) 764 goto out; 765 766 tee_fs_rpc_remove_dfh(OPTEE_MSG_RPC_CMD_FS, &dfh); 767 768 assert(tee_fs_dirfile_find(dirh, &po->uuid, po->obj_id, po->obj_id_len, 769 &dfh)); 770 out: 771 put_dirh(dirh); 772 mutex_unlock(&ree_fs_mutex); 773 774 return res; 775 } 776 777 static TEE_Result ree_fs_truncate(struct tee_file_handle *fh, size_t len) 778 { 779 TEE_Result res; 780 struct tee_fs_dirfile_dirh *dirh = NULL; 781 struct tee_fs_fd *fdp = (struct tee_fs_fd *)fh; 782 783 mutex_lock(&ree_fs_mutex); 784 785 res = get_dirh(&dirh); 786 if (res != TEE_SUCCESS) 787 goto out; 788 789 res = ree_fs_ftruncate_internal(fdp, len); 790 if (!res) 791 goto out; 792 793 res = tee_fs_htree_sync_to_storage(&fdp->ht, fdp->dfh.hash); 794 if (!res) 795 goto out; 796 797 res = tee_fs_dirfile_update_hash(dirh, &fdp->dfh); 798 799 out: 800 put_dirh(dirh); 801 mutex_unlock(&ree_fs_mutex); 802 803 return res; 804 } 805 806 static TEE_Result ree_fs_opendir_rpc(const TEE_UUID *uuid, 807 struct tee_fs_dir **dir) 808 809 { 810 TEE_Result res; 811 struct tee_fs_dir *d = calloc(1, sizeof(*d)); 812 813 if (!d) 814 return TEE_ERROR_OUT_OF_MEMORY; 815 816 d->uuid = uuid; 817 818 mutex_lock(&ree_fs_mutex); 819 820 res = get_dirh(&d->dirh); 821 if (res) 822 goto out; 823 824 /* See that there's at least one file */ 825 d->idx = -1; 826 d->d.oidlen = sizeof(d->d.oid); 827 res = tee_fs_dirfile_get_next(d->dirh, d->uuid, &d->idx, d->d.oid, 828 &d->d.oidlen); 829 d->idx = -1; 830 831 out: 832 if (!res) { 833 *dir = d; 834 } else { 835 if (d) 836 put_dirh(d->dirh); 837 free(d); 838 } 839 mutex_unlock(&ree_fs_mutex); 840 841 return res; 842 } 843 844 static void ree_fs_closedir_rpc(struct tee_fs_dir *d) 845 { 846 if (d) { 847 mutex_lock(&ree_fs_mutex); 848 849 put_dirh(d->dirh); 850 free(d); 851 852 mutex_unlock(&ree_fs_mutex); 853 } 854 } 855 856 static TEE_Result ree_fs_readdir_rpc(struct tee_fs_dir *d, 857 struct tee_fs_dirent **ent) 858 { 859 TEE_Result res; 860 861 mutex_lock(&ree_fs_mutex); 862 863 d->d.oidlen = sizeof(d->d.oid); 864 res = tee_fs_dirfile_get_next(d->dirh, d->uuid, &d->idx, d->d.oid, 865 &d->d.oidlen); 866 if (res == TEE_SUCCESS) 867 *ent = &d->d; 868 869 mutex_unlock(&ree_fs_mutex); 870 871 return res; 872 } 873 874 const struct tee_file_operations ree_fs_ops = { 875 .open = ree_fs_open, 876 .create = ree_fs_create, 877 .close = ree_fs_close, 878 .read = ree_fs_read, 879 .write = ree_fs_write, 880 .truncate = ree_fs_truncate, 881 .rename = ree_fs_rename, 882 .remove = ree_fs_remove, 883 .opendir = ree_fs_opendir_rpc, 884 .closedir = ree_fs_closedir_rpc, 885 .readdir = ree_fs_readdir_rpc, 886 }; 887