1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen

Talk camd3 auf Raspberry PI per qemu möglich?

Dieses Thema im Forum "Raspberry Pi" wurde erstellt von stonev, 17. September 2012.

  1. stonev
    Offline

    stonev Ist oft hier

    Registriert:
    28. November 2008
    Beiträge:
    112
    Zustimmungen:
    137
    Punkte für Erfolge:
    43
    Hallo,

    ich überlege gerade den Raspberry (nur 3,5 Watt) als CS Server einzusetzen und meine Fritte zu entlasten.
    Oscam ist ja kein Problem.

    Allerdings wäre es schön, wenn man über den Raspberry auch camd3 keys teilen könnte. Mir ist klar, dass die camd3 auf ARM nicht läuft. Ich habe aber gelesen, dass z. B. qemu einen MIPS-Prozessoer emulieren kann.

    Wäre es möglich (und auch sinnvoll) per Emulation einen camd3 Server neben Oscam auf dem Raspberry laufen zu lassen?
     
    #1
  2. phantom

    Nervigen User Advertisement

  3. aragorn
    Offline

    aragorn Guest

    AW: camd3 auf Raspberry PI per qemu möglich?

    ich hab mir daran schon mal die zähne ausgebissen den user-space-mode dafür zu nutzen..
    ein komplettes system zu emulieren ist denk ich übertrieben hab ich aber auch schon versucht bin aber an der netzwerk verbindung zwischen host und gast gescheitert..

    wenn du das hin kriegen solltest dann gib bitte bescheid :emoticon-0116-evilg


    edit: hatte auch schon probiert i386 anstatt mips zu nutzen..
    ich poste dir mal meine bisher mühsam zusammen geschusterte vorgehensweise/howto die aber leider bisher auch kein erfolg gebracht hat..
    vielleicht hilft es dir ja oder du findest einen fehler.. wär auf jeden fall super wenn du das hier dann posten/mitteilen würdest :)
    Vorbereitungen auf dem PC:

    1) QEMU für Windows laden und installieren: http://qemu.weilnetz.de/w32/qemu-w32.exe
    2) Debian i386 netinstall laden: http://cdimage.debian.org/debian-cd/6.0.5/i386/iso-cd/debian-6.0.5-i386-netinst.iso
    3) Per Eingabeaufforderung in C:\Program Files\qemu\ wechseln
    4) 900MB Image erstellen: qemu-img.exe create -f qcow2 G:\debian.img 900M (nach installation sind ca. 480MB belegt. das image ist aber ca. 720MB gross)
    5) Debian installation starten (512mb ram und nur ein cpu-core, auf keinen fall mehr cores da der raspberry auch nur einen hat!):
    qemu -cpu 486 -hda G:\debian.img -cdrom G:\debian-6.0.4-i386-netinst.iso -boot d -m 512 -smp 1
    6) Absolut minimale Installation durchführen (KEINE Pakete auswählen!)

    7) apt-get remove grub-common grub-pc
    8) apt-get install lilo
    9) nano /etc/lilo.conf :

    boot=/dev/sda
    lba32
    large-memory

    install=text
    timeout=50
    default=linux

    image=/boot/vmlinuz-2.6.32-5-486
    initrd=/boot/initrd.img-2.6.32-5-486
    root=/dev/sda1
    label=linux

    10) liloconfig



    Vorbereitungen auf dem Raspberry:

    1) apt-get install git zlib1g-dev libsdl1.2-dev libncurses5-dev ncurses-dev
    2) mkdir raspidev && cd raspidev
    3) wget http://thoronir.net/raspi-dev/qemu-git.tar.bz2
    4) tar xfj qemu-git.tar.bz2
    5) cd qemu
    6) ./configure --target-list="i386-softmmu" --prefix=/usr --extra-cflags="-O3 -mfloat-abi=hard -mfpu=vfp -mcpu=arm1176jzf-s -mtune=arm1176jzf-s -march=armv6zk"
    7) nano tcg/arm/tcg-target.c
    static void tcg_out_addi(TCGContext *s, int reg, tcg_target_long val)
    in folgendes ändern:
    static inline void tcg_out_addi(TCGContext *s, int reg, tcg_target_long val)

    8) nano tcg/i386/tcg-target.c .. das selbe wie in 7)
    9) rm qapi/qmp-input-visitor.c
    10) nano qapi/qmp-input-visitor.c .. und copy&past:
    Code:
    /*
     * Input Visitor
     *
     * Copyright IBM, Corp. 2011
     *
     * Authors:
     *  Anthony Liguori   <aliguori@us.ibm.com>
     *
     * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
     * See the COPYING.LIB file in the top-level directory.
     *
     */
    
    #include "qmp-input-visitor.h"
    #include "qemu-queue.h"
    #include "qemu-common.h"
    #include "qemu-objects.h"
    #include "qerror.h"
    
    #define QIV_STACK_SIZE 1024
    
    typedef struct StackObject
    {
        const QObject *obj;
        const  QListEntry *entry;
    } StackObject;
    
    struct QmpInputVisitor
    {
        Visitor visitor;
        QObject *obj;
        StackObject stack[QIV_STACK_SIZE];
        int nb_stack;
    };
    
    static QmpInputVisitor *to_qiv(Visitor *v)
    {
        return container_of(v, QmpInputVisitor, visitor);
    }
    
    static const QObject *qmp_input_get_object(QmpInputVisitor *qiv,
                                               const char *name)
    {
        const QObject *qobj;
    
        if (qiv->nb_stack == 0) {
            qobj = qiv->obj;
        } else {
            qobj = qiv->stack[qiv->nb_stack - 1].obj;
        }
    
        if (name && qobject_type(qobj) == QTYPE_QDICT) {
            return qdict_get(qobject_to_qdict(qobj), name);
        } else if (qiv->nb_stack > 0 && qobject_type(qobj) == QTYPE_QLIST) {
            return qlist_entry_obj(qiv->stack[qiv->nb_stack - 1].entry);
        }
    
        return qobj;
    }
    
    static void qmp_input_push(QmpInputVisitor *qiv, const QObject *obj, Error **errp)
    {
        qiv->stack[qiv->nb_stack].obj = obj;
        if (qobject_type(obj) == QTYPE_QLIST) {
            qiv->stack[qiv->nb_stack].entry = qlist_first(qobject_to_qlist(obj));
        }
        qiv->nb_stack++;
    
        if (qiv->nb_stack >= QIV_STACK_SIZE) {
            error_set(errp, QERR_BUFFER_OVERRUN);
            return;
        }
    }
    
    static void qmp_input_pop(QmpInputVisitor *qiv, Error **errp)
    {
        qiv->nb_stack--;
        if (qiv->nb_stack < 0) {
            error_set(errp, QERR_BUFFER_OVERRUN);
            return;
        }
    }
    
    static void qmp_input_start_struct(Visitor *v, void **obj, const char *kind,
                                       const char *name, size_t size, Error **errp)
    {
        QmpInputVisitor *qiv = to_qiv(v);
        const QObject *qobj = qmp_input_get_object(qiv, name);
    
        if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
            error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                      "QDict");
            return;
        }
    
        qmp_input_push(qiv, qobj, errp);
        if (error_is_set(errp)) {
            return;
        }
    
        if (obj) {
            *obj = g_malloc0(size);
        }
    }
    
    static void qmp_input_end_struct(Visitor *v, Error **errp)
    {
        QmpInputVisitor *qiv = to_qiv(v);
    
        qmp_input_pop(qiv, errp);
    }
    
    static void qmp_input_start_list(Visitor *v, const char *name, Error **errp)
    {
        QmpInputVisitor *qiv = to_qiv(v);
        const QObject *qobj = qmp_input_get_object(qiv, name);
    
        if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
            error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                      "list");
            return;
        }
    
        qmp_input_push(qiv, qobj, errp);
    }
    
    static GenericList *qmp_input_next_list(Visitor *v, GenericList **list,
                                            Error **errp)
    {
        QmpInputVisitor *qiv = to_qiv(v);
        GenericList *entry;
        StackObject *so = &qiv->stack[qiv->nb_stack - 1];
    
        if (so->entry == NULL) {
            return NULL;
        }
    
        entry = g_malloc0(sizeof(*entry));
        if (*list) {
            so->entry = qlist_next(so->entry);
            if (so->entry == NULL) {
                g_free(entry);
                return NULL;
            }
            (*list)->next = entry;
        }
        *list = entry;
    
    
        return entry;
    }
    
    static void qmp_input_end_list(Visitor *v, Error **errp)
    {
        QmpInputVisitor *qiv = to_qiv(v);
    
        qmp_input_pop(qiv, errp);
    }
    
    static void qmp_input_type_int(Visitor *v, int64_t *obj, const char *name,
                                   Error **errp)
    {
        QmpInputVisitor *qiv = to_qiv(v);
        const QObject *qobj = qmp_input_get_object(qiv, name);
    
        if (!qobj || qobject_type(qobj) != QTYPE_QINT) {
            error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                      "integer");
            return;
        }
    
        *obj = qint_get_int(qobject_to_qint(qobj));
    }
    
    static void qmp_input_type_bool(Visitor *v, bool *obj, const char *name,
                                    Error **errp)
    {
        QmpInputVisitor *qiv = to_qiv(v);
        const QObject *qobj = qmp_input_get_object(qiv, name);
    
        if (!qobj || qobject_type(qobj) != QTYPE_QBOOL) {
            error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                      "boolean");
            return;
        }
    
        *obj = qbool_get_int(qobject_to_qbool(qobj));
    }
    
    static void qmp_input_type_str(Visitor *v, char **obj, const char *name,
                                   Error **errp)
    {
        QmpInputVisitor *qiv = to_qiv(v);
        const QObject *qobj = qmp_input_get_object(qiv, name);
    
        if (!qobj || qobject_type(qobj) != QTYPE_QSTRING) {
            error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                      "string");
            return;
        }
    
        *obj = g_strdup(qstring_get_str(qobject_to_qstring(qobj)));
    }
    
    static void qmp_input_type_number(Visitor *v, double *obj, const char *name,
                                      Error **errp)
    {
        QmpInputVisitor *qiv = to_qiv(v);
        const QObject *qobj = qmp_input_get_object(qiv, name);
    
        if (!qobj || qobject_type(qobj) != QTYPE_QFLOAT) {
            error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                      "double");
            return;
        }
    
        *obj = qfloat_get_double(qobject_to_qfloat(qobj));
    }
    
    static void qmp_input_type_enum(Visitor *v, int *obj, const char *strings[],
                                    const char *kind, const char *name,
                                    Error **errp)
    {
        int64_t value = 0;
        char *enum_str;
        assert(strings);
       enum_str = (char *)strings[value];
        qmp_input_type_str(v, &enum_str, name, errp);
        if (error_is_set(errp)) {
            return;
        }
    
        while (strings[value] != NULL) {
            if (strcmp(strings[value], enum_str) == 0) {
                break;
            }
            value++;
        }
    
        if (strings[value] == NULL) {
            error_set(errp, QERR_INVALID_PARAMETER, name ? name : "null");
            return;
        }
    
        *obj = value;
    }
    
    static void qmp_input_start_optional(Visitor *v, bool *present,
                                         const char *name, Error **errp)
    {
        QmpInputVisitor *qiv = to_qiv(v);
        const QObject *qobj = qmp_input_get_object(qiv, name);
    
        if (!qobj) {
            *present = false;
            return;
        }
    
        *present = true;
    }
    
    static void qmp_input_end_optional(Visitor *v, Error **errp)
    {
    }
    
    Visitor *qmp_input_get_visitor(QmpInputVisitor *v)
    {
        return &v->visitor;
    }
    
    void qmp_input_visitor_cleanup(QmpInputVisitor *v)
    {
        qobject_decref(v->obj);
        g_free(v);
    }
    
    QmpInputVisitor *qmp_input_visitor_new(QObject *obj)
    {
        QmpInputVisitor *v;
    
        v = g_malloc0(sizeof(*v));
    
        v->visitor.start_struct = qmp_input_start_struct;
        v->visitor.end_struct = qmp_input_end_struct;
        v->visitor.start_list = qmp_input_start_list;
        v->visitor.next_list = qmp_input_next_list;
        v->visitor.end_list = qmp_input_end_list;
        v->visitor.type_enum = qmp_input_type_enum;
        v->visitor.type_int = qmp_input_type_int;
        v->visitor.type_bool = qmp_input_type_bool;
        v->visitor.type_str = qmp_input_type_str;
        v->visitor.type_number = qmp_input_type_number;
        v->visitor.start_optional = qmp_input_start_optional;
        v->visitor.end_optional = qmp_input_end_optional;
    
        v->obj = obj;
        qobject_incref(v->obj);
    
        return v;
    }

    11) make && make install
    12) Fehlende sgabios.bin in /usr/share/qemu/ laden
    wget -O/usr/share/qemu/sgabios.bin http://qemu.weilnetz.de/w32/2012-06-28/sgabios.bin




    Das zuvor unter Windows erstellte debian.img Image auf den Raspberry in den Ordner /qemu/ kopieren (ordner anlegen)
    Starten:
    /usr/bin/qemu -cpu 486 -hda /qemu/debian.img -m 64 -nographic -pidfile /var/run/qemu.i386.pid


    Netzwerk:
    http://www.helbing.nu/projekte/linux/qemu.html


    Netzwerk des Raspberry:
    1) apt-get install bridge-utils
    2) nano /etc/network/interfaces
    alle zeilen eth0 betreffend auskommentieren und stattdessen folgendes einfügen:
    Code:
    auto br0
    iface br0 inet static
       address 192.168.1.10
       network 192.168.1.0
       netmask 255.255.255.0
       broadcast 192.168.1.255
       gateway 192.168.1.1
       bridge_ports eth0
       bridge_fd 9
       bridge_hello 2
       bridge_maxage 12
       bridge_stp off
    3) nano /etc/qemu-ifup
    #!/bin/sh
    sudo -p "Password for $0:" /sbin/ifconfig $1 0.0.0.0 promisc up
    sudo -p "Password for $0:" /sbin/brctl addif br0 $1


    Netzwerk der qemu:
    1) qemu -cpu 486 -hda /qemu/debian.img -m 64 -nographic -pidfile /var/run/qemu.i386.pid -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 -no-acpi
    2) nano /etc/sysconfig/network-scripts/ifcfg-eth0
    DEVICE=eth0
    IPADDR=192.168.1.10
    NETMASK=255.255.255.0
    NETWORK=192.168.1.0
    BROADCAST=255.255.255.255
    GATEWAY=192.168.1.1
    ONBOOT=yes
    TYPE=Ethernet
    HWADDR=52:54:00:12:34:56
     
    Zuletzt von einem Moderator bearbeitet: 17. September 2012
    #2
  4. stonev
    Offline

    stonev Ist oft hier

    Registriert:
    28. November 2008
    Beiträge:
    112
    Zustimmungen:
    137
    Punkte für Erfolge:
    43
    AW: camd3 auf Raspberry PI per qemu möglich?

    Hi aragorn,

    so tiefgreifend sind meine Linuxkenntnisse leider nicht, dass ich etwas derartiges selber erarbeiten könnte. Es reicht gerade aus, um zu reproduzieren. Ich suche aber gern weiter und melde zurück, wenn ich etwas sinnvolles finde.

    Im Raspberry Forum hat jemand das gleiche versucht und ist auch nicht weiter gekommen *Link entfernt* (hoffe man darf hier in einem solchen Fall auf ein anderes Forum verlinken, sonst bitte löschen) Der Thread ist aber recht aktuell und vielleicht wird dort noch eine Lösung gefunden.

    Aus einem anderen Thread aus diesem Forum noch folgender Hinweis von asb:
    Die haben es immerhin geschafft Win95 und XP per qemu auf dem PI laufen zu lassen und x86 zu emulieren.
     
    Zuletzt bearbeitet: 18. September 2012
    #3
  5. stonev
    Offline

    stonev Ist oft hier

    Registriert:
    28. November 2008
    Beiträge:
    112
    Zustimmungen:
    137
    Punkte für Erfolge:
    43
    AW: camd3 auf Raspberry PI per qemu möglich?

    Ich habe in der aktuellen CT den hgier entdeckt:

    Kann mann das nicht zusätzlich zum Raspberry hernehmen, um camd3 drauf laufen zu lassen. Für camd3 müsste die Leistung doch reichen, oder?
     
    #4
  6. aragorn
    Offline

    aragorn Guest

    AW: camd3 auf Raspberry PI per qemu möglich?

    naja noch einen extra strom verbraucher nur für camd3 an zu schaffen fände übertrieben
    auf wlan würde ich dabei auch verzichten weil wlan hat zum einen höhere latenzen und ist zudem anfälliger als lan

    allerdings macht mich folgendes stutzig:
    also nicht 22eu sondern mindestens 39eu!

    der bericht ist hier zu finden:

    Dieser Link ist nur für Mitglieder!!! Jetzt kostenlos Registrieren ?



    ausserdem ist fraglich wieviel von den 8mb flash noch frei wären um die camd3 plus key files aufpsielen zu können



    ps: hab gerade noch mal nach geguckt aber sehe nur eine mipsel aber keine mips camd3 binary. die einzigen camd3 binaries die ich hier habe sind für : armeb, cygwin, i386, mipsel, ppc, ppc405 und sh4
     
    #5
  7. huberhans
    Offline

    huberhans Ist gelegentlich hier

    Registriert:
    16. Oktober 2010
    Beiträge:
    56
    Zustimmungen:
    5
    Punkte für Erfolge:
    0
    Re: AW: camd3 auf Raspberry PI per qemu möglich?

    Hi,

    Ich würde debian + IPC installieren. So habe ich es auf meinem RasPI laufen.
     
    #6
  8. aragorn
    Offline

    aragorn Guest

    AW: camd3 auf Raspberry PI per qemu möglich?

    huberhans: dieses Thema hier dreht sich aber um die frage, ob man camd3 auf dem rpi betreiben kann - das geht auch nicht wenn man IPC installiert also ist dein post hier offtopic



    zwinschenzeitlich (der letzte post hier ist 6 monate alt) ist aber zwischenzeitlich

    Dieser Link ist nur für Mitglieder!!! Jetzt kostenlos Registrieren ?

    raus gekommen mit dem man die emu-key-files, wofür camd3 genutzt wurde, ebenfals nutzen kann..
     
    #7

Diese Seite empfehlen