Subversion Repositories openrisc

/*
 *  XXX
 *
 *  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.
 *
 *  $Id: imfs_directory.c,v 1.2 2001-09-27 12:01:15 chris Exp $
 */
 
#include <sys/types.h>
#include <sys/stat.h>
#include <chain.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <dirent.h>
 
#include "imfs.h"
#include "libio_.h"
 
/* -----------------------------------------------------------------------
 * This rountine will verify that the node being opened as a directory is
 * in fact a directory node. If it is then the offset into the directory 
 * will be set to 0 to position to the first directory entry.
 */
 
int imfs_dir_open( 
  rtems_libio_t  *iop,
  const char *pathname,
  unsigned32 flag,
  unsigned32 mode
)
{
  IMFS_jnode_t      *the_jnode;
 
  /* Is the node a directory ? */
  the_jnode = (IMFS_jnode_t *) iop->file_info;
 
  if ( the_jnode->type != IMFS_DIRECTORY )
     return -1;		/* It wasn't a directory --> return error */
 
  iop->offset = 0;
  return 0;
}
 
 
 
/* -----------------------------------------------------------------------
 * This routine will read the next directory entry based on the directory 
 * offset. The offset should be equal to -n- time the size of an individual
 * dirent structure. If n is not an integer multiple of the sizeof a 
 * dirent structure, an integer division will be performed to determine 
 * directory entry that will be returned in the buffer. Count should reflect
 * -m- times the sizeof dirent bytes to be placed in the buffer.
 * If there are not -m- dirent elements from the current directory position
 * to the end of the exisiting file, the remaining entries will be placed in 
 * the buffer and the returned value will be equal to -m actual- times the
 * size of a directory entry.
 */
 
int imfs_dir_read(
  rtems_libio_t  *iop,
  void *buffer,
  unsigned32 count
)
{
  /*
   *  Read up to element  iop->offset in the directory chain of the
   *  imfs_jnode_t struct for this file descriptor.
   */
   Chain_Node        *the_node;
   Chain_Control     *the_chain;
   IMFS_jnode_t      *the_jnode;
   int                bytes_transferred;
   int 	              current_entry;
   int 	              first_entry;
   int 	              last_entry;
   struct dirent      tmp_dirent;
 
   the_jnode = (IMFS_jnode_t *)iop->file_info;
   the_chain = &the_jnode->info.directory.Entries;
 
   if ( Chain_Is_empty( the_chain ) )
      return 0;
 
   /* Move to the first of the desired directory entries */
   the_node = the_chain->first;
 
   bytes_transferred = 0;
   first_entry = iop->offset;
   /* protect against using sizes that are not exact multiples of the */
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
 
   /* The directory was not empty so try to move to the desired entry in chain*/
   for( 
      current_entry = 0; 
      current_entry < last_entry; 
      current_entry = current_entry + sizeof(struct dirent) ){
 
      if ( Chain_Is_tail( the_chain, the_node ) ){ 
         /* We hit the tail of the chain while trying to move to the first */
         /* entry in the read */
         return bytes_transferred;  /* Indicate that there are no more */
                                    /* entries to return */
      }
 
      if( current_entry >= first_entry ) {
         /* Move the entry to the return buffer */
         tmp_dirent.d_ino = 1;
         tmp_dirent.d_off = current_entry;
         tmp_dirent.d_reclen = sizeof( struct dirent );
         the_jnode = (IMFS_jnode_t *) the_node;
         tmp_dirent.d_namlen = strlen( the_jnode->name );
         strcpy( tmp_dirent.d_name, the_jnode->name );
         memcpy( 
            buffer + bytes_transferred, 
            (void *)&tmp_dirent, 
            sizeof( struct dirent ) 
         );
         iop->offset = iop->offset + sizeof(struct dirent);
         bytes_transferred = bytes_transferred + sizeof( struct dirent );
      }
 
      the_node = the_node->next;
   }
 
   /* Success */
   return bytes_transferred;
}
 
 
 
/* -----------------------------------------------------------------------
 * This routine will be called by the generic close routine to cleanup any
 * resources that have been allocated for the management of the file
 */
 
int imfs_dir_close(
  rtems_libio_t  *iop
)
{
  /* The generic close routine handles the deallocation of the file control */
  /* and associated memory. At present the imfs_dir_close simply      */
  /* returns a successful completion status                                 */
 
  return 0;
}
 
 
 
/* -----------------------------------------------------------------------
 * This routine will behave in one of three ways based on the state of 
 * argument whence. Based on the state of its value the offset argument will
 * be interpreted using one of the following methods:
 *
 * 	SEEK_SET - offset is the absolute byte offset from the start of the
 *                 logical start of the dirent sequence that represents the
 *                 directory
 * 	SEEK_CUR - offset is used as the relative byte offset from the current
 *                 directory position index held in the iop structure
 *	SEEK_END - N/A --> This will cause an assert.
 */
 
int imfs_dir_lseek(
  rtems_libio_t  *iop,
  off_t           offset,
  int             whence
)
{
  off_t normal_offset;
 
  normal_offset = (offset/sizeof(struct dirent)) * sizeof(struct dirent);
 
 
  switch( whence )
  {
     case SEEK_SET:	/* absolute move from the start of the file */
        iop->offset = normal_offset;
        break;
 
     case SEEK_CUR:	/* relative move */
        iop->offset = iop->offset + normal_offset;
        break;
 
     case SEEK_END:	/* Movement past the end of the directory via lseek */
	      		/* is not a permitted operation                     */
      default:
        set_errno_and_return_minus_one( EINVAL );
        break;
 
  }
 
  return 0;
}
 
 
 
/* -----------------------------------------------------------------------
 * This routine will obtain the following information concerning the current 
 * directory:
 * 	st_dev		0ll
 *	st_ino		1
 *  	st_mode		mode extracted from the jnode
 *	st_nlink	number of links to this node
 * 	st_uid		uid extracted from the jnode
 *	st_gid		gid extracted from the jnode
 * 	st_rdev		0ll
 *	st_size		the number of bytes in the directory 
 *			This is calculated by taking the number of entries
 *			in the directory and multiplying by the size of a 
 *			dirent structure
 *	st_blksize	0
 *   	st_blocks	0
 *	stat_atime	time of last access
 *	stat_mtime	time of last modification
 *	stat_ctime	time of the last change
 *
 * This information will be returned to the calling function in a -stat- struct
 *	
 */
 
int imfs_dir_fstat(
  rtems_filesystem_location_info_t *loc,
  struct stat                      *buf
)
{
   Chain_Node        *the_node;
   Chain_Control     *the_chain;
   IMFS_jnode_t      *the_jnode;
 
 
   the_jnode = (IMFS_jnode_t *) loc->node_access;
 
   buf->st_dev = 0ll;
   buf->st_ino   = the_jnode->st_ino;
   buf->st_mode  = the_jnode->st_mode;
   buf->st_nlink = the_jnode->st_nlink;
   buf->st_uid   = the_jnode->st_uid;
   buf->st_gid   = the_jnode->st_gid;
   buf->st_rdev = 0ll;
   buf->st_blksize = 0;
   buf->st_blocks = 0;
   buf->st_atime = the_jnode->stat_atime;
   buf->st_mtime = the_jnode->stat_mtime;
   buf->st_ctime = the_jnode->stat_ctime;
 
   buf->st_size = 0;
 
   the_chain = &the_jnode->info.directory.Entries;
 
   /* Run through the chain and count the number of directory entries */
   /* that are subordinate to this directory node                     */
   for ( the_node = the_chain->first ;
         !_Chain_Is_tail( the_chain, the_node ) ;
         the_node = the_node->next ) {
 
      buf->st_size = buf->st_size + sizeof( struct dirent );
   }
 
   return 0;
}
 
/*
 *  IMFS_dir_rmnod
 *
 *  This routine is available from the optable to remove a node 
 *  from the IMFS file system.
 */
 
int imfs_dir_rmnod(
  rtems_filesystem_location_info_t      *pathloc       /* IN */
)
{
  IMFS_jnode_t *the_jnode;  
 
  the_jnode = (IMFS_jnode_t *) pathloc->node_access;
 
  /* 
   * You cannot remove a node that still has children 
   */
 
  if ( ! Chain_Is_empty( &the_jnode->info.directory.Entries ) )
     set_errno_and_return_minus_one( ENOTEMPTY );
 
  /* 
   * You cannot remove the file system root node.
   */
 
  if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
     set_errno_and_return_minus_one( EBUSY );
 
  /* 
   * You cannot remove a mountpoint.
   */
 
   if ( the_jnode->info.directory.mt_fs != NULL )
     set_errno_and_return_minus_one( EBUSY );          
 
  /* 
   * Take the node out of the parent's chain that contains this node 
   */
 
  if ( the_jnode->Parent != NULL ) {
    Chain_Extract( (Chain_Node *) the_jnode );
    the_jnode->Parent = NULL;
  }
 
  /*
   * Decrement the link counter and see if we can free the space.
   */
 
  the_jnode->st_nlink--;
  IMFS_update_ctime( the_jnode );
 
  /*
   * The file cannot be open and the link must be less than 1 to free.
   */
 
  if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) {
 
    /* 
     * Is the rtems_filesystem_current is this node?
     */
 
    if ( rtems_filesystem_current.node_access == pathloc->node_access )
       rtems_filesystem_current.node_access = NULL;
 
    /*
     * Free memory associated with a memory file.
     */
 
    free( the_jnode );
  }
 
  return 0;
 
}