Added base version of file system infrastructure. This includes a major

overhaul of the RTEMS system call interface.  This base file system is
the "In-Memory File System" aka IMFS.

The design and implementation was done by the following people:

  + Joel Sherrill (joel@OARcorp.com)
  + Jennifer Averett (jennifer@OARcorp.com)
  + Steve "Mr Mount" Salitasc (salitasc@OARcorp.com)
  + Kerwin Wade (wade@OARcorp.com)

PROBLEMS
========
  + It is VERY likely that merging this will break the UNIX port.  This
    can/will be fixed.

  + There is likely some reentrancy/mutual exclusion needed.

  + Eventually, there should be a "mini-IMFS" description table to
    eliminate links, symlinks, etc to save memory.  All you need to
    have "classic RTEMS" functionality is technically directories
    and device IO.  All the rest could be left out to save memory.

1 files changed, 1000 insertions, 0 deletions

diff --git a/c/src/exec/libfs/src/imfs/memfile.c b/c/src/exec/libfs/src/imfs/memfile.c
new file mode 100644
index 0000000000..01aee443f3
--- /dev/null
+++ b/c/src/exec/libfs/src/imfs/memfile.c
@@ -0,0 +1,1000 @@
+/*
+ *  IMFS Device Node Handlers
+ *
+ *  This file contains the set of handlers used to process operations on
+ *  IMFS memory file nodes.  The memory files are created in memory using
+ *  malloc'ed memory.  Thus any data stored in one of these files is lost
+ *  at system shutdown unless special arrangements to copy the data to 
+ *  some type of non-volailte storage are made by the application.
+ *
+ *  COPYRIGHT (c) 1989-1998.
+ *  On-Line Applications Research Corporation (OAR).
+ *  Copyright assigned to U.S. Government, 1994.
+ *
+ *  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$
+ */
+
+#include <stdlib.h>
+#include <assert.h>
+#include <errno.h>
+
+#include <rtems.h>
+#include <rtems/libio.h>
+#include "imfs.h"
+#include "libio_.h"
+
+#define MEMFILE_STATIC 
+
+/*
+ *  Prototypes of private routines 
+ */
+
+MEMFILE_STATIC int IMFS_memfile_extend(
+   IMFS_jnode_t  *the_jnode,
+   off_t          new_length
+);
+
+MEMFILE_STATIC int IMFS_memfile_addblock(
+   IMFS_jnode_t  *the_jnode,
+   unsigned int   block
+);
+
+MEMFILE_STATIC int IMFS_memfile_remove_block(
+   IMFS_jnode_t  *the_jnode,
+   unsigned int   block
+);
+
+MEMFILE_STATIC block_p *IMFS_memfile_get_block_pointer(
+   IMFS_jnode_t   *the_jnode,
+   unsigned int    block,
+   int             malloc_it
+);
+
+MEMFILE_STATIC int IMFS_memfile_read(
+   IMFS_jnode_t    *the_jnode,
+   off_t            start,
+   unsigned char   *destination,
+   unsigned int     length
+);
+
+MEMFILE_STATIC int IMFS_memfile_write(
+   IMFS_jnode_t          *the_jnode,
+   off_t                  start,
+   const unsigned char   *source,
+   unsigned int           length
+);
+
+void *memfile_alloc_block(void);
+
+void memfile_free_block(
+  void *memory
+);
+
+/*
+ *  memfile_open
+ *
+ *  This routine processes the open() system call.  Note that there is
+ *  nothing special to be done at open() time.
+ */
+
+int memfile_open(
+  rtems_libio_t *iop,
+  const char    *pathname,
+  unsigned32     flag,
+  unsigned32     mode
+)
+{
+  IMFS_jnode_t  *the_jnode;
+
+  the_jnode = iop->file_info;
+
+  return 0;
+}
+
+/*
+ *  memfile_close
+ *
+ *  This routine processes the close() system call.  Note that there is
+ *  nothing to flush or memory to free at this point.
+ */
+
+int memfile_close(
+  rtems_libio_t *iop
+)
+{
+  IMFS_jnode_t   *the_jnode;
+
+  the_jnode = iop->file_info;
+
+  return 0;
+}
+
+/*
+ *  memfile_read
+ *
+ *  This routine processes the read() system call.
+ */
+
+int memfile_read(
+  rtems_libio_t *iop,
+  void          *buffer,
+  unsigned32     count
+)
+{
+  IMFS_jnode_t   *the_jnode;
+
+  the_jnode = iop->file_info;
+
+  return IMFS_memfile_read( the_jnode, iop->offset, buffer, count );
+}
+
+/*
+ *  memfile_write
+ *
+ *  This routine processes the write() system call.
+ */
+
+int memfile_write(
+  rtems_libio_t *iop,
+  const void    *buffer,
+  unsigned32     count
+)
+{
+  IMFS_jnode_t   *the_jnode;
+
+  the_jnode = iop->file_info;
+
+  return IMFS_memfile_write( the_jnode, iop->offset, buffer, count );
+}
+
+/*
+ *  memfile_ioctl
+ *
+ *  This routine processes the ioctl() system call.
+ *
+ *  NOTE:  No ioctl()'s are supported for in-memory files.
+ */
+
+int memfile_ioctl(
+  rtems_libio_t *iop,
+  unsigned32     command,
+  void          *buffer
+)
+{
+  IMFS_jnode_t   *the_jnode;
+
+  the_jnode = iop->file_info;
+
+  return 0;
+}
+
+/*
+ *  memfile_lseek
+ *
+ *  This routine processes the lseek() system call.
+ */
+
+int memfile_lseek(
+  rtems_libio_t   *iop,
+  off_t            offset,
+  int              whence
+)
+{
+  IMFS_jnode_t   *the_jnode;
+
+  the_jnode = iop->file_info;
+
+  if (IMFS_memfile_extend( the_jnode, iop->offset ))
+    set_errno_and_return_minus_one( ENOSPC );
+
+  return 0;
+}
+
+/*
+ *  memfile_stat
+ *
+ *  This IMFS_stat() can be used.
+ */
+
+/*
+ *  memfile_ftruncate
+ *
+ *  This routine processes the ftruncate() system call.
+ */
+
+int memfile_ftruncate(
+  rtems_libio_t        *iop,
+  off_t                 length
+)
+{
+  IMFS_jnode_t   *the_jnode;
+
+  the_jnode = iop->file_info;
+
+  /*
+   *  POSIX 1003.1b does not specify what happens if you truncate a file
+   *  and the new length is greater than the current size.  We treat this
+   *  as an extend operation.
+   */
+
+  if ( length > the_jnode->info.file.size )
+    return IMFS_memfile_extend( the_jnode, length );
+
+  /*
+   *  The in-memory files do not currently reclaim memory until the file is
+   *  deleted.  So we leave the previously allocated blocks in place for
+   *  future use and just set the length.
+   */
+
+  the_jnode->info.file.size = length;
+
+  IMFS_update_atime( the_jnode );
+
+  return 0;
+}
+
+/*
+ *  IMFS_memfile_extend
+ *
+ *  This routine insures that the in-memory file is of the length
+ *  specified.  If necessary, it will allocate memory blocks to 
+ *  extend the file.
+ */
+
+MEMFILE_STATIC int IMFS_memfile_extend(
+   IMFS_jnode_t  *the_jnode,
+   off_t          new_length
+)
+{
+  unsigned int   block;
+  unsigned int   new_blocks;
+  unsigned int   old_blocks;
+
+  /*
+   *  Perform internal consistency checks
+   */
+
+  assert( the_jnode );
+  if ( !the_jnode )
+    set_errno_and_return_minus_one( EIO );
+
+  assert( the_jnode->type == IMFS_MEMORY_FILE );
+  if ( the_jnode->type != IMFS_MEMORY_FILE )
+    set_errno_and_return_minus_one( EIO );
+
+  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
+    set_errno_and_return_minus_one( EINVAL );
+
+  if ( new_length <= the_jnode->info.file.size )
+    return 0;
+
+  /*
+   *  Calculate the number of range of blocks to allocate
+   */
+
+  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
+  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
+
+  /*
+   *  Now allocate each of those blocks.
+   */
+
+  for ( block=old_blocks ; block<=new_blocks ; block++ ) {
+    if ( IMFS_memfile_addblock( the_jnode, block ) ) {
+       for ( ; block>=old_blocks ; block-- ) {
+          IMFS_memfile_remove_block( the_jnode, block );
+       }
+       set_errno_and_return_minus_one( ENOSPC );
+    }
+  }
+
+  /*
+   *  Set the new length of the file.
+   */
+
+  the_jnode->info.file.size = new_length;
+  return 0;
+}
+
+/*
+ *  IMFS_memfile_addblock
+ *
+ *  This routine adds a single block to the specified in-memory file.
+ */
+
+MEMFILE_STATIC int IMFS_memfile_addblock(
+   IMFS_jnode_t  *the_jnode,
+   unsigned int   block
+)
+{
+  block_p  memory;
+  block_p *block_entry_ptr;
+
+  assert( the_jnode );
+  if ( !the_jnode )
+    set_errno_and_return_minus_one( EIO );
+
+  assert( the_jnode->type == IMFS_MEMORY_FILE );
+  if ( the_jnode->type != IMFS_MEMORY_FILE )
+    set_errno_and_return_minus_one( EIO );
+
+  block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
+  if ( *block_entry_ptr )
+    return 0;
+
+#if 0
+  printf( "%d %p", block, block_entry_ptr );
+    fflush(stdout);
+#endif
+
+  memory = memfile_alloc_block();
+  assert( memory );
+  if ( !memory )
+    return 1;
+  *block_entry_ptr = memory;
+
+  return 0;
+}
+
+/*
+ *  IMFS_memfile_remove_block
+ *
+ *  This routine removes the specified block from the in-memory file.
+ *
+ *  NOTE:  This is a support routine and is called only to remove
+ *         the last block or set of blocks in a file.  Removing a
+ *         block from the middle of a file would be exceptionally
+ *         dangerous and the results unpredictable.
+ */
+
+MEMFILE_STATIC int IMFS_memfile_remove_block(
+   IMFS_jnode_t  *the_jnode,
+   unsigned int   block
+)
+{
+  block_p *block_entry_ptr;
+  block_p  ptr;
+
+  block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
+  ptr = *block_entry_ptr;
+  *block_entry_ptr = 0;
+
+  memfile_free_block( ptr );
+
+  return 1;
+}
+
+/*
+ *  memfile_free_blocks_in_table
+ *
+ *  This is a support routine for IMFS_memfile_remove.  It frees all the
+ *  blocks in one of the indirection tables.
+ */
+
+void memfile_free_blocks_in_table(
+  block_p **block_table,
+  int       entries
+)
+{
+  int      i;
+  block_p *b;
+
+  /*
+   *  Perform internal consistency checks
+   */
+
+  assert( block_table );
+  if ( !block_table )
+    return;
+
+  /*
+   *  Now go through all the slots in the table and free the memory.
+   */
+
+  b = *block_table;
+
+  for ( i=0 ; i<entries ; i++ ) {
+    if ( b[i] ) {
+      memfile_free_block( b[i] );
+      b[i] = 0;
+    }
+  }
+
+  /*
+   *  Now that all the blocks in the block table are free, we can 
+   *  free the block table itself.
+   */
+
+  memfile_free_block( *block_table );
+  *block_table = 0;
+}
+
+/*
+ *  IMFS_memfile_remove
+ *
+ *  This routine frees all memory associated with an in memory file.
+ *
+ *  NOTE:  This is an exceptionally conservative implementation.  
+ *         It will check EVERY pointer which is non-NULL and insure
+ *         any child non-NULL pointers are freed.  Optimistically, all that
+ *         is necessary is to scan until a NULL pointer is found.  There
+ *         should be no allocated data past that point.
+ *
+ *         In experimentation on the powerpc simulator, it was noted
+ *         that using blocks which held 128 slots versus 16 slots made
+ *         a significant difference in the performance of this routine.
+ *
+ *         Regardless until the IMFS implementation is proven, it
+ *         is better to stick to simple, easy to understand algorithms.
+ */
+
+int IMFS_memfile_remove(
+ IMFS_jnode_t  *the_jnode
+)
+{
+  IMFS_memfile_t  *info;
+  int              i;
+  int              j;
+  unsigned int     to_free;
+  block_p         *p;
+
+  /*
+   *  Perform internal consistency checks
+   */
+
+  assert( the_jnode );
+  if ( !the_jnode )
+    set_errno_and_return_minus_one( EIO );
+
+  assert( the_jnode->type == IMFS_MEMORY_FILE );
+  if ( the_jnode->type != IMFS_MEMORY_FILE )
+    set_errno_and_return_minus_one( EIO );
+
+  /*
+   *  Eventually this could be set smarter at each call to
+   *  memfile_free_blocks_in_table to greatly speed this up.
+   */
+
+  to_free = IMFS_MEMFILE_BLOCK_SLOTS;
+
+  /*
+   *  Now start freeing blocks in this order:
+   *    + indirect
+   *    + doubly indirect
+   *    + triply indirect
+   */
+
+  info = &the_jnode->info.file;
+
+  if ( info->indirect ) {
+    memfile_free_blocks_in_table( &info->indirect, to_free );
+  }
+
+  if ( info->doubly_indirect ) {
+
+    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
+      if ( info->doubly_indirect[i] ) {
+        memfile_free_blocks_in_table(
+         (block_p **)&info->doubly_indirect[i], to_free );
+      }
+    }
+    memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
+
+  }
+  
+  if ( info->triply_indirect ) {
+    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
+      p = (block_p *) info->triply_indirect[i];
+      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
+        if ( p[j] ) {
+          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
+        }
+      }
+      memfile_free_blocks_in_table(
+        (block_p **)&info->triply_indirect[i], to_free );
+    }
+    memfile_free_blocks_in_table(
+        (block_p **)&info->triply_indirect, to_free );
+  }
+
+  return 0;
+}
+
+/*
+ *  IMFS_memfile_read
+ *
+ *  This routine read from memory file pointed to by the_jnode into
+ *  the specified data buffer specified by destination.  The file
+ *  is NOT extended.  An offset greater than the length of the file
+ *  is considered an error.  Read from an offset for more bytes than
+ *  are between the offset and the end of the file will result in 
+ *  reading the data between offset and the end of the file (truncated
+ *  read).
+ */
+
+MEMFILE_STATIC int IMFS_memfile_read(
+   IMFS_jnode_t    *the_jnode,
+   off_t            start,
+   unsigned char   *destination,
+   unsigned int     length
+)
+{
+  block_p             *block_ptr;
+  unsigned int         block;
+  unsigned int         my_length;
+  unsigned int         to_copy = 0;
+  unsigned int         last_byte;
+  unsigned int         copied;
+  unsigned int         start_offset;
+  unsigned char       *dest;
+
+  dest = destination;
+
+  /*
+   *  Perform internal consistency checks
+   */
+
+  assert( the_jnode );
+  if ( !the_jnode )
+    set_errno_and_return_minus_one( EIO );
+
+  assert( the_jnode->type == IMFS_MEMORY_FILE );
+  if ( the_jnode->type != IMFS_MEMORY_FILE )
+    set_errno_and_return_minus_one( EIO );
+
+  /*
+   *  Error checks on arguments
+   */
+
+  assert( dest );
+  if ( !dest )
+    set_errno_and_return_minus_one( EINVAL );
+
+  /*
+   *  If there is nothing to read, then quick exit.
+   */
+
+  my_length = length;
+  if ( !my_length )
+    set_errno_and_return_minus_one( EINVAL );
+
+  /*
+   *  If the last byte we are supposed to read is past the end of this
+   *  in memory file, then shorten the length to read.
+   */
+
+  last_byte = start + length;
+  if ( last_byte > the_jnode->info.file.size )
+    my_length = the_jnode->info.file.size - start;
+
+  copied = 0;
+
+  /*
+   *  Three phases to the read:
+   *    + possibly the last part of one block
+   *    + all of zero of more blocks
+   *    + possibly the first part of one block
+   */
+
+  /*
+   *  Phase 1: possibly the last part of one block
+   */
+
+  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
+  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
+  if ( start_offset )  {
+    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
+    if ( to_copy > my_length )
+      to_copy = my_length;
+    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
+    assert( block_ptr );
+    if ( !block_ptr )
+      return copied;
+    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
+    dest += to_copy;
+    block++;
+    my_length -= to_copy;
+    copied += to_copy;
+  }
+
+  /*
+   *  Phase 2: all of zero of more blocks
+   */
+
+  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
+  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
+    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
+    assert( block_ptr );
+    if ( !block_ptr )
+      return copied;
+    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
+    dest += to_copy;
+    block++;
+    my_length -= to_copy;
+    copied += to_copy;
+  }
+
+  /*
+   *  Phase 3: possibly the first part of one block
+   */
+
+  assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
+
+  if ( my_length ) {
+    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
+    assert( block_ptr );
+    if ( !block_ptr )
+      return copied;
+    memcpy( dest, &(*block_ptr)[ 0 ], my_length );
+    copied += my_length;
+  }
+
+  IMFS_update_atime( the_jnode );
+
+  return copied;
+}
+
+/*
+ *  IMFS_memfile_write
+ *
+ *  This routine writes the specified data buffer into the in memory
+ *  file pointed to by the_jnode.  The file is extended as needed.
+ */
+
+MEMFILE_STATIC int IMFS_memfile_write(
+   IMFS_jnode_t          *the_jnode,
+   off_t                  start,
+   const unsigned char   *source,
+   unsigned int           length
+)
+{
+  block_p             *block_ptr;
+  unsigned int         block;
+  int                  status;
+  unsigned int         my_length;
+  unsigned int         to_copy = 0;
+  unsigned int         last_byte;
+  unsigned int         start_offset;
+  int                  copied;
+  const unsigned char *src;
+
+  src = source;
+
+  /*
+   *  Perform internal consistency checks
+   */
+
+  assert( the_jnode );
+  if ( !the_jnode )
+    set_errno_and_return_minus_one( EIO );
+
+  assert( the_jnode->type == IMFS_MEMORY_FILE );
+  if ( the_jnode->type != IMFS_MEMORY_FILE )
+    set_errno_and_return_minus_one( EIO );
+
+  /*
+   *  Error check arguments
+   */
+
+  assert( source );
+  if ( !source )
+    set_errno_and_return_minus_one( EINVAL );
+
+
+  /*
+   *  If there is nothing to write, then quick exit.
+   */
+
+  my_length = length;
+  if ( !my_length )
+    set_errno_and_return_minus_one( EINVAL );
+
+  /*
+   *  If the last byte we are supposed to write is past the end of this
+   *  in memory file, then extend the length.
+   */
+
+  last_byte = start + length;
+  if ( last_byte > the_jnode->info.file.size ) {
+    status = IMFS_memfile_extend( the_jnode, last_byte );
+    if ( status )
+      set_errno_and_return_minus_one( ENOSPC );
+  }
+
+  copied = 0;
+
+  /*
+   *  Three phases to the write:
+   *    + possibly the last part of one block
+   *    + all of zero of more blocks
+   *    + possibly the first part of one block
+   */
+
+  /*
+   *  Phase 1: possibly the last part of one block
+   */
+
+  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
+  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
+  if ( start_offset )  {
+    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
+    if ( to_copy > my_length )
+      to_copy = my_length;
+    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
+    assert( block_ptr );
+    if ( !block_ptr )
+      return copied;
+    memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
+    src += to_copy;
+    block++;
+    my_length -= to_copy;
+    copied += to_copy;
+  }
+
+  /*
+   *  Phase 2: all of zero of more blocks
+   */
+
+  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
+  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
+    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
+    assert( block_ptr );
+    if ( !block_ptr )
+      return copied;
+    memcpy( &(*block_ptr)[ 0 ], src, to_copy );
+    src += to_copy;
+    block++;
+    my_length -= to_copy;
+    copied += to_copy;
+  }
+
+  /*
+   *  Phase 3: possibly the first part of one block
+   */
+
+  assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
+
+  to_copy = my_length;
+  if ( my_length ) {
+    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
+    assert( block_ptr );
+    if ( !block_ptr )
+      return copied;
+    memcpy( &(*block_ptr)[ 0 ], src, my_length );
+    my_length = 0;
+    copied += to_copy;
+  }
+
+  IMFS_atime_mtime_update( the_jnode );
+
+  return copied;
+}
+
+/*
+ *  IMFS_memfile_get_block_pointer
+ *
+ *  This routine looks up the block pointer associated with the given block
+ *  number.  If that block has not been allocated and "malloc_it" is
+ *  TRUE, then the block is allocated.  Otherwise, it is an error.
+ */
+
+block_p *IMFS_memfile_get_block_pointer(
+   IMFS_jnode_t   *the_jnode,
+   unsigned int    block,
+   int             malloc_it
+)
+{
+  unsigned int    my_block;
+  IMFS_memfile_t *info;
+  unsigned int    singly;
+  unsigned int    doubly;
+  unsigned int    triply;
+  block_p        *p;
+  block_p        *p1;
+  block_p        *p2;
+
+  /*
+   *  Perform internal consistency checks
+   */
+
+  assert( the_jnode );
+  if ( !the_jnode )
+    return NULL;
+
+  assert( the_jnode->type == IMFS_MEMORY_FILE );
+  if ( the_jnode->type != IMFS_MEMORY_FILE )
+    return NULL;
+
+  info = &the_jnode->info.file;
+
+  my_block = block;
+
+  /*
+   *  Is the block number in the simple indirect portion?
+   */
+
+  if ( my_block <= LAST_INDIRECT ) {
+#if 0
+printf( "(s %d) ", block );
+fflush(stdout);
+#endif
+    p = info->indirect;
+
+    if ( malloc_it ) {
+
+      if ( !p ) {
+        p = memfile_alloc_block();
+        if ( !p )
+           return 0;
+        info->indirect = p;
+      }
+      return &info->indirect[ my_block ];
+    }
+
+    if ( !p )
+      return 0;
+
+    return &info->indirect[ my_block ];
+  }
+
+  /*
+   *  Is the block number in the doubly indirect portion?
+   */
+
+  if ( my_block <= LAST_DOUBLY_INDIRECT ) {
+#if 0
+printf( "(d %d) ", block );
+fflush(stdout);
+#endif
+
+    my_block -= FIRST_DOUBLY_INDIRECT;
+
+    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
+    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
+
+    p = info->doubly_indirect;
+    if ( malloc_it ) {
+
+      if ( !p ) {
+        p = memfile_alloc_block();
+        if ( !p )
+           return 0;
+        info->doubly_indirect = p;
+      }
+
+      p1 = (block_p *)p[ doubly ];
+      if ( !p1 ) {
+        p1 = memfile_alloc_block();
+        if ( !p1 )
+           return 0;
+        p[ doubly ] = (block_p) p1;
+      }
+
+      return (block_p *)&p[ singly ];
+    }
+
+    if ( !p )
+      return 0;
+
+    p = (block_p *)p[ doubly ];
+    if ( !p ) 
+      return 0;
+
+#if 0
+printf( "(d %d %d %d %d %p %p) ", block, my_block, doubly,
+                                       singly, p, &p[singly] );
+fflush(stdout);
+#endif
+    return (block_p *)&p[ singly ];
+  }
+
+#if 0
+printf( "(t %d) ", block );
+fflush(stdout);
+#endif
+  /*
+   *  Is the block number in the triply indirect portion?
+   */
+
+  if ( my_block <= LAST_TRIPLY_INDIRECT ) {
+    my_block -= FIRST_TRIPLY_INDIRECT;
+
+    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
+    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
+    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
+    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
+
+    p = info->triply_indirect;
+
+    if ( malloc_it ) {
+      if ( !p ) {
+        p = memfile_alloc_block();
+        if ( !p )
+           return 0;
+        info->triply_indirect = p;
+      }
+
+      p1 = (block_p *) p[ triply ];
+      if ( !p1 ) {
+        p1 = memfile_alloc_block();
+        if ( !p1 )
+           return 0;
+        p[ triply ] = (block_p) p1;
+      }
+
+      p2 = (block_p *)p1[ doubly ];
+      if ( !p2 ) {
+        p2 = memfile_alloc_block();
+        if ( !p2 )
+           return 0;
+        p1[ doubly ] = (block_p) p2;
+      }
+      return (block_p *)&p2[ singly ];
+    }
+
+    if ( !p )
+      return 0;
+
+#if 0
+printf( "(t %d %d %d %d %d) ", block, my_block, triply, doubly, singly );
+fflush(stdout);
+#endif
+    p1 = (block_p *) p[ triply ];
+    if ( !p1 )
+      return 0;
+
+    p2 = (block_p *)p1[ doubly ];
+    if ( !p )
+      return 0;
+
+    return (block_p *)&p2[ singly ];
+  }
+
+  /*
+   *  This means the requested block number is out of range.
+   */
+
+  return 0;
+}
+
+/*
+ *  memfile_alloc_block
+ *
+ *  Allocate a block for an in-memory file.
+ */
+
+int memfile_blocks_allocated = 0;
+
+void *memfile_alloc_block(void)
+{
+  void *memory;
+
+  memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
+  if ( memory )
+    memfile_blocks_allocated++;
+
+  return memory;
+}
+
+/*
+ *  memfile_free_blocK
+ *
+ *  Free a block from an in-memory file.
+ */
+
+void memfile_free_block(
+  void *memory
+)
+{
+#if 0
+printf( "(d %p) ", memory );
+fflush(stdout);
+#endif
+  free(memory);
+  memfile_blocks_allocated--;
+}
+