Return to grubfs_fs.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs

Annotation of qemu/roms/openbios/fs/grubfs/grubfs_fs.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     /packages/grubfs-files
        !             3:  *
        !             4:  *     grub vfs
        !             5:  *
        !             6:  *   Copyright (C) 2004 Stefan Reinauer
        !             7:  *   Copyright (C) 2004 Samuel Rydh
        !             8:  *   Copyright (C) 2010 Mark Cave-Ayland
        !             9:  *
        !            10:  *   inspired by HFS code from Samuel Rydh
        !            11:  *
        !            12:  *   This program is free software; you can redistribute it and/or
        !            13:  *   modify it under the terms of the GNU General Public License
        !            14:  *   as published by the Free Software Foundation
        !            15:  *
        !            16:  */
        !            17: 
        !            18: #include "config.h"
        !            19: #include "libopenbios/bindings.h"
        !            20: #include "fs/fs.h"
        !            21: #include "filesys.h"
        !            22: #include "glue.h"
        !            23: #include "libc/diskio.h"
        !            24: #include "libc/vsprintf.h"
        !            25: 
        !            26: extern void     grubfs_init( void );
        !            27: 
        !            28: /************************************************************************/
        !            29: /*     grub GLOBALS (horrible... but difficult to fix)                 */
        !            30: /************************************************************************/
        !            31: 
        !            32: /* the grub drivers want these: */
        !            33: int            filepos;
        !            34: int            filemax;
        !            35: grub_error_t   errnum;
        !            36: char           FSYS_BUF[FSYS_BUFLEN];
        !            37: 
        !            38: /* these are not even used by us, instead
        !            39:  * the grub fs drivers want them:
        !            40:  */
        !            41: int            fsmax;
        !            42: void           (*disk_read_hook) (int, int, int);
        !            43: void           (*disk_read_func) (int, int, int);
        !            44: 
        !            45: 
        !            46: /************************************************************************/
        !            47: /*     filsystem table                                                 */
        !            48: /************************************************************************/
        !            49: 
        !            50: typedef struct fsys_entry {
        !            51:         const char *name;
        !            52:        int     (*mount_func) (void);
        !            53:        int     (*read_func) (char *buf, int len);
        !            54:        int     (*dir_func) (char *dirname);
        !            55:        void    (*close_func) (void);
        !            56:        int     (*embed_func) (int *start_sector, int needed_sectors);
        !            57: } fsys_entry_t;
        !            58: 
        !            59: static const struct fsys_entry fsys_table[] = {
        !            60: # ifdef CONFIG_FSYS_FAT
        !            61:     {"fat", fat_mount, fat_read, fat_dir, NULL, NULL},
        !            62: # endif
        !            63: # ifdef CONFIG_FSYS_EXT2FS
        !            64:     {"ext2fs", ext2fs_mount, ext2fs_read, ext2fs_dir, NULL, NULL},
        !            65: # endif
        !            66: # ifdef CONFIG_FSYS_MINIX
        !            67:     {"minix", minix_mount, minix_read, minix_dir, NULL, NULL},
        !            68: # endif
        !            69: # ifdef CONFIG_FSYS_REISERFS
        !            70:     {"reiserfs", reiserfs_mount, reiserfs_read, reiserfs_dir, NULL, reiserfs_embed},
        !            71: # endif
        !            72: # ifdef CONFIG_FSYS_JFS
        !            73:     {"jfs", jfs_mount, jfs_read, jfs_dir, NULL, jfs_embed},
        !            74: # endif
        !            75: # ifdef CONFIG_FSYS_XFS
        !            76:     {"xfs", xfs_mount, xfs_read, xfs_dir, NULL, NULL},
        !            77: # endif
        !            78: # ifdef CONFIG_FSYS_UFS
        !            79:     {"ufs", ufs_mount, ufs_read, ufs_dir, NULL, ufs_embed},
        !            80: # endif
        !            81: # ifdef CONFIG_FSYS_ISO9660
        !            82:     {"iso9660", iso9660_mount, iso9660_read, iso9660_dir, NULL, NULL},
        !            83: # endif
        !            84: # ifdef CONFIG_FSYS_NTFS
        !            85:     {"ntfs", ntfs_mount, ntfs_read, ntfs_dir, NULL, NULL},
        !            86: # endif
        !            87: # ifdef CONFIG_FSYS_AFFS
        !            88:     {"affs", affs_mount, affs_read, affs_dir, NULL, NULL},
        !            89: # endif
        !            90: };
        !            91: 
        !            92: /* We don't provide a file search mechanism (yet) */
        !            93: typedef struct {
        !            94:        unsigned long   pos;
        !            95:        unsigned long   len;
        !            96:        const char      *path;
        !            97: } grubfile_t;
        !            98: 
        !            99: typedef struct {
        !           100:        const struct fsys_entry *fsys;
        !           101:        grubfile_t *fd;
        !           102:        int dev_fd;
        !           103:        long long offset;       /* Offset added onto each device read; should only ever be non-zero
        !           104:                                when probing a partition for a filesystem */
        !           105: } grubfs_t;
        !           106: 
        !           107: typedef struct {
        !           108:        grubfs_t *gfs;
        !           109: } grubfs_info_t;
        !           110: 
        !           111: /* Static block and global pointer required for I/O glue */
        !           112: static grubfs_t dummy_fs;
        !           113: static grubfs_t *curfs = &dummy_fs;
        !           114: 
        !           115: DECLARE_NODE( grubfs, 0, sizeof(grubfs_info_t), "+/packages/grubfs-files" );
        !           116: 
        !           117: 
        !           118: /************************************************************************/
        !           119: /*     I/O glue (called by grub source)                                */
        !           120: /************************************************************************/
        !           121: 
        !           122: int
        !           123: devread( unsigned long sector, unsigned long byte_offset,
        !           124:         unsigned long byte_len, void *buf )
        !           125: {
        !           126:        long long offs = (long long)sector * 512 + byte_offset;
        !           127: 
        !           128: #ifdef CONFIG_DEBUG_FS
        !           129:        //printk("devread s=%x buf=%x, fd=%x\n",sector, buf, curfs->dev_fd);
        !           130: #endif
        !           131: 
        !           132:        if( !curfs ) {
        !           133: #ifdef CONFIG_DEBUG_FS
        !           134:                printk("devread: fsys == NULL!\n");
        !           135: #endif
        !           136:                return -1;
        !           137:        }
        !           138: 
        !           139:        if( seek_io(curfs->dev_fd, offs + curfs->offset) ) {
        !           140: #ifdef CONFIG_DEBUG_FS
        !           141:                printk("seek failure\n");
        !           142: #endif
        !           143:                return -1;
        !           144:        }
        !           145:        return (read_io(curfs->dev_fd, buf, byte_len) == byte_len) ? 1:0;
        !           146: }
        !           147: 
        !           148: int
        !           149: file_read( void *buf, unsigned long len )
        !           150: {
        !           151:        if (filepos < 0 || filepos > filemax)
        !           152:                filepos = filemax;
        !           153:        if (len > filemax-filepos)
        !           154:                len = filemax - filepos;
        !           155:        errnum = 0;
        !           156:        return curfs->fsys->read_func( buf, len );
        !           157: }
        !           158: 
        !           159: 
        !           160: /************************************************************************/
        !           161: /*     Standard package methods                                        */
        !           162: /************************************************************************/
        !           163: 
        !           164: /* ( -- success? ) */
        !           165: static void
        !           166: grubfs_files_open( grubfs_info_t *mi )
        !           167: {
        !           168:        int fd, i;
        !           169:        char *path = my_args_copy();
        !           170:        char *s;
        !           171: 
        !           172:        fd = open_ih( my_parent() );
        !           173:        if ( fd == -1 ) {
        !           174:                free( path );
        !           175:                RET( 0 );
        !           176:        }
        !           177: 
        !           178:        mi->gfs = &dummy_fs;
        !           179: 
        !           180:        for (i = 0; i < sizeof(fsys_table)/sizeof(fsys_table[0]); i++) {
        !           181: #ifdef CONFIG_DEBUG_FS
        !           182:                printk("Trying %s\n", fsys_table[i].name);
        !           183: #endif
        !           184:                if (fsys_table[i].mount_func()) {
        !           185:                        const fsys_entry_t *fsys = &fsys_table[i];
        !           186: #ifdef CONFIG_DEBUG_FS
        !           187:                        printk("Mounted %s\n", fsys->name);
        !           188: #endif
        !           189:                        mi->gfs = malloc(sizeof(grubfs_t));
        !           190:                        mi->gfs->fsys = fsys;
        !           191:                        mi->gfs->dev_fd = fd;
        !           192:                        mi->gfs->offset = 0;
        !           193: 
        !           194:                        s = path;
        !           195:                        while (*s) {
        !           196:                                if(*s=='\\') *s='/';
        !           197:                                s++;
        !           198:                        }
        !           199: #ifdef CONFIG_DEBUG_FS
        !           200:                        printk("Path=%s\n",path);
        !           201: #endif
        !           202:                        if (!mi->gfs->fsys->dir_func((char *) path)) {
        !           203:                                forth_printf("File not found\n");
        !           204:                                RET( 0 );
        !           205:                        }
        !           206: 
        !           207:                        mi->gfs->fd = malloc(sizeof(grubfile_t));
        !           208:                        mi->gfs->fd->pos = filepos;
        !           209:                        mi->gfs->fd->len = filemax;
        !           210:                        mi->gfs->fd->path = strdup(path);
        !           211: 
        !           212:                        RET( -1 );
        !           213:                }
        !           214:        }
        !           215: #ifdef CONFIG_DEBUG_FS
        !           216:        printk("Unknown filesystem type\n");
        !           217: #endif
        !           218: 
        !           219:        RET( 0 );
        !           220: }
        !           221: 
        !           222: /* ( -- ) */
        !           223: static void
        !           224: grubfs_files_close( grubfs_info_t *mi )
        !           225: {
        !           226:        grubfile_t *gf = mi->gfs->fd;
        !           227: 
        !           228:        if (gf->path)
        !           229:                free((void *)(gf->path));
        !           230:        free(gf);
        !           231: 
        !           232:        filepos = 0;
        !           233:        filemax = 0;
        !           234: }
        !           235: 
        !           236: /* ( buf len -- actlen ) */
        !           237: static void
        !           238: grubfs_files_read( grubfs_info_t *mi )
        !           239: {
        !           240:        int count = POP();
        !           241:        char *buf = (char *)cell2pointer(POP());
        !           242: 
        !           243:        grubfile_t *file = mi->gfs->fd;
        !           244:         int ret;
        !           245: 
        !           246:        filepos = file->pos;
        !           247:        filemax = file->len;
        !           248: 
        !           249:        if (count > filemax - filepos)
        !           250:                count = filemax - filepos;
        !           251: 
        !           252:        ret = mi->gfs->fsys->read_func(buf, count);
        !           253: 
        !           254:        file->pos = filepos;
        !           255: 
        !           256:        RET( ret );
        !           257: }
        !           258: 
        !           259: /* ( pos.d -- status ) */
        !           260: static void
        !           261: grubfs_files_seek( grubfs_info_t *mi )
        !           262: {
        !           263:        long long pos = DPOP();
        !           264:        int offs = (int)pos;
        !           265:        int whence = SEEK_SET;
        !           266: 
        !           267:        grubfile_t *file = mi->gfs->fd;
        !           268:        unsigned long newpos;
        !           269: 
        !           270:        switch( whence ) {
        !           271:        case SEEK_END:
        !           272:                if (offs < 0 && (unsigned long) -offs > file->len)
        !           273:                        newpos = 0;
        !           274:                else
        !           275:                        newpos = file->len + offs;
        !           276:                break;
        !           277:        default:
        !           278:        case SEEK_SET:
        !           279:                newpos = (offs < 0) ? 0 : offs;
        !           280:                break;
        !           281:        }
        !           282: 
        !           283:        if (newpos > file->len)
        !           284:                newpos = file->len;
        !           285: 
        !           286:        file->pos = newpos;
        !           287: 
        !           288:        if (newpos)
        !           289:                RET( -1 );
        !           290:        else
        !           291:                RET( 0 );
        !           292: }
        !           293: 
        !           294: /* ( addr -- size ) */
        !           295: static void
        !           296: grubfs_files_load( grubfs_info_t *mi )
        !           297: {
        !           298:        char *buf = (char *)cell2pointer(POP());
        !           299:        int count, ret;
        !           300: 
        !           301:        grubfile_t *file = mi->gfs->fd;
        !           302:        count = file->len;
        !           303: 
        !           304:        ret = mi->gfs->fsys->read_func(buf, count);
        !           305:        file->pos = filepos;
        !           306: 
        !           307:        RET( ret );
        !           308: }
        !           309: 
        !           310: /* ( -- cstr ) */
        !           311: static void
        !           312: grubfs_files_get_path( grubfs_info_t *mi )
        !           313: {
        !           314:        grubfile_t *file = mi->gfs->fd;
        !           315:        const char *path = file->path;
        !           316: 
        !           317:        RET( pointer2cell(strdup(path)) );
        !           318: }
        !           319: 
        !           320: /* ( -- cstr ) */
        !           321: static void
        !           322: grubfs_files_get_fstype( grubfs_info_t *mi )
        !           323: {
        !           324:        grubfs_t *gfs = mi->gfs;
        !           325: 
        !           326:        PUSH( pointer2cell(strdup(gfs->fsys->name)) );
        !           327: }
        !           328: 
        !           329: 
        !           330: /* static method, ( pos.d ih -- flag? ) */
        !           331: static void
        !           332: grubfs_files_probe( grubfs_info_t *dummy )
        !           333: {
        !           334:        ihandle_t ih = POP_ih();
        !           335:        long long offs = DPOP();
        !           336:        int i;
        !           337: 
        !           338:        curfs->dev_fd = open_ih(ih);
        !           339:         if (curfs->dev_fd == -1) {
        !           340:                 RET( -1 );
        !           341:         }
        !           342:        curfs->offset = offs;
        !           343: 
        !           344:        for (i = 0; i < sizeof(fsys_table)/sizeof(fsys_table[0]); i++) {
        !           345: #ifdef CONFIG_DEBUG_FS
        !           346:                printk("Probing for %s\n", fsys_table[i].name);
        !           347: #endif
        !           348:                if (fsys_table[i].mount_func()) {
        !           349:                        RET( -1 );
        !           350:                }
        !           351:        }
        !           352: 
        !           353: #ifdef CONFIG_DEBUG_FS
        !           354:        printk("Unknown filesystem type\n");
        !           355: #endif
        !           356: 
        !           357:        close_io(curfs->dev_fd);
        !           358: 
        !           359:        RET ( 0 );
        !           360: }
        !           361: 
        !           362: /* static method, ( pathstr len ihandle -- ) */
        !           363: static void
        !           364: grubfs_files_dir( grubfs_info_t *dummy )
        !           365: {
        !           366:        forth_printf("dir method not implemented for grubfs filesystem\n");
        !           367:        POP();
        !           368:        POP();
        !           369:        POP();
        !           370: }
        !           371: 
        !           372: static void
        !           373: grubfs_initializer( grubfs_info_t *dummy )
        !           374: {
        !           375:        fword("register-fs-package");
        !           376: }
        !           377: 
        !           378: NODE_METHODS( grubfs ) = {
        !           379:        { "probe",      grubfs_files_probe      },
        !           380:        { "open",       grubfs_files_open       },
        !           381:        { "close",      grubfs_files_close      },
        !           382:        { "read",       grubfs_files_read       },
        !           383:        { "seek",       grubfs_files_seek       },
        !           384:        { "load",       grubfs_files_load       },
        !           385:        { "dir",        grubfs_files_dir        },
        !           386: 
        !           387:        /* special */
        !           388:        { "get-path",   grubfs_files_get_path   },
        !           389:        { "get-fstype", grubfs_files_get_fstype },
        !           390: 
        !           391:        { NULL,         grubfs_initializer      },
        !           392: };
        !           393: 
        !           394: void
        !           395: grubfs_init( void )
        !           396: {
        !           397:        REGISTER_NODE( grubfs );
        !           398: }

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