IDE support.

Angelo Fraietta angelo_f at bigpond.com
Sun May 18 02:32:53 UTC 2003


I forgot the header

Angelo Fraietta wrote:

>
>
> Chris Johns wrote:
>
>> Hell Angelo,
>
>
> It gets a bit like that sometimes
>
>>
>> I hope you are staying dry in this wet weather.
>>
>> 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.
>>
>> I understand Thomas sent you a README. Also you asked for a simple 
>> demo app. I would also like one.
>>
>> 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.
>>
>> I feel your help would be invaluable to me and RTEMS.
>>
> The fsmount are the files needed to get the dsofs working.
>
> the init.c is the example that came with patch-- it is quite easy to 
> understand
>
>
> To get it working for me, I included the fsmount into my project and 
> added the functionality from init.c into my project.
>
> I have it working in my embedded target quite well.
>
>------------------------------------------------------------------------
>
>/*===============================================================*\
>| Project: RTEMS fsmount                                          |
>+-----------------------------------------------------------------+
>| File: fsmount.c                                                 |
>+-----------------------------------------------------------------+
>|                    Copyright (c) 2003 IMD                       |
>|      Ingenieurbuero fuer Microcomputertechnik Th. Doerfler      |
>|               <Thomas.Doerfler at imd-systems.de>                  |
>|                       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           |
>|  http://www.OARcorp.com/rtems/license.html.                     |
>|                                                                 |
>+-----------------------------------------------------------------+
>|   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;
>}
>  
>
>------------------------------------------------------------------------
>
>/*===============================================================*\
>| Project: RTEMS fsmount                                          |
>+-----------------------------------------------------------------+
>| File: fsmount.h                                                 |
>+-----------------------------------------------------------------+
>|                    Copyright (c) 2003 IMD                       |
>|      Ingenieurbuero fuer Microcomputertechnik Th. Doerfler      |
>|               <Thomas.Doerfler at imd-systems.de>                  |
>|                       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           |
>|  http://www.OARcorp.com/rtems/license.html.                     |
>|                                                                 |
>+-----------------------------------------------------------------+
>|   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 */
>  
>
>------------------------------------------------------------------------
>
>/*  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 <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();
>}
>
>  
>

-- 
Angelo Fraietta

PO Box 859
Hamilton NSW 2303

Home Page


http://www.users.bigpond.com/angelo_f/

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)


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.rtems.org/pipermail/users/attachments/20030518/650a3faa/attachment.html>
-------------- next part --------------
An embedded and charset-unspecified text was scrubbed...
Name: system.h
URL: <http://lists.rtems.org/pipermail/users/attachments/20030518/650a3faa/attachment.h>


More information about the users mailing list