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