<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=ISO-8859-1">
<title></title>
</head>
<body>
I forgot the header<br>
<br>
Angelo Fraietta wrote:<br>
<blockquote type="cite" cite="mid3EC6A781.3050605@bigpond.com"> <br>
<br>
Chris Johns wrote: <br>
<br>
<blockquote type="cite">Hell Angelo, <br>
</blockquote>
<br>
It gets a bit like that sometimes <br>
<br>
<blockquote type="cite"> <br>
I hope you are staying dry in this wet weather. <br>
<br>
I am tring to get an IDE interface working under RTEMS. I currently cannot
find any doco on how this software all goes together and the mail archives
have you asking these questions a while ago. This is the reason for the
email. <br>
<br>
I understand Thomas sent you a README. Also you asked for a simple demo
app. I would also like one. <br>
<br>
I would like to achieve a couple of things, first get my IDE hardware to
work :-), and pull all the doco together and get it into CVS. <br>
<br>
I feel your help would be invaluable to me and RTEMS. <br>
<br>
</blockquote>
The fsmount are the files needed to get the dsofs working. <br>
<br>
the init.c is the example that came with patch-- it is quite easy to understand
<br>
<br>
<br>
To get it working for me, I included the fsmount into my project and added
the functionality from init.c into my project. <br>
<br>
I have it working in my embedded target quite well. <br>
<br>
<pre wrap="">
<hr width="90%" size="4">
/*===============================================================*\
| Project: RTEMS fsmount |
+-----------------------------------------------------------------+
| File: fsmount.c |
+-----------------------------------------------------------------+
| Copyright (c) 2003 IMD |
| Ingenieurbuero fuer Microcomputertechnik Th. Doerfler |
| <a class="moz-txt-link-rfc2396E" href="mailto:Thomas.Doerfler@imd-systems.de"><Thomas.Doerfler@imd-systems.de></a> |
| all rights reserved |
+-----------------------------------------------------------------+
| this file contains the fsmount functions. These functions |
| are used to mount a list of filesystems (and create their mount |
| points before) |
| |
| The license and distribution terms for this file may be |
| found in the file LICENSE in this distribution or at |
| <a class="moz-txt-link-freetext" href="http://www.OARcorp.com/rtems/license.html">http://www.OARcorp.com/rtems/license.html</a>. |
| |
+-----------------------------------------------------------------+
| date history ID |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 02.07.03 creation doe |
\*===============================================================*/
#include <rtems.h>
#include <rtems/fsmount.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <imfs.h>
#include <sys/stat.h>
/*=========================================================================*\
| Function: |
\*-------------------------------------------------------------------------*/
int rtems_fsmount_create_mountpoint
(
/*-------------------------------------------------------------------------*\
| Purpose: |
| This function will create the mount point given |
+---------------------------------------------------------------------------+
| Input Parameters: |
\*-------------------------------------------------------------------------*/
const char *mount_point
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int rc = 0;
char *tok_buffer = NULL;
char *token = NULL;
int token_len;
size_t total_len;
IMFS_token_types token_type;
struct stat file_info;
/*
* allocate temp memory to rebuild path name
*/
tok_buffer = calloc(strlen(mount_point)+1,sizeof(char));
token = tok_buffer;
total_len = 0;
do {
/*
* scan through given string, one segment at a time
*/
token_type = IMFS_get_token(mount_point+total_len,token,&token_len);
total_len += token_len;
strncpy(tok_buffer,mount_point,total_len);
tok_buffer[total_len] = '\0';
if ((token_type != IMFS_NO_MORE_PATH) &&
(token_type != IMFS_CURRENT_DIR) &&
(token_type != IMFS_INVALID_TOKEN)) {
/*
* check, whether segment exists
*/
if (0 != stat(tok_buffer,&file_info)) {
/*
* if not, create directory
*/
rc = mknod(tok_buffer,S_IRWXU | S_IRWXG | S_IRWXO | S_IFDIR,0);
}
}
} while ((rc == 0) &&
(token_type != IMFS_NO_MORE_PATH) &&
(token_type != IMFS_INVALID_TOKEN));
/*
* return token buffer to heap
*/
if (tok_buffer != NULL) {
free(tok_buffer);
}
return rc;
}
/*=========================================================================*\
| Function: |
\*-------------------------------------------------------------------------*/
int rtems_fsmount
(
/*-------------------------------------------------------------------------*\
| Purpose: |
| This function will create the mount points listed and mount the file |
| systems listed in the calling parameters |
+---------------------------------------------------------------------------+
| Input Parameters: |
\*-------------------------------------------------------------------------*/
const fstab_t *fstab_ptr,
int fstab_count,
int *fail_idx
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int rc = 0;
int tmp_rc;
int fstab_idx = 0;
rtems_filesystem_mount_table_entry_t *tmp_mt_entry;
boolean terminate = FALSE;
/*
* scan through all fstab entries;
*/
while (!terminate &&
(fstab_idx < fstab_count)) {
tmp_rc = 0;
/*
* create mount point
*/
if (tmp_rc == 0) {
tmp_rc = rtems_fsmount_create_mountpoint(fstab_ptr->mount_point);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
printf("fsmount: creation of mount point \"%s\" failed: %s\n",
fstab_ptr->mount_point,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNTPNT_CRTERR)) {
terminate = TRUE;
rc = tmp_rc;
}
}
}
/*
* mount device to given mount point
*/
if (tmp_rc == RTEMS_SUCCESSFUL) {
tmp_rc = mount(&tmp_mt_entry,
fstab_ptr->fs_ops,
fstab_ptr->mount_options,
fstab_ptr->dev,
fstab_ptr->mount_point);
if (tmp_rc != RTEMS_SUCCESSFUL) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
printf("fsmount: mounting of \"%s\" to"
" \"%s\" failed: %s\n",
fstab_ptr->dev,
fstab_ptr->mount_point,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_FAILED)) {
terminate = TRUE;
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
printf("fsmount: mounting of \"%s\" to"
" \"%s\" succeeded\n",
fstab_ptr->dev,
fstab_ptr->mount_point);
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_OK)) {
terminate = TRUE;
}
}
}
/*
* proceed to next entry
*/
if (!terminate) {
fstab_ptr++;
fstab_idx++;
}
}
if (fail_idx != NULL) {
*fail_idx = fstab_idx;
}
return rc;
}
</pre>
<pre wrap="">
<hr width="90%" size="4">
/*===============================================================*\
| Project: RTEMS fsmount |
+-----------------------------------------------------------------+
| File: fsmount.h |
+-----------------------------------------------------------------+
| Copyright (c) 2003 IMD |
| Ingenieurbuero fuer Microcomputertechnik Th. Doerfler |
| <a class="moz-txt-link-rfc2396E" href="mailto:Thomas.Doerfler@imd-systems.de"><Thomas.Doerfler@imd-systems.de></a> |
| all rights reserved |
+-----------------------------------------------------------------+
| this file contains the fsmount functions. These functions |
| are used to mount a list of filesystems (and create their mount |
| points before) |
| |
| The license and distribution terms for this file may be |
| found in the file LICENSE in this distribution or at |
| <a class="moz-txt-link-freetext" href="http://www.OARcorp.com/rtems/license.html">http://www.OARcorp.com/rtems/license.html</a>. |
| |
+-----------------------------------------------------------------+
| date history ID |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 02.07.03 creation doe |
\*===============================================================*/
#ifndef _FSMOUNT_H
#define _FSMOUNT_H
#include <rtems.h>
#include <rtems/libio.h>
#include <rtems/libcsupport.h>
/*
* bits to define, what errors will cause reporting (via printf) and
* abort of mount processing
* Use a combination of these bits
* for the fields "report_reasons" and "abort_reasons"
*/
#define FSMOUNT_MNT_OK 0x0001 /* mounted ok */
#define FSMOUNT_MNTPNT_CRTERR 0x0002 /* cannot create mount point */
#define FSMOUNT_MNT_FAILED 0x0004 /* mounting failed */
typedef struct {
char *dev;
char *mount_point;
rtems_filesystem_operations_table *fs_ops;
rtems_filesystem_options_t mount_options;
unsigned16 report_reasons;
unsigned16 abort_reasons;
} fstab_t;
/*=========================================================================*\
| Function: |
\*-------------------------------------------------------------------------*/
int rtems_fsmount
(
/*-------------------------------------------------------------------------*\
| Purpose: |
| This function will create the mount points listed and mount the file |
| systems listed in the calling parameters |
+---------------------------------------------------------------------------+
| Input Parameters: |
\*-------------------------------------------------------------------------*/
const fstab_t *fstab_ptr, /* Ptr to filesystem mount table */
int fstab_count, /* number of entries in mount table*/
int *fail_idx /* return: index of failed entry */
);
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
#endif /* _FSMOUNT_H */
</pre>
<pre wrap="">
<hr width="90%" size="4">
/* 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
* <a class="moz-txt-link-freetext" href="http://www.OARcorp.com/rtems/license.html">http://www.OARcorp.com/rtems/license.html</a>.
*
* init.c,v 1.11 2000/06/12 15:00:12 joel Exp
*/
#define CONFIGURE_INIT
#include "system.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <rtems.h>
#include <fcntl.h>
#include <rtems/error.h>
#include <dosfs.h>
#include <ctype.h>
#include <rtems/ide_part_table.h>
#include <rtems/libcsupport.h>
#include <rtems/fsmount.h>
/*
* 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 <rtems/shell.h>
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();
}
</pre>
</blockquote>
<br>
<pre class="moz-signature" cols="$mailwrapcol">--
Angelo Fraietta
PO Box 859
Hamilton NSW 2303
Home Page
<a class="moz-txt-link-freetext" href="http://www.users.bigpond.com/angelo_f/">http://www.users.bigpond.com/angelo_f/</a>
There are those who seek knowledge for the sake of knowledge - that is CURIOSITY
There are those who seek knowledge to be known by others - that is VANITY
There are those who seek knowledge in order to serve - that is LOVE
Bernard of Clairvaux (1090 - 1153)</pre>
<br>
</body>
</html>