Return to pseudodisk.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / arch / ppc / mol

Annotation of qemu/roms/openbios/arch/ppc/mol/pseudodisk.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *   Creation Date: <2003/11/26 16:55:47 samuel>
                      3:  *   Time-stamp: <2004/01/07 19:41:54 samuel>
                      4:  *
                      5:  *     <pseudodisk.c>
                      6:  *
                      7:  *     pseudodisk (contains files exported from linux)
                      8:  *
                      9:  *   Copyright (C) 2003, 2004 Samuel Rydh ([email protected])
                     10:  *
                     11:  *   This program is free software; you can redistribute it and/or
                     12:  *   modify it under the terms of the GNU General Public License
                     13:  *   version 2
                     14:  *
                     15:  */
                     16: 
                     17: #include "config.h"
                     18: #include "libopenbios/bindings.h"
                     19: #include "osi_calls.h"
                     20: #include "libc/string.h"
                     21: #include "libopenbios/ofmem.h"
                     22: #include "mol/prom.h"
                     23: #include "mol/mol.h"
                     24: #include "osi_calls.h"
                     25: #include "pseudofs_sh.h"
                     26: 
                     27: typedef struct {
                     28:        int     seekpos;
                     29:        int     fd;
                     30:        char    *myargs;
                     31:        char    *name;
                     32:        int     size;
                     33: } pdisk_data_t;
                     34: 
                     35: 
                     36: DECLARE_NODE( pdisk, INSTALL_OPEN, sizeof(pdisk_data_t), "/mol/pseudo-disk/disk" );
                     37: 
                     38: static void
                     39: pdisk_open( pdisk_data_t *pb )
                     40: {
                     41:        char *ep, *name = NULL;
                     42:        int part;
                     43: 
                     44:        pb->myargs = my_args_copy();
                     45:        /* printk("pdisk-open: %s\n", pb->myargs ); */
                     46: 
                     47:        part = strtol( pb->myargs, &ep, 10 );
                     48:        if( *ep ) {
                     49:                if( (name=strchr(pb->myargs, ',')) ) {
                     50:                        *name = 0;
                     51:                        name++;
                     52:                } else {
                     53:                        name = pb->myargs;
                     54:                }
                     55:        }
                     56:        if( part )
                     57:                goto err;
                     58: 
                     59:        if( !name || !strlen(name) )
                     60:                pb->fd = -1;
                     61:        else {
                     62:                if( (pb->fd=PseudoFSOpen(name)) < 0 )
                     63:                        goto err;
                     64:                pb->size = PseudoFSGetSize( pb->fd );
                     65:        }
                     66:        pb->name = name;
                     67:        RET( -1 );
                     68:  err:
                     69:        free( pb->myargs );
                     70:        RET(0);
                     71: }
                     72: 
                     73: /* ( addr len -- actual ) */
                     74: static void
                     75: pdisk_read( pdisk_data_t *pb )
                     76: {
                     77:        int len = POP();
                     78:        char *dest = (char*)POP();
                     79:        int cnt;
                     80: 
                     81:        if( pb->fd < 0 ) {
                     82:                memset( dest, 0, len );
                     83:                PUSH(len);
                     84:                return;
                     85:        }
                     86:        /* dest is not "mol-DMA" safe (might have a nontrivial mapping) */
                     87:        for( cnt=0; cnt<len; ) {
                     88:                char buf[2048];
                     89:                int n = MIN( len-cnt, sizeof(buf) );
                     90: 
                     91:                n = PseudoFSRead( pb->fd, pb->seekpos, buf, n );
                     92:                if( n <= 0 )
                     93:                        break;
                     94: 
                     95:                memcpy( dest+cnt, buf, n );
                     96:                cnt += n;
                     97:                pb->seekpos += n;
                     98:        }
                     99:        PUSH( cnt );
                    100: }
                    101: 
                    102: /* ( addr len -- actual ) */
                    103: static void
                    104: pdisk_write( pdisk_data_t *pb )
                    105: {
                    106:        POP(); POP(); PUSH(-1);
                    107:        printk("pdisk write\n");
                    108: }
                    109: 
                    110: /* ( pos.lo pos.hi -- status ) */
                    111: static void
                    112: pdisk_seek( pdisk_data_t *pb )
                    113: {
                    114:        int pos_lo;
                    115:        POP();
                    116:        pos_lo = POP();
                    117: 
                    118:        if( pb->fd >= 0 ) {
                    119:                if( pos_lo == -1 )
                    120:                        pos_lo = pb->size;
                    121:        }
                    122: 
                    123:        pb->seekpos = pos_lo;
                    124: 
                    125:        PUSH(0);        /* ??? */
                    126: }
                    127: 
                    128: /* ( -- pos.d ) */
                    129: static void
                    130: pdisk_tell( pdisk_data_t *pb )
                    131: {
                    132:        DPUSH( pb->seekpos );
                    133: }
                    134: 
                    135: /* ( -- cstr ) */
                    136: static void
                    137: pdisk_get_path( pdisk_data_t *pb )
                    138: {
                    139:        PUSH( (int)pb->name );
                    140: }
                    141: 
                    142: /* ( -- cstr ) */
                    143: static void
                    144: pdisk_get_fstype( pdisk_data_t *pb )
                    145: {
                    146:        PUSH( (int)"PSEUDO" );
                    147: }
                    148: 
                    149: /* ( -- cstr ) */
                    150: static void
                    151: pdisk_volume_name( pdisk_data_t *pb )
                    152: {
                    153:        PUSH( (int)"Virtual Volume" );
                    154: }
                    155: 
                    156: static void
                    157: pdisk_block_size( pdisk_data_t *pb )
                    158: {
                    159:        PUSH(1);
                    160: }
                    161: 
                    162: NODE_METHODS( pdisk ) = {
                    163:        { "open",               pdisk_open              },
                    164:        { "read",               pdisk_read              },
                    165:        { "write",              pdisk_write             },
                    166:        { "seek",               pdisk_seek              },
                    167:        { "tell",               pdisk_tell              },
                    168:        { "block-size",         pdisk_block_size        },
                    169:        { "get-path",           pdisk_get_path          },
                    170:        { "get-fstype",         pdisk_get_fstype        },
                    171:        { "volume-name",        pdisk_volume_name       },
                    172: };
                    173: 
                    174: void
                    175: pseudodisk_init( void )
                    176: {
                    177:        REGISTER_NODE( pdisk );
                    178: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.