Return to blk.c CVS log

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

Annotation of qemu/roms/openbios/arch/unix/blk.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *  <arch/unix/blk.c>
        !             3:  *
        !             4:  *     block device emulation for unix hosts
        !             5:  *
        !             6:  *   Copyright (C) 2004 Stefan Reinauer <[email protected]>
        !             7:  *
        !             8:  *   This program is free software; you can redistribute it and/or
        !             9:  *   modify it under the terms of the GNU General Public License
        !            10:  *   version 2
        !            11:  *
        !            12:  */
        !            13: 
        !            14: #include "config.h"
        !            15: #include "libopenbios/bindings.h"
        !            16: #include "blk.h"
        !            17: 
        !            18: typedef struct {
        !            19:        int     unit;
        !            20:        int     channel;
        !            21: } blk_data_t;
        !            22: 
        !            23: 
        !            24: DECLARE_NODE( blk, INSTALL_OPEN, sizeof(blk_data_t), "+/unix/block/disk" );
        !            25: 
        !            26: static void
        !            27: blk_open( blk_data_t *pb )
        !            28: {
        !            29:        phandle_t ph;
        !            30: 
        !            31:        fword("my-unit");
        !            32: 
        !            33:        pb->unit = POP();
        !            34:        pb->channel = 0;        /* FIXME */
        !            35: 
        !            36:        selfword("open-deblocker");
        !            37: 
        !            38:        /* interpose disk-label */
        !            39:        ph = find_dev("/packages/disk-label");
        !            40:        fword("my-args");
        !            41:        PUSH_ph( ph );
        !            42:        fword("interpose");
        !            43: 
        !            44:        /* printk("osi-blk: open %d\n", pb->unit ); */
        !            45: 
        !            46:        PUSH( -1 );
        !            47: }
        !            48: 
        !            49: static void
        !            50: blk_close( __attribute__((unused)) blk_data_t *pb )
        !            51: {
        !            52:        selfword("close-deblocker");
        !            53: }
        !            54: 
        !            55: 
        !            56: /* ( buf blk nblks -- actual ) */
        !            57: static void
        !            58: blk_read_blocks( blk_data_t *pb )
        !            59: {
        !            60:        cell i, n = POP();
        !            61:        cell blk = POP();
        !            62:        char *dest = (char*)POP();
        !            63: 
        !            64:        // printk("blk_read_blocks %x block=%d n=%d\n", (ucell)dest, blk, n );
        !            65: 
        !            66:        for( i=0; i<n; ) {
        !            67:                char buf[4096];
        !            68:                ucell m = MIN( n-i, sizeof(buf)/512 );
        !            69: 
        !            70:                if( read_from_disk(pb->channel, pb->unit, blk+i, (ucell)buf, m*512) < 0 ) {
        !            71:                        printk("read_from_disk: error\n");
        !            72:                        RET(0);
        !            73:                }
        !            74:                memcpy( dest, buf, m * 512 );
        !            75:                i += m;
        !            76:                dest += m * 512;
        !            77:        }
        !            78:        PUSH( n );
        !            79: }
        !            80: 
        !            81: /* ( -- bs ) */
        !            82: static void
        !            83: blk_block_size( __attribute__((unused)) blk_data_t *pb )
        !            84: {
        !            85:        PUSH( 512 );
        !            86: }
        !            87: 
        !            88: /* ( -- maxbytes ) */
        !            89: static void
        !            90: blk_max_transfer( __attribute__((unused)) blk_data_t *pb )
        !            91: {
        !            92:        PUSH( 1024*1024 );
        !            93: }
        !            94: 
        !            95: static void
        !            96: blk_initialize( __attribute__((unused)) blk_data_t *pb )
        !            97: {
        !            98:        fword("is-deblocker");
        !            99: }
        !           100: 
        !           101: 
        !           102: NODE_METHODS( blk ) = {
        !           103:        { NULL,                 blk_initialize  },
        !           104:        { "open",               blk_open        },
        !           105:        { "close",              blk_close       },
        !           106:        { "read-blocks",        blk_read_blocks },
        !           107:        { "block-size",         blk_block_size  },
        !           108:        { "max-transfer",       blk_max_transfer},
        !           109: };
        !           110: 
        !           111: void
        !           112: blk_init( void )
        !           113: {
        !           114:        REGISTER_NODE( blk );
        !           115: }

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