Subversion Repositories openrisc_2011-10-31

//==========================================================================

//

//      misc.cxx

//

//      Fileio miscellaneous functions

//

//==========================================================================

//####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

// Copyright (C) 2003 Gary Thomas

//

// eCos is free software; you can redistribute it and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation; either version 2 or (at your option) any later version.

//

// eCos is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License along

// with eCos; if not, write to the Free Software Foundation, Inc.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

//

// As a special exception, if other files instantiate templates or use macros

// or inline functions from this file, or you compile this file and link it

// with other works to produce a work based on this file, this file does not

// by itself cause the resulting work to be covered by the GNU General Public

// License. However the source code for this file must still be made available

// in accordance with section (3) of the GNU General Public License.

//

// This exception does not invalidate any other reasons why a work based on

// this file might be covered by the GNU General Public License.

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

// -------------------------------------------

//####ECOSGPLCOPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):           nickg

// Contributors:        nickg

// Date:                2000-05-25

// Purpose:             Fileio miscellaneous functions

// Description:         This file contains various miscellaneous functions

//                      for use with the fileio system. These include startup,

//                      table management, and other service routines.

//

//####DESCRIPTIONEND####

//

//==========================================================================

#include <pkgconf/system.h>

#include <pkgconf/hal.h>

#include <pkgconf/io_fileio.h>

#ifdef CYGPKG_LIBC_TIME

#include <pkgconf/libc_time.h>

#endif

#include <cyg/infra/cyg_trac.h>        // tracing macros

#include <cyg/infra/cyg_ass.h>         // assertion macros

#include <string.h>                    // strcmp()

#include <time.h>                      // time()

#ifdef CYGPKG_IO_WALLCLOCK

# include <cyg/io/wallclock.hxx>       // Wallclock class

#endif

#ifdef CYGPKG_KERNEL

#include <pkgconf/kernel.h>

#include <cyg/kernel/ktypes.h>         // base kernel types

#include <cyg/kernel/clock.inl>         // Clock inlines

#endif

#include "fio.h"                       // Private header

//==========================================================================

// forward definitions

static void cyg_mtab_init();

__externC int chdir( const char *path );

//==========================================================================

// Filesystem tables

// -------------------------------------------------------------------------

// Filesystem table.

// This array contains entries for all filesystem that are installed in

// the system.

__externC cyg_fstab_entry fstab[];

CYG_HAL_TABLE_BEGIN( fstab, fstab );

// end of filesystem table, set in linker script.

__externC cyg_fstab_entry fstab_end;

CYG_HAL_TABLE_END( fstab_end, fstab );

#ifdef CYGPKG_KERNEL

// Array of mutexes for locking the fstab entries

Cyg_Mutex fstab_lock[CYGNUM_FILEIO_FSTAB_MAX] CYGBLD_ATTRIB_INIT_PRI(CYG_INIT_IO_FS);

#endif

// -------------------------------------------------------------------------

// Mount table.

// This array contains entries for all valid running filesystems.

__externC cyg_mtab_entry mtab[];

CYG_HAL_TABLE_BEGIN( mtab, mtab );

// Extra entries at end of mtab for dynamic mount points.

cyg_mtab_entry mtab_extra[CYGNUM_FILEIO_MTAB_EXTRA] CYG_HAL_TABLE_EXTRA(mtab) = { { NULL } };

// End of mount table, set in the linker script.

__externC cyg_mtab_entry mtab_end;

CYG_HAL_TABLE_END( mtab_end, mtab );

#ifdef CYGPKG_KERNEL

// Array of mutexes for locking the mtab entries

Cyg_Mutex mtab_lock[CYGNUM_FILEIO_MTAB_MAX] CYGBLD_ATTRIB_INIT_PRI(CYG_INIT_IO_FS);

#endif

//==========================================================================

// Current directory

cyg_mtab_entry *cdir_mtab_entry = NULL;

cyg_dir cdir_dir = CYG_DIR_NULL;

//==========================================================================

// Initialization object

class Cyg_Fileio_Init_Class

{

public:

    Cyg_Fileio_Init_Class();

};

static Cyg_Fileio_Init_Class fileio_initializer CYGBLD_ATTRIB_INIT_PRI(CYG_INIT_IO_FS);

Cyg_Fileio_Init_Class::Cyg_Fileio_Init_Class()

{

    cyg_fd_init();

    cyg_mtab_init();

    chdir("/");

}

//==========================================================================

// Mount table initializer

static void cyg_mtab_init()

{

    cyg_mtab_entry *m;

    for( m = &mtab[0]; m != &mtab_end; m++ )

    {

        const char *fsname = m->fsname;

        cyg_fstab_entry *f;

        // Ignore empty entries

        if( m->name == NULL )

            continue;

        // stop if there are more than the configured maximum

        if( m-&mtab[0] >= CYGNUM_FILEIO_MTAB_MAX )

            break;

        for( f = &fstab[0]; f != &fstab_end; f++ )

        {

            // stop if there are more than the configured maximum

            if( f-&fstab[0] >= CYGNUM_FILEIO_FSTAB_MAX )

                break;

            if( strcmp( fsname, f->name) == 0 )

            {

                // We have a match.

                if( f->mount( f, m ) == 0 )

                {

                    m->valid    = true;

                    m->fs       = f;

                    // m->root installed by fs.

                }

                else

                {

                    m->valid = false;

                }

                break;

            }

        }

    }

}

//==========================================================================

// Mount table matching

// -------------------------------------------------------------------------

// matchlen() compares two strings and returns the number of bytes by which

// they match.

static int matchlen( const char *s1, const char *s2 )

{

    int len = 0;

    while( s1[len] == s2[len] && s1[len] && s2[len] ) len++;

    // Return length only if s2 is an initial substring of s1,

    // and it terminates in s1 at end-of-string or a '/'.

    // Special case for s2 == "/"

    if( len == 1 && s2[0] == '/' && s2[1] == 0 )

        return len;

    if( (s2[len] == 0) && (s1[len] == 0 || s1[len] == '/'))

         return len;

    else return 0;

}

// -------------------------------------------------------------------------

// Search the mtab for the entry that matches the longest substring of

// **name. 

__externC int cyg_mtab_lookup( cyg_dir *dir, const char **name, cyg_mtab_entry **mte)

{

    cyg_mtab_entry *m, *best = NULL;

    int best_len = 0;

    // Unrooted file names go straight to current dir

    if( **name != '/' ) {

        if (*mte == (cyg_mtab_entry *)NULL) {

            // No known current directory

            return -1;

        }

        // Current directory is well known

        return 0;

    }

    // Otherwise search the mount table.

    for( m = &mtab[0]; m != &mtab_end; m++ )

    {

        if( m->name != NULL && m->valid )

        {

            int len = matchlen(*name,m->name);

            if( len > best_len )

                best = m, best_len = len;

        }

    }

    // No match found, bad path name...

    if( best_len == 0 ) return -1;

    *name += best_len;

    if( **name == '/' )

        (*name)++;

    *mte = best;

    *dir = best->root;

    return 0;

}

//==========================================================================

// mount filesystem

__externC int mount( const char *devname,

                     const char *dir,

                     const char *fsname)

{

    FILEIO_ENTRY();

    cyg_mtab_entry *m;

    cyg_fstab_entry *f;

    int result = ENOERR;

    // Search the mount table for an empty entry

    for( m = &mtab[0]; m != &mtab_end; m++ )

    {

        // stop if there are more than the configured maximum

        if( m-&mtab[0] >= CYGNUM_FILEIO_MTAB_MAX )

        {

            m = &mtab_end;

            break;

        }

         if( m->name == NULL ) break;

    }

    if( m == &mtab_end )

        FILEIO_RETURN(ENOMEM);

    // Now search the fstab for the filesystem implementation

    for( f = &fstab[0]; f != &fstab_end; f++ )

    {

        // stop if there are more than the configured maximum

        if( f-&fstab[0] >= CYGNUM_FILEIO_FSTAB_MAX )

            break;

        if( strcmp( fsname, f->name) == 0 )

            break;

    }

    if( f == &fstab_end )

        FILEIO_RETURN(ENODEV);

    // We have a match.

    m->name = dir;

    m->fsname = fsname;

    m->devname = devname;

    if( (result = f->mount( f, m )) == 0 )

    {

        m->valid    = true;

        m->fs       = f;

        // m->root installed by fs.

    }

    else

    {

        m->valid = false;

        m->name = NULL;

    }

    // Make sure that there is something to search (for open)

    if (cdir_mtab_entry == (cyg_mtab_entry *)NULL) {

        cdir_mtab_entry = m;

    }

    FILEIO_RETURN(result);

}

//==========================================================================

// unmount filesystem

__externC int umount( const char *name)

{

    int err = ENOERR;

    FILEIO_ENTRY();

    cyg_mtab_entry *m;

    // Search the mount table for a matching entry

    for( m = &mtab[0]; m != &mtab_end; m++ )

    {

        // stop if there are more than the configured maximum

        if( m-&mtab[0] >= CYGNUM_FILEIO_MTAB_MAX )

        {

            m = &mtab_end;

            break;

        }

        // Ignore empty or invalid entries

         if( m->name == NULL || !m->valid ) continue;

         // match names.

         if( strcmp(name,m->name) == 0 ) break;

         // Match device name too?

    }

    if( m == &mtab_end )

        FILEIO_RETURN(EINVAL);

    // We have a match, call the umount function

    err = m->fs->umount( m );

    if( err == ENOERR )

    {

        m->valid        = false;

        m->name         = NULL;

    }

    FILEIO_RETURN(err);

}

//==========================================================================

// Implement filesystem locking protocol. 

void cyg_fs_lock( cyg_mtab_entry *mte, cyg_uint32 syncmode )

{

    CYG_ASSERT(mte != NULL, "Bad mount table entry");

    if( syncmode & CYG_SYNCMODE_FILE_FILESYSTEM ) {

        CYG_ASSERT(mte->fs-&fstab[0] < CYGNUM_FILEIO_FSTAB_MAX, "Bad file system");

        FILEIO_MUTEX_LOCK( fstab_lock[mte->fs-&fstab[0]] );

    }

    if( syncmode & CYG_SYNCMODE_FILE_MOUNTPOINT ) {

        CYG_ASSERT(mte-&mtab[0] < CYGNUM_FILEIO_MTAB_MAX, "Bad mount point");

        FILEIO_MUTEX_LOCK( mtab_lock[mte-&mtab[0]] );

    }

}

void cyg_fs_unlock( cyg_mtab_entry *mte, cyg_uint32 syncmode )

{

    CYG_ASSERT(mte != NULL, "Bad mount table entry");

    if( syncmode & CYG_SYNCMODE_FILE_FILESYSTEM ) {

        CYG_ASSERT(mte->fs-&fstab[0] < CYGNUM_FILEIO_FSTAB_MAX, "Bad file system");

        FILEIO_MUTEX_UNLOCK( fstab_lock[mte->fs-&fstab[0]] );

    }

    if( syncmode & CYG_SYNCMODE_FILE_MOUNTPOINT ) {

        CYG_ASSERT(mte-&mtab[0] < CYGNUM_FILEIO_MTAB_MAX, "Bad mount point");

        FILEIO_MUTEX_UNLOCK( mtab_lock[mte-&mtab[0]] );

    }

}

//==========================================================================

// Timestamp support

// This provides access to the current time/date, expressed as a

// time_t.  It uses a number of mechanisms to do this, selecting

// whichever is available in the current configuration.

__externC time_t cyg_timestamp()

{

#if defined(CYGPKG_IO_WALLCLOCK)

    // First, try to get the time from the wallclock device.

    return (time_t) Cyg_WallClock::wallclock->get_current_time();

#elif defined(CYGINT_ISO_POSIX_TIMERS)

    // If POSIX is present, use the current value of the realtime

    // clock.

    struct timespec tp;

    clock_gettime( CLOCK_REALTIME, &tp );

    return (time_t) tp.tv_sec;

#elif defined(CYGPKG_KERNEL) 

    // If all else fails, get the current realtime clock value and

    // convert it to seconds ourself.

    static struct Cyg_Clock::converter sec_converter;

    static cyg_bool initialized = false;

    cyg_tick_count ticks;

    if( !initialized )

    {

        Cyg_Clock::real_time_clock->get_clock_to_other_converter( 1000000000, &sec_converter );

        initialized = true;

    }

    ticks = Cyg_Clock::real_time_clock->current_value();

    return (time_t) Cyg_Clock::convert( ticks, &sec_converter );

#else    

    /* No clock support at all. */

    return (time_t) 0;

#endif    

}

//==========================================================================

// Default functions

__externC int cyg_fileio_enosys() { return ENOSYS; }

__externC int cyg_fileio_erofs() { return EROFS; }

__externC int cyg_fileio_enoerr() { return ENOERR; }

__externC int cyg_fileio_enotdir() { return ENOTDIR; }

__externC int cyg_fileio_seltrue (struct CYG_FILE_TAG *fp, int which, CYG_ADDRWORD info)

{ return 1; }

// -------------------------------------------------------------------------

// EOF misc.cxx