![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to romemu_luna.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm|
Return to romemu_luna.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm |
1.1 root 1: //
2: // nono
1.1.1.2 root 3: // Copyright (C) 2020 nono project
4: // Licensed under nono-license.txt
1.1 root 5: //
6:
1.1.1.2 root 7: // LUNA-I の ROM エミュレーション
8:
9: // IODevice
10: // |
11: // +----------+----------+
12: // v v
13: // ROMDevice LunaPROMEmuDeivce (ROM エミュレーション)
14: // |
15: // v
16: // PROMDevice (実ROM)
17:
18: #include "romemu_luna.h"
1.1 root 19: #include "aout.h"
20: #include "bitmap.h"
21: #include "bt454.h"
1.1.1.2 root 22: #include "ethernet.h"
1.1 root 23: #include "ffs_dinode.h"
24: #include "ffs_dir.h"
25: #include "ffs_fs.h"
26: #include "mainapp.h"
27: #include "memorystream.h"
28: #include "mk48t02.h"
1.1.1.2 root 29: #include "mpu680x0.h"
1.1 root 30: #include "pio.h"
31: #include "ram.h"
32: #include "sio.h"
33: #include "spc.h"
34:
35: // ROM エミュレーションの状態遷移
36: enum {
37: STATE_CLOSED = 0, // バックドアは塞がれている
38: STATE_RESET, // リセット後、アクセス前
39: STATE_INIT, // プロンプト初期化中
40: STATE_PROMPT, // プロンプト実行中
41: };
42:
43: // コンストラクタ
44: LunaPROMEmuDevice::LunaPROMEmuDevice()
45: {
1.1.1.2 root 46: // LUNA-I の ROM の特定アドレスを読み出す人がいるので、
47: // サイズは実 ROM と同じにしておく必要がある。
48: devlen = 128 * 1024;
49: romdata.reset(new uint8 [devlen]);
1.1 root 50: }
51:
52: // デストラクタ
53: LunaPROMEmuDevice::~LunaPROMEmuDevice()
54: {
55: }
56:
57: bool
58: LunaPROMEmuDevice::Init()
59: {
60: // 都度都度 dynamic_cast は面倒なので、ここで一度代入しとく
61: nvram = dynamic_cast<MK48T02Device*>(gRTC.get());
62:
1.1.1.2 root 63: MemoryStreamBE ms(romdata.get());
1.1 root 64: ms.Write32(0x00002000); // +00: リセットベクタ SP
65: ms.Write32(0x41000400); // +04: リセットベクタ PC
66: ms.Write32(0); // +08
67: ms.Write32(0x41000500); // +0c: メモリサイズ格納先
68:
69: // リセット時に実行する命令
1.1.1.2 root 70: ms.SetPtr(&romdata[0x400]);
71: ms.Write16(0x2039); // move.l (ROMIO_INIT),d0
72: ms.Write32(ROMIO_INIT);
73: ms.Write16(0x660c); // bne _go ; 起動先あればGO
1.1 root 74: //_prompt:
1.1.1.2 root 75: ms.Write32(0x4e722500); // stop #0x2500 ; キー入力を待つ
76: ms.Write16(0x2039); // move.l (ROMIO_KEYIN),d0
77: ms.Write32(ROMIO_KEYIN); // ; キー入力処理
78: ms.Write16(0x67f4); // beq _prompt ; 起動先なければループ
1.1 root 79: //_go:
80: ms.Write16(0x2040); // move.l d0,a0 ; ジャンプ先を a0 にセット
1.1.1.2 root 81: ms.Write16(0x2039); // move.l (ROMIO_CLOSE),d0
82: ms.Write32(ROMIO_CLOSE); // ; 後始末
1.1 root 83: ms.Write16(0x4ed0); // jmp (a0) ; ジャンプ
84:
85: // Lv6 (SIO) 割り込みハンドラ
86: // キーボード割り込みが上がったら STOP 命令から戻ってくるだけでいい
1.1.1.2 root 87: ms.SetPtr(&romdata[0x600]);
1.1 root 88: ms.Write16(0x4e73); // rte
89:
1.1.1.2 root 90: // MAC アドレス
91: const macaddr_t macaddr = gEthernet->GetMacAddr();
92: strcpy((char *)&romdata[0x1ffd8], "ENADDR");
93: memcpy(&romdata[0x1ffe0], macaddr.to_string().c_str(), 12);
1.1 root 94:
95: // RAM にベクタを書き込む
96: // XXX VBR を 41000000 に向けるのとどっちが楽かはある
97: gRAM->Write32(0x78, 0x41000600); // +78: Lv6 割り込み
98:
99: return true;
100: }
101:
102: void
103: LunaPROMEmuDevice::ResetHard()
104: {
1.1.1.2 root 105: is_closed = false;
1.1 root 106: }
107:
108: // アドレスデコーダ
109: inline uint64
110: LunaPROMEmuDevice::Decoder(uint32 addr) const
111: {
1.1.1.2 root 112: // 折り返しなし
1.1 root 113: return addr - baseaddr;
114: }
115:
116: uint64
1.1.1.2 root 117: LunaPROMEmuDevice::Read8(uint32 addr)
118: {
119: uint64 offset = Decoder(addr);
120:
121: // 謎の IO 空間はロングワードアクセスのみ
122: return romdata[offset & (devlen - 1)];
123: }
124:
125: uint64
126: LunaPROMEmuDevice::Read16(uint32 addr)
127: {
128: uint64 offset = Decoder(addr);
129:
130: // 謎の IO 空間はロングワードアクセスのみ
131: return be16toh(*(uint16 *)&romdata[offset & (devlen - 1)]);
132: }
133:
134: uint64
1.1 root 135: LunaPROMEmuDevice::Read32(uint32 addr)
136: {
137: uint64 offset = Decoder(addr);
138:
139: // ロングワードアクセスでだけ謎の I/O 空間が見える
1.1.1.2 root 140: if (!is_closed) {
1.1 root 141: switch (offset) {
1.1.1.2 root 142: case ROMIO_INIT - baseaddr:
143: return ROM_Init();
1.1 root 144:
1.1.1.2 root 145: case ROMIO_KEYIN - baseaddr:
146: return ROM_Keyin();
1.1 root 147:
1.1.1.2 root 148: case ROMIO_CLOSE - baseaddr:
149: return ROM_Close();
1.1 root 150:
151: default:
152: break;
153: }
154: }
1.1.1.2 root 155: return be32toh(*(uint32 *)&romdata[offset & (devlen - 1)]);
156: }
157:
158: uint64
159: LunaPROMEmuDevice::Write8(uint32 addr, uint32 data)
160: {
161: return 0;
162: }
163:
164: uint64
165: LunaPROMEmuDevice::Write16(uint32 addr, uint32 data)
166: {
167: return 0;
168: }
169:
170: uint64
171: LunaPROMEmuDevice::Write32(uint32 addr, uint32 data)
172: {
173: return 0;
174: }
175:
176: uint64
177: LunaPROMEmuDevice::Peek8(uint32 addr)
178: {
179: uint64 offset = Decoder(addr);
180:
181: return romdata[offset & (devlen - 1)];
1.1 root 182: }
183:
184: // 起動時の処理を行う。
185: // 次段実行ファイルの読み込みに成功すればそのエントリポイントを返す。
186: // そうでなければ 0 を返すので、プロンプトに処理を移すこと。
187: uint32
1.1.1.2 root 188: LunaPROMEmuDevice::ROM_Init()
1.1 root 189: {
190: MemoryStreamBE ms;
191: uint32 entry;
192:
193: entrypoint = 0;
194:
195: // ROM 0x41000000.L リセットベクタ(SP,PC)もカーネルが参照している
196: // (これは Init() が用意している)
197: // ROM 0x4100000c.L メモリサイズ(バイト数)格納先アドレス
198: // ROM 0x410000b8.L プレーンマスク格納先アドレス
199:
200: // メモリサイズはとりあえず 0x41000500 に格納
1.1.1.2 root 201: ms.SetPtr(&romdata[0x500]);
1.1 root 202: ms.Write32(::ram_size);
203:
204: // プレーン数(1..4)をプレーンマスク(0x01..0x0f)に
205: int nplane = gBitmap->GetPlaneCount();
206: int planemask = (1 << nplane) - 1;
207: // 実際は RAM 上を指しているのだが、とりあえずすぐ隣に置いておく。
1.1.1.2 root 208: ms.SetPtr(&romdata[0xb8]);
1.1 root 209: ms.Write32(0x410000bc);
210: ms.Write32(planemask);
211:
212: // 初期パレット
213: gBT454->Write8(0, 14 << 4); // select palette
214: gBT454->Write8(1, 15 << 4); // R=15
215: gBT454->Write8(1, 15 << 4); // G=15
216: gBT454->Write8(1, 15 << 4); // B=15
217:
218: // SCSI
219: // BDID の書き込みによってホストデバイスがバスにアタッチされる構造なので。
220: gSPC->Write8(SPC::BDID, 7);
221:
1.1.1.2 root 222: // 内蔵 ROM: キーボード(chB)を初期化
223: gSIO->Write8(0x51000006, 0x01); // CR1
224: gSIO->Write8(0x51000006, 0x10); // RX Int(all char)
225: gSIO->Write8(0x51000006, 0x03); // CR3
226: gSIO->Write8(0x51000006, 0xc1); // RX Enable, 8bit
227: gSIO->Write8(0x51000006, 0x04); // CR4
228: gSIO->Write8(0x51000006, 0x44); // Stop 1bit
229: gSIO->Write8(0x51000006, 0x05); // CR5
230: gSIO->Write8(0x51000006, 0x68); // TX Enable, 8bit
231:
232: // 内蔵 ROM: スクリーンを初期化
1.1 root 233: text.Init(80, 32);
234: gBitmap->EmuConsoleOpen(&text);
1.1.1.2 root 235: inputbuf.clear();
236: inputpos = 0;
237: is_shift = false;
1.1.1.3 ! root 238: mousecnt = 0;
1.1.1.2 root 239: prompt_idx = 0;
240: prompt = default_prompt;
1.1 root 241:
242: text.Print(0, 0, "NONO %d.%d.%d Emulated ROM Monitor",
243: NONO_MAJOR_VER, NONO_MINOR_VER, NONO_PATCH_VER);
244: text.Locate(0, 2);
245:
246: // 表示環境が整ったところで NVRAM を照合
247: if (VerifyNVRAM() == false) {
248: InitNVRAM();
249: text.Print("** NVRAM Initialized.\n");
250: text.Print("\n");
251: return 0;
252: }
253:
254: // 実際の画面更新は EmuConsoleUpdate() を呼ぶことで行われるので、
255: // タイトルを Print してはいるが、エラーなくブートプログラムに制御を
256: // 渡せた場合にはそれすら表示せずにゲストに処理を移す。
257: // 意図して或いは意図せずプロンプトに降りる場合だけ Update が起きて
258: // 初めて画面が更新される。
259:
260: // DIPSW#1-1 が UP なら自動起動、DOWN なら ROM モニタ起動なので、
261: // これを真似する。
262: entry = 0;
263: if ((gPIO0->GetDIPSW1() & 1)) {
264: if (gMainApp.host_file) {
265: // ホストのファイルを読み込んでエントリポイントアドレスを
266: // この Read アクセスの読み出し値として返す。
267: // エラーがあればエラーメッセージは呼び出し先側で表示してある。
268: entry = LoadHostFile();
269: } else {
270: // NVRAM の設定に従ってブート先を探す。
271: errmsg.clear();
272: entry = LoadByNVRAM("");
273: if (entry == 0) {
274: text.Print("** %s\n", errmsg.c_str());
275: }
276: }
277: }
278:
1.1.1.2 root 279: if (entry == 0) {
280: ConsoleUpdate();
281: }
282:
1.1 root 283: return entry;
284: }
285:
286: // ROM 処理のクローズ。
287: // 次段プログラムにジャンプするための処理も含む。
288: uint32
1.1.1.2 root 289: LunaPROMEmuDevice::ROM_Close()
1.1 root 290: {
291: // ここでバックドアに蓋をする
1.1.1.2 root 292: is_closed = true;
1.1 root 293:
294: // コンソールクローズ
295: gBitmap->EmuConsoleClose();
296:
297: // NetBSD のブートローダがカーネルを読み込む時にはいくつかレジスタ
298: // 渡しのパラメータがあるので、ここで用意する。本当はターゲットが
299: // NetBSD カーネルの時に限定すべきのような気もするけど、とりあえず。
300: // ROM がブートローダを読み込む時にはそのような取り決め事は一切ない
301: // ので、ブートローダを読む時にも同じ値が入ってしまうが気にしない
302: // ことにする。
303: // 必要なパラメータは
304: // %d6 に bootdev、NetBSD/luna68k の場合は
305: // bootdev = $MACUPP00
306: // ||||++-- パーティション番号
307: // |||+---- SCSI ID (XXX ただしここでは 6 決め打ち)
308: // ||+----- unit (spc0 なら 0 のやつのはず)
309: // |+------ アダプタ (spc = 0、lance = 1)
310: // +------- magic ($a)
311: //
312: // %d7 に howto (0 でよい)
313: // (と %a0 にジャンプ先を入れるがこれは Init() が書き出した ROM
314: // アセンブラコード側で行っている)
315: m68kcpu *cpu = gMPU680x0->GetCPU();
316: RegD(6) = 0xa0060000;
317: RegD(7) = 0;
318:
319: // 戻り値は使わないのでなんでもいい
320: return 0;
321: }
322:
1.1.1.2 root 323: // ROM プロンプトのキー入力。
1.1 root 324: // VM 側の仮想マシンを回すため、ここでは入力待ちはしない。
325: // エントリポイントが取得できればそれを、そうでなければ 0 を返す。
326: uint32
1.1.1.2 root 327: LunaPROMEmuDevice::ROM_Keyin()
1.1 root 328: {
1.1.1.2 root 329: uint32 lunakey = gSIO->Read8(0x51000004);
1.1 root 330:
1.1.1.3 ! root 331: // マウス入力の 2, 3バイト目は無視
! 332: if (mousecnt > 0) {
! 333: mousecnt--;
! 334: return 0;
! 335: }
! 336:
1.1.1.2 root 337: // SHIFT キーだけ状態を持つので先に処理
338: if (lunakey == 0x0c || lunakey == 0x0d) { // 左右SHIFT押下
339: is_shift = true;
340: return 0;
341: }
342: if (lunakey == 0x8c || lunakey == 0x8d) { // 左右SHIFT開放
1.1 root 343: is_shift = false;
1.1.1.2 root 344: return 0;
345: }
1.1.1.3 ! root 346: // マウスデータの1バイト目なら、後続2バイトをスキップ
! 347: if ((lunakey & 0xf8) == 0x80) {
! 348: mousecnt = 2;
! 349: return 0;
! 350: }
! 351: // キー開放は無視してよい
1.1.1.2 root 352: if ((lunakey & 0x80)) {
353: return 0;
354: }
1.1 root 355:
1.1.1.2 root 356: switch (lunakey) {
357: case 0x11: // BS
358: if (inputpos > 0) {
359: inputbuf.erase(--inputpos);
1.1 root 360: }
1.1.1.2 root 361: break;
362: case 0x12: // Enter
363: {
364: // 現在位置のカーソルを消去
365: uint16 *rawbuf = text.GetRawBuf();
366: int curx = prompt.length() + inputpos;
367: rawbuf[text.GetY() * text.GetCol() + curx] &= ~TA::On;
368: // 改行
369: text.Putc('\n');
370: // コマンド処理。
371: // エントリポイントが見付かればもうここは放棄するので帰るだけ。
372: uint32 entry = Command();
373: if (entry != 0) {
374: return entry;
1.1 root 375: }
1.1.1.2 root 376: inputbuf.clear();
377: inputpos = 0;
378: break;
379: }
380: case 0x1d: // ←
381: if (inputpos > 0) {
382: inputpos--;
1.1 root 383: }
1.1.1.2 root 384: break;
385: case 0x1e: // →
386: if (inputpos < inputbuf.length()) {
1.1 root 387: inputpos++;
388: }
389: break;
1.1.1.2 root 390: default: // 通常文字
391: {
392: char asciicode;
393: if (is_shift) {
394: asciicode = lunakey2shifttable[lunakey];
395: } else {
396: asciicode = lunakey2asciitable[lunakey];
397: }
398: if (asciicode == 0) {
399: // 割り当てなし
400: return 0;
401: }
402: inputbuf.insert(inputbuf.begin() + inputpos, asciicode);
403: inputpos++;
404: break;
405: }
1.1 root 406: }
1.1.1.2 root 407: putmsg(2, "inputbuf=%zd|%s|", inputbuf.length(), inputbuf.c_str());
408: ConsoleUpdate();
409: return 0;
410: }
1.1 root 411:
1.1.1.2 root 412: // 画面を更新
413: void
414: LunaPROMEmuDevice::ConsoleUpdate()
415: {
1.1 root 416: // 入力行全体を都度更新 (面倒なので行をはみ出さないようにする)
417: std::string buf = prompt + inputbuf;
418: text.Print(0, text.GetY(), "%-79s", buf.c_str());
419: // カーソルを描画 (生バッファを触って属性を立てる)
420: uint16 *rawbuf = text.GetRawBuf();
421: int curx = prompt.length() + inputpos;
422: rawbuf[text.GetY() * text.GetCol() + curx] |= TA::On;
423: // 画面更新
424: gBitmap->EmuConsoleUpdate();
425: }
426:
427: // 入力コマンド処理
428: uint32
1.1.1.2 root 429: LunaPROMEmuDevice::Command()
1.1 root 430: {
1.1.1.2 root 431: std::vector<char> buf(inputbuf.length() + 1);
1.1 root 432: std::vector<std::string> arg;
433:
434: // 1ワードごとに分解
1.1.1.2 root 435: strcpy(&buf[0], inputbuf.c_str());
436: char *p = &buf[0];
1.1 root 437: char *s = p;
438: while (*p != '\0') {
439: if (*p == ' ') {
440: *p++ = '\0';
441: arg.push_back(std::string(s));
442: s = p;
443: } else {
444: p++;
445: }
446: }
447: if (p != s) {
448: arg.push_back(std::string(s));
449: }
450: if (loglevel >= 1) {
451: for (int i = 0; i < arg.size(); i++) {
452: putmsg("arg[%d]=|%s|", i, arg[i].c_str());
453: }
454: }
455:
456: // "k" コマンド中ならここで先に処理する
457: if (prompt_idx != 0) {
1.1.1.2 root 458: CommandK(arg);
1.1 root 459: return 0;
460: }
461:
462: // 空行
463: if (arg.size() == 0) {
464: return 0;
465: }
466:
467: // 1ワード目がコマンド
468: if (arg[0] == "h") {
469: // ヘルプメッセージ
470: text.Print("Commands\n");
471: text.Print(
472: " g [<filename>] : load program\n"
473: " gh : load host program (specified by -A option)\n"
474: " h : show this message\n"
475: " k : show/set boot constants\n"
476: " x : execute loaded program\n"
477: );
478: return 0;
479: }
480: if (arg[0] == "g") {
1.1.1.2 root 481: CommandG(arg);
1.1 root 482: return 0;
483: }
484: if (arg[0] == "gh") {
1.1.1.2 root 485: CommandGH();
1.1 root 486: return 0;
487: }
488: if (arg[0] == "k") {
1.1.1.2 root 489: CommandK(arg);
1.1 root 490: return 0;
491: }
492: if (arg[0] == "x") {
1.1.1.2 root 493: return CommandX();
1.1 root 494: }
495:
496: text.Print("** Unknown command: %s\n", arg[0].c_str());
497: return 0;
498: }
499:
500: // "g" コマンド
501: // g なら NVRAM の情報に従ってプログラムをロード。
502: // g <fname> なら NVRAM の fname だけ指定の名前を使ってロード。NVRAM には
503: // 書き込まない。
504: void
1.1.1.2 root 505: LunaPROMEmuDevice::CommandG(const std::vector<std::string>& arg)
1.1 root 506: {
507: std::string ctlr = nvram->PeekString(0x0030);
508: if (ctlr == "dk") { // harddisk
509: std::string fname {};
510:
511: switch (arg.size()) {
512: case 1:
513: break;
514: case 2:
515: fname = arg[1];
516: break;
517: default:
518: text.Print("** Invalid argument.\n");
519: return;
520: }
521: errmsg.clear();
522: entrypoint = LoadByNVRAM(fname);
523: if (entrypoint == 0) {
524: text.Print("** %s\n", errmsg.c_str());
525: }
526:
527: } else if (ctlr == "et" || // netboot
528: ctlr == "sd" || // cassette tape
529: ctlr == "fl" ) // floppy
530: {
531: text.Print("** %s boot not supported.\n", ctlr.c_str());
532: return;
533: } else {
534: // 起きないはず
535: text.Print("** Invalid boot controller name.\n");
536: return;
537: }
538:
539: if (entrypoint) {
540: text.Print("Loaded. Entry point = $%08x\n", entrypoint);
541: }
542: }
543:
544: // "gh" コマンド (勝手に拡張)
545: // -A オプションで指定されたホストプログラムをロードする。
546: void
1.1.1.2 root 547: LunaPROMEmuDevice::CommandGH()
1.1 root 548: {
549: entrypoint = 0;
550: if (gMainApp.host_file) {
551: // 指定されてたら読み込む
552: entrypoint = LoadHostFile();
553: } else {
554: text.Print("** Cannot loaded; host program is not specified.\n");
555: }
556: }
557:
558: // -A オプションで指定されたホストファイルをロードする。
559: // ロードできればエントリポイントを返す。
560: // host_file が指定されている時に呼ぶこと。
561: uint32
562: LunaPROMEmuDevice::LoadHostFile()
563: {
564: assert(gMainApp.host_file);
565:
566: uint32 entry = gRAM->LoadFile(gMainApp.host_file, AOUT_MID_M68K);
567: if (entry) {
568: text.Print("Host program loaded. Entry point = $%08x\n",
569: entry);
570: } else {
571: text.Print("** Couldn't load specified host program.\n");
572: }
573: return entry;
574: }
575:
576:
577: // k コマンドのパラメータ表
578: struct kinfo {
579: uint32 offset; // NVRAM 上のオフセット
580: const char * const name; // 表示名
581: int next; // 次インデックス
582: };
583: static const struct kinfo kinfo[] = {
584: { 0 }, // 0 は通常プロンプトを指すのでここでは使わない
585: { 0x0030, "controller", 0 }, // [1] BOOT (next は動的判定する)
586: { 0x0090, "drive unit", 3 }, // [2] DKUNIT
587: { 0x00b0, "partition ", 4 }, // [3] DKPART
588: { 0x00d0, "filename ", 0 }, // [4] FLNAME
589: { 0x0050, "hostname ", 6 }, // [5] HOST
590: { 0x0070, "servername", 7 }, // [6] SERVER
591: { 0x0190, "filename ", 8 }, // [7] ETBOOT
592: { 0x01b0, "", 0 }, // [8] ETFILE (ETBOOT と1行で処理する)
593: };
594:
595: // "k" コマンド
596: void
1.1.1.2 root 597: LunaPROMEmuDevice::CommandK(const std::vector<std::string>& arg)
1.1 root 598: {
599: uint32 offset;
600: const char *name;
601: int next;
602:
603: // 入力を処理
604: if (prompt_idx == 0) {
605: // ここは1行目表示前なので前行の入力はない。
606: next = 1;
607: } else {
608: std::string val;
609: bool rv;
610:
611: // 入力があれば更新
612: if (arg.size() != 0) {
613: rv = CommandKInput(arg[0]);
614: } else {
615: // [7] の時に入力があれば CommandKInput() の中で更新されるが、
616: // 入力がなければそこを通らないので、こっちでやらないといけない。
617: // うーん。
618: if (prompt_idx == 7) {
619: prompt_idx = kinfo[prompt_idx].next;
620: }
621: rv = true;
622: }
623:
624: // これ以降は更新後の prompt_idx を使う
625:
626: // 入力エラーがあった時はこの行を再入力するため
627: next = prompt_idx;
628:
629: if (rv == true) {
630: // 入力があっても空でも次インデックスへ。
631: if (prompt_idx == 1) {
632: // BOOT なら現在値によって次のインデックスが変わる
633: // "dk" なら [2]、"et" なら [5]。他は未対応
634: offset = kinfo[prompt_idx].offset;
635: val = nvram->PeekString(offset);
636: if (val == "dk") {
637: next = 2;
638: } else if (val == "et") {
639: next = 5;
640: } else {
641: // 起きることはないはず
642: text.Print("** Inconsistent boot parameter: %s\n",
643: val.c_str());
644: }
645: } else {
646: // それ以外はテーブルにかかれている通り
647: next = kinfo[prompt_idx].next;
648: }
649: }
650: }
651:
652: // この行のプロンプト文字列を作成
653: prompt_idx = next;
654: if (prompt_idx == 0) {
655: // 最終行なら元に戻す
656: prompt = default_prompt;
657: } else {
658: // 次のプロンプトに変更
659: name = kinfo[prompt_idx].name;
660: offset = kinfo[prompt_idx].offset;
661: std::string val = nvram->PeekString(offset);
662:
663: // [7] ETBOOT だけ1行で ETBOOT:ETFILE 形式
664: if (prompt_idx == 7) {
665: next = kinfo[prompt_idx].next; // ETFILE
666: offset = kinfo[next].offset;
667: val += ":";
668: val += nvram->PeekString(offset);
669: }
670:
671: prompt = string_format("%s: %s ?", name, val.c_str());
672: }
673: }
674:
675: // k コマンドの入力値を処理する部分。
676: // 成功すれば true を返す。
677: // 失敗すれば false を返す。
678: // 実機 ROM は入力値にエラーがあると黙って再入力を促す。
679: // エラーメッセージくらい表示してもいいかもだがとりあえず真似しておく。
680: bool
681: LunaPROMEmuDevice::CommandKInput(const std::string& val)
682: {
683: int offset;
684: bool rv = true;
685:
686: offset = kinfo[prompt_idx].offset;
687:
688: switch (prompt_idx) {
689: case 1: // BOOT
690: // 正常な入力値は "dk", "et", "sd", "fl" のみ。
691: if (val != "dk" && val != "et" && val != "sd" && val != "fl") {
692: return false;
693: }
694: rv = nvram->WriteString(offset, val);
695: if (rv == false) {
696: return false;
697: }
698: break;
699:
700: case 7: // ETBOOT
701: {
702: // こいつだけ ETBOOT:ETFILE 形式で2つのパラメータを同時に処理する
703:
704: // ':' で前後に分ける
705: int sep = val.find(':');
706: if (sep == std::string::npos) {
707: return false;
708: }
709: std::string etboot = val.substr(0, sep);
710: std::string etfile = val.substr(sep + 1, val.size() - sep + 1);
711: if (etboot.empty() || etfile.empty()) {
712: return false;
713: }
714:
715: // ETBOOT
716: rv = nvram->WriteString(offset, etboot);
717: if (rv == false) {
718: return false;
719: }
720:
721: // 次へ
722: prompt_idx = kinfo[prompt_idx].next;
723:
724: // ETFILE
725: offset = kinfo[prompt_idx].offset;
726: rv = nvram->WriteString(offset, etfile);
727: if (rv == false) {
728: return false;
729: }
730: break;
731: }
732:
733: default:
734: rv = nvram->WriteString(offset, val);
735: if (rv == false) {
736: return false;
737: }
738: break;
739: }
740:
741: WriteNVRAMCsum();
742: return rv;
743: }
744:
745: // "x" コマンド
746: // すでに読み込まれてるはずのエントリポイントにジャンプするだけ。
747: uint32
1.1.1.2 root 748: LunaPROMEmuDevice::CommandX()
1.1 root 749: {
750: if (entrypoint == 0) {
751: text.Print("** Program is not loaded.\n");
752: }
753: return entrypoint;
754: }
755:
756: // NVRAM のチェックサムを返す
757: uint8
758: LunaPROMEmuDevice::CalcNVRAMCsum()
759: {
760: uint8 eor = 0;
761: for (uint32 addr = 0x20; addr < 0x560; addr++) {
762: eor ^= nvram->Peek(addr);
763: }
764: return eor;
765: }
766:
767: // NVRAM のチェックサムを計算して書き込む
768: void
769: LunaPROMEmuDevice::WriteNVRAMCsum()
770: {
771: uint8 eor = CalcNVRAMCsum();
772:
773: nvram->Write(0x001c, eor);
774: nvram->Write(0x001d, eor);
775: nvram->Write(0x001e, eor);
776: }
777:
778: // NVRAM のマジックとチェックサムを照合する
779: bool
780: LunaPROMEmuDevice::VerifyNVRAM()
781: {
782: if (nvram->PeekString(0x0004) != "<nv>") {
783: return false;
784: }
785:
786: uint8 eor = CalcNVRAMCsum();
787: for (uint32 addr = 0x1c; addr < 0x1f; addr++) {
788: if (nvram->Peek(addr) != eor) {
789: return false;
790: }
791: }
792: return true;
793: }
794:
795: // NVRAM を初期化する
796: bool
797: LunaPROMEmuDevice::InitNVRAM()
798: {
799: // 初期値どうしたもんか
800: nvram->WriteString(0x0004, "<nv>");
801: nvram->WriteString(0x0020, "BOOT");
802: nvram->WriteString(0x0030, "dk");
803: nvram->WriteString(0x0040, "HOST");
804: nvram->WriteString(0x0050, "nono"); // 偽札的なアレ
805: nvram->WriteString(0x0060, "SERVER");
806: nvram->WriteString(0x0070, "servername");
807: nvram->WriteString(0x0080, "DKUNIT");
808: nvram->WriteString(0x0090, "0");
809: nvram->WriteString(0x00a0, "DKPART");
810: nvram->WriteString(0x00b0, "c");
811: nvram->WriteString(0x00c0, "DKFILE");
812: nvram->WriteString(0x00d0, "vmunix");
813: nvram->WriteString(0x00e0, "FLUNIT");
814: nvram->WriteString(0x00f0, "2");
815: nvram->WriteString(0x0100, "FLFILE");
816: nvram->WriteString(0x0110, "vmunix");
817: nvram->WriteString(0x0120, "STUNIT");
818: nvram->WriteString(0x0130, "0");
819: nvram->WriteString(0x0140, "STFLNO");
820: nvram->WriteString(0x0150, "1");
821: nvram->WriteString(0x0160, "STFILE");
822: nvram->WriteString(0x0170, "vmunix");
823: nvram->WriteString(0x0180, "ETBOOT");
824: nvram->WriteString(0x0190, "server");
825: nvram->WriteString(0x01a0, "ETFILE");
826: nvram->WriteString(0x01b0, "/vmunix");
827: nvram->WriteString(0x0560, "ENADDR");
828: nvram->WriteString(0x0570, ""); // どうするか
829:
830: // チェックサム再計算
831: WriteNVRAMCsum();
832:
833: return true;
834: }
835:
836: // キーコードから文字への変換
837: /*static*/ const uint8
838: LunaPROMEmuDevice::lunakey2asciitable[] = {
839: 0, 0, 0, 0, 0, 0, 0, 0,
840: 0, 0, 0, 0, 0, 0, 0, 0,
841: 0, 0, 0, 0, ' ', 0, 0, 0,
842: 0, 0, 0, 0, 0, 0, 0, 0,
843: 0, 0, '1', '2', '3', '4', '5', '6',
844: '7', '8', '9', '0', '-', '^', '\\', 0,
845: 0, 0, 'q', 'w', 'e', 'r', 't', 'y',
846: 'u', 'i', 'o', 'p', '@', '[', 0, 0,
847: 0, 0, 'a', 's', 'd', 'f', 'g', 'h',
848: 'j', 'k', 'l', ';', ':', ']', 0, 0,
849: 0, 0, 'z', 'x', 'c', 'v', 'b', 'n',
850: 'm', ',', '.', '/', 0, 0, 0, 0,
851: 0, 0, 0, 0, 0, 0, 0, 0, // XXX テンキー
852: 0, 0, 0, 0, 0, 0, 0, 0,
853: 0, 0, 0, 0, 0, 0, 0, 0,
854: 0, 0, 0, 0, 0, 0, 0, 0,
855: };
856: /*static*/ const uint8
857: LunaPROMEmuDevice::lunakey2shifttable[] = {
858: 0, 0, 0, 0, 0, 0, 0, 0,
859: 0, 0, 0, 0, 0, 0, 0, 0,
860: 0, 0, 0, 0, ' ', 0, 0, 0,
861: 0, 0, 0, 0, 0, 0, 0, 0,
862: 0, 0, '1', '2', '3', '4', '5', '6',
863: '7', '8', '9', '0', '=', '~', '|', 0,
864: 0, 0, 'Q', 'W', 'E', 'R', 'T', 'Y',
865: 'U', 'I', 'O', 'P', '`', '{', 0, 0,
866: 0, 0, 'A', 'S', 'D', 'F', 'G', 'H',
867: 'J', 'K', 'L', '+', '*', '}', 0, 0,
868: 0, 0, 'Z', 'X', 'C', 'V', 'B', 'N',
869: 'M', '<', '>', '?', '_', 0, 0, 0,
870: 0, 0, 0, 0, 0, 0, 0, 0, // XXX テンキー
871: 0, 0, 0, 0, 0, 0, 0, 0,
872: 0, 0, 0, 0, 0, 0, 0, 0,
873: 0, 0, 0, 0, 0, 0, 0, 0,
874: };
875:
876:
877: //
878: // UFS ブート
879: //
880:
881: // ディスクラベル (1セクタ目)
882: // svnweb.freebsd.org/csrg/sys/luna68k/stand/omron_disklabel.h
883: struct scd_dk_label
884: {
885: char asciilabel[128]; /* for compatibility */
886: char pad[512 - (128 + 8*8 + 11*2 + 4)];
887: uint16 badchk; /* checksum of bad track */
888: uint32 maxblk; /* # of total logical block */
889: uint16 dtype; /* disk drive type */
890: uint16 ndisk; /* # of disk drives */
891: uint16 ncyl; /* # of data cylinders */
892: uint16 acyl; /* # of altenate cylinders */
893: uint16 nhead; /* # of heads in this partition */
894: uint16 nsect; /* # of 512 byte sectors per track */
895: uint16 bhead; /* identifies proper label locations */
896: uint16 ppart; /* physical partition # */
897: struct { /* logical partitions */
898: uint32 blkno; /* starting block */
899: uint32 nblk; /* number of blocks */
900: } map[8];
901: uint16 magic; /* identifies this label format */
902: uint16 cksum; /* xor checksum of sector */
903:
904: static const uint16 DKL_MAGIC = 0xdabe;
905: };
906: static_assert(sizeof(scd_dk_label) == 512, "size must be 512");
907:
908: // オレオレ inode 情報クラス
1.1.1.2 root 909: class inodefile final
1.1 root 910: {
911: public:
912: inodefile(Device *dev) {
913: parent = dev;
914: }
1.1.1.2 root 915: ~inodefile() { }
1.1 root 916:
917: // ディレクトリエントリからファイルを検索
918: uint32 FindFile(const std::string& name);
919:
920: uint32 ino {}; // inode 番号
921: struct ufs1_dinode di {}; // disk inode 情報 (ゲストエンディアンで保持)
922: std::vector<uint8> data {}; // ファイル(またはディレクトリ)本文
923: private:
924: Device *parent {}; // 親デバイス
925: };
926:
927: // ファイルシステムハンドルっぽいもの
1.1.1.2 root 928: class Filesys final
1.1 root 929: {
930: public:
931: Filesys(Device *dev) {
932: parent = dev;
933: fs = &fs0;
934: }
1.1.1.2 root 935: ~Filesys() { }
1.1 root 936:
937: // ファイルシステムをオープン
938: bool Open(SCSIHD *hd_, uint32 start, uint32 size);
939: // inode 情報を読み込む
940: bool Readi(inodefile& inode);
941: // データを読み込む
942: bool ReadData(inodefile& inode);
943:
944: std::string errstr{}; // エラーメッセージ
945:
946: private:
947: Device *parent {}; // 親デバイス
948: SCSIHD *hd {}; // ターゲット SCSI HD
949: // パーティション情報
950: uint32 part_start {}; // パーティションの先頭セクタ
951: uint32 part_size {}; // パーティションのサイズ(セクタ数)
952: // スーパーブロック情報
953: // fs の(たぶんほとんどの)整数パラメータは読み込み時にホストエンディアン
954: // に変換してあるのでそのままアクセスしてよい。構造体とかまでは全部対応
955: // してないので、必要になったら書き足すこと。
956: struct fs *fs; // 体裁を揃えるためポインタを使いたい
957: struct fs fs0; // こっちが実体
958: };
959:
960: // NVRAM の設定に従って起動先を探す。
961: // fname が指定されればそれをファイル名に使う。empty なら NVRAM の DKFILE
962: // をファイル名に使う。
963: // 成功すればエントリポイントを返す。
964: // 失敗ならをエラーメッセージを errmsg にセットして 0 を返す。
965: uint32
966: LunaPROMEmuDevice::LoadByNVRAM(const std::string& fname)
967: {
968: // 起動先情報を NVRAM (mk48t02) に問い合わせる
969: // DKUNIT はとりあえず無視して SCSI ID=6
970: // DKPART は 'a'..'h' でパーティション。
971: // DKFILE が読み込むカーネル名 (NetBSD ではブートローダ)。
972: int dkunit = nvram->Peek(0x0090) - '0';
973: int dkpart = nvram->Peek(0x00b0) - 'a';
974: std::string dkfile_name;
975: if (!fname.empty()) {
976: dkfile_name = fname;
977: } else {
978: dkfile_name = nvram->PeekString(0x00d0);
979: }
980: putmsg(1, "%s DKUNIT=%d", __func__, dkunit);
981: putmsg(1, "%s DKPART=%c", __func__, dkpart + 'a');
982: putmsg(1, "%s DKFILE=|%s|", __func__, dkfile_name.c_str());
983:
984: // ユニット (今は SCSI ID=6 決め打ち)
985: int id = 6;
986: SCSITarget *target = gSPC->GetTarget(id);
987: if (target == NULL) {
988: errmsg = "No bootable disks";
989: putmsg(0, "%s", errmsg.c_str());
990: return 0;
991: }
1.1.1.3 ! root 992: if (target->GetDevType() != SCSI::DevType::HD) {
1.1 root 993: errmsg = "No bootable disks";
994: putmsg(0, "%s", errmsg.c_str());
995: return 0;
996: }
997:
998: SCSIHD *hd = dynamic_cast<SCSIHD*>(target);
999: putmsg(2, "%s SCSIHD[%d] found", __func__, id);
1000:
1001: // +0 セクタ目(512byte)に Sun disklabel
1002: scd_dk_label dk;
1003: if (hd->PeekImage(&dk, 0, sizeof(dk)) == false) {
1004: putmsg(0, "SCSIHD[%d] ReadSector failed", id);
1005: errmsg = string_format("dk%d Read disklabel failed.", dkunit);
1006: return 0;
1007: }
1008:
1009: // +$1fc の MAGIC をチェック
1010: uint32 magic = be16toh(dk.magic);
1011: if (magic != scd_dk_label::DKL_MAGIC) {
1012: putmsg(0, "SCSIHD[%d] Bad magic 0x%04x (!= 0x%x)",
1013: id, magic, scd_dk_label::DKL_MAGIC);
1014: errmsg = string_format("dk%d Bad disklabel magic.", dkunit);
1015: return 0;
1016: }
1017:
1018: // チェックサム照合は手抜きで省略
1019:
1020: // 指定パーティションの開始位置とサイズ
1021: if (loglevel >= 2) {
1022: // デバッグ用に全部表示
1023: for (int i = 0; i < 8; i++) {
1024: putmsg("%s partition %c: { start=%8u size=%8u }", __func__,
1025: 'a' + i,
1026: be32toh(dk.map[i].blkno),
1027: be32toh(dk.map[i].nblk));
1028: }
1029: }
1030: uint32 part_start = be32toh(dk.map[dkpart].blkno);
1031: uint32 part_size = be32toh(dk.map[dkpart].nblk);
1032: putmsg(1, "%s partition=%c, start=%u size=%u", __func__,
1033: dkpart + 'a', part_start, part_size);
1034:
1035: // ファイルシステムをオープン (マウントっぽいイメージ)
1036: Filesys fsys(this);
1037: if (fsys.Open(hd, part_start, part_size) == false) {
1038: putmsg(0, "SCSIHD[%d] %c: %s", id, dkpart + 'a', fsys.errstr.c_str());
1039: errmsg = string_format("dk%d Open ffs failed.", dkunit);
1040: return 0;
1041: }
1042:
1043: // XXX 以降エラーメッセージ全部同じ
1044: errmsg = string_format("dk%d Read ffs failed.", dkunit);
1045:
1046: std::vector<std::string> dkfile_paths;
1047: int idx = 0;
1048: inodefile dir(this);
1049: inodefile dkfile(this);
1050:
1051: enum {
1052: STATE_REG, // 通常ファイル (終了条件)
1053: STATE_PATH, // パス解析
1054: STATE_DIR, // ディレクトリ読み込み
1055: STATE_FIND, // ディレクトリからファイルを検索
1056: STATE_LINK, // シンボリックリンク
1057: } state;
1058:
1059: // DKFILE の先頭に '/' がなければここで足しておく。
1060: // ファイル名を分解する際にルートディレクトリマークが必要なので。
1061: if (dkfile_name[0] != '/') {
1062: dkfile_name.insert(0, 1, '/');
1063: }
1064: state = STATE_PATH;
1065:
1066: while (state != STATE_REG) {
1067: switch (state) {
1068: case STATE_PATH:
1069: // ファイル名をパスに分解
1070: // dkfile_name にパス名をセットしてからここに来ること。
1071: putmsg(1, "%s Path dkfile_name=|%s|", __func__,
1072: dkfile_name.c_str());
1073: if (dkfile_name.empty()) {
1074: putmsg(0, "SCSIHD[%d] %c: Filename empty?", id, dkpart + 'a');
1075: return 0;
1076: }
1077: dkfile_paths.clear();
1078: for (int s = 0; s < dkfile_name.size(); ) {
1079: int p = dkfile_name.find('/', s);
1080: if (p == std::string::npos) {
1081: p = dkfile_name.size();
1082: }
1083: // '/' が連続していなければパスコンポーネント
1084: if (p != s) {
1085: dkfile_paths.push_back(dkfile_name.substr(s, p - s));
1086: }
1087: s = p + 1;
1088: }
1089: idx = 0;
1090: if (loglevel >= 1) {
1091: for (int i = 0; i < dkfile_paths.size(); i++) {
1092: putmsg("%s dkfile_path[%d]=|%s|",
1093: __func__, i, dkfile_paths[i].c_str());
1094: }
1095: }
1096: // パスが '/' から始まっていればルートディレクトリの読み込みから。
1097: // そうでなければ現在のディレクトリでファイルの検索から。
1098: if (dkfile_name[0] == '/') {
1099: // ルートディレクトリの inode 番号は伝統的に #2 と
1100: // いうことになっている。
1101: dir.ino = 2;
1102: state = STATE_DIR;
1103: } else {
1104: state = STATE_FIND;
1105: }
1106: break;
1107:
1108: case STATE_DIR:
1109: // inode 番号からディレクトリエントリを取得。
1110: // dir.ino をセットしてからここに来ること。
1111: putmsg(1, "%s Readdir ino=%d", __func__, dir.ino);
1112: if (fsys.Readi(dir) == false) {
1113: putmsg(0, "SCSIHD[%d] %c: %s",
1114: id, dkpart + 'a', fsys.errstr.c_str());
1115: return 0;
1116: }
1117: // 中身(ディレクトリエントリ) を取得
1118: if (fsys.ReadData(dir) == false) {
1119: putmsg(0, "SCSIHD[%d] %c: %s",
1120: id, dkpart + 'a', fsys.errstr.c_str());
1121: return 0;
1122: }
1123: state = STATE_FIND;
1124: break;
1125:
1126: case STATE_FIND:
1127: // ディレクトリエントリ dir.data から
1128: // ファイル名 dkfile_paths[idx] を探す。
1129: putmsg(1, "%s FindFile %s", __func__, dkfile_paths[idx].c_str());
1130: dkfile.ino = dir.FindFile(dkfile_paths[idx]);
1131: if (dkfile.ino == 0) {
1132: putmsg(0, "SCSIHD[%d] %c: %s",
1133: id, dkpart + 'a', fsys.errstr.c_str());
1134: return 0;
1135: }
1136: // ファイルの inode 情報を取得。
1137: if (fsys.Readi(dkfile) == false) {
1138: putmsg(0, "SCSIHD[%d] %c: %s",
1139: id, dkpart + 'a', fsys.errstr.c_str());
1140: return 0;
1141: }
1142: switch (be16toh(dkfile.di.di_mode) & IFMT) {
1143: case IFREG: // 通常ファイル
1144: state = STATE_REG;
1145: break;
1146:
1147: case IFLNK: // シンボリックリンク
1148: state = STATE_LINK;
1149: break;
1150:
1151: case IFDIR: // ディレクトリ
1152: dir.ino = dkfile.ino;
1153: idx++;
1154: state = STATE_DIR;
1155: break;
1156:
1157: default: // それ以外は対応してないし来ないはず
1158: putmsg(0, "SCSIHD[%d] %c:%s invalid filemode %06o",
1159: id, dkpart + 'a', dkfile_name.c_str(),
1160: be16toh(dkfile.di.di_mode));
1161: return 0;
1162: }
1163: break;
1164:
1165: case STATE_LINK:
1166: // リンク先ファイル名を取り出す
1167: putmsg(1, "%s Readlink", __func__);
1168: if (fsys.ReadData(dkfile) == false) {
1169: return 0;
1170: }
1171: dkfile_name = std::string((const char *)dkfile.data.data(),
1172: dkfile.data.size());
1173: // パス解析へ
1174: state = STATE_PATH;
1175: break;
1176:
1177: default:
1178: __unreachable();
1179: }
1180: }
1181: // 通常ファイルに到達
1182:
1183: if (idx != dkfile_paths.size() - 1) {
1184: // パスの最後のコンポーネントじゃなければエラー
1185: putmsg(0, "SCSIHD[%d] %c:%s path not found",
1186: id, dkpart + 'a', dkfile_name.c_str());
1187: return 0;
1188: }
1189: // ファイル本体を読み込み
1190: if (fsys.ReadData(dkfile) == false) {
1191: putmsg(0, "SCSIHD[%d] %c: %s", id, dkpart + 'a', fsys.errstr.c_str());
1192: return 0;
1193: }
1194:
1195: // ロード
1196: uint32 entry;
1197: std::string name = string_format("SCSIHD %d,%c:%s",
1198: id, dkpart + 'a', dkfile_name.c_str());
1199: entry = gRAM->LoadFile(name.c_str(), dkfile.data.data(),
1200: dkfile.data.size(), AOUT_MID_M68K);
1201:
1202: return entry;
1203: }
1204:
1205: // パーティションを FFS としてオープンする(マウントのようなイメージ)。
1206: // start, size はこのパーティションの開始セクタとセクタ数。
1207: bool
1208: Filesys::Open(SCSIHD *hd_, uint32 start, uint32 size)
1209: {
1210: hd = hd_;
1211: part_start = start;
1212: part_size = size;
1213:
1214: // FFS の先頭にはブートブロックがあり、続けてスーパーブロックがある。
1215: // ブートブロックはブートローダのための領域で、ここもファイルシステムの
1216: // 内側という認識のようだ。
1217: //
1218: // ブートブロックの大きさはおそらくファイルシステムごとに固定で、
1219: // FFSv1(?) なら 8KB のようだ。ここは LUNA-I の ROM が解釈できるのと
1220: // 同じファイルシステムだけ扱えればよいので、8KB 固定とする。
1221: // 続いてスーパーブロックがある。ここにこのファイルシステムのパラメータ
1222: // が書いてある。
1223: //
1224: // +-------------+ 0 <- part_start (パーティション先頭)
1225: // | BootBlock |
1226: // +-------------+ 8KB
1227: // | SuperBlock |
1228: // | fs_iblkno ---+
1229: // +-------------+ |
1230: // : : |
1231: // |
1232: // : : |
1233: // +-------------+ <-+
1234: // | InodeBlock? |
1235: //
1236: // スーパーブロックの構造は <ufs/ffs/fs.h> の struct fs 参照。
1237:
1238: // スーパーブロックを読む
1239: hd->PeekImage(&fs0, part_start * 512 + 8192, sizeof(fs0));
1240: // 読み込んだスーパーブロックはゲストエンディアン(BE) なので
1241: // 使う前に (もう面倒なのでほぼ全部) ホストエンディアンにしておく。
1242: // ヘッダに定義してあるマクロをそのまま使いたいからだけど、正気かなこれ。
1243: fs->fs_firstfield = be32toh(fs->fs_firstfield);
1244: fs->fs_sblkno = be32toh(fs->fs_sblkno);
1245: fs->fs_cblkno = be32toh(fs->fs_cblkno);
1246: fs->fs_iblkno = be32toh(fs->fs_iblkno);
1247: fs->fs_dblkno = be32toh(fs->fs_dblkno);
1248: fs->fs_old_cgoffset = be32toh(fs->fs_old_cgoffset);
1249: fs->fs_old_cgmask = be32toh(fs->fs_old_cgmask);
1250: fs->fs_old_time = be32toh(fs->fs_old_time);
1251: fs->fs_old_size = be32toh(fs->fs_old_size);
1252: fs->fs_old_dsize = be32toh(fs->fs_old_dsize);
1253: fs->fs_ncg = be32toh(fs->fs_ncg);
1254: fs->fs_bsize = be32toh(fs->fs_bsize);
1255: fs->fs_fsize = be32toh(fs->fs_fsize);
1256: fs->fs_frag = be32toh(fs->fs_frag);
1257: fs->fs_minfree = be32toh(fs->fs_minfree);
1258: fs->fs_old_rotdelay = be32toh(fs->fs_old_rotdelay);
1259: fs->fs_old_rps = be32toh(fs->fs_old_rps);
1260: fs->fs_bmask = be32toh(fs->fs_bmask);
1261: fs->fs_fmask = be32toh(fs->fs_fmask);
1262: fs->fs_bshift = be32toh(fs->fs_bshift);
1263: fs->fs_fshift = be32toh(fs->fs_fshift);
1264: fs->fs_maxcontig = be32toh(fs->fs_maxcontig);
1265: fs->fs_maxbpg = be32toh(fs->fs_maxbpg);
1266: fs->fs_fragshift = be32toh(fs->fs_fragshift);
1267: fs->fs_fsbtodb = be32toh(fs->fs_fsbtodb);
1268: fs->fs_sbsize = be32toh(fs->fs_sbsize);
1269: //fs->fs_spare1[2]
1270: fs->fs_nindir = be32toh(fs->fs_nindir);
1271: fs->fs_inopb = be32toh(fs->fs_inopb);
1272: fs->fs_old_nspf = be32toh(fs->fs_old_nspf);
1273: fs->fs_optim = be32toh(fs->fs_optim);
1274: fs->fs_old_npsect = be32toh(fs->fs_old_npsect);
1275: fs->fs_old_interleave = be32toh(fs->fs_old_interleave);
1276: fs->fs_old_trackskew = be32toh(fs->fs_old_trackskew);
1277: fs->fs_id[0] = be32toh(fs->fs_id[0]);
1278: fs->fs_id[1] = be32toh(fs->fs_id[1]);
1279: fs->fs_old_csaddr = be32toh(fs->fs_old_csaddr);
1280: fs->fs_cssize = be32toh(fs->fs_cssize);
1281: fs->fs_cgsize = be32toh(fs->fs_cgsize);
1282: fs->fs_spare2 = be32toh(fs->fs_spare2);
1283: fs->fs_old_nsect = be32toh(fs->fs_old_nsect);
1284: fs->fs_old_spc = be32toh(fs->fs_old_spc);
1285: fs->fs_old_ncyl = be32toh(fs->fs_old_ncyl);
1286: fs->fs_old_cpg = be32toh(fs->fs_old_cpg);
1287: fs->fs_ipg = be32toh(fs->fs_ipg);
1288: fs->fs_fpg = be32toh(fs->fs_fpg);
1289: //struct csum fs_old_cstotal
1290: //u_char fs_fsmnt[MAXMNTLEN]
1291: //u_char fs_volname[MAXVOLLEN]
1292: fs->fs_swuid = be64toh(fs->fs_swuid);
1293: fs->fs_pad = be32toh(fs->fs_pad);
1294: fs->fs_cgrotor = be32toh(fs->fs_cgrotor);
1295: //void *fs_ocsp[NOCSPTRS]
1296: //struct csum *fs_csp
1297: //uint32_t *fs_maxcluster
1298: //u_char *fs_active
1299: fs->fs_old_cpc = be32toh(fs->fs_old_cpc);
1300: fs->fs_maxbsize = be32toh(fs->fs_maxbsize);
1301: fs->fs_journal_flags = be32toh(fs->fs_journal_flags);
1302: //uint64_t fs->fs_journallocs[4]
1303: fs->fs_quota_magic = be32toh(fs->fs_quota_magic);
1304: //uint64_t fs->fs_quotafile[2]
1305: //uint64_t fs->fs_sparecon64[9]
1306: fs->fs_sblockloc = be64toh(fs->fs_sblockloc);
1307: //struct csum_total fs_cstotal
1308: fs->fs_time = be64toh(fs->fs_time);
1309: fs->fs_size = be64toh(fs->fs_size);
1310: fs->fs_dsize = be64toh(fs->fs_dsize);
1311: fs->fs_csaddr = be64toh(fs->fs_csaddr);
1312: fs->fs_pendingblocks = be64toh(fs->fs_pendingblocks);
1313: fs->fs_pendinginodes = be32toh(fs->fs_pendinginodes);
1314: // uint32_t fs->fs_snapinum[FSMAXSNAP]
1315: fs->fs_avgfilesize = be32toh(fs->fs_avgfilesize);
1316: fs->fs_avgfpdir = be32toh(fs->fs_avgfpdir);
1317: fs->fs_save_cgsize = be32toh(fs->fs_save_cgsize);
1318: // uint32_t fs->fs_sparecon32[26]
1319: fs->fs_flags = be32toh(fs->fs_flags);
1320: fs->fs_contigsumsize = be32toh(fs->fs_contigsumsize);
1321: fs->fs_maxsymlinklen = be32toh(fs->fs_maxsymlinklen);
1322: fs->fs_old_inodefmt = be32toh(fs->fs_old_inodefmt);
1323: fs->fs_maxfilesize = be64toh(fs->fs_maxfilesize);
1324: fs->fs_qbmask = be64toh(fs->fs_qbmask);
1325: fs->fs_qfmask = be64toh(fs->fs_qfmask);
1326: fs->fs_state = be32toh(fs->fs_state);
1327: fs->fs_old_postblformat = be32toh(fs->fs_old_postblformat);
1328: fs->fs_old_nrpos = be32toh(fs->fs_old_nrpos);
1329: // uint32_t fs->fs_spare5[2]
1330: fs->fs_magic = be32toh(fs->fs_magic);
1331:
1332: // マジック
1333: if (fs->fs_magic != FS_UFS1_MAGIC) {
1334: errstr = string_format("Bad superblock magic 0x%08x (!= 0x%08x)",
1335: fs->fs_magic, FS_UFS1_MAGIC);
1336: return false;
1337: }
1338:
1339: // なんとなく主要なパラメータを表示してみるか
1340: if (parent->loglevel >= 2) {
1341: uint32 sblkno = fs->fs_sblkno; // super block in filesys
1342: uint32 cblkno = fs->fs_cblkno; // cylinder group block in filesys
1343: uint32 iblkno = fs->fs_iblkno; // inode block in filesys
1344: uint32 dblkno = fs->fs_dblkno; // data block in filesys
1345: uint32 bsize = fs->fs_bsize; // size of basic blocks
1346: uint32 ipg = fs->fs_ipg; // inodes per group
1347: uint32 fpg = fs->fs_fpg; // blocks per group x fs_frag
1348: uint32 old_cgoffset = fs->fs_old_cgoffset; // cg. offset in cyl.
1349:
1350: parent->putmsg("%s fs.fs_sblkno=0x%x (0x%x)",
1351: __func__, sblkno, sblkno * 512);
1352: parent->putmsg("%s fs.fs_cblkno=0x%x (0x%x)",
1353: __func__, cblkno, cblkno * 512);
1354: parent->putmsg("%s fs.fs_dblkno=0x%x (0x%x)",
1355: __func__, dblkno, dblkno * 512);
1356: parent->putmsg("%s fs.fs_iblkno=0x%x (0x%x)",
1357: __func__, iblkno, iblkno * 512);
1358: parent->putmsg("%s fs.fs_bsize=0x%x", __func__, bsize);
1359: parent->putmsg("%s fs.fs_ipg=0x%x", __func__, ipg);
1360: parent->putmsg("%s fs.fs_fpg=0x%x", __func__, fpg);
1361: parent->putmsg("%s fs.fs_old_cgoffset=0x%x", __func__, old_cgoffset);
1362: }
1363:
1364: return true;
1365: }
1366:
1367: // inode.ino で指定された disk inode 情報を inode.di に返す
1368: bool
1369: Filesys::Readi(inodefile& inode)
1370: {
1371: // di は inode のディスク上の記録構造で 128 バイト長。
1372: // 詳細は <ufs/ufs/dinode.h> の ufs1_dinode 参照。
1373: // 基本的には inode ブロックにこの dinode が配列のように並んでいるが
1374: // シリンダグループを越えるためには謎のマクロを使う。
1375: // sys/lib/libsa/ufs.c 参照。
1376: //
1377: // dinode のうち、ここで関係するかも知れないのは
1378: // di_mode (のうちファイルモード)
1379: // di_size (ファイルサイズ)
1380: // di_db[] (直接ブロック)
1381: // di_ib[] (間接ブロック)
1382: // di_blocks (ブロック数)
1383: // くらいか。
1384:
1385: uint32 ino = inode.ino;
1386: struct ufs1_dinode *di = &inode.di;
1387:
1388: // ino が含まれるブロックを読み込む
1.1.1.2 root 1389: std::vector<char> buf(fs->fs_bsize);
1.1 root 1390: uint32 ino_sector = FFS_FSBTODB(fs, ino_to_fsba(fs, ino));
1.1.1.2 root 1391: hd->PeekImage(&buf[0], part_start + ino_sector * 512, buf.size());
1.1 root 1392:
1393: // ino で示される inode を取得
1.1.1.2 root 1394: *di = ((ufs1_dinode *)(&buf[0]))[ino_to_fsbo(fs, ino)];
1.1 root 1395: uint16 di_mode = be16toh(di->di_mode);
1396: uint16 di_nlink = be16toh(di->di_nlink);
1397: uint64 di_size = be64toh(di->di_size);
1398: parent->putmsg(2, "%s di[%d].di_mode=%05o di_nlink=%d di_size=%" PRIu64,
1399: __func__, ino, di_mode, di_nlink, di_size);
1400:
1401: return true;
1402: }
1403:
1404: // inode.di で指定されたファイル(またはディレクトリ)の本文を
1405: // inode.data に返す
1406: bool
1407: Filesys::ReadData(inodefile& inode)
1408: {
1409: // di (ufs1_dinode) にはこの inode (ファイルまたはディレクトリ)の
1410: // データの格納ブロックが記録されている。ディレクトリとは中身が
1411: // ディレクトリエントリであるファイルと同じ構造のもの。
1412: // di_db[] (直接ブロック)
1413: // di_ib[] (間接ブロック)
1414: // di_blocks (実際に使用しているブロック数)
1415: //
1416: // 直接ブロック di_db[] は12要素の配列で、データブロックの位置が
1417: // 記録されている (未使用なら 0 のようだ)。
1418: // データブロックは fs->fs_bsize でたぶん基本 4KB のやつ。
1419: // これもパーティション先頭からのセクタ番号で表記される。なので
1420: // ディスク上で連続しているファイルなら di_db[N] と di_db[N + 1] は
1421: // 8 ずつ増えてるのが見えるはず。
1422: // 例えば以下のサンプル断片は、直接ブロック2つでセクタ 100 から
1423: // セクタ 115 までの連続する 16KB を所有している様子を示している。
1424: //
1425: // #100 #101 #102 #107
1426: // +------+------+------+- .. -+------+
1427: // di_db[0] = 100 ---> | Data | Data | Data | | Data |
1428: // +------+------+------+- .. -+------+
1429: //
1430: // #108 #115
1431: // +------+------+------+- .. -+------+
1432: // di_db[1] = 108 ---> | Data | Data | Data | | Data |
1433: // +------+------+------+- .. -+------+
1434: //
1435: // 間接ブロック di_ib[0], [1], [2] はそれぞれ一次、二次、三次の
1436: // 間接記録になっている。一次間接だとこういう感じ。
1437: //
1438: // #120
1439: // +--------+ +------+- ..
1440: // di_ib[0] = 120 ---> | #200 ------> #200 | Data |
1441: // | | +------+- ..
1442: // | #208 ------> #208 | Data |
1443: // +--------+ +------+- ..
1444: //
1445:
1446: uint32 ino = inode.ino;
1447: struct ufs1_dinode *di = &inode.di;
1448: std::vector<uint8>& data = inode.data;
1449: uint64 bsize64 = (uint64)fs->fs_bsize;
1450:
1451: uint64 di_size = be64toh(di->di_size);
1452: uint32 di_blocks = be32toh(di->di_blocks);
1453: // di->di_db[] にファイル(またはディレクトリ)の内容の位置が並んでいる
1454: if (parent->loglevel >= 2) {
1455: parent->putmsg("%s di[%d].di_blocks=%u", __func__, ino, di_blocks);
1456:
1457: std::string dbstr;
1458: for (int i = 0; i < UFS_NDADDR; i++) {
1459: dbstr += string_format(" %u", be32toh(di->di_db[i]));
1460: }
1461: parent->putmsg("%s di[%d].di_db[]=%s",
1462: __func__, ino, dbstr.c_str() + 1);
1463:
1464: std::string distr;
1465: for (int i = 0; i < UFS_NIADDR; i++) {
1466: distr += string_format(" %u", be32toh(di->di_ib[i]));
1467: }
1468: parent->putmsg("%s di[%d].di_ib[]=%s",
1469: __func__, ino, distr.c_str() + 1);
1470: }
1471:
1472: uint64 offset = 0; // 次に読み込む位置 (ここまでに読み込んだバイト数)
1473:
1474: // サイズが分かっているのであらかじめ確保しておく
1475: data.resize(di_size);
1476:
1477: // 直接ブロック
1478: for (int i = 0; i < countof(di->di_db); i++) {
1479: uint64 remain = di_size - offset; // 残りバイト数
1480: uint32 nbytes = std::min(remain, bsize64); // 今回読み込み分
1481: hd->PeekImage(&data[offset], be32toh(di->di_db[i]) * 512, nbytes);
1482: offset += nbytes;
1483: if (offset >= di_size)
1484: break;
1485: }
1486: // 一次間接ブロック
1.1.1.2 root 1487: std::vector<uint32> ib0buf(fs->fs_bsize / sizeof(uint32));
1488: hd->PeekImage(&ib0buf[0], be32toh(di->di_ib[0]) * 512,
1489: ib0buf.size() * sizeof(uint32));
1.1 root 1490: if (parent->loglevel >= 2) {
1491: std::string distr;
1.1.1.2 root 1492: for (const auto& x : ib0buf) {
1493: if (x == 0)
1.1 root 1494: break;
1.1.1.2 root 1495: distr += string_format(" %u", be32toh(x));
1.1 root 1496: }
1497: parent->putmsg("%s di[%d].di_ib[0]=%s",
1498: __func__, ino, distr.c_str() + 1);
1499: }
1.1.1.2 root 1500: for (const auto& x : ib0buf) {
1.1 root 1501: uint64 remain = di_size - offset; // 残りバイト数
1502: uint32 nbytes = std::min(remain, bsize64); // 今回読み込み分
1.1.1.2 root 1503: hd->PeekImage(&data[offset], be32toh(x) * 512, nbytes);
1.1 root 1504: offset += nbytes;
1505: if (offset >= di_size)
1506: break;
1507: }
1508:
1509: // 二次、三次ブロックは未対応
1510: if (offset < di_size) {
1511: PANIC("di_ib[1] not supported");
1512: }
1513:
1514: return true;
1515: }
1516:
1517: // ディレクトリエントリ dirbuf から name で指定されるファイル名に対応する
1518: // inode 番号を返す。見付からなければ 0 を返す。
1519: uint32
1520: inodefile::FindFile(const std::string& name)
1521: {
1522: // ディレクトリエントリは可変長で並んでいる。
1523: // d->d_reclen がこの1つ分のエントリの長さなので、次のエントリ位置は
1524: // このエントリの頭から d->d_reclen を足したところになる。
1525: // 最終エントリの d_reclen を足すとバッファ末尾になるようになっている
1526: // ようだ。
1527: const char *dp = (const char *)(data.data());
1528: const char *dend = dp + data.size();
1529: uint32 file_ino;
1530: uint16 reclen;
1531:
1532: for (; dp < dend; dp += reclen) {
1533: const struct direct *d = (const struct direct *)dp;
1534: file_ino = be32toh(d->d_fileno);
1535: reclen = be16toh(d->d_reclen);
1536:
1537: std::string str = string_format("ino=%u reclen=%u name=|%s|",
1538: file_ino, reclen, d->d_name);
1539: if (strcmp(name.c_str(), d->d_name) == 0) {
1540: parent->putmsg(2, "%s %s found", __func__, str.c_str());
1.1.1.2 root 1541: return file_ino;
1.1 root 1542: } else {
1543: parent->putmsg(2, "%s %s skip", __func__, str.c_str());
1544: }
1545: }
1.1.1.2 root 1546: parent->putmsg(2, "%s %s not found", __func__, name.c_str());
1547: return 0;
1.1 root 1548: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.