#lost · 2013-09-14
745 Nachrichten · Seite 3 von 4 · Original-CSV herunterladen
- JonathanUnd was würde eine Applikation sonst tun, wenn sie mit der schlauen Karte nicht klarkäme?
- Svenska*seufz* Artikulier ich mich so beschissen oder verstehst du mich einfach nicht?
- SvenskaFolgendes... du hast eine dumme und eine schlaue Karte
- SvenskaBeide nutzen verschiedene Treiber.
- JonathanNein! Ich hab eine schlaue Karte, die einen Treiber hat! Und dieser Treiber kann sich für dumme Programme wie ein dummer Treiber mit einer dummen Karte verhalten, und für schlaue Programme wie ein schlauer Treiber mit schlauer Karte!
- SvenskaBeide Treiber erscheinen dem System gegenüber aber als Klasse "seriell". Vollkommen identisch, damit die Anwendung nicht wissen muss, welche seriellen Karten es gerade auf dem Markt gibt (Wichtig!)
- SvenskaWenn deine Anwendung die nur weiß, wie sie mit "seriell" umgehen muss, die schlaue Karte konfiguriert, dann passiert das. Wenn sie versucht, die dumme Karte zu konfigurieren, kommt der Hinweis "wird nicht unterstützt" zurück.
- SvenskaWas ist so schlecht an diesem Ansatz?
- SvenskaWarum muss jede Anwendung, die eine serielle Karte nutzen können möchte, NEUER sein als _alle_ auf dem Markt vorhandenen Karten?
- JonathanIch glaub, du verstehst mich etwas falsch.
- SvenskaWas passiert, wenn du "serielle Karte, intelligent" entwickelst und ich eine "serielle Karte, intelligent" entwickle und beide _nicht_zueinander_kompatibel_sind_?
- JonathanDann wird die Karte in einem niedrigeren Modus betrieben, in dem sie kompatibel sind.
- SvenskaDeine kann Baudraten und Handshaking. Meine kann Baudraten, Pegel und Protokoll, aber kein Handshaking.
- SvenskaSchon brauchst du mindestens 5 verschiedene Fähigkeiten für serielle Karten.
- JonathanWenn die Anwendung Baudraten und Handshaking kann, wird sie bei meiner Karte beides nutzen, bei deiner die Karte jedoch wie eine Karte mit nur Baudrate sehen und sie auch so ansteuern.
- JonathanPegel und Protokoll werden dann vom Treiber auf Defaultwerte gesetzt.
- SvenskaUnd dann kommt so ein oberschlauer Ingeneur und stellt fest, dass ISDN theoretisch ja auch wie ein Modem aussehen kann (auf Kosten von ein paar Fähigkeiten) - und implementiert noch ein paar zusätzliche Protokolle.
- SvenskaUnd ISDN-Fähigkeit.
- JonathanWenn die Anwendung das kann, wird sie das auch nutzen, ansonsten eben wieder einen niedrigeren kompatiblen Modus.
- SvenskaUnd weil ISDN mit fixer Baudrate läuft, fehlt die Baudrate.
- SvenskaMerkst du, dass damit die Anzahl der möglichen Fähigkeiten explodiert?
- Svenska(Und vor allem muss jede Anwendung mit jedem möglichen Satz an Fähigkeiten klarkommen.)
- JonathanNein, muss sie nicht.
- SvenskaNa gut. Muss sie nicht. :-)
- JonathanWenn eine Anwendung auf so eine Super-Karte stößt, und nicht mit ihr umgehen kann... Dann meldet sich die Karte bei der Anwendung wie eine, mit der die Anwendung umgehen kann, und die dafür ein paar Features weniger hat.
- JonathanDie Anwendung nutzt die Karte dann wie genau so eine, und der Rest, der dann fehlt, wird vom Treiber auf Defaultwerte gesetzt.
- Svenska"Dann meldet sich die Karte bei der Anwendung"?
- Svenskasrsly?
- Svenska^^
- JonathanSagen wir so, sie wird gemeldet. :P
- SvenskaBesser. :P
- SvenskaNoch besser: Die Anwendung fragt, kriegt die Liste und ignoriert Fähigkeiten, die sie nicht kennt.
- JonathanIm Klassen-Deskriptor für eine Karte gibt es dann verschiedene abwärtskompatible Einträge.
- SvenskaWie groß ist denn so ein Deskriptor?
- SvenskaWieviele Einträge kann er denn machen?
- JonathanNoch nicht festgelegt, aber 12 Bytes wären schön. *g*
- JonathanGeht aber auch mehr.
- SvenskaUnd wenn ich 13 Fähigkeiten habe?
- SvenskaUnd eine andere Karte 13 _andere_ Fähigkeiten? Schon brauchst du 26 Byte. :)
- JonathanIch würde es wie die Java-Klassen-Variante machen: NPC extends Creature extends MapObject extends ScreenObject.
- JonathanWer mit einem NPC umgehen kann, bittesehr.
- SvenskaWarum hältst du es für unglaublich wichtig, dass die Anwendung alle Fähigkeiten der Karte genau kennt, _bevor_ sie die Karte überhaupt anfässt?
- JonathanWer nur mit einem MapObject umgehen kann, behandelt den NPC einfach wie ein MapObject - geht auch.
- JonathanWieso das? Die Anwendung fragt doch bei der Karte (bzw. beim Treiber) nach, was der Treiber (nicht die Karte!) für Klassen unterstützt.
- SvenskaJa, aber das tut sie, bevor sie die Karte benutzt.
- JonathanHmmm... Du wärst also für "Hallo Treiber, ich hätte das und das und das mit dir vor, kannst du das?"
- Svenskanö
- SvenskaIch wäre für "Oh, du bist eine serielle Schnittstelle, konfigurier mal die Baudrate auf 19200".
- SvenskaDa kommt entweder ein "OK." oder ein "Geht nicht." zurück. :)
- JonathanIch wäre für "Oh, du bist eine serielle Schnittstelle. Aber...oh, da liegt ja schon die Adresse für den Handshake, jetzt hab ich Mist gemacht."
- SvenskaUnd das ganze noch erweitert auf: "Oh, du bist eine serielle Schnittstelle vom Typ <Gerätetyp>, mach mal bitte <Typspezifische_Konfiguration>"
- Svenska?
- JonathanAber das würde dann ja auf meinen Ansatz hinauslaufen.
- JonathanWenn jemand <Gerätetyp> nochmal erweitert hat?
- JonathanWas macht man dann?
- SvenskaKurz: alle serielle Schnittstellen bieten <Liste> an und zusätzlich dürfen sie noch <private_Liste> an.
- SvenskaUnd wenn du <private_Liste> erweiterst, dann teilen sich beide Karten sowieso einen Treiber.
- SvenskaWas du dir sparst, sind aber sämtliche Hardwaredeskriptoren.
- JonathanVielleicht denke ich einfach zu universell.
- SvenskaEs gibt eine Klassen-ID (Byte reicht) sowie eine Karten-ID (Wort reicht)
- SvenskaSelbst USB kommt mit einer Karten-ID von 32 Bit hin...
- Svenska...ISAPnP nutzt 16.
- JonathanBei beidem hab ich jetzt Bytes, das würde bei mir reichen.
- SvenskaJa.
- JonathanAber es geht mir ja nicht nur um Karten, sondern generell um _Treiber_.
- SvenskaEin Treiber ist immer speziell für eine Karten-ID, nicht für eine Klassen-ID.
- JonathanJa, das ist auch alles schon so geplant und implementiert.
- SvenskaAber ein Treiber bietet immer das Interface der Klassen-ID an.
- SvenskaUnd zusätzlich eines der Karten-ID, wenn er möchte.
- JonathanUnd genau darum geht es mir.
- JonathanWie soll *der Treiber* das anbieten?
- SvenskaHä?
- SvenskaWie, "wie soll der das anbieten"?
- JonathanNaja, ich rede die ganze Zeit davon, wie der Treiber dem System klarmachen soll, was er kann.
- SvenskaWarum sollte er?
- JonathanWarum sollte er nicht?!
- SvenskaWeil es Speicher kostet?
- Svenska(Und unnütz ist?)
- JonathanWieso ist es unnütz?
- SvenskaWenn eine Anwendung eine serielle Schnittstelle will, dann kann sie jeden Treiber benutzen, der die Klasse <SERIAL> anbietet.
- SvenskaWenn die Anwendung das Gerät XY aber speziell kennt (z.B. weil die Anwendung vom Gerätehersteller stammt), dann kann sie den privaten Bereich auch nutzen.
- SvenskaPer Definition ist der private Bereich privat, d.h. verdammt hardwarespezifisch.
- JonathanUnd jetzt stell dir vor, es gäbe eine Klasse <MODEM>, die als Unterklasse <SERIAL> enthält. Dann könnte eine Anwendung, die <MODEM> unterstützt, das auch nutzen, und eine, die nur <SERIAL> kann, eben nur die serielle Schnittstelle.
- Jonathan(Naja ok, Beispiel ist schlecht, aber solche Fälle mit Unterklassen wird es geben.)
- SvenskaJa. Und wer verbietet dir, <MODEM> als erweitertes <SERIAL> zu definieren?
- JonathanUnd wer verbietet mir, dass der Treiber einer Anwendung sagt: "Ja ich bin <MODEM> (Anwendung versteht nix), aber du kannst auch gern <SERIAL> zu mir sagen (ah!)"
- SvenskaWarum darf die Anwendung nicht sagen: "Du <MODEM> da drüben, mach mal V.32bis" - "Nee, kann ich nicht."
- JonathanWoher will die Anwendung überhaupt wissen, dass sie <MODEM> für Sachen nutzen kann, die sonst eigentlich <SERIAL> kann?
- JonathanWenn sie überhaupt nicht weiß, wass ein <MODEM> ist?
- SvenskaWarum interessiert sich die Anwendung überhaupt dafür, ob das Ding da nun genau <MODEM> oder <SERIAL> ist?
- SvenskaIch mein, der Benutzer (der das weiß), hat die Anwendung doch aufgefordert, die Hardware zu benutzen?
- SvenskaUnd wenn ich mein Terminalprogramm auf die Festplatte loslasse, bin ich irgendwo doch selbst schuld - oder? ^^
- JonathanUnd wenn ich da trotzdem gern hätte, dass die Anwendungen wüssten, womit sie reden, bevor sie Mist machen? ;P
- SvenskaWomit wir wieder da wären, wo ich die ganze Zeit hinwollte: Eigentlich reicht doch <SERIAL> und <BLOCK> :-D
- JonathanxD
- Svenska<SERIAL> kann: in/out/conf, <BLOCK> kann: in/out/seek/conf :D
- JonathanIch wäre für "Du kannst mich als <SERIAL> nutzen, aber wenn du es unterstützt, magst du mich auch als <MODEM> nutzen"
- SvenskaWie weit willst du die Abstraktion treiben? Guck mal in die Spec für USB, was da in den Deskriptoren drin steht.
- SvenskaDa ist genau beschrieben, was ein Gerät alles in welcher Art und Weise wie genau und mit welchen Verfahren unterstützt.
- SvenskaDummerweise brauchst du eigentlich trotzdem für die meisten Geräte einen eigenen Treiber. :-/
- JonathanSoweit, dass ein Gerät maximal 6 Klassen besitzen darf, die zu einander abwärtskompatibel sind.
- Svenska(und selbst, wenn du ihn nicht strikt brauchst, willst du ihn)
- Svenskahm
- Jonathan* Ein Treiber, nicht ein Gerät.
- Svenskas/6/N/
- SvenskaOk.
- Jonathan6 ist speicherplatzbedingt. *g*
- SvenskaIch geb mich geschlagen.
- SvenskaDu bist Java-Programmierer. ^^
- Jonathanxd
- SvenskaMit Herz und Seele.
- JonathanBeides verkauft, an Java.
- Svenskas/Java/Oracle/
- JonathanStimmt
- JonathanAaaaber: Wenn es dich glücklich macht, kann ja ein Treiberinterface auch mehrere Klassen implementieren.
- JonathanAber das driftet dann ja schon in Richtung "gruselig" ab.
- JonathanWerd ich eigentlich aber auch nicht brauchen.
- SvenskaIch hab ne 8 Bit Karten-ID, die im Monitor eingetragen wird und vom OS abgefragt werden kann. (Hält die Hardware einfach.)
- JonathanWenn ein Treiber sowas wirklich braucht, kann er zwei Interfaces zur Verfügung stellen.
- JonathanDie dann beide Klassen mit Unterklassen haben.
- SvenskaUnd meine Treiber werden <CHAR> und <BLOCK> implementieren, wie oben skizziert - und gute Treiber davon mehrere.
- Svenskas/<CHAR> und <BLOCK>/<CHAR> oder <BLOCK>/
- JonathanMag sein, dass dein Treibersystem anders funktionieren wird, als meins. ;P
- Svenskajo
- JonathanFunktionieren werden sie hoffentlich beide *g*
- Svenskajo
- JonathanDamit wäre dann auch das Dateisystem einfach:
- JonathanEine offene Datei wird einfach als Treiberinterface vom Dateisystemserver zurückgegeben.
- Svenskajede datei ist ein eigenes interface?
- JonathanNaja, um es mal mit verständlicheren Worten auszudrücken: Der Dateisystemserver öffnet einen Port.
- JonathanAuf den kann dann gelesen oder geschrieben werden, was dann effektiv auf die Datei liest/schreibt.
- Svenskawie wäre es mit seek? ^^
- JonathanGeht auch ^^
- Svenskanaja, mach mal
- Jonathan"Ports" sind bei mir 16-Bit-Werte mit dem Aufbau PID:INTF
- JonathanUnd an jeden dieser Port kann man 65536 verschiedene Messages senden.
- Jonathan<SERIAL>-Message 1: Lies was
- Jonathan<SERIAL>-Message 2: Schreib was
- Jonathan<SERIAL>-Message 3: Seek
- Svenskaso ähnlich wird das bei mir wohl auch laufen. die anwendung kriegt vom kernel ein 8-bit handle zurück und kann damit dann arbeiten.
- Svenskaääh, seek ist auf nem <SERIAL>-interface blöd ^^
- JonathanStimmt xD
- Svenskadas unterscheidet es von <BLOCK> interfaces ^^
- JonathanMag sein :P
- JonathanWird dann wohl auf <BLOCK> extends <SERIAL> hinauslaufen
- Svenskaok.
- JonathanUnd damit wäre es auch möglich, eine Ausgabe in eine Datei umzuleiten.
- JonathanEin Programm, das <SERIAL> bedienen kann, nutzt einfach den <SERIAL>-Teil von der <BLOCK>-Klasse der Datei.
- JonathanSchwupps, Ausgaben in der Datei.
- Svenska<BLOCK> extends <SERIAL> extends <DEVICE>
- JonathanxD
- Jonathan<DEVICE> ist alles, das brauch man nicht mehr hinzuschreiben :P
- Jonathan(Die wertvollen 2 Bytes will ich mir sparen)
- Svenskatree ohne root stinkt :p
- JonathanPfff :P
- Svenskaaußerdem hat <DEVICE> gewisse methoden, die du implementieren solltest
- Svenska(evtl. ist es eher <HANDLE> statt <DEVICE>)
- Jonathanz.B. Identify
- Svenskajup
- Svenskaich würde dir übrigens nen c++-compiler empfehlen :D
- JonathanAber...Identify wird sogar aufgerufen, bevor man überhaupt weiß, was es überhaupt ist ;P
- Svenskaebe
- Svenskaeben
- JonathanVon daher ist es ziemlich unnötig, <HANDLE> in die knappe Liste zu packen.
- JonathanAußer Identify ist da eigentlich nicht mehr viel, oder? Dispose vllt noch, aber sonst...
- Svenskakonstruktor/destruktor :-)
- JonathanJa ^^
- JonathanNaja wobei
- Svenskainteressanter ist, dass du eigentlich zwei ansätze haben könntest...
- JonathanEin Identify, dass Klassen zurück gibt, und eins, das Fähigkeiten liefert?
- Svenska<BLOCK>-<SERIAL>-<DEVICE>-<HANDLE> (für festplatten) und <BLOCK>-<SERIAL>-<HANDLE> (für dateien)
- Svenskaeine datei hat ja keine addressräume und interrupts...
- JonathanAddressräume und Interrupts will ich doch lieber komplett den Treibern überlassen, die direkt an der Hardware sitzen
- JonathanDas mit den Klassen soll nur für die IPC sein
- Svenskaäh, <DEVICE> ist der teil der hierarchie, den die treiber implementieren ^^
- Jonathan<DEVICE> ist keine echte Untermenge von <SERIAL>.
- Svenskahm
- JonathanSonst kommt noch jemand auf die Idee, auf eine Datei Interrupts oder so anwenden zu wollen.
- JonathanUnd das ist ein Problem.
- Svenskanaja, aber wenn du eine serielle schnittstelle hast, möchtest du die eventuell auf interrupts mappen können
- Svenskaoder adressen zuweisen
- JonathanNee, wie bereits gesagt sollen das die Treiber übernehmen, die direkt an der Karte sitzen
- JonathanDas mit den Klassen ist wirklich nur für IPC
- Svenskaich finds bissl übertrieben, aber so ist das eben.
- JonathanGenerell sollte jeder Prozess bei PID:0 ein Interface vom Typ <PROCESS>-<HANDLE> haben.
- JonathanDamit der Kernel die Prozesse über Interrupts benachrichtigen kann.
- JonathanOder man den Prozessen TERM/KILL-Messages senden kann.
- Svenskabei mir gibts dann eher ein register_interrupt()
- Svenskadu hast eine pro-task-liste der vorhandenen interrupts
- Svenskaund ich eine pro-interrupt-liste der betroffenen tasks
- Svenskaspart speicher :D
- JonathanWerde ich doch auch haben o:
- Svenskazusätzlich, ja ^^
- Svenskawobei
- JonathanUnd wenn ein Int eintrifft, sagt der Kernel (oder eher ein Interrupt-Distribution-Service) den vom Int betroffenen Tasks per Message an PID:0, dass der Int eingetroffen ist.
- Svenskamoment, ich hab grad mist verstanden
- Svenskabzw. gedacht.
- Jonathan?
- Svenskaignorier das
- JonathanÄh, okay.