From ac0a2afe7392f4cb790fb67702da0f3b02cde556 Mon Sep 17 00:00:00 2001 From: Jennifer Averett Date: Wed, 6 Aug 2003 19:20:52 +0000 Subject: 2003-08-06 Thomas Doerfler PR 369/filesystem * Makefile.am, configure.ac: sample application to show the use of the DOSFS functions * fileio/Makefile.am, fileio/fileio.doc, fileio/init.c, fileio/system.h: New files. --- testsuites/samples/fileio/init.c | 600 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 600 insertions(+) create mode 100644 testsuites/samples/fileio/init.c (limited to 'testsuites/samples/fileio/init.c') diff --git a/testsuites/samples/fileio/init.c b/testsuites/samples/fileio/init.c new file mode 100644 index 0000000000..965a54dbd7 --- /dev/null +++ b/testsuites/samples/fileio/init.c @@ -0,0 +1,600 @@ +/* Init + * + * This routine is the initialization task for this test program. + * It is called from init_exec and has the responsibility for creating + * and starting the tasks that make up the test. If the time of day + * clock is required for the test, it should also be set to a known + * value by this function. + * + * Input parameters: NONE + * + * Output parameters: NONE + * + * COPYRIGHT (c) 1989-1999. + * On-Line Applications Research Corporation (OAR). + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * init.c,v 1.11 2000/06/12 15:00:12 joel Exp + */ + +#define CONFIGURE_INIT +#include "system.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * Table of FAT file systems that will be mounted + * with the "fsmount" function. + * See cpukit/libmisc/fsmount for definition of fields + */ +fstab_t fs_table[] = { + { + "/dev/hda1","/mnt/hda1", + &msdos_ops, RTEMS_FILESYSTEM_READ_WRITE, + FSMOUNT_MNT_OK | FSMOUNT_MNTPNT_CRTERR | FSMOUNT_MNT_FAILED, + 0 + }, + { + "/dev/hda2","/mnt/hda2", + &msdos_ops, RTEMS_FILESYSTEM_READ_WRITE, + FSMOUNT_MNT_OK | FSMOUNT_MNTPNT_CRTERR | FSMOUNT_MNT_FAILED, + 0 + }, + { + "/dev/hda3","/mnt/hda3", + &msdos_ops, RTEMS_FILESYSTEM_READ_WRITE, + FSMOUNT_MNT_OK | FSMOUNT_MNTPNT_CRTERR | FSMOUNT_MNT_FAILED, + 0 + }, + { + "/dev/hda4","/mnt/hda4", + &msdos_ops, RTEMS_FILESYSTEM_READ_WRITE, + FSMOUNT_MNT_OK | FSMOUNT_MNTPNT_CRTERR | FSMOUNT_MNT_FAILED, + 0 + }, + { + "/dev/hdc1","/mnt/hdc1", + &msdos_ops, RTEMS_FILESYSTEM_READ_WRITE, + FSMOUNT_MNT_OK | FSMOUNT_MNTPNT_CRTERR | FSMOUNT_MNT_FAILED, + 0 + }, + { + "/dev/hdc2","/mnt/hdc2", + &msdos_ops, RTEMS_FILESYSTEM_READ_WRITE, + FSMOUNT_MNT_OK | FSMOUNT_MNTPNT_CRTERR | FSMOUNT_MNT_FAILED, + 0 + }, + { + "/dev/hdc3","/mnt/hdc3", + &msdos_ops, RTEMS_FILESYSTEM_READ_WRITE, + FSMOUNT_MNT_OK | FSMOUNT_MNTPNT_CRTERR | FSMOUNT_MNT_FAILED, + 0 + }, + { + "/dev/hdc4","/mnt/hdc4", + &msdos_ops, RTEMS_FILESYSTEM_READ_WRITE, + FSMOUNT_MNT_OK | FSMOUNT_MNTPNT_CRTERR | FSMOUNT_MNT_FAILED, + 0 + } +}; + +#ifndef MIN +#define MIN(a,b) (((a) > (b)) ? (b) : (a)) +#endif + +#define USE_SHELL + +#ifdef USE_SHELL +#include + +void fileio_start_shell(void) +{ + printf(" =========================\n"); + printf(" starting shell\n"); + printf(" =========================\n"); + shell_init("SHLL",0,100,"/dev/console", + B9600 | CS8, + 0); + rtems_task_suspend(RTEMS_SELF); +} + +#endif /* USE_SHELL */ + +void fileio_print_free_heap(void) +{ + printf("--- unused dynamic memory: %lu bytes ---\n", + (unsigned long) malloc_free_space()); +} + + +void fileio_part_table_initialize(void) +{ + char devname[64]; + rtems_status_code rc; + + printf(" =========================\n"); + printf(" Initialize partition table\n"); + printf(" =========================\n"); + fileio_print_free_heap(); + printf(" Enter device to initialize ==>"); + fgets(devname,sizeof(devname)-1,stdin); + while (devname[strlen(devname)-1] == '\n') { + devname[strlen(devname)-1] = '\0'; + } + /* + * call function + */ + rc = rtems_ide_part_table_initialize(devname); + printf("result = %d\n",rc); + fileio_print_free_heap(); +} + +void fileio_fsmount(void) +{ + rtems_status_code rc; + + printf(" =========================\n"); + printf(" Process fsmount table\n"); + printf(" =========================\n"); + fileio_print_free_heap(); + /* + * call function + */ + rc = rtems_fsmount( fs_table, + sizeof(fs_table)/sizeof(fs_table[0]), + NULL); + printf("result = %d\n",rc); + fileio_print_free_heap(); +} + +void fileio_list_file(void) +{ + char fname[1024]; + char *buf_ptr = NULL; + unsigned32 flen = 0; + int fd = -1; + ssize_t n; + size_t buf_size = 100; + + rtems_interval start_tick,curr_tick,ticks_per_sec; + + printf(" =========================\n"); + printf(" LIST FILE ... \n"); + printf(" =========================\n"); + fileio_print_free_heap(); + printf(" Enter filename to list ==>"); + fgets(fname,sizeof(fname)-1,stdin); + while (fname[strlen(fname)-1] == '\n') { + fname[strlen(fname)-1] = '\0'; + } + /* + * allocate buffer of given size + */ + if (buf_size > 0) { + buf_ptr = malloc(buf_size); + } + + if (buf_ptr != NULL) { + printf("\n Trying to open file \"%s\" for read\n",fname); + fd = open(fname,O_RDONLY); + if (fd < 0) { + printf("*** file open failed, errno = %d(%s)\n",errno,strerror(errno)); + } + } + + if (fd >= 0) { + rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start_tick); + do { + n = read(fd,buf_ptr,buf_size); + if (n > 0) { + write(1,buf_ptr,n); + flen += n; + } + } while (n > 0); + + rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &curr_tick); + + printf("\n ******** End of file reached, flen = %d\n",flen); + close(fd); + + rtems_clock_get(RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticks_per_sec); + printf("time elapsed for read: %g seconds\n", + ((double)curr_tick-start_tick)/ticks_per_sec); + } + /* + * free buffer + */ + if (buf_ptr != NULL) { + free(buf_ptr); + } + fileio_print_free_heap(); +} + +/* + * convert a size string (like 34K or 12M) to actual byte count + */ +boolean fileio_str2size(const char *str,unsigned32 *res_ptr) +{ + boolean failed = FALSE; + unsigned long size; + char suffix = ' '; + + if (1 > sscanf(str,"%lu%c",&size,&suffix)) { + failed = TRUE; + } + else if (toupper(suffix) == 'K') { + size *= 1024; + } + else if (toupper(suffix) == 'M') { + size *= 1024UL*1024UL; + } + else if (isalpha(suffix)) { + failed = TRUE; + } + + if (!failed) { + *res_ptr = size; + } + return failed; +} + +void fileio_write_file(void) +{ + char fname[1024]; + char tmp_str[32]; + unsigned32 file_size = 0; + unsigned32 buf_size = 0; + size_t curr_pos,bytes_to_copy; + int fd = -1; + ssize_t n; + rtems_interval start_tick,curr_tick,ticks_per_sec; + char *bufptr = NULL; + boolean failed = FALSE; + static const char write_test_string[] = + "The quick brown fox jumps over the lazy dog\n"; + static const char write_block_string[] = + "\n----- end of write buffer ------\n"; + + printf(" =========================\n"); + printf(" WRITE FILE ... \n"); + printf(" =========================\n"); + fileio_print_free_heap(); + /* + * get number of ticks per second + */ + rtems_clock_get(RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticks_per_sec); + + /* + * get path to file to write + */ + if (!failed) { + printf("Enter path/filename ==>"); + fgets(fname,sizeof(fname)-1,stdin); + while (fname[strlen(fname)-1] == '\n') { + fname[strlen(fname)-1] = '\0'; + } + if (0 == strlen(fname)) { + printf("*** no filename entered, aborted\n"); + failed = TRUE; + } + } + /* + * get total file size to write + */ + if (!failed) { + printf("use suffix K for Kbytes, M for Mbytes or no suffix for bytes:\n" + "Enter filesize to write ==>"); + fgets(tmp_str,sizeof(tmp_str)-1,stdin); + failed = fileio_str2size(tmp_str,&file_size); + if (failed) { + printf("*** illegal file size, aborted\n"); + } + } + /* + * get block size to write + */ + if (!failed) { + printf("use suffix K for Kbytes, M for Mbytes or no suffix for bytes:\n" + "Enter block size to use for write calls ==>"); + fgets(tmp_str,sizeof(tmp_str)-1,stdin); + failed = fileio_str2size(tmp_str,&buf_size); + if (failed) { + printf("*** illegal block size, aborted\n"); + } + } + + /* + * allocate buffer + */ + if (!failed) { + printf("... allocating %lu bytes of buffer for write data\n", + (unsigned long)buf_size); + bufptr = malloc(buf_size+1); /* extra space for terminating NUL char */ + if (bufptr == NULL) { + printf("*** malloc failed, aborted\n"); + failed = TRUE; + } + } + /* + * fill buffer with test pattern + */ + if (!failed) { + printf("... filling buffer with write data\n"); + curr_pos = 0; + /* + * fill buffer with test string + */ + while (curr_pos < buf_size) { + bytes_to_copy = MIN(buf_size-curr_pos, + sizeof(write_test_string)-1); + memcpy(bufptr+curr_pos,write_test_string,bytes_to_copy); + curr_pos += bytes_to_copy; + } + /* + * put "end" mark at end of buffer + */ + bytes_to_copy = sizeof(write_block_string)-1; + if (buf_size >= bytes_to_copy) { + memcpy(bufptr+buf_size-bytes_to_copy, + write_block_string, + bytes_to_copy); + } + } + /* + * create file + */ + if (!failed) { + printf("... creating file \"%s\"\n",fname); + fd = open(fname,O_WRONLY | O_CREAT | O_TRUNC,S_IREAD|S_IWRITE); + if (fd < 0) { + printf("*** file create failed, errno = %d(%s)\n",errno,strerror(errno)); + failed = TRUE; + } + } + /* + * write file + */ + if (!failed) { + printf("... writing to file\n"); + rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start_tick); + curr_pos = 0; + do { + bytes_to_copy = buf_size; + do { + n = write(fd, + bufptr + (buf_size-bytes_to_copy), + MIN(bytes_to_copy,file_size-curr_pos)); + if (n > 0) { + bytes_to_copy -= n; + curr_pos += n; + } + } while ((bytes_to_copy > 0) && (n > 0)); + } while ((file_size > curr_pos) && (n > 0)); + rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &curr_tick); + if (n < 0) { + failed = TRUE; + printf("*** file write failed, " + "%lu bytes written, " + "errno = %d(%s)\n", + (unsigned long)curr_pos,errno,strerror(errno)); + } + else { + printf("time elapsed for write: %g seconds\n", + ((double)curr_tick-start_tick)/ticks_per_sec); + printf("write data rate: %g KBytes/second\n", + (((double)file_size) / 1024.0 / + (((double)curr_tick-start_tick)/ticks_per_sec))); + } + } + if (fd >= 0) { + printf("... closing file\n"); + close(fd); + } + if (bufptr != NULL) { + printf("... deallocating buffer\n"); + free(bufptr); + bufptr = NULL; + } + printf("\n ******** End of file write\n"); + fileio_print_free_heap(); +} + +void fileio_read_file(void) +{ + char fname[1024]; + char tmp_str[32]; + unsigned32 buf_size = 0; + size_t curr_pos; + int fd = -1; + ssize_t n; + rtems_interval start_tick,curr_tick,ticks_per_sec; + char *bufptr = NULL; + boolean failed = FALSE; + + printf(" =========================\n"); + printf(" READ FILE ... \n"); + printf(" =========================\n"); + fileio_print_free_heap(); + /* + * get number of ticks per second + */ + rtems_clock_get(RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticks_per_sec); + + /* + * get path to file to read + */ + if (!failed) { + printf("Enter path/filename ==>"); + fgets(fname,sizeof(fname)-1,stdin); + while (fname[strlen(fname)-1] == '\n') { + fname[strlen(fname)-1] = '\0'; + } + if (0 == strlen(fname)) { + printf("*** no filename entered, aborted\n"); + failed = TRUE; + } + } + /* + * get block size to read + */ + if (!failed) { + printf("use suffix K for Kbytes, M for Mbytes or no suffix for bytes:\n" + "Enter block size to use for read calls ==>"); + fgets(tmp_str,sizeof(tmp_str)-1,stdin); + failed = fileio_str2size(tmp_str,&buf_size); + if (failed) { + printf("*** illegal block size, aborted\n"); + } + } + + /* + * allocate buffer + */ + if (!failed) { + printf("... allocating %lu bytes of buffer for write data\n", + (unsigned long)buf_size); + bufptr = malloc(buf_size+1); /* extra space for terminating NUL char */ + if (bufptr == NULL) { + printf("*** malloc failed, aborted\n"); + failed = TRUE; + } + } + /* + * open file + */ + if (!failed) { + printf("... opening file \"%s\"\n",fname); + fd = open(fname,O_RDONLY); + if (fd < 0) { + printf("*** file open failed, errno = %d(%s)\n",errno,strerror(errno)); + failed = TRUE; + } + } + /* + * read file + */ + if (!failed) { + printf("... reading from file\n"); + rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start_tick); + curr_pos = 0; + do { + n = read(fd, + bufptr, + buf_size); + if (n > 0) { + curr_pos += n; + } + } while (n > 0); + rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &curr_tick); + if (n < 0) { + failed = TRUE; + printf("*** file read failed, " + "%lu bytes read, " + "errno = %d(%s)\n", + (unsigned long)curr_pos,errno,strerror(errno)); + } + else { + printf("%lu bytes read\n", + (unsigned long)curr_pos); + printf("time elapsed for read: %g seconds\n", + ((double)curr_tick-start_tick)/ticks_per_sec); + printf("read data rate: %g KBytes/second\n", + (((double)curr_pos) / 1024.0 / + (((double)curr_tick-start_tick)/ticks_per_sec))); + } + } + if (fd >= 0) { + printf("... closing file\n"); + close(fd); + } + if (bufptr != NULL) { + printf("... deallocating buffer\n"); + free(bufptr); + bufptr = NULL; + } + printf("\n ******** End of file read\n"); + fileio_print_free_heap(); + +} + +void fileio_menu (void) +{ + char inbuf[10]; + + /* + * Wait for characters from console terminal + */ + for (;;) { + printf(" =========================\n"); + printf(" RTEMS FILE I/O Test Menu \n"); + printf(" =========================\n"); + printf(" p -> part_table_initialize\n"); + printf(" f -> mount all disks in fs_table\n"); + printf(" l -> list file\n"); + printf(" r -> read file\n"); + printf(" w -> write file\n"); +#ifdef USE_SHELL + printf(" s -> start shell\n"); +#endif + printf(" Enter your selection ==>"); + + inbuf[0] = '\0'; + fgets(inbuf,sizeof(inbuf),stdin); + switch (inbuf[0]) { + case 'l': + fileio_list_file (); + break; + case 'r': + fileio_read_file (); + break; + case 'w': + fileio_write_file (); + break; + case 'p': + fileio_part_table_initialize (); + break; + case 'f': + fileio_fsmount (); + break; +#ifdef USE_SHELL + case 's': + fileio_start_shell (); + break; +#endif + default: + printf("Selection `%c` not implemented\n",inbuf[0]); + break; + } + + } + exit (0); +} + +int menu_tid; + +/* + * RTEMS Startup Task + */ +rtems_task +Init (rtems_task_argument ignored) +{ + puts( "\n\n*** FILE I/O SAMPLE AND TEST ***" ); + + fileio_menu(); +} + + -- cgit v1.2.3