-
Notifications
You must be signed in to change notification settings - Fork 154
/
Copy path3.4.html
1214 lines (697 loc) · 90.4 KB
/
3.4.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE HTML>
<html lang="" >
<head>
<meta charset="UTF-8">
<meta content="text/html; charset=utf-8" http-equiv="Content-Type">
<title>文件系统 · GitBook</title>
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="description" content="">
<meta name="generator" content="GitBook 3.2.3">
<link rel="stylesheet" href="gitbook/style.css">
<link rel="stylesheet" href="gitbook/gitbook-plugin-intopic-toc/style.css">
<link rel="stylesheet" href="gitbook/gitbook-plugin-page-footer-ex/style/plugin.css">
<link rel="stylesheet" href="gitbook/gitbook-plugin-callouts/plugin.css">
<link rel="stylesheet" href="gitbook/gitbook-plugin-highlight/website.css">
<link rel="stylesheet" href="gitbook/gitbook-plugin-search/search.css">
<link rel="stylesheet" href="gitbook/gitbook-plugin-fontsettings/website.css">
<link rel="stylesheet" href="gitbook/gitbook-plugin-theme-comscore/test.css">
<link rel="stylesheet" href="styles.css">
<meta name="HandheldFriendly" content="true"/>
<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<link rel="apple-touch-icon-precomposed" sizes="152x152" href="gitbook/images/apple-touch-icon-precomposed-152.png">
<link rel="shortcut icon" href="gitbook/images/favicon.ico" type="image/x-icon">
<link rel="next" href="3.5.html" />
<link rel="prev" href="3.3.html" />
</head>
<body>
<div class="book">
<div class="book-summary">
<div id="book-search-input" role="search">
<input type="text" placeholder="Type to search" />
</div>
<nav role="navigation">
<ul class="summary">
<li class="chapter " data-level="1.1" data-path="index.html">
<a href="index.html">
Introduction
</a>
</li>
<li class="chapter " data-level="1.2" data-path="PA0.html">
<a href="PA0.html">
PA0 - 世界诞生的前夜: 开发环境配置
</a>
<ul class="articles">
<li class="chapter " data-level="1.2.1" data-path="0.1.html">
<a href="0.1.html">
Installing GNU/Linux
</a>
</li>
<li class="chapter " data-level="1.2.2" data-path="0.2.html">
<a href="0.2.html">
First Exploration with GNU/Linux
</a>
</li>
<li class="chapter " data-level="1.2.3" data-path="0.3.html">
<a href="0.3.html">
Installing Tools
</a>
</li>
<li class="chapter " data-level="1.2.4" data-path="0.4.html">
<a href="0.4.html">
Configuring vim
</a>
</li>
<li class="chapter " data-level="1.2.5" data-path="0.5.html">
<a href="0.5.html">
More Exploration
</a>
</li>
<li class="chapter " data-level="1.2.6" data-path="0.6.html">
<a href="0.6.html">
Getting Source Code for PAs
</a>
</li>
</ul>
</li>
<li class="chapter " data-level="1.3" data-path="PA1.html">
<a href="PA1.html">
PA1 - 开天辟地的篇章: 最简单的计算机
</a>
<ul class="articles">
<li class="chapter " data-level="1.3.1" data-path="1.1.html">
<a href="1.1.html">
在开始愉快的PA之旅之前
</a>
</li>
<li class="chapter " data-level="1.3.2" data-path="1.2.html">
<a href="1.2.html">
开天辟地的篇章
</a>
</li>
<li class="chapter " data-level="1.3.3" data-path="1.3.html">
<a href="1.3.html">
RTFSC
</a>
</li>
<li class="chapter " data-level="1.3.4" data-path="1.4.html">
<a href="1.4.html">
基础设施
</a>
</li>
<li class="chapter " data-level="1.3.5" data-path="1.5.html">
<a href="1.5.html">
表达式求值
</a>
</li>
<li class="chapter " data-level="1.3.6" data-path="1.6.html">
<a href="1.6.html">
监视点
</a>
</li>
<li class="chapter " data-level="1.3.7" data-path="1.7.html">
<a href="1.7.html">
如何阅读手册
</a>
</li>
</ul>
</li>
<li class="chapter " data-level="1.4" data-path="PA2.html">
<a href="PA2.html">
PA2 - 简单复杂的机器: 冯诺依曼计算机系统
</a>
<ul class="articles">
<li class="chapter " data-level="1.4.1" data-path="2.1.html">
<a href="2.1.html">
不停计算的机器
</a>
</li>
<li class="chapter " data-level="1.4.2" data-path="2.2.html">
<a href="2.2.html">
RTFSC(2)
</a>
</li>
<li class="chapter " data-level="1.4.3" data-path="2.3.html">
<a href="2.3.html">
程序, 运行时环境与AM
</a>
</li>
<li class="chapter " data-level="1.4.4" data-path="2.4.html">
<a href="2.4.html">
基础设施(2)
</a>
</li>
<li class="chapter " data-level="1.4.5" data-path="2.5.html">
<a href="2.5.html">
输入输出
</a>
</li>
</ul>
</li>
<li class="chapter " data-level="1.5" data-path="PA3.html">
<a href="PA3.html">
PA3 - 穿越时空的旅程: 批处理系统
</a>
<ul class="articles">
<li class="chapter " data-level="1.5.1" data-path="3.1.html">
<a href="3.1.html">
最简单的操作系统
</a>
</li>
<li class="chapter " data-level="1.5.2" data-path="3.2.html">
<a href="3.2.html">
穿越时空的旅程
</a>
</li>
<li class="chapter " data-level="1.5.3" data-path="3.3.html">
<a href="3.3.html">
用户程序和系统调用
</a>
</li>
<li class="chapter active" data-level="1.5.4" data-path="3.4.html">
<a href="3.4.html">
文件系统
</a>
</li>
<li class="chapter " data-level="1.5.5" data-path="3.5.html">
<a href="3.5.html">
精彩纷呈的应用程序
</a>
</li>
</ul>
</li>
<li class="chapter " data-level="1.6" data-path="PA4.html">
<a href="PA4.html">
PA4 - 虚实交错的魔法: 分时多任务
</a>
<ul class="articles">
<li class="chapter " data-level="1.6.1" data-path="4.1.html">
<a href="4.1.html">
多道程序
</a>
</li>
<li class="chapter " data-level="1.6.2" data-path="4.2.html">
<a href="4.2.html">
虚实交错的魔法
</a>
</li>
<li class="chapter " data-level="1.6.3" data-path="4.3.html">
<a href="4.3.html">
超越容量的界限
</a>
</li>
<li class="chapter " data-level="1.6.4" data-path="4.4.html">
<a href="4.4.html">
来自外部的声音
</a>
</li>
<li class="chapter " data-level="1.6.5" data-path="4.5.html">
<a href="4.5.html">
编写不朽的传奇
</a>
</li>
</ul>
</li>
<li class="chapter " data-level="1.7" data-path="blank.html">
<a href="blank.html">
杂项
</a>
<ul class="articles">
<li class="chapter " data-level="1.7.1" data-path="FAQ.html">
<a href="FAQ.html">
常见问题(FAQ)
</a>
</li>
<li class="chapter " data-level="1.7.2" data-path="why.html">
<a href="why.html">
为什么要学习计算机系统基础
</a>
</li>
<li class="chapter " data-level="1.7.3" data-path="linux.html">
<a href="linux.html">
Linux入门教程
</a>
</li>
<li class="chapter " data-level="1.7.4" data-path="man.html">
<a href="man.html">
man入门教程
</a>
</li>
<li class="chapter " data-level="1.7.5" data-path="git.html">
<a href="git.html">
git入门教程
</a>
</li>
<li class="chapter " data-level="1.7.6" data-path="nemu-isa-api.html">
<a href="nemu-isa-api.html">
NEMU ISA相关API说明文档
</a>
</li>
<li class="chapter " data-level="1.7.7" data-path="changelog.html">
<a href="changelog.html">
更新日志
</a>
</li>
<li class="chapter " data-level="1.7.8" data-path="i386-intro.html">
<a href="i386-intro.html">
i386手册指令集阅读指南
</a>
</li>
<li class="chapter " data-level="1.7.9" data-path="exec.html">
<a href="exec.html">
指令执行例子
</a>
</li>
</ul>
</li>
<li class="divider"></li>
<li>
<a href="https://www.gitbook.com" target="blank" class="gitbook-link">
Published with GitBook
</a>
</li>
</ul>
</nav>
</div>
<div class="book-body">
<div class="body-inner">
<div class="book-header" role="navigation">
<!-- Title -->
<h1>
<i class="fa fa-circle-o-notch fa-spin"></i>
<a href="." >文件系统</a>
</h1>
</div>
<div class="page-wrapper" tabindex="-1" role="main">
<div class="page-inner">
<div id="book-search-results">
<div class="search-noresults">
<section class="normal markdown-section">
<h2 id="简易文件系统">简易文件系统</h2>
<p>要实现一个完整的批处理系统, 我们还需要向系统提供多个程序.
我们之前把程序以文件的形式存放在ramdisk之中,
但如果程序的数量增加之后, 我们就要知道哪个程序在ramdisk的什么位置.
我们的ramdisk已经提供了读写接口, 使得我们可以很方便地访问某一个位置的内容,
这对Nanos-lite来说貌似没什么困难的地方;
另一方面, 用户程序也需要处理数据, 它们处理的数据也可能会组织成文件,
那么对用户程序来说, 它怎么知道文件位于ramdisk的哪一个位置呢?
更何况文件会动态地增删, 用户程序并不知情.
这说明, 把ramdisk的读写接口直接提供给用户程序来使用是不可行的.
操作系统还需要在存储介质的驱动程序之上为用户程序提供一种更高级的抽象, 那就是文件.</p>
<p>文件的本质就是字节序列, 另外还由一些额外的属性构成.
在这里, 我们先讨论普通意义上的文件.
这样, 那些额外的属性就维护了文件到ramdisk存储位置的映射.
为了管理这些映射, 同时向上层提供文件操作的接口, 我们需要在Nanos-lite中实现一个文件系统.</p>
<p>不要被"文件系统"四个字吓到了, 我们对文件系统的需求并不是那么复杂,
因此我们可以定义一个简易文件系统sfs(Simple File System):</p>
<ul>
<li>每个文件的大小是固定的</li>
<li>写文件时不允许超过原有文件的大小</li>
<li>文件的数量是固定的, 不能创建新文件</li>
<li>没有目录</li>
</ul>
<p>既然文件的数量和大小都是固定的, 我们自然可以把每一个文件分别固定在ramdisk中的某一个位置.
这些简化的特性大大降低了文件系统的实现难度.
当然, 真实的文件系统远远比sfs复杂.</p>
<p>我们约定文件从ramdisk的最开始一个挨着一个地存放:</p>
<pre><code>0
+-------------+---------+----------+-----------+--
| file0 | file1 | ...... | filen |
+-------------+---------+----------+-----------+--
\ / \ / \ /
+ size0 + +size1+ + sizen +
</code></pre><p>为了记录ramdisk中各个文件的名字和大小, 我们还需要一张"文件记录表".
Nanos-lite的Makefile已经提供了维护这些信息的脚本, 先对<code>nanos-lite/Makefile</code>作如下修改:</p>
<pre><code class="lang-diff"><span class="hljs-comment">--- nanos-lite/Makefile</span>
<span class="hljs-comment">+++ nanos-lite/Makefile</span>
<span class="hljs-meta">@@ -1,2 +1,2 @@</span>
<span class="hljs-deletion">-#HAS_NAVY = 1</span>
<span class="hljs-addition">+HAS_NAVY = 1</span>
RAMDISK_FILE = build/ramdisk.img
</code></pre>
<p>然后运行<code>make ARCH=$ISA-nemu update</code>就会自动编译Navy中的程序,
并把<code>navy-apps/fsimg/</code>目录下的所有内容整合成ramdisk镜像<code>navy-apps/build/ramdisk.img</code>,
同时生成这个ramdisk镜像的文件记录表<code>navy-apps/build/ramdisk.h</code>,
Nanos-lite的<code>Makefile</code>会通过软连接把它们链接到项目中.</p>
<div class="panel panel-success"><div class="panel-heading"><h5 class="panel-title" id="记得更新镜像文件"><i class="fa fa-lightbulb-o"></i> 记得更新镜像文件</h5></div><div class="panel-body"><p>如果你修改了Navy中的内容, 请记得通过上述命令来更新镜像文件.</p></div></div>
<p>"文件记录表"其实是一个数组, 数组的每个元素都是一个结构体:</p>
<pre><code class="lang-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">struct</span> {
<span class="hljs-keyword">char</span> *name; <span class="hljs-comment">// 文件名</span>
<span class="hljs-keyword">size_t</span> size; <span class="hljs-comment">// 文件大小</span>
<span class="hljs-keyword">size_t</span> disk_offset; <span class="hljs-comment">// 文件在ramdisk中的偏移</span>
} Finfo;
</code></pre>
<p>在sfs中, 这三项信息都是固定不变的. 其中的文件名和我们平常使用的习惯不太一样:
由于sfs没有目录, 我们把目录分隔符<code>/</code>也认为是文件名的一部分,
例如<code>/bin/hello</code>是一个完整的文件名.
这种做法其实也隐含了目录的层次结构,
对于文件数量不多的情况, 这种做法既简单又奏效.</p>
<p>有了这些信息, 就已经可以实现最基本的文件读写操作了:</p>
<pre><code class="lang-c"><span class="hljs-keyword">size_t</span> read(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> *filename, <span class="hljs-keyword">void</span> *buf, <span class="hljs-keyword">size_t</span> len);
<span class="hljs-keyword">size_t</span> write(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> *filename, <span class="hljs-keyword">const</span> <span class="hljs-keyword">void</span> *buf, <span class="hljs-keyword">size_t</span> len);
</code></pre>
<p>但在真实的操作系统中, 这种直接用文件名来作为读写操作参数的做法却有所缺陷.
例如, 我们在用<code>less</code>工具浏览文件的时候:</p>
<pre><code class="lang-bash">cat file | less
</code></pre>
<p><code>cat</code>工具希望把文件内容写到<code>less</code>工具的标准输入中,
但我们却无法用文件名来标识<code>less</code>工具的标准输入!
实际上, 操作系统中确实存在不少"没有名字"的文件.
为了统一管理它们, 我们希望通过一个编号来表示文件, 这个编号就是文件描述符(file descriptor).
一个文件描述符对应一个正在打开的文件, 由操作系统来维护文件描述符到具体文件的映射.
于是我们很自然地通过<code>open()</code>系统调用来打开一个文件, 并返回相应的文件描述符</p>
<pre><code class="lang-c"><span class="hljs-function"><span class="hljs-keyword">int</span> <span class="hljs-title">open</span><span class="hljs-params">(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> *pathname, <span class="hljs-keyword">int</span> flags, <span class="hljs-keyword">int</span> mode)</span></span>;
</code></pre>
<p>在Nanos-lite中, 由于sfs的文件数目是固定的,
我们可以简单地把文件记录表的下标作为相应文件的文件描述符返回给用户程序.
在这以后, 所有文件操作都通过文件描述符来标识文件:</p>
<pre><code class="lang-c"><span class="hljs-keyword">size_t</span> read(<span class="hljs-keyword">int</span> fd, <span class="hljs-keyword">void</span> *buf, <span class="hljs-keyword">size_t</span> len);
<span class="hljs-keyword">size_t</span> write(<span class="hljs-keyword">int</span> fd, <span class="hljs-keyword">const</span> <span class="hljs-keyword">void</span> *buf, <span class="hljs-keyword">size_t</span> len);
<span class="hljs-function"><span class="hljs-keyword">int</span> <span class="hljs-title">close</span><span class="hljs-params">(<span class="hljs-keyword">int</span> fd)</span></span>;
</code></pre>
<p>另外, 我们也不希望每次读写操作都需要从头开始.
于是我们需要为每一个已经打开的文件引入偏移量属性<code>open_offset</code>, 来记录目前文件操作的位置.
每次对文件读写了多少个字节, 偏移量就前进多少.</p>
<div class="panel panel-info"><div class="panel-heading"><h5 class="panel-title" id="文件偏移量和用户程序"><i class="fa fa-comment-o"></i> 文件偏移量和用户程序</h5></div><div class="panel-body"><p>事实上在真正的操作系统中, 把偏移量放在文件记录表中维护会导致用户程序无法实现某些功能.
但解释这个问题需要理解一些超出课程范围的知识, 我们在此就不展开叙述了.
你可以在学习操作系统课程的时候再来思考这个问题.</p><p>由于Nanos-lite是一个精简版的操作系统, 上述问题暂时不会出现,
为了简化实现, 我们还是把偏移量放在文件记录表中进行维护.</p></div></div>
<p>偏移量可以通过<code>lseek()</code>系统调用来调整, 从而可以对文件中的任意位置进行读写:</p>
<pre><code class="lang-c"><span class="hljs-keyword">size_t</span> lseek(<span class="hljs-keyword">int</span> fd, <span class="hljs-keyword">size_t</span> offset, <span class="hljs-keyword">int</span> whence);
</code></pre>
<p>为了方便用户程序进行标准输入输出, 操作系统准备了三个默认的文件描述符:</p>
<pre><code class="lang-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> FD_STDIN 0</span>
<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> FD_STDOUT 1</span>
<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> FD_STDERR 2</span>
</code></pre>
<p>它们分别对应标准输入<code>stdin</code>, 标准输出<code>stdout</code>和标准错误<code>stderr</code>.
我们经常使用的printf, 最终会调用<code>write(FD_STDOUT, buf, len)</code>进行输出;
而scanf将会通过调用<code>read(FD_STDIN, buf, len)</code>进行读入.</p>
<p><code>nanos-lite/src/fs.c</code>中定义的<code>file_table</code>会包含<code>nanos-lite/src/files.h</code>,
其中前面还有3个特殊的文件: <code>stdin</code>, <code>stdout</code>和<code>stderr</code>的占位表项,
它们只是为了保证sfs和约定的标准输入输出的文件描述符保持一致,
例如根据约定<code>stdout</code>的文件描述符是<code>1</code>, 而我们添加了三个占位表项之后,
文件记录表中的<code>1</code>号下标也就不会分配给其它的普通文件了.</p>
<p>根据以上信息, 我们就可以在文件系统中实现以下的文件操作了:</p>
<pre><code class="lang-c"><span class="hljs-function"><span class="hljs-keyword">int</span> <span class="hljs-title">fs_open</span><span class="hljs-params">(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> *pathname, <span class="hljs-keyword">int</span> flags, <span class="hljs-keyword">int</span> mode)</span></span>;
<span class="hljs-keyword">size_t</span> fs_read(<span class="hljs-keyword">int</span> fd, <span class="hljs-keyword">void</span> *buf, <span class="hljs-keyword">size_t</span> len);
<span class="hljs-keyword">size_t</span> fs_write(<span class="hljs-keyword">int</span> fd, <span class="hljs-keyword">const</span> <span class="hljs-keyword">void</span> *buf, <span class="hljs-keyword">size_t</span> len);
<span class="hljs-keyword">size_t</span> fs_lseek(<span class="hljs-keyword">int</span> fd, <span class="hljs-keyword">size_t</span> offset, <span class="hljs-keyword">int</span> whence);
<span class="hljs-function"><span class="hljs-keyword">int</span> <span class="hljs-title">fs_close</span><span class="hljs-params">(<span class="hljs-keyword">int</span> fd)</span></span>;
</code></pre>
<p>这些文件操作实际上是相应的系统调用在内核中的实现.
你可以通过 <code>man</code> 查阅它们的功能, 例如</p>
<pre><code>man 2 open
</code></pre><p>其中<code>2</code>表示查阅和系统调用相关的manual page. 实现这些文件操作的时候注意以下几点:</p>
<ul>
<li>由于sfs中每一个文件都是固定的, 不会产生新文件,
因此"<code>fs_open()</code>没有找到<code>pathname</code>所指示的文件"属于异常情况, 你需要使用assertion终止程序运行.</li>
<li>为了简化实现, 我们允许所有用户程序都可以对所有已存在的文件进行读写,
这样以后, 我们在实现<code>fs_open()</code>的时候就可以忽略<code>flags</code>和<code>mode</code>了.</li>
<li>使用<code>ramdisk_read()</code>和<code>ramdisk_write()</code>来进行文件的真正读写.</li>
<li>由于文件的大小是固定的, 在实现<code>fs_read()</code>,
<code>fs_write()</code>和<code>fs_lseek()</code>的时候, 注意偏移量不要越过文件的边界.</li>
<li>除了写入<code>stdout</code>和<code>stderr</code>之外(用<code>putch()</code>输出到串口),
其余对于<code>stdin</code>, <code>stdout</code>和<code>stderr</code>这三个特殊文件的操作可以直接忽略.</li>
<li>由于sfs没有维护文件打开的状态, <code>fs_close()</code>可以直接返回<code>0</code>, 表示总是关闭成功.</li>
</ul>
<p>最后你还需要在Nanos-lite和Navy的libos中添加相应的系统调用, 来调用相应的文件操作.</p>
<div class="panel panel-warning"><div class="panel-heading"><h5 class="panel-title" id="让loader使用文件"><i class="fa fa-edit"></i> 让loader使用文件</h5></div><div class="panel-body"><p>我们之前是让loader来直接调用<code>ramdisk_read()</code>来加载用户程序.
ramdisk中的文件数量增加之后, 这种方式就不合适了,
我们首先需要让loader享受到文件系统的便利.</p><p>你需要先实现<code>fs_open()</code>, <code>fs_read()</code>和<code>fs_close()</code>,
这样就可以在loader中使用文件名来指定加载的程序了, 例如"/bin/hello".</p><p>实现之后, 以后更换用户程序只需要修改传入<code>naive_uload()</code>函数的文件名即可.</p></div></div>
<!-- -->
<div class="panel panel-warning"><div class="panel-heading"><h5 class="panel-title" id="实现完整的文件系统"><i class="fa fa-edit"></i> 实现完整的文件系统</h5></div><div class="panel-body"><p>实现<code>fs_write()</code>和<code>fs_lseek()</code>, 然后运行测试程序<code>navy-apps/tests/file-test</code>.
为了编译它, 你需要把它加到<code>navy-apps/Makefile</code>的<code>TESTS</code>变量中,
这样它最终就会被包含在ramdisk镜像中.
这个测试程序用于进行一些简单的文件读写和定位操作.
如果你的实现正确, 你将会看到程序输出<code>PASS!!!</code>的信息.</p></div></div>
<!-- -->
<div class="panel panel-success"><div class="panel-heading"><h5 class="panel-title" id="记得更新应用程序列表"><i class="fa fa-lightbulb-o"></i> 记得更新应用程序列表</h5></div><div class="panel-body"><p>如果你希望在镜像中添加一个应用程序, 请记得将它加入到上述Makefile文件的应用程序列表中.</p></div></div>
<!-- -->
<div class="panel panel-warning"><div class="panel-heading"><h5 class="panel-title" id="支持sfs的strace"><i class="fa fa-edit"></i> 支持sfs的strace</h5></div><div class="panel-body"><p>由于sfs的特性, 打开同一个文件总是会返回相同的文件描述符.
这意味着, 我们可以把strace中的文件描述符直接翻译成文件名, 得到可读性更好的trace信息.
尝试实现这一功能, 它可以为你将来使用strace提供一些便利.</p></div></div>
<h2 id="一切皆文件">一切皆文件</h2>
<p>AM中的IOE向我们展现了程序进行输入输出的需求.
那么在Nanos-lite上, 如果用户程序想访问设备, 要怎么办呢?
一种最直接的方式, 就是让操作系统为每个设备单独提供一个系统调用,
用户程序通过这些系统调用, 就可以直接使用相应的功能了.
然而这种做法却存在不少问题:</p>
<ul>
<li>首先, 设备的类型五花八门, 其功能更是数不胜数,
要为它们分别实现系统调用来给用户程序提供接口, 本身就已经缺乏可行性了;</li>
<li>此外, 由于设备的功能差别较大, 若提供的接口不能统一, 程序和设备之间的交互就会变得困难.
所以我们需要有一种方式对设备的功能进行抽象, 向用户程序提供统一的接口.</li>
</ul>
<p>我们之前提到, 文件的本质就是字节序列.
事实上, 计算机系统中到处都是字节序列(如果只是无序的字节集合, 计算机要如何处理?),
我们可以轻松地举出很多例子:</p>
<ul>
<li>内存是以字节编址的, 天然就是一个字节序列, 因而我们之前使用的ramdisk作为字节序列也更加显而易见了</li>
<li>管道(shell命令中的<code>|</code>)是一种先进先出的字节序列, 本质上它是内存中的一个队列缓冲区</li>
<li>磁盘也可以看成一个字节序列:
我们可以为磁盘上的每一个字节进行编号, 例如第x柱面第y磁头第z扇区中的第n字节,
把磁盘上的所有字节按照编号的大小进行排列, 便得到了一个字节序列</li>
<li>socket(网络套接字)也是一种字节序列, 它有一个缓冲区, 负责存放接收到的网络数据包,
上层应用将socket中的内容看做是字节序列, 并通过一些特殊的文件操作来处理它们.
我们在PA2中介绍了DiffTest, 如果你RTFSC, 就会发现其中的<code>qemu-diff</code>就是通过socket与QEMU进行通信的,
而操作socket的方式就是<code>fgetc()</code>和<code>fputc()</code></li>
<li>操作系统的一些信息可以以字节序列的方式暴露给用户, 例如CPU的配置信息</li>
<li>操作系统提供的一些特殊的功能, 如随机数生成器, 也可以看成一个无穷长的字节序列</li>
<li>甚至一些非存储类型的硬件也可以看成是字节序列:
我们在键盘上按顺序敲入按键的编码形成了一个字节序列,
显示器上每一个像素的内容按照其顺序也可以看做是字节序列...</li>
</ul>
<p>既然文件就是字节序列, 那很自然地, 上面这些五花八门的字节序列应该都可以看成文件.
Unix就是这样做的, 因此有"一切皆文件"(Everything is a file)的说法.
这种做法最直观的好处就是为不同的事物提供了统一的接口:
我们可以使用文件的接口来操作计算机上的一切, 而不必对它们进行详细的区分: 例如
<code>navy-apps/Makefile</code>的<code>ramdisk</code>规则通过管道把各个shell工具的输入输出连起来, 生成文件记录表</p>
<pre><code class="lang-bash">wc -c $(FSIMG_FILES) | grep -v <span class="hljs-string">'total$$'</span> | sed <span class="hljs-_">-e</span> <span class="hljs-string">'s+ ./fsimg+ +'</span> |
awk -v sum=0 <span class="hljs-string">'{print "\x7b\x22" $$2 "\x22\x2c " $$1 "\x2c " sum "\x7d\x2c";sum += $$1}'</span> >> $(RAMDISK_H)
</code></pre>
<p>以十六进制的方式查看磁盘上的内容</p>
<pre><code class="lang-bash">head -c 512 /dev/sda | hd
</code></pre>
<p>查看CPU是否有Spectre漏洞</p>
<pre><code class="lang-bash">cat /proc/cpuinfo | grep <span class="hljs-string">'spectre'</span>
</code></pre>
<p>甚至我们在PA2中提供的"小星星"示例音频, 也是通过简单的文件操作暴力拼接而成的</p>
<pre><code class="lang-bash">cat Do.ogg Do.ogg So.ogg So.ogg La.ogg La.ogg So.ogg > little-star.ogg
</code></pre>
<p>而</p>
<pre><code class="lang-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-string">"/dev/urandom"</span></span>
</code></pre>
<p>则会将urandom设备中的内容包含到源文件中: 由于urandom设备是一个长度无穷的字节序列,
提交一个包含上述内容的程序源文件将会令一些检测功能不强的Online Judge平台直接崩溃.</p>
<p>"一切皆文件"的抽象使得我们可以通过标准工具很容易完成一些在Windows下不易完成的工作,
这其实体现了Unix哲学的部分内容: 每个程序采用文本文件作为输入输出, 这样可以使程序之间易于合作.
GNU/Linux继承自Unix, 也自然继承了这种优秀的特性.
为了向用户程序提供统一的抽象, Nanos-lite也尝试将IOE抽象成文件.</p>
<h3 id="虚拟文件系统">虚拟文件系统</h3>
<p>为了实现一切皆文件的思想, 我们之前实现的文件操作就需要进行扩展了:
我们不仅需要对普通文件进行读写, 还需要支持各种"特殊文件"的操作.
至于扩展的方式, 你是再熟悉不过的了, 那就是抽象!</p>
<p>我们对之前实现的文件操作API的语义进行扩展, 让它们可以支持任意文件(包括"特殊文件")的操作:</p>
<pre><code class="lang-c"><span class="hljs-function"><span class="hljs-keyword">int</span> <span class="hljs-title">fs_open</span><span class="hljs-params">(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> *pathname, <span class="hljs-keyword">int</span> flags, <span class="hljs-keyword">int</span> mode)</span></span>;
<span class="hljs-keyword">size_t</span> fs_read(<span class="hljs-keyword">int</span> fd, <span class="hljs-keyword">void</span> *buf, <span class="hljs-keyword">size_t</span> len);
<span class="hljs-keyword">size_t</span> fs_write(<span class="hljs-keyword">int</span> fd, <span class="hljs-keyword">const</span> <span class="hljs-keyword">void</span> *buf, <span class="hljs-keyword">size_t</span> len);
<span class="hljs-keyword">size_t</span> fs_lseek(<span class="hljs-keyword">int</span> fd, <span class="hljs-keyword">size_t</span> offset, <span class="hljs-keyword">int</span> whence);
<span class="hljs-function"><span class="hljs-keyword">int</span> <span class="hljs-title">fs_close</span><span class="hljs-params">(<span class="hljs-keyword">int</span> fd)</span></span>;
</code></pre>
<p>这组扩展语义之后的API有一个酷炫的名字, 叫<a href="https://en.wikipedia.org/wiki/Virtual_file_system" target="_blank">VFS(虚拟文件系统)</a>.
既然有虚拟文件系统, 那相应地也应该有"真实文件系统",
这里所谓的真实文件系统, 其实是指具体如何操作某一类文件.
比如在Nanos-lite上, 普通文件通过ramdisk的API进行操作;
在真实的操作系统上, 真实文件系统的种类更是数不胜数:
比如熟悉Windows的你应该知道管理普通文件的NTFS, 目前在GNU/Linux上比较流行的则是EXT4;
至于特殊文件的种类就更多了, 于是相应地有<code>procfs</code>, <code>tmpfs</code>, <code>devfs</code>, <code>sysfs</code>, <code>initramfs</code>...
这些不同的真实文件系统, 它们都分别实现了这些文件的具体操作方式.</p>
<p>所以, VFS其实是对不同种类的真实文件系统的抽象,
它用一组API来描述了这些真实文件系统的抽象行为, 屏蔽了真实文件系统之间的差异,
上层模块(比如系统调用处理函数)不必关心当前操作的文件具体是什么类型,
只要调用这一组API即可完成相应的文件操作.
有了VFS的概念, 要添加一个真实文件系统就非常容易了:
只要把真实文件系统的访问方式包装成VFS的API,
上层模块无需修改任何代码, 就能支持一个新的真实文件系统了.</p>
<div class="panel panel-danger"><div class="panel-heading"><h5 class="panel-title" id="又来了"><i class="fa fa-bullhorn"></i> 又来了</h5></div><div class="panel-body"><p>阅读上述文字的时候, 如果你想起了AM的概念, 这就对了, 因为VFS背后的思想, 也是抽象.</p></div></div>
<p>在Nanos-lite中, 实现VFS的关键就是<code>Finfo</code>结构体中的两个读写函数指针:</p>
<pre><code class="lang-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">struct</span> {
<span class="hljs-keyword">char</span> *name; <span class="hljs-comment">// 文件名</span>
<span class="hljs-keyword">size_t</span> size; <span class="hljs-comment">// 文件大小</span>
<span class="hljs-keyword">size_t</span> disk_offset; <span class="hljs-comment">// 文件在ramdisk中的偏移</span>
ReadFn read; <span class="hljs-comment">// 读函数指针</span>
WriteFn write; <span class="hljs-comment">// 写函数指针</span>
} Finfo;
</code></pre>
<p>其中<code>ReadFn</code>和<code>WriteFn</code>分别是两种函数指针, 它们用于指向真正进行读写的函数, 并返回成功读写的字节数.
有了这两个函数指针, 我们只需要在文件记录表中对不同的文件设置不同的读写函数,
就可以通过<code>f->read()</code>和<code>f->write()</code>的方式来调用具体的读写函数了.</p>
<div class="panel panel-info"><div class="panel-heading"><h5 class="panel-title" id="用c语言模拟面向对象编程"><i class="fa fa-comment-o"></i> 用C语言模拟面向对象编程</h5></div><div class="panel-body"><p>VFS的实现展示了如何用C语言来模拟面向对象编程的一些基本概念:
例如通过结构体来实现类的定义, 结构体中的普通变量可以看作类的成员,
函数指针就可以看作类的方法, 给函数指针设置不同的函数可以实现方法的重载...</p><p>这说明, OOP中那些看似虚无缥缈的概念也没比C语言高级到哪里去,
只不过是OOP的编译器帮我们做了更多的事情, 编译成机器代码之后, OOP也就不存在了.
<a href="https://www.cs.rit.edu/~ats/books/ooc.pdf" target="_blank">Object-Oriented Programming With ANSI-C</a>