![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ufs.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 ufs.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2020 nono project
4: // Licensed under nono-license.txt
5: //
6:
7: // UFS
8:
9: #include "ufs.h"
10: #include "ffs_dir.h"
11: #include "scsidev.h"
12:
13: //
14: // ファイルシステムハンドルっぽいもの
15: //
16:
17: // コンストラクタ
18: Filesys::Filesys(Device *parent_)
19: {
20: parent = parent_;
21: fs = &fs0;
22: }
23:
24: // デストラクタ
25: Filesys::~Filesys()
26: {
27: }
28:
29: // パーティションを FFS としてオープンする(マウントのようなイメージ)。
30: // start, size はこのパーティションの開始セクタとセクタ数。
31: // 成功すれば true を返す。
32: // 失敗すれば errstr にエラーメッセージをセットして false を返す。
33: bool
34: Filesys::Mount(SCSIHD *hd_, uint32 start, uint32 size)
35: {
36: hd = hd_;
37: part_start = start;
38: part_size = size;
39:
40: // FFS の先頭にはブートブロックがあり、続けてスーパーブロックがある。
41: // ブートブロックはブートローダのための領域で、ここもファイルシステムの
42: // 内側という認識のようだ。
43: //
44: // ブートブロックの大きさはおそらくファイルシステムごとに固定で、
45: // FFSv1(?) なら 8KB のようだ。ここは LUNA-I の ROM が解釈できるのと
46: // 同じファイルシステムだけ扱えればよいので、8KB 固定とする。
47: // 続いてスーパーブロックがある。ここにこのファイルシステムのパラメータ
48: // が書いてある。
49: //
50: // +-------------+ 0 <- part_start (パーティション先頭)
51: // | BootBlock |
52: // +-------------+ 8KB
53: // | SuperBlock |
54: // | fs_iblkno ---+
55: // +-------------+ |
56: // : : |
57: // |
58: // : : |
59: // +-------------+ <-+
60: // | InodeBlock? |
61: //
62: // スーパーブロックの構造は <ufs/ffs/fs.h> の struct fs 参照。
63:
64: // スーパーブロックを読む (ここはまだ PeekBlock() は使えない)
65: hd->PeekImage(&fs0, part_start * 512 + 8192, sizeof(fs0));
66: // 読み込んだスーパーブロックはゲストエンディアン(BE) なので
67: // 使う前に (もう面倒なのでほぼ全部) ホストエンディアンにしておく。
68: // ヘッダに定義してあるマクロをそのまま使いたいからだけど、正気かなこれ。
69: fs->fs_firstfield = be32toh(fs->fs_firstfield);
70: fs->fs_sblkno = be32toh(fs->fs_sblkno);
71: fs->fs_cblkno = be32toh(fs->fs_cblkno);
72: fs->fs_iblkno = be32toh(fs->fs_iblkno);
73: fs->fs_dblkno = be32toh(fs->fs_dblkno);
74: fs->fs_old_cgoffset = be32toh(fs->fs_old_cgoffset);
75: fs->fs_old_cgmask = be32toh(fs->fs_old_cgmask);
76: fs->fs_old_time = be32toh(fs->fs_old_time);
77: fs->fs_old_size = be32toh(fs->fs_old_size);
78: fs->fs_old_dsize = be32toh(fs->fs_old_dsize);
79: fs->fs_ncg = be32toh(fs->fs_ncg);
80: fs->fs_bsize = be32toh(fs->fs_bsize);
81: fs->fs_fsize = be32toh(fs->fs_fsize);
82: fs->fs_frag = be32toh(fs->fs_frag);
83: fs->fs_minfree = be32toh(fs->fs_minfree);
84: fs->fs_old_rotdelay = be32toh(fs->fs_old_rotdelay);
85: fs->fs_old_rps = be32toh(fs->fs_old_rps);
86: fs->fs_bmask = be32toh(fs->fs_bmask);
87: fs->fs_fmask = be32toh(fs->fs_fmask);
88: fs->fs_bshift = be32toh(fs->fs_bshift);
89: fs->fs_fshift = be32toh(fs->fs_fshift);
90: fs->fs_maxcontig = be32toh(fs->fs_maxcontig);
91: fs->fs_maxbpg = be32toh(fs->fs_maxbpg);
92: fs->fs_fragshift = be32toh(fs->fs_fragshift);
93: fs->fs_fsbtodb = be32toh(fs->fs_fsbtodb);
94: fs->fs_sbsize = be32toh(fs->fs_sbsize);
95: //fs->fs_spare1[2]
96: fs->fs_nindir = be32toh(fs->fs_nindir);
97: fs->fs_inopb = be32toh(fs->fs_inopb);
98: fs->fs_old_nspf = be32toh(fs->fs_old_nspf);
99: fs->fs_optim = be32toh(fs->fs_optim);
100: fs->fs_old_npsect = be32toh(fs->fs_old_npsect);
101: fs->fs_old_interleave = be32toh(fs->fs_old_interleave);
102: fs->fs_old_trackskew = be32toh(fs->fs_old_trackskew);
103: fs->fs_id[0] = be32toh(fs->fs_id[0]);
104: fs->fs_id[1] = be32toh(fs->fs_id[1]);
105: fs->fs_old_csaddr = be32toh(fs->fs_old_csaddr);
106: fs->fs_cssize = be32toh(fs->fs_cssize);
107: fs->fs_cgsize = be32toh(fs->fs_cgsize);
108: fs->fs_spare2 = be32toh(fs->fs_spare2);
109: fs->fs_old_nsect = be32toh(fs->fs_old_nsect);
110: fs->fs_old_spc = be32toh(fs->fs_old_spc);
111: fs->fs_old_ncyl = be32toh(fs->fs_old_ncyl);
112: fs->fs_old_cpg = be32toh(fs->fs_old_cpg);
113: fs->fs_ipg = be32toh(fs->fs_ipg);
114: fs->fs_fpg = be32toh(fs->fs_fpg);
115: //struct csum fs_old_cstotal
116: //u_char fs_fsmnt[MAXMNTLEN]
117: //u_char fs_volname[MAXVOLLEN]
118: fs->fs_swuid = be64toh(fs->fs_swuid);
119: fs->fs_pad = be32toh(fs->fs_pad);
120: fs->fs_cgrotor = be32toh(fs->fs_cgrotor);
121: //void *fs_ocsp[NOCSPTRS]
122: //struct csum *fs_csp
123: //uint32_t *fs_maxcluster
124: //u_char *fs_active
125: fs->fs_old_cpc = be32toh(fs->fs_old_cpc);
126: fs->fs_maxbsize = be32toh(fs->fs_maxbsize);
127: fs->fs_journal_flags = be32toh(fs->fs_journal_flags);
128: //uint64_t fs->fs_journallocs[4]
129: fs->fs_quota_magic = be32toh(fs->fs_quota_magic);
130: //uint64_t fs->fs_quotafile[2]
131: //uint64_t fs->fs_sparecon64[9]
132: fs->fs_sblockloc = be64toh(fs->fs_sblockloc);
133: //struct csum_total fs_cstotal
134: fs->fs_time = be64toh(fs->fs_time);
135: fs->fs_size = be64toh(fs->fs_size);
136: fs->fs_dsize = be64toh(fs->fs_dsize);
137: fs->fs_csaddr = be64toh(fs->fs_csaddr);
138: fs->fs_pendingblocks = be64toh(fs->fs_pendingblocks);
139: fs->fs_pendinginodes = be32toh(fs->fs_pendinginodes);
140: // uint32_t fs->fs_snapinum[FSMAXSNAP]
141: fs->fs_avgfilesize = be32toh(fs->fs_avgfilesize);
142: fs->fs_avgfpdir = be32toh(fs->fs_avgfpdir);
143: fs->fs_save_cgsize = be32toh(fs->fs_save_cgsize);
144: // uint32_t fs->fs_sparecon32[26]
145: fs->fs_flags = be32toh(fs->fs_flags);
146: fs->fs_contigsumsize = be32toh(fs->fs_contigsumsize);
147: fs->fs_maxsymlinklen = be32toh(fs->fs_maxsymlinklen);
148: fs->fs_old_inodefmt = be32toh(fs->fs_old_inodefmt);
149: fs->fs_maxfilesize = be64toh(fs->fs_maxfilesize);
150: fs->fs_qbmask = be64toh(fs->fs_qbmask);
151: fs->fs_qfmask = be64toh(fs->fs_qfmask);
152: fs->fs_state = be32toh(fs->fs_state);
153: fs->fs_old_postblformat = be32toh(fs->fs_old_postblformat);
154: fs->fs_old_nrpos = be32toh(fs->fs_old_nrpos);
155: // uint32_t fs->fs_spare5[2]
156: fs->fs_magic = be32toh(fs->fs_magic);
157:
158: // マジック
159: if (fs->fs_magic != FS_UFS1_MAGIC) {
160: errstr = string_format("Bad superblock magic 0x%08x (!= 0x%08x)",
161: fs->fs_magic, FS_UFS1_MAGIC);
162: return false;
163: }
164:
165: // なんとなく主要なパラメータを表示してみるか
166: if (parent->loglevel >= 2) {
167: uint32 sblkno = fs->fs_sblkno; // super block in filesys
168: uint32 cblkno = fs->fs_cblkno; // cylinder group block in filesys
169: uint32 iblkno = fs->fs_iblkno; // inode block in filesys
170: uint32 dblkno = fs->fs_dblkno; // data block in filesys
171: uint32 bsize = fs->fs_bsize; // size of basic blocks
172: uint32 ipg = fs->fs_ipg; // inodes per group
173: uint32 fpg = fs->fs_fpg; // blocks per group x fs_frag
174: uint32 old_cgoffset = fs->fs_old_cgoffset; // cg. offset in cyl.
175: uint32 fsbtodb= fs->fs_fsbtodb; // shift constant
176:
177: parent->putmsgn("%s fs.fs_sblkno=0x%x (0x%x)",
178: __func__, sblkno, sblkno * 512);
179: parent->putmsgn("%s fs.fs_cblkno=0x%x (0x%x)",
180: __func__, cblkno, cblkno * 512);
181: parent->putmsgn("%s fs.fs_dblkno=0x%x (0x%x)",
182: __func__, dblkno, dblkno * 512);
183: parent->putmsgn("%s fs.fs_iblkno=0x%x (0x%x)",
184: __func__, iblkno, iblkno * 512);
185: parent->putmsgn("%s fs.fs_bsize=0x%x", __func__, bsize);
186: parent->putmsgn("%s fs.fs_ipg=0x%x", __func__, ipg);
187: parent->putmsgn("%s fs.fs_fpg=0x%x", __func__, fpg);
188: parent->putmsgn("%s fs.fs_old_cgoffset=0x%x", __func__, old_cgoffset);
189: parent->putmsgn("%s fs.fs_fsbtodb=%d", __func__, fsbtodb);
190: }
191:
192: return true;
193: }
194:
195: // ファイル名からファイルをオープンする。
196: // オープンできれば file を埋めて true を返す。
197: // オープンできなければ errstr にエラーメッセージをセットして false を返す。
198: bool
199: Filesys::OpenFile(inodefile& file, const std::string& filename_)
200: {
201: std::string filename(filename_);
202: std::vector<std::string> path;
203: int idx = 0;
204: inodefile dir(parent);
205:
206: enum {
207: STATE_REG, // 通常ファイル (終了条件)
208: STATE_PATH, // パス解析
209: STATE_DIR, // ディレクトリ読み込み
210: STATE_FIND, // ディレクトリからファイルを検索
211: STATE_LINK, // シンボリックリンク
212: } state;
213:
214: // DKFILE の先頭に '/' がなければここで足しておく。
215: // ファイル名を分解する際にルートディレクトリマークが必要なので。
216: if (filename[0] != '/') {
217: filename.insert(0, 1, '/');
218: }
219: state = STATE_PATH;
220:
221: while (state != STATE_REG) {
222: switch (state) {
223: case STATE_PATH:
224: // ファイル名をパスに分解
225: // filename にパス名をセットしてからここに来ること。
226: parent->putmsgf(1, lstr("%s Path filename=|%s|",
227: lam_func, filename.c_str()));
228: if (filename.empty()) {
229: errstr = "Filename empty?";
230: return false;
231: }
232: path.clear();
233: for (int s = 0; s < filename.size(); ) {
234: int p = filename.find('/', s);
235: if (p == std::string::npos) {
236: p = filename.size();
237: }
238: // '/' が連続していなければパスコンポーネント
239: if (p != s) {
240: path.push_back(filename.substr(s, p - s));
241: }
242: s = p + 1;
243: }
244: idx = 0;
245: if (parent->loglevel >= 1) {
246: for (int i = 0; i < path.size(); i++) {
247: parent->putmsgn("%s path[%d]=|%s|",
248: __func__, i, path[i].c_str());
249: }
250: }
251: // パスが '/' から始まっていればルートディレクトリの読み込みから。
252: // そうでなければ現在のディレクトリでファイルの検索から。
253: if (filename[0] == '/') {
254: // ルートディレクトリの inode 番号は伝統的に #2 と
255: // いうことになっている。
256: dir.ino = 2;
257: state = STATE_DIR;
258: } else {
259: state = STATE_FIND;
260: }
261: break;
262:
263: case STATE_DIR:
264: // inode 番号からディレクトリエントリを取得。
265: // dir.ino をセットしてからここに来ること。
266: parent->putmsgf(1, lstr("%s Readdir ino=%d", lam_func, dir.ino));
267: Readi(dir);
268: // 中身(ディレクトリエントリ) を取得
269: ReadData(dir);
270: state = STATE_FIND;
271: break;
272:
273: case STATE_FIND:
274: // ディレクトリエントリ dir.data から
275: // ファイル名 path[idx] を探す。
276: parent->putmsgf(1, lstr("%s FindFile %s",
277: lam_func, path[idx].c_str()));
278: file.ino = dir.FindFile(path[idx]);
279: if (file.ino == 0) {
280: errstr = string_format("file not found");
281: return false;
282: }
283: // ファイルの inode 情報を取得。
284: Readi(file);
285: switch (be16toh(file.di.di_mode) & IFMT) {
286: case IFREG: // 通常ファイル
287: state = STATE_REG;
288: break;
289:
290: case IFLNK: // シンボリックリンク
291: state = STATE_LINK;
292: break;
293:
294: case IFDIR: // ディレクトリ
295: dir.ino = file.ino;
296: idx++;
297: // パスの最後のコンポーネントがまだディレクトリならエラー
298: if (idx >= path.size()) {
299: errstr = "is a directory";
300: return false;
301: }
302: state = STATE_DIR;
303: break;
304:
305: default: // それ以外は対応してないし来ないはず
306: errstr = string_format("invalid filemode %06o",
307: be16toh(file.di.di_mode));
308: return false;
309: }
310: break;
311:
312: case STATE_LINK:
313: // リンク先ファイル名を取り出す
314: parent->putmsgf(1, lstr("%s Readlink", lam_func));
315: ReadData(file);
316: filename = std::string((const char *)file.data.data(),
317: file.data.size());
318: // パス解析へ
319: state = STATE_PATH;
320: break;
321:
322: default:
323: __unreachable();
324: }
325: }
326: // 通常ファイルに到達
327:
328: if (idx != path.size() - 1) {
329: // パスの最後のコンポーネントじゃなければエラー
330: errstr = "path not found";
331: return false;
332: }
333:
334: return true;
335: }
336:
337: // inode(.di) で指定されたファイル(またはディレクトリ)の本文を
338: // inode.data に返す。
339: // 今の所エラーは起きない。
340: void
341: Filesys::ReadData(inodefile& inode)
342: {
343: // di (ufs1_dinode) にはこの inode (ファイルまたはディレクトリ)の
344: // データの格納ブロックが記録されている。ディレクトリとは中身が
345: // ディレクトリエントリであるファイルと同じ構造のもの。
346: // di_db[] (直接ブロック)
347: // di_ib[] (間接ブロック)
348: // di_blocks (実際に使用しているブロック数)
349: //
350: // 直接ブロック di_db[] は12要素の配列で、データブロックの位置が
351: // 記録されている (未使用なら 0 のようだ)。
352: // データブロックは fs->fs_bsize でたぶん基本 4KB のやつ。
353: // これもパーティション先頭からのセクタ番号で表記される。なので
354: // ディスク上で連続しているファイルなら di_db[N] と di_db[N + 1] は
355: // 8 ずつ増えてるのが見えるはず。
356: // 例えば以下のサンプル断片は、直接ブロック2つでセクタ 100 から
357: // セクタ 115 までの連続する 16KB を所有している様子を示している。
358: //
359: // #100 #101 #102 #107
360: // +------+------+------+- .. -+------+
361: // di_db[0] = 100 ---> | Data | Data | Data | | Data |
362: // +------+------+------+- .. -+------+
363: //
364: // #108 #115
365: // +------+------+------+- .. -+------+
366: // di_db[1] = 108 ---> | Data | Data | Data | | Data |
367: // +------+------+------+- .. -+------+
368: //
369: // 間接ブロック di_ib[0], [1], [2] はそれぞれ一次、二次、三次の
370: // 間接記録になっている。一次間接だとこういう感じ。
371: //
372: // #120
373: // +--------+ +------+- ..
374: // di_ib[0] = 120 ---> | #200 ------> #200 | Data |
375: // | | +------+- ..
376: // | #208 ------> #208 | Data |
377: // +--------+ +------+- ..
378: //
379:
380: uint32 ino = inode.ino;
381: struct ufs1_dinode *di = &inode.di;
382: std::vector<uint8>& data = inode.data;
383: uint64 bsize64 = (uint64)fs->fs_bsize;
384:
385: uint64 di_size = be64toh(di->di_size);
386: uint32 di_blocks = be32toh(di->di_blocks);
387: // di->di_db[] にファイル(またはディレクトリ)の内容の位置が並んでいる
388: if (parent->loglevel >= 2) {
389: parent->putmsgn("%s di[%d].di_blocks=%u", __func__, ino, di_blocks);
390:
391: std::string dbstr;
392: for (int i = 0; i < UFS_NDADDR; i++) {
393: dbstr += string_format(" %u", be32toh(di->di_db[i]));
394: }
395: parent->putmsgn("%s di[%d].di_db[]=%s, di_ib[]=%u %u %u",
396: __func__, ino, dbstr.c_str() + 1,
397: be32toh(di->di_ib[0]),
398: be32toh(di->di_ib[1]),
399: be32toh(di->di_ib[2]));
400: }
401:
402: uint64 offset = 0; // 次に読み込む位置 (ここまでに読み込んだバイト数)
403:
404: // サイズが分かっているのであらかじめ確保しておく
405: data.resize(di_size);
406:
407: // 直接ブロック
408: for (int i = 0; i < countof(di->di_db); i++) {
409: uint64 remain = di_size - offset; // 残りバイト数
410: uint32 nbytes = std::min(remain, bsize64); // 今回読み込み分
411: PeekBlock(&data[offset], be32toh(di->di_db[i]), nbytes);
412: offset += nbytes;
413: if (offset >= di_size) {
414: return;
415: }
416: }
417: // 一次間接ブロック
418: std::vector<uint32> ib0buf(fs->fs_bsize / sizeof(uint32));
419: PeekBlock(&ib0buf[0], be32toh(di->di_ib[0]), fs->fs_bsize);
420: if (parent->loglevel >= 2) {
421: std::string distr;
422: for (const auto& x : ib0buf) {
423: if (x == 0)
424: break;
425: distr += string_format(" %u", be32toh(x));
426: }
427: parent->putmsgn("%s di[%d].di_ib[0]=%s",
428: __func__, ino, distr.c_str() + 1);
429: }
430: for (const auto& x : ib0buf) {
431: uint64 remain = di_size - offset; // 残りバイト数
432: uint32 nbytes = std::min(remain, bsize64); // 今回読み込み分
433: PeekBlock(&data[offset], be32toh(x), nbytes);
434: offset += nbytes;
435: if (offset >= di_size) {
436: return;
437: }
438: }
439:
440: // 二次、三次ブロックは未対応
441: if (offset < di_size) {
442: PANIC("di_ib[1] not supported");
443: }
444: }
445:
446: // inode.ino で指定された disk inode 情報を inode.di に返す。
447: // 今の所エラーは起きない。
448: void
449: Filesys::Readi(inodefile& inode)
450: {
451: // di は inode のディスク上の記録構造で 128 バイト長。
452: // 詳細は <ufs/ufs/dinode.h> の ufs1_dinode 参照。
453: // 基本的には inode ブロックにこの dinode が配列のように並んでいるが
454: // シリンダグループを越えるためには謎のマクロを使う。
455: // sys/lib/libsa/ufs.c 参照。
456: //
457: // dinode のうち、ここで関係するかも知れないのは
458: // di_mode (のうちファイルモード)
459: // di_size (ファイルサイズ)
460: // di_db[] (直接ブロック)
461: // di_ib[] (間接ブロック)
462: // di_blocks (ブロック数)
463: // くらいか。
464:
465: uint32 ino = inode.ino;
466:
467: // ino が含まれるブロックを読み込む。
468: // ino_to_fsba(fs, ino) が指定の ino が含まれるブロックを返す。
469: // ino_to_fsbo(fs, ino) はそのブロック内での ino のオフセットを返す。
470: // 例えば inode=2 の fsba が 0x18、fsbo が 2 なら、0x18ブロック目の
471: // [2] からつまり256バイト目からとなる。
472: std::vector<char> buf(fs->fs_bsize);
473: uint64 fsba = ino_to_fsba(fs, ino);
474: uint32 fsbo = ino_to_fsbo(fs, ino);
475: PeekBlock(&buf[0], fsba, buf.size());
476:
477: // ino で示される inode のディスク上構造を
478: // (ゲストエンディアンのまま) di にコピーして持っておく。
479: struct ufs1_dinode *di = &inode.di;
480: memcpy(di, &((ufs1_dinode *)(&buf[0]))[fsbo], sizeof(*di));
481: uint16 di_mode = be16toh(di->di_mode);
482: uint16 di_nlink = be16toh(di->di_nlink);
483: uint64 di_size = be64toh(di->di_size);
484: parent->putmsgf(2,
485: lstr("%s di[%d].di_mode=%05o di_nlink=%d di_size=%" PRIu64,
486: lam_func, ino, di_mode, di_nlink, di_size));
487: }
488:
489: // ディスクの指定ブロック b の先頭から len バイト読み出して buf に返す。
490: // buf は少なくとも len バイト確保してあること。
491: void
492: Filesys::PeekBlock(void *buf, uint32 b, uint32 len) const
493: {
494: // FFS_FSBTODB(fs, b) がブロック番号 b をセクタ番号に変換する。
495: uint32 sector = part_start + FFS_FSBTODB(fs, b);
496: hd->PeekImage(buf, sector * 512, len);
497: }
498:
499:
500: //
501: // inode 情報クラス
502: //
503:
504: // コンストラクタ
505: inodefile::inodefile(Device *parent_)
506: {
507: parent = parent_;
508: }
509:
510: // デストラクタ
511: inodefile::~inodefile()
512: {
513: }
514:
515: // ディレクトリエントリ dirbuf から name で指定されるファイル名に対応する
516: // inode 番号を返す。見付からなければ 0 を返す。
517: uint32
518: inodefile::FindFile(const std::string& name)
519: {
520: // ディレクトリエントリは struct direct が可変長で並んでいる。
521: // ../host/ffs_dir.h (元は NetBSD の <ufs/ufs/dir.h>) 参照。
522: // d->d_reclen がこの1つ分のエントリの長さなので、次のエントリ位置は
523: // このエントリの頭から d->d_reclen を足したところになる。
524: // 最終エントリの d_reclen を足すとバッファ末尾になるようになっている
525: // ようだ。
526: const char *dp = (const char *)(data.data());
527: const char *dend = dp + data.size();
528: uint32 file_ino;
529: uint16 reclen;
530:
531: for (; dp < dend; dp += reclen) {
532: const struct direct *d = (const struct direct *)dp;
533: file_ino = be32toh(d->d_fileno);
534: reclen = be16toh(d->d_reclen);
535:
536: std::string str = string_format("ino=%u reclen=%u name=|%s|",
537: file_ino, reclen, d->d_name);
538: if (d->d_reclen == 0) {
539: parent->putmsgf(1, lstr("%s reclen=0 !", lam_func));
540: break;
541: }
542:
543: if (strcmp(name.c_str(), d->d_name) == 0) {
544: parent->putmsgf(2, lstr("%s %s found", lam_func, str.c_str()));
545: return file_ino;
546: } else {
547: parent->putmsgf(2, lstr("%s %s skip", lam_func, str.c_str()));
548: }
549: }
550: parent->putmsgf(2, lstr("%s %s not found", lam_func, name.c_str()));
551: return 0;
552: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.