アセンブラ最高！

・・・大間違いである」と考えています。

1. おかしいぞ！OS自作本の初期に、Kが自分でそう書いているじゃないか！
2. OSASKが機能が少ないといっても面白い性能を出すのはアセンブラのおかげだろう！。普通にCとかで書いたらKが批判?するLinuxと大して変わらない性能になるはずじゃないか！

なるほど！。では説明。

まず、「1」ね。

もう一回よーく読んでみてください。OS自作本でKタンは、「アゼンブラ最強」とは書いていますが、「アセンブラ最高」とは書いてませんね？。

え？単なる言い回しだけだって？。本当に本読みました？。すこし先にちゃーんと書いてありますよね。

• 「これは紙と鉛筆さえあればどんな名作でも書けると言っているのと同じ」

アセンブラを使えばどんなプログラムを書くことも不可能ではないといっているだけです。「不可能ではないのだからこれを使いましょう」などとは一言も言っていないし、「使うと性能が良くなる」などとも言っていません。

次、「２」。

いまだにこういう誤解がはびこっています。（もう何年も前に間違いだということになったのに・・・

• OSASKが小さいのはアセンブラでゴリゴリ書いたからだ
• Linuxは全てCで書かれている

C++最低！

C++と書きましたが、JAVAやD言語等の「高級言語」と呼ばれるものを総称しています。

よくKタンは、C++やJAVAの良くない部分を語ります。なるほど、Kタンはアセンブラとかが好きなので、その対極ともいえるこれら高級言語が好かんと。そういう言語はよくないと。

・・・まずこれは、オイラはともかく、Kタンは間違いなく「大間違いである」と言うでしょう。

以外かもしれませんが、昔オイラはKタンに聞いたことがあります。

• 「非常に大規模。たとえばemacsやモジラのようなソフトをOSASKで作れる環境が整ったとします。オイラがそれをやろうと思ったらどんな言語を薦めますか？」
• 「C++がいいと思いますよ。」
• 「おぉ！以外。せいぜいCかと思ったのですが・・・。なぜですか？」
• 「だって楽でしょ？。そのほうが」

Kタンは「高級言語がキライなので悪口を言う」と思っているのならそれは大間違いですよ。Kタンは「少なくともOSを作る上では不便のほうが多い」と言っているだけです。KタンはOS作成関連の作業やツール作成ばっかりやっているのでそういう発言が目立つだけです。

結局、OSを作る言語はなにがいいんだ？

なるほど。もっともな質問ですね？。では答え。

• 「まずその「何言語がいいか」という発想を捨てることが正解です」

なに？。意味がわからないって？。ではこういう例え話をしましょう。

• アナタは新米の大工さんです。家を作ろうとしています。
• 「大工」という仕事は何百年も前からあるのは知っていますよね？
• 昔。じゃあ江戸時代としましょうか。
• この頃も大工さんはいましたし、家もありました。でも今とはものすごく違います。一番大きな違いは、「電気がなかった」ことですね。
• 昔は電気がなかったので、当然電動工具は使えません。当然そんな工具はありませんでした。
• そんな昔はどうやって家を建てていたのでしょう。そう。ほとんど人力です。
• 使う道具も原始的は人力の物ばかりでした。ノコギリ・ノミ・トンカチ・・・
• こんな原始的な道具でりっぱな家を建てていました。きっととても大変だったでしょう。
• さて。現代です。電気もあります。すばらしい電動工具もあります。トラックもパワーシャベルもありますね。
• さて質問です。あなたはそんな現代の大工さんです。家を建てようとした時、誰かが、「昔は全部人力でやったものだ。プロの大工ならオマエも電動工具など使わずにやってみろ」といいました。アナタならどう答えますか？
• オイラの答え。「修行や習作・趣味ならともかく、電動工具でできることを人力でやるのはアホである」
• さらにこんな質問。「あそこに2mmだけクギが出ている。あっちでは4mmくらい木が出っ張っている。修正してほしいが当然電動ハンマーや電気カンナで削るのだろう？」
• 同じく他の人は知りませんが、オイラなら「人力で簡単にできることを無理に電気でやるのはアホである」

まあ「アホである」というのはちょっと言いすぎかもしれませんが、意味は解りますよね？。つまりなんらかの作業をする場合、先に道具を決定しておくというのは本末転倒ということなのです。上記の例え話をさらに進めると、

• 太さ5mmの木の棒を切りたいが、カッターナイフ・ノコギリ・電動ノコ・レーザーカッター。どれを使うと一番早くて便利？

というふうに、まず作業があって、その作業の実行に一番楽で正確で早いものを考えてから使うのが正解ですよね？。これを、

• とにかく電動ノコギリだ。電動ノコギリを使うのだ！。さあ！作業をもってこい！

・・・これはどう考えてもおかしいですよね？。（初めてすごい機械を買ってもらった子供じゃあるまいし）

最初の、まずその「何言語がいいか」という発想を捨てることが正解ですというのはこういう意味なのです。

割り箸削りから大木切り倒しまで全てこなせる便利な工具など存在しえないのはわかりますよね？。それと同じこと。万能でこれさえ知っていればなにもいらないなんていう言語もまた存在しません。ましてや、OSを作るとなると・・・

もちろん、習作や技術的なチャレンジ・実験などでこれを行うことにはりっぱに意味がありますよ。ちゃんとそう解っていてあえて行うのならば。誤解なきように。

ではKタンはなぜアセンブラとCを使ったのか？

OS自作入門のはりぼてOS。これは主にアセンブラとC言語で作られています。（OSASKなんかもそうですね）。では、なぜアセンブラ+Cなのでしょうか？。VB+JAVAではダメでしょうか？。C++だけで作ることはできないでしょうか？？？。

まず結論から言うと、

• アセンブラなしでOSを作ることは、少なくとも現在ではできない

となります。理由はとても簡単で、

• アセンブラ以外にレジスタや周辺機器にアクセスできる言語がないから

です。（もしあればきっと使われていることでしょう）

え？LinuxはCで書かれているって？。ほんとにLinuxのソースやブートの仕組み見てみました？

そしてCを使っている理由ですが、これは本にちゃんと書いてありますよ？

• 1番説明が少なくて済むので（読むほうも少ない説明で済む）楽だから

です。それだけのことです。もしC++が同じように少ない説明で済む言語なら、もしかしたらKタンもC++で書いていたかもしれませんよ？

ウソだ！オレはC++のほうが簡単に感じた！

人間は最初に触れたものを良しとする傾向があります。Machintoshを最初に触った人は「マックは簡単だ」と言い張り、Windowsから入った人は「マックは不便だ！」といいます。英語は難しい、いや日本語のほうがむずかしい。・・・どっちも、その国で生まれ育った人なら5歳児でもしゃべれます。それだけのことです。なんなら試しに、はりぼてOSのCの部分を全てC++に置き換えてみてください。そしてその解説を、700ページ以内に収めることができるのなら、きっとKタンも「もっといい方法があった。」と認めることでしょう。

余談ですが、bayside氏という方がこのC++による実装を実現されています。(ここです)。間違えないでほしいのは、氏は少なくともはりぼてOSのアセンブラを読み、同じくCで書かれた部分を読み解き、さらにそれをC++に置換できるという、非常に高いレベルの実力を持った方です。C++しかわかんないなんて方ではないので誤解なきように。

他の言語はダメなの？

とんでもありません。何度も言いますが、向き不向きがあるだけです。逆にそこまで一つの言語にこだわるという理由が私にはわかりません。

上の大工さんの例の通り、「どうしてそこまでなんでもかんでも電動ノコギリでやりたいの？」と質問したいくらいです。

・・・まさかと思いますが、単に「他の言語を勉強するのが面倒くさいから」じゃないでしょうね？

これまで書いた通り、アセンブラをはずすことはまずできません。そうなると、そのアセンブラで書かれた部分とうまく、そしてできるだけ簡単に連携できる言語が必要になります。逆に言えば、JAVAだろうとC++だろうとD言語だろうと、それさえ出来れば決してできないことはないはずです。

・・・ただ、一つ言えること。おそらくネット等ではC言語がもっとも豊富に解説されている言語だろうと思います。そのC言語ですら、アセンブラとの連携の方法を探すのは一苦労でした。

私はJAVA等、他の言語についてあまり詳しくないのですが、どうでしょう？。容易にアセンブラ連携ができるのでしょうか？。そしてそのための解説やサンプルが見つかるのでしょうか？

まとめ

私は別にC言語に詳しいわけではありません。（っていうか、大したスキルは持ってません）

逆に、そんな初心者に毛の生えた程度の私だから言えます。結局はアセンブラ+C言語が一番楽で早くてすぐに学習できるのだと。

JAVAやD言語等の他の言語。興味はありますが、それらをアセンブラと自由に連携できるレベルまで勉強しているウチに、はりぼてOSは出来上がってしまいますよ。きっと。

bayside氏のように高いスキルを既に持っている人がやるのならともかく、「初心者がJAVAを勉強しながらOSを作る」のはとても困難だと考えます。

そんな困難を承知でがんばってみようという方。そりゃあもうすばらしいです。すごいことです。（イヤミとかじゃないですよ念のため。マジにすごいと思う）

・・・でも、「僕はJAVAを勉強してやっと出来るようになってきた。他の言語なんて勉強したくない。面倒なCなど勉強せずにすませたいのでJAVAで！」なーんて考えているのなら、「やめたほうがいいよ。倍時間がかかるから」と進言したいですね。

補足

上記の、「単に面倒なので知ってる言語でなんとかしたい」という理由のほかに、「いまどきは・これからは」というお題目に毒されている人もいるかもしれませんね。

構造化・オブジェクト指向等、確かにこれらは新しい概念です。そしてすばらしいものでもあります。

しかし何度も例に出しますが、電動ノコギリやパワーシャベルは万能ではありません!!。

どんなものでも向き不向きがあります。また、新しいことはすばらしいことですが、それと万能・永続とは別のことです。同じ意味で、古くからあるものが時代遅れだったり無駄なものとも限らないのです。

新しいの古いのだけで物を判断するようでは道具を使いこなすことはきっとできないでしょう。

~
それともう一点。可読性。

• CよりC++のほうが。C++よりJAVAのほうが可読性が高い。アセンブラは可読性が悪い。

これは全て、迷信ですよ。

JAVAは知らないけどC++なら何でも作れる！。そんなプログラマはいくらでもいます。なんでも作れてしまうすばらしい実力を持ったプログラマでも、知らない言語はやっぱりわかりません。

こんな方法はダメだろうか？

あくまでも妄想のレベルなのだが・・・

• システムとしてシートを管理しているんだけど、実はシートはクライアント領域しかない。
• システムがなんにもしないと、クライアント領域のものだけが描画されるような状態。（当然枠もタイトルバーもなにもないような状態）
• システムがシートを描画する時に、自動で枠等をそのつど「描画する」
• マウスがタイトルバー等をクリックした場合はどうするか？
• システムが自動でそれを演算するだけ

・・・これはでも、そうとう大掛かりな変更になるなぁ。でも、とにかく一旦、この路線でやってみるか・・・

挫折・・・・orz

くっそぉ・・・どーもうまくイカン・・・。マウスが重なった時の書き換えがより複雑になってしまうような・・・。

別の案

じゃ、これならどーーだ！！！

[添付]

難しく考え杉？

・・・ここに来てふと思った・・・・

たとえばだけど、アプリからのウィンドゥへの書き込み。これを全て、APIを通してしか出来ないなんてしておけばOK？　もしかして？？？

そうすると・・・・openwin関数を改良。バッファはシステム側で用意してアドレスを返すとかしておけばいいのかな？？

えーっと・・・現在のopenwinは・・・

• EDX：5
• EBX：ウィンドゥのバッファ
• ESI：ウィンドゥのX方向の大きさ
• EDI：ウィンドゥのY方向の大きさ
• EAX：透明色
• ECX：ウィンドゥの名前
  • 戻り値：ウインドゥの番号

これを、

• EDX：5
• ESI：ウィンドゥのX方向の大きさ
• EDI：ウィンドゥのY方向の大きさ
• EAX：透明色
• ECX：ウィンドゥの名前
• EBX：ウィンドゥの属性
  • 戻り値：ウインドゥの番号 こうしちゃう。バッファはシステム側で用意する。（もちろん権限はシステムなので勝手に書き換えることはできない）

そうなると・・・

こういうふうに改造すると、今度は当たり前だけどウィンドゥに物を書くことができない。なのでそういうことをするAPIが必要になるよね。

ええと・・・改造が必要なAPIは・・・

うーん。あと、ブロック転送するようなAPIほしいよね？

• EBX：転送元のポインタ（もしくは配列）
• EAX：転送するシート
• ESI：転送するY点
• EDI：転送するX点
• ECX：転送する幅
• EBP：転送する高さ
  • 戻り値：はみ出たかはみ出ないか

こんなの、どじゃろ？？？

よーし。在来のAPIの改良はこれでいいかな・・・・

ブロック転送APIを作るか。

api_blocksend

• EDX：120
• EBX：転送元のポインタ（もしくは配列）
• EAX：転送するシート
• ESI：転送するY点
• EDI：転送するX点
• ECX：転送する幅
• EBP：転送する高さ
  • 戻り値：はみ出たかはみ出ないか

でけた〜！！

struct WINDOW {
       struct SHEET sheet;        //使っているシート
       struct TASK  task;         //どのタスクに所属しているか？
       int c_xsize;               //クライアント領域の横サイズ
       int c_ysize;               //クライアント領域の横サイズ
       char have_tb;              //タイトルバーを所有しているか？
       char have_fr;              //フレームを所有しているか？
       char have_fb;              //フットバーを所有しているか？
}

リビジョン110

えっと・・・とりあえずこんなもんかな？？？？

さて。次。

マウス直下にもうひとつ、特別なシートを設定と。

えーっと。シートってどうなってたっけ。

オベンキョ！

いろいろ細かいことがあるが、ようするに、32ビット化（プロテクトモード）したマシンで、あるセグメントを「お前は8086と同じ動作をしろ！」と命令することができるモード。

CPUは起動時には16ビット状態（リアルモード）である。この状態だとMS-DOS等が動かせる。また、BIOS等、リアルモードでないと動作しないものも動く。

しかし一旦プロテクトモードになるとこうはいかない。処々細かい意見はあるだろうが、CPUがいきなり変わってしまったのと同じくらい変化してしまうので、MS-DOS、またそれ上で動くようプログラムされたソフトは動かなくなってしまう。 （PS2でゲームをやっていた。あるスイッチを押すと、中身がポン！とX-BOXに変わってしまうようなもの。当然中に入っていて今まで動いていたバイオハザードは動かなくなってしまうよね？）

BIOSも同じである。

どうしても16ビット用のソフトを動かしたい、BIOSを呼び出したいと言う場合。普通に考えれば、32ビットモードから再び16ビットモードに戻ればいいということになる。 しかしこれそのものは可能だが、BIOSなりMS-DOSのソフトなりを実行し終えたあと、再び32ビットモードに戻したとしても、元には戻らない。つまり、電源スイッチを押したのよりちょっとだけ早いと、そんな程度である。

そこで386CPUは32ビットになった時、あるセグメントにあるスイッチを入れておくと、そこだけが16ビットとして動く。そんな仕組みを搭載している。これが仮想86モード。

ちょうど、WindowsVISTAのある窓でMSXのシュミレータが動いている。そんな感じを想像してもらうとわかりやすいかも。

具体的に！！！

セグメントの簡単な復習

• 386以降CPU（以下x86と呼称）はCPUそのものにマルチタスクを行うための機能が搭載されている。
• しかし、マルチタスクは別に並行して同時に動作をできるわけではないのだ。別々の処理を高速に切り替えて行えるというだけである。
• たとえばメモリが0x0000〜0xFFFFまで搭載されていたとする。
• そんなマシンで萌え絵を描きながら（PhotoShop）、鉄人タイガーセブンの歌を聞きながら（Winamp）、愛と勇気とかしわもち(パズルゲーム）をやりたいとする。
• 0x0000〜0x0FFFまではOSが使用する。そうなると、ソフトが使うことができるメモリは0x1000〜0xFFFFとなる。
• ならば、0x1000〜0x1FFFをPhotoShopが。0x2000〜0x2FFFをWinampが。0x3000〜0x3FFFをカシワモチが使う。そしてOSは、これを高速に切り替えてくれる。これなら3つのソフトはまるで同時に動いているように扱える。ばんざーーい！

・・・・・　orz　・・・・　問題発生 ・・・・・・

問題点！

• 使う番地が固定じゃ困る!
  • 上記の方法だと、カシワモチはかならず0x3000に読み込まれないといけない。だって、プログラムする時困るじゃない！
  • 「カシワモチは0x3000」と決められちゃうと、カシワモチをやらない人のマシンは困る！　どんなに新型のマシンを買ってきてメモリを増やしても、0x3000〜0x3FFFはポカーンと空いたまま、だれにも使われない。
• 侵略された！
  • 0x1000〜0x1FFFを使っているPhotoShop。大きな画像を扱っているので、つい、0x2100まで使っちゃった！　さあ大変。いままで動いていたWinampが急におかしくなっちゃった！

・・・こんなふうに、ちょっと考えただけでも大問題発生。そこでこういったことをなんとかしようとしてOSが進化して行った。同時にそんなOSの動きを補助しようとCPUにもそういった命令が搭載されていった。

15日目

• CPUは「切り替えろ！」と命令がくると、レジスタのほぼ全てをメモリに書き出す。（退避させるというほうがいいかも）

• そして今度は、切り替わるべき別のタスク用のレジスタ内容を一気に読み込んでしまう。

• 最期に、eip（次は何番地のメモリの命令を読み込んで実行するか？）の値をその新しいタスク用のものにパチンと切り替える。

• これで次の命令からは、あたかもずーっとその仕事をしていたかのように動作を始める。

• これを高速に交互に行うのがマルチタスク

どこに退避させる？？

• 退避先のメモリはどこでもいいわけではない。あるフォーマットと属性で作られた、専用のセグメントを使わないといけない。この特殊なセグメントをtssという。

• tssはCPU内部のレジスタのほぼ全てを退避できる量（逆に言えばそれ以上の余計な量は必要ない）を確保する。通常104バイト。内訳は

struct TSS32 {
      int backlink,esp0,ss0,esp1,ss1,esp2,ss2,cr3;     /*タスクの状態を表すもの
      int eip,eflags,eax,ecx,edx,ebx,esp,ebp,esi,edi;  /*通常のレジスタ
      int es,cs,ss,ds,fs,gs;                           /*  〃 （16ビットのもの）
      int ldtr,iomap;　　　　　　　　　　　　　　　　　/*タスクの状態を表すもの
}

• tssは切り替わるタスクの退避場所なので、素直に考えると、タスクが10個平行して動く場合はtssも10個用意するべきもの。

tssの作成&登録

• 先に書いたように、tssはセグメントの一種。なので、作成や登録はセグメント管理部分であるGDTに書き込みを行うことで実現する。

• tssの作成と登録の実際

  struct TSS32 tss_a,tss_b;   /*構造体として親切する
  
  tss_a.ldtr = 0;             /*ldtrとiomapはとりあえずこの数値にする。
  tss_a.iomap = 0x40000000;
  tss_b.ldtr = 0;
  tss_b.iomap = 0x40000000;
  
  /*gdtへの登録
  set_segmdesc(gdt + 3,103,(int) &tss_a,AR_TSS32);   /*それぞれ、GDT3番と4番に
  set_segmdesc(gdt + 4,103,(int) &tss_a,AR_TSS32);   /*登録した。

疑問点:一つのタスクにはそれぞれtssとメモリ空間が必要。で、tssはセグメント。メモリ空間も当然セグメント。ということは、理屈ではタスクは4,095個以上は絶対に作れないということでOKなのか？

タスクの準備

• タスクという概念で考えると、現在動いている部分とてタスクとなる。（つまり、一つ目のタスクということになる）

• これまではマルチタスクではなかったので意識していなかったが、一番最初にやらなくてはならないことは、「俺も実はタスク！　で、オレが動いているセグメントは2番！」ということのほかに、「俺が動いているタスクの退避用tssはセグメントの3番だよ！」という登録をしてやらないといけない。

• そこで、load_tr(3 * 8）関数を実行する。これにより、「俺が動いているタスクの退避用tssはセグメントの3番だよ！」という設定になる。（言い方を変えれば、このタスクが別のタスクに切り替わる時には、セグメント3番のtssに退避される）

• タスクを複数用意しなければ当然切り替えなどできない。

• タスクは仕事を続けるものでないといけない。（一つ仕事をしてすぐ終わってしまうのでは単なる関数）

• 通常はなんらかのループ構造にするもの。たとえば

  void task_b_main(void){
       for(;;){io_hlt();}
  }

• よし！　これでOKだ！　と思うがそうではない。task_bにはまだ準備がいる。
• まず、そもそもtask_bはまだ一度も動いていないのだ。最初の切り替わりで始めて動き出す。しかも、その最初の動作時も「切り替わり」なのだから、tss4からドバっとレジスタの値を読み込んで動き始める。tss4にはまだいい加減な数字しか入っていない。（これでは切り替わった瞬間に暴走の危険がある）

• そのため、とりあえず各レジスタの初期値を設定しておく。また、タスク、そもそもこのタスクに切り替わった場合、どこを実行するのかやスタックなどの設定も調整しておかなくてはならない。

P296の初期設定
tss_b.eip = (int) &task_b_main;　　/* 関数task_b_mainの先頭アドレス


/* これはtask_b専用のスタックの設定。mamman_allocと使い64kbを確保。
/* 後ろの計算式はスタックの最終番地を計算したもの
int task_b_esp;
task_b_esp = memman_alloc_4k(memman,64*1024)+64*1024;
tss_b.esp = tssk_b_esp;


tss_b.eflags = 0x00000202;　　　/*？？？　どういう意味だ？

tss_b.eax = 0;　　　/*　通常の各レジスタの初期値。
tss_b.ecx = 0;
tss_b.edx = 0;
tss_b.ebx = 0;
tss_b.ebp = 0;
tss_b.esi = 0;
tss_b.edi = 0;
　
tss_b.cs = 2 * 8;    /*　task_bはGDT2番のセグメントでプログラムを実行する。
                     /*　今回は単に面倒なので。もちろん別に用意してもいい。
tss_b.es = 1 * 8;　　/*　同じ理由でGDTの1番を使用する。
tss_b.ss = 1 * 8;
tss_b.ds = 1 * 8;
tss_b.fs = 1 * 8;
tss_b.gs = 1 * 8;

準備完了！　タスクスイッチ！

• ここまでできれば、あとはtaskswich4関数（中身は単にアセンブラでfarJumpしているだけ。切り替えたいタスクのtss（task_bは4番）にfarJumpする。

P298のタスク戻し

• これは説明するまでもない。解る。

疑問点:タスクはかならずしもメモリを別セグメントにして動かすとは限らないことが上記の簡易切り替えで解った。そうなるとメモリ用に1個として、理屈ではタスクは8,190個以上は絶対に作れないということでOKなのか？

自動的にタスクを行き来

• P300のソースはわかりやすい。HariMainがtask_a。task_b_mainはtask_bと見る。
• 実際のソースよりすこし整理して端折ったソースを載せる。

void HariMain(void)
{
　　　　（中略）

　　　　/*タイマー timer_tsを新設。*/
	struct TIMER *timer, *timer2, *timer3, *timer_ts;
 
　　　　（中略）

　　　　/*新設したタイマーを初期化*/
	timer_ts = timer_alloc();
	timer_init(timer_ts, &fifo, 2);　/* タイムアウトしたら「２」をFIFOに送るよう設定
	timer_settime(timer_ts, 2);　/* タイムアウト時間を0.02秒に設定
 
　　　　（中略）

　　　　/*　上記は設定。ここ以下のforループがtask_aの本質部分*/
	for (;;) {
 
　　　　（中略）
　　　　　　　　/* FIFOに2が来たら(timer_tsがタイムアウトしたら　　*/
			if (i == 2) {
				farjmp(0, 4 * 8);    /*タスクをtask_bに切り替える
				timer_settime(timer_ts, 2);　/*ここに復帰した時、再度タイマーをセットする
			} else if (256 <= i && i <= 511) { /* キーボードデータ */
 
　　　　（中略）
 
}


void task_b_main(void)
{
	struct FIFO32 fifo;　　　　　/*これら構造体は、タイマーを使う
	struct TIMER *timer_ts;　　　/*ために必要なもの。
	int i, fifobuf[128];

	fifo32_init(&fifo, 128, fifobuf);　　/*FIFOを初期化して準備する。
	timer_ts = timer_alloc();　　　　　　/*そうしないとタイマーが使えないから
	timer_init(timer_ts, &fifo, 1);　　　/*タイムアウトすると1を返してくるタイマー。
	timer_settime(timer_ts, 2);

	for (;;) {
 
　　　　（中略）
 
			i = fifo32_get(&fifo);　　　　　　　　/*FIFOから一つ数値を得る。
			io_sti();　　　　　　　　　　　　　　
			if (i == 1) { /* タスクスイッチ */　　/*もしその通知が1ならタスクスイッチ！
				farjmp(0, 3 * 8);
				timer_settime(timer_ts, 2);

			}
		}
	}
}

• ・・・だめだ・・・P304がどうしても理解できない・・・・orz

• 「とにかくこの方法でsht_backの値をtask_b_mainに渡せる」と理解しておこう。（これ以上は無理）
  • ただ、一つ解ったことがある。
  • 通常、別のタスク（task_bとか）には、それ用のtssと同時にそれ用のスタックが必要。（そらそーだ。分けないとごっちゃごちゃになっちゃう）
  • 別のタスクになにも変数を渡す必要がない場合。（たとえば void task_b_main() なんて場合）
  • task_b_esp = memman_alloc_4k(memman,64*1024)+64*1024;
  • こんなことして、task_b用のスタックを確保している。おそらく、大半のタスクでもこれは必要な行為だろう。（スタックを一切使用しない動作だけのタスクとかそういう特殊なのは別ね）
  • それに対して、今回はようするに、task_bに対して値を渡したいというだけ。
  • で、task_bは引数を持つ関数になっている。（void task_b_main(struct SHEET *sht_back);　　）
  • 普通に関数を呼ぶだけならなんの問題もない。そのまま呼べばよい。
  • しかし、今回の相手は「別に動くタスク」だ。なので、呼び出しで引数を渡せない
  • しかし、今回どうしても理解できなかった部分の登場となる。いまだにわからない。
  • ・・・しかし、このわからない部分は、
  • task_b_esp = memman_alloc_4k(memman,64*1024)+64*1024 -8;
  • である。普通に用意するスタックから　８　を引いているだけだ。
  • これがヒントになるかもしれない。いずれ解るかも。

自動タスクスイッチ

• 上記のソースを見ての通り、これまではお互いのタスクが相手のタスクに切り替わるという動作をしていたが、こういうプログラム部をなくしてもフルオートで切り替えが出来ないものだろうか？

• タスクスイッチ専用の特殊なタイマーを1個確保したと考えればよい。

疑問点解決？:タスクはかならずしもメモリを別セグメントにして動かすとは限らない（上記参照）。また、状況によってはtssを共有することすら可能。（タスクA,B,Cとあった場合、絶対tssが3個必要というわけではない。屁理屈チックだが、タスクAとタスクCが絶対同時に動かないような調整をすればtssは2個でも十分マルチタスクは可能）よってこの場合は、タスクではなくtssはどう頑張っても8,190個以上は作れないということでOKのようだ。（・・・なんかあったりまえな答えになってしまったな・・・(^^;））

struct TASK *task_init(struct MEMMAN *memman)
{
　	int i;
　	struct TASK *task;　　　　　/* タスクを一つ準備する。
/*----------------------------------------------------------------------------*/ 
        /* これまででは、
          struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
          set_segmdesc(gdt + 何番目?, 103, (int) どのtss構造体？, AR_TSS32);
        ・・・と、こういう指定でtssをGDTにセットしていた。　*/
/*----------------------------------------------------------------------------*/

/* ここはまあ、前と同じだが・・・・　*/
　	struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
    /*これ以降が違う。GDTの何番目にセットするのか。セットするtss構造体はどれなのか？
    という情報を、以下のプログラムで自動的に探し出してセットしている*/

       /* ちなみにtaskctl構造体がデカイのでメモリをゲットしているところ。
	taskctl = (struct TASKCTL *) memman_alloc_4k(memman, sizeof (struct TASKCTL));

/* ここにあるforで0〜最大タスク個数まで繰り返す。空いている番号が見つかったら
   そこを新しいタスクとする。これにより、GDTの何番目を使うのか、tssがどの
   タスク内のものなのかがわかる*/

/*↑・・・っと思い込んでたが大間違いだった。
/*ここは、とにかくGDTの3(TASK_GDT0)〜最大数までのGDTテーブルを一気にtss化して
/*予約してしまうのだ！さらに、taskctl内のtasks0[]と一対一に対応させちゃう。
/*なので、以降は単に「どのtasks[?]が空いてるかな？」を探し、空きが見つかったら
/*そのtasks0[?]に当て込めば自動的にtssも設定させると！。こういう仕掛けか！

	for (i = 0; i < MAX_TASKS; i++) {
		taskctl->tasks0[i].flags = 0;
		taskctl->tasks0[i].sel = (TASK_GDT0 + i) * 8;
		set_segmdesc(gdt + TASK_GDT0 + i, 103, (int) &taskctl->tasks0[i].tss, AR_TSS32);
	}


/*上記のGDTの予約？のおかげで、もうGDTは気にしなくていいのだ！
/*以降は、task_allocさえすれば、自動的にタスクがすぐ走れる状態で
/*1個準備される。

/*以下は、今動いている自分自身（HariMain。これまでの仮想的なtask_aのこと）を
/*ひとつのタスクとして登録しているだけ。

	task = task_alloc();
	task->flags = 2; /* 動作中マーク */
	taskctl->running = 1;
	taskctl->now = 0;
	taskctl->tasks[0] = task;
	load_tr(task->sel);
	task_timer = timer_alloc();
	timer_settime(task_timer, 2);
	return task;
}

struct TASK *task_alloc(void)
{
       int i;
       struct TASK *task;                          /*とりあえずtask構造体を一つ用意する*/

       for (i = 0; i < MAX_TASKS; i++){             /*このforループで、taskctl内にある */
                                                    /*tasks0[]配列を上からチェックする。*/

            if (taskctl->tasks0[i].flags == 0 {     /*もしflagsが0。つまり使用されていないtasks0[]があったら　*/
               task = &taskctl->tasks0[i];          /*よし！ここだ！上で今回用意したtask構造体をこのtasks0[]とする */
               task->flags = 1;　　　　　　　　     /*そこをとりあえず使用中とするためマークする。（確保するわけ）　*/
               task->tss.eflags = 0x00000202;       /*これ以降は、まったく新しいタスクの
                                                    /*tssを準備したのだから、初期化処理をする。*/
               task->tss.eax  = 0;
                       :
                       :
               task->tss.ldtr = 0;
               task->tss.iomap = 0x40000000;
               return task;
             }
        }
 }

ソフトウェア的用途区分

• 0x00000000 - 0x000003ff ： リアルモード用INTベクタ
  • もちろんこれはIDTを変更すれば変更できるが、とりあえず標準的にはこのアドレスが使われる。
  • 0x00000300 - 0x000003ffはBIOS用スタック？
• 0x00000400 - 0x000004ff ： BIOS用ワークエリア？
• 0x00007c00 - 0x00007dff ： ブートセクタが読み込まれるアドレス
• 0x0009fc00 - 0x0009ffff ： ACPI用ワークエリア（の場合がある）
  • 0x0009fc00から始まっているという保障は全くない。本来ならBIOSに問い合わせるべき。個人的には最悪でも0x0009efffまでは勝手に使っても平気なんじゃないかと思ってはいる。--K
  • っていうか、僕はこれを無視してこの辺を好き勝手に使っているような気が・・・。大丈夫なのか？OSASK！
• ISAホールがなければ、16bit-PCICで利用可能なメモリ領域は、0x000c8000〜0x000dffffのどこかになるでしょう。

0x4E　ファイルを検索する

• EAX　検索用のファイル名またはパターン文字列を格納しているアドレス

• • この文字列は終端に0を置くこと。（これによってどこまでかを判定している）

• EBX　検索結果を受け取るバッファのアドレス

• 戻り値
  • 見つかったファイルの数。（0なら見つからなかったかエラー）

28　ファイルを検索する

• EAX　検索用のファイル名またはパターン文字列を格納しているアドレス

• • この文字列は終端に0を置くこと。（これによってどこまでかを判定している）

• EBX　検索結果を受け取るバッファのアドレス

• ESI　結果待ちのフラグを受け取るアドレス
  • 適当な場所を16バイト確保しておく。初期値を0以外にしておいてコールする。正常終了すると0がセットされる。

このAPIは指令を送るだけ。なので、ESIにセットしたメモリの内容を監視するループを設けて「待ち」を入れないとすぐ次の命令を実行してしまうので注意

0xa21

• • EAX　オープンするファイル名を格納しているアドレス（0で終わり、パターンではないこと）

• • 戻り値
    • EAX　成果。0なら異常終了もしくはファイルがなかった。成功ならファイルハンドルを返す

• • • PukiWiki って 何なの?
    • 新しいページを作成するには?
    • リンクについてる(3m)とかは?
    • 掲示板と違う?
    • 誰かが書き込みを消してまう?
    • ブラウザやプロクシのキャッシュで人の変更消してしまう?

PukiWiki って 何なの?

すべてのページが誰でも編集できます。変更したいページでページ上部の「編集」をクリックするとそのページが編集できます。編集内容は、整形ルールに従って整形されます。
練習用ページは基本的にどのように手を加えても問題ないので、結果を恐れず編集してみてください。

新しいページを作成するには?

すでにあるページ(例えば練習用ページなど)で、ページのどこかにWikiName(大文字と小文字混合)かBracketName([[]]で囲う)を入力すると入力した部分の後ろに ? というリンクがつきます。そこをクリックすると新しいページの編集画面が用意されるので、あとは普通のページ変更と同様に書き込むことができます。

リンクについてる(3m)とかは?

3mは3分前くらい、5hは5時間前くらい、8dは8日前くらいに更新された、という意味です。

掲示板と違う?

ページに手を加えても誰がその変更をしたかわからなくなります。不安な場合は、手を加えた部分に自分の名前を書いておきましょう。 -- hogehoge ←こんなかんじで。

誰かが書き込みを消してまう?

WikiCloneとはそういうものです。誰でもどこでも汚したり、消したり、荒らしたりできます。が、PukiWikiには定期的にバックアップを取る機能があるので無駄といえば無駄かもしれません。不完全ではありますが、復旧もできると思います。

ブラウザやプロクシのキャッシュで人の変更消してしまう?

ページを編集する以上、編集時の状態から手を加える形になります。しかし、もし編集中に誰かが更新していてしまっていたらどうします? 安心してください。PukiWikiには、更新時のページの更新日時と元データの更新日時を比較して一緒かどうかチェックします。

異なる場合には「更新の衝突」が起きるので、その場合は更新されていたページをリロードして編集しなおしてください。