| /* |
| * Copyright (c) 2023 Husqvarna AB |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include "test_fat.h" |
| |
| #ifdef CONFIG_FS_FATFS_REENTRANT |
| |
| #define REENTRANT_TEST_STACK_SIZE 500 |
| #define SEMAPHORE_OP_SUCCESS 0 |
| #define TEST_FILE2 FATFS_MNTP"/tfile2.txt" |
| |
| void tlock_mutex(void *p1, void *p2, void *p3); |
| void tfile2_access(void *p1, void *p2, void *p3); |
| |
| K_THREAD_STACK_DEFINE(tlock_mutex_stack_area, REENTRANT_TEST_STACK_SIZE); |
| K_THREAD_STACK_DEFINE(tfile2_access_stack_area, REENTRANT_TEST_STACK_SIZE); |
| struct k_thread tlock_mutex_data; |
| struct k_thread tfile2_access_data; |
| struct k_sem mutex_unlocked_sem; |
| struct k_sem run_non_thread_sem; |
| |
| static int test_reentrant_access(void) |
| { |
| int res; |
| |
| TC_PRINT("\nReentrant tests:\n"); |
| zassert_ok(k_sem_init(&mutex_unlocked_sem, 0, 1), NULL); |
| zassert_ok(k_sem_init(&run_non_thread_sem, 0, 1), NULL); |
| |
| /* Start mutex locking thread */ |
| k_tid_t tid = k_thread_create(&tlock_mutex_data, tlock_mutex_stack_area, |
| K_THREAD_STACK_SIZEOF(tlock_mutex_stack_area), |
| tlock_mutex, |
| NULL, NULL, NULL, |
| K_PRIO_PREEMPT(0), 0, K_NO_WAIT); |
| |
| /* Make sure thread was able to lock mutex */ |
| k_sem_take(&run_non_thread_sem, K_FOREVER); |
| |
| /* File open should wait here, as the fs is locked. Therefore, automatic switch back to |
| * thread |
| */ |
| TC_PRINT("Open file\n"); |
| res = fs_open(&filep, TEST_FILE, FS_O_CREATE | FS_O_RDWR); |
| zassert_ok(res, "Err: File could not be opened [%d]\n", res); |
| TC_PRINT("File opened\n"); |
| |
| /* Check if mutex thread really unlocked the mutexes */ |
| zassert_equal(SEMAPHORE_OP_SUCCESS, k_sem_take(&mutex_unlocked_sem, K_NO_WAIT), |
| "File open with locked mutex"); |
| |
| /* Cleanup */ |
| res = fs_close(&filep); |
| zassert_ok(res, "Error closing file [%d]\n", res); |
| res = fs_unlink(TEST_FILE); |
| zassert_ok(res, "Error deleting file [%d]\n", res); |
| |
| k_thread_join(tid, K_FOREVER); |
| |
| return res; |
| } |
| |
| static int test_reentrant_parallel_file_access(void) |
| { |
| int res; |
| |
| TC_PRINT("\nParallel reentrant-safe file access test:\n"); |
| |
| TC_PRINT("Open file 1\n"); |
| res = fs_open(&filep, TEST_FILE, FS_O_CREATE | FS_O_RDWR); |
| zassert_ok(res, "Err: File 1 could not be opened [%d]\n", res); |
| TC_PRINT("File 1 opened 1\n"); |
| |
| /* Start 2nd file acces thread */ |
| k_tid_t tid = k_thread_create(&tfile2_access_data, tfile2_access_stack_area, |
| K_THREAD_STACK_SIZEOF(tfile2_access_stack_area), |
| tfile2_access, |
| NULL, NULL, NULL, |
| K_PRIO_PREEMPT(0), 0, K_NO_WAIT); |
| |
| /* Wait for thread to finish accessing file 2 */ |
| k_thread_join(tid, K_FOREVER); |
| |
| /* Check existence of file 2 */ |
| struct fs_file_t filep2; |
| |
| fs_file_t_init(&filep2); |
| |
| TC_PRINT("Check file 2 existence\n"); |
| res = fs_open(&filep2, TEST_FILE2, FA_OPEN_EXISTING | FA_READ); |
| zassert_ok(res, "Err: File 2 does not exist [%d]\n", res); |
| |
| /* Cleanup */ |
| res = fs_close(&filep2); |
| zassert_ok(res, "Error closing file 2 [%d]\n", res); |
| res = fs_unlink(TEST_FILE2); |
| zassert_ok(res, "Error deleting file 2 [%d]\n", res); |
| res = fs_close(&filep); |
| zassert_ok(res, "Error closing file 1 [%d]\n", res); |
| res = fs_unlink(TEST_FILE); |
| zassert_ok(res, "Error deleting file 1 [%d]\n", res); |
| |
| return res; |
| } |
| |
| void release_dirty_mutex(void) |
| { |
| ff_mutex_give(fat_fs.ldrv); |
| } |
| |
| int request_dirty_mutex(void) |
| { |
| return ff_mutex_take(fat_fs.ldrv); |
| } |
| |
| void tlock_mutex(void *p1, void *p2, void *p3) |
| { |
| TC_PRINT("Mutex thread: Started, locking fs\n"); |
| request_dirty_mutex(); |
| TC_PRINT("Mutex thread: Lock acquired, yield to switch back to try to open file\n"); |
| k_sem_give(&run_non_thread_sem); |
| k_yield(); |
| |
| TC_PRINT("Mutex thread: Got back to thread, release mutex now and give semaphore to check " |
| "if file opened\n"); |
| k_sem_give(&mutex_unlocked_sem); |
| release_dirty_mutex(); |
| |
| TC_PRINT("Mutex thread: Lock released, thread terminating\n"); |
| } |
| |
| void tfile2_access(void *p1, void *p2, void *p3) |
| { |
| int res; |
| ssize_t brw; |
| struct fs_file_t filep2; |
| |
| TC_PRINT("File 2 access thread started\n"); |
| |
| /* Init fp for 2nd File for parallel access test */ |
| fs_file_t_init(&filep2); |
| |
| /* open 2nd file */ |
| TC_PRINT("Open file 2\n"); |
| res = fs_open(&filep2, TEST_FILE2, FS_O_CREATE | FS_O_RDWR); |
| zassert_ok(res, "Err: File 2 could not be opened [%d]\n", res); |
| TC_PRINT("File 2 opened 2\n"); |
| |
| /* Verify fs_write() not locked */ |
| brw = fs_write(&filep2, (char *)test_str, strlen(test_str)); |
| if (brw < 0) { |
| TC_PRINT("Failed writing to file [%zd]\n", brw); |
| fs_close(&filep2); |
| return; |
| } |
| |
| if (brw < strlen(test_str)) { |
| TC_PRINT("Unable to complete write. Volume full.\n"); |
| TC_PRINT("Number of bytes written: [%zd]\n", brw); |
| fs_close(&filep2); |
| return; |
| } |
| |
| /* Close file and switch back to test context*/ |
| res = fs_close(&filep2); |
| zassert_ok(res, "Error closing file [%d]\n", res); |
| |
| TC_PRINT("File 2 access thread successfully wrote to file 2\n"); |
| } |
| |
| void test_fat_file_reentrant(void) |
| { |
| zassert_true(test_reentrant_access() == TC_PASS, NULL); |
| zassert_true(test_reentrant_parallel_file_access() == TC_PASS, NULL); |
| } |
| #endif /* CONFIG_FS_FATFS_REENTRANT */ |